LLVM  14.0.0git
LTOCodeGenerator.cpp
Go to the documentation of this file.
1 //===-LTOCodeGenerator.cpp - LLVM Link Time Optimizer ---------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Link Time Optimization library. This library is
10 // intended to be used by linker to optimize code at link time.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 
16 #include "llvm/ADT/Statistic.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/Analysis/Passes.h"
24 #include "llvm/Config/config.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DataLayout.h"
27 #include "llvm/IR/DebugInfo.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/DiagnosticInfo.h"
31 #include "llvm/IR/LLVMContext.h"
34 #include "llvm/IR/Mangler.h"
35 #include "llvm/IR/Module.h"
36 #include "llvm/IR/PassTimingInfo.h"
37 #include "llvm/IR/Verifier.h"
38 #include "llvm/InitializePasses.h"
39 #include "llvm/LTO/LTO.h"
40 #include "llvm/LTO/LTOBackend.h"
43 #include "llvm/Linker/Linker.h"
44 #include "llvm/MC/MCAsmInfo.h"
45 #include "llvm/MC/MCContext.h"
50 #include "llvm/Support/Host.h"
52 #include "llvm/Support/Signals.h"
59 #include "llvm/Transforms/IPO.h"
65 #include <system_error>
66 using namespace llvm;
67 
69 #ifdef LLVM_VERSION_INFO
70  return PACKAGE_NAME " version " PACKAGE_VERSION ", " LLVM_VERSION_INFO;
71 #else
72  return PACKAGE_NAME " version " PACKAGE_VERSION;
73 #endif
74 }
75 
76 namespace llvm {
78  "lto-discard-value-names",
79  cl::desc("Strip names from Value during LTO (other than GlobalValue)."),
80 #ifdef NDEBUG
81  cl::init(true),
82 #else
83  cl::init(false),
84 #endif
85  cl::Hidden);
86 
88  "lto-pass-remarks-with-hotness",
89  cl::desc("With PGO, include profile count in optimization remarks"),
90  cl::Hidden);
91 
94  "lto-pass-remarks-hotness-threshold",
95  cl::desc("Minimum profile count required for an "
96  "optimization remark to be output."
97  " Use 'auto' to apply the threshold from profile summary."),
98  cl::value_desc("uint or 'auto'"), cl::init(0), cl::Hidden);
99 
101  RemarksFilename("lto-pass-remarks-output",
102  cl::desc("Output filename for pass remarks"),
103  cl::value_desc("filename"));
104 
106  RemarksPasses("lto-pass-remarks-filter",
107  cl::desc("Only record optimization remarks from passes whose "
108  "names match the given regular expression"),
109  cl::value_desc("regex"));
110 
112  "lto-pass-remarks-format",
113  cl::desc("The format used for serializing remarks (default: YAML)"),
114  cl::value_desc("format"), cl::init("yaml"));
115 
117  "lto-stats-file",
118  cl::desc("Save statistics to the specified file"),
119  cl::Hidden);
120 }
121 
123  : Context(Context), MergedModule(new Module("ld-temp.o", Context)),
124  TheLinker(new Linker(*MergedModule)) {
127 
128  Config.CodeModel = None;
129  Config.StatsFile = LTOStatsFile;
130  Config.PreCodeGenPassesHook = [](legacy::PassManager &PM) {
131  PM.add(createObjCARCContractPass());
132  };
133 }
134 
136 
138  const std::vector<StringRef> &undefs = Mod->getAsmUndefinedRefs();
139  for (int i = 0, e = undefs.size(); i != e; ++i)
140  AsmUndefinedRefs.insert(undefs[i]);
141 }
142 
144  assert(&Mod->getModule().getContext() == &Context &&
145  "Expected module in same context");
146 
147  bool ret = TheLinker->linkInModule(Mod->takeModule());
149 
150  // We've just changed the input, so let's make sure we verify it.
151  HasVerifiedInput = false;
152 
153  return !ret;
154 }
155 
156 void LTOCodeGenerator::setModule(std::unique_ptr<LTOModule> Mod) {
157  assert(&Mod->getModule().getContext() == &Context &&
158  "Expected module in same context");
159 
160  AsmUndefinedRefs.clear();
161 
162  MergedModule = Mod->takeModule();
163  TheLinker = std::make_unique<Linker>(*MergedModule);
165 
166  // We've just changed the input, so let's make sure we verify it.
167  HasVerifiedInput = false;
168 }
169 
171  Config.Options = Options;
172 }
173 
175  switch (Debug) {
177  EmitDwarfDebugInfo = false;
178  return;
179 
181  EmitDwarfDebugInfo = true;
182  return;
183  }
184  llvm_unreachable("Unknown debug format!");
185 }
186 
188  Config.OptLevel = Level;
189  Config.PTO.LoopVectorization = Config.OptLevel > 1;
190  Config.PTO.SLPVectorization = Config.OptLevel > 1;
191  switch (Config.OptLevel) {
192  case 0:
193  Config.CGOptLevel = CodeGenOpt::None;
194  return;
195  case 1:
196  Config.CGOptLevel = CodeGenOpt::Less;
197  return;
198  case 2:
200  return;
201  case 3:
203  return;
204  }
205  llvm_unreachable("Unknown optimization level!");
206 }
207 
209  if (!determineTarget())
210  return false;
211 
212  // We always run the verifier once on the merged module.
213  verifyMergedModuleOnce();
214 
215  // mark which symbols can not be internalized
216  applyScopeRestrictions();
217 
218  // create output file
219  std::error_code EC;
220  ToolOutputFile Out(Path, EC, sys::fs::OF_None);
221  if (EC) {
222  std::string ErrMsg = "could not open bitcode file for writing: ";
223  ErrMsg += Path.str() + ": " + EC.message();
224  emitError(ErrMsg);
225  return false;
226  }
227 
228  // write bitcode to it
229  WriteBitcodeToFile(*MergedModule, Out.os(), ShouldEmbedUselists);
230  Out.os().close();
231 
232  if (Out.os().has_error()) {
233  std::string ErrMsg = "could not write bitcode file: ";
234  ErrMsg += Path.str() + ": " + Out.os().error().message();
235  emitError(ErrMsg);
236  Out.os().clear_error();
237  return false;
238  }
239 
240  Out.keep();
241  return true;
242 }
243 
244 bool LTOCodeGenerator::compileOptimizedToFile(const char **Name) {
245  // make unique temp output file to put generated code
246  SmallString<128> Filename;
247 
248  auto AddStream =
249  [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
250  StringRef Extension(Config.CGFileType == CGFT_AssemblyFile ? "s" : "o");
251 
252  int FD;
253  std::error_code EC =
254  sys::fs::createTemporaryFile("lto-llvm", Extension, FD, Filename);
255  if (EC)
256  emitError(EC.message());
257 
258  return std::make_unique<lto::NativeObjectStream>(
259  std::make_unique<llvm::raw_fd_ostream>(FD, true));
260  };
261 
262  bool genResult = compileOptimized(AddStream, 1);
263 
264  if (!genResult) {
265  sys::fs::remove(Twine(Filename));
266  return false;
267  }
268 
269  // If statistics were requested, save them to the specified file or
270  // print them out after codegen.
271  if (StatsFile)
272  PrintStatisticsJSON(StatsFile->os());
273  else if (AreStatisticsEnabled())
274  PrintStatistics();
275 
276  NativeObjectPath = Filename.c_str();
277  *Name = NativeObjectPath.c_str();
278  return true;
279 }
280 
281 std::unique_ptr<MemoryBuffer>
283  const char *name;
284  if (!compileOptimizedToFile(&name))
285  return nullptr;
286 
287  // read .o file into memory buffer
289  name, /*IsText=*/false, /*RequiresNullTerminator=*/false);
290  if (std::error_code EC = BufferOrErr.getError()) {
291  emitError(EC.message());
292  sys::fs::remove(NativeObjectPath);
293  return nullptr;
294  }
295 
296  // remove temp files
297  sys::fs::remove(NativeObjectPath);
298 
299  return std::move(*BufferOrErr);
300 }
301 
303  if (!optimize())
304  return false;
305 
306  return compileOptimizedToFile(Name);
307 }
308 
309 std::unique_ptr<MemoryBuffer> LTOCodeGenerator::compile() {
310  if (!optimize())
311  return nullptr;
312 
313  return compileOptimized();
314 }
315 
316 bool LTOCodeGenerator::determineTarget() {
317  if (TargetMach)
318  return true;
319 
320  TripleStr = MergedModule->getTargetTriple();
321  if (TripleStr.empty()) {
322  TripleStr = sys::getDefaultTargetTriple();
323  MergedModule->setTargetTriple(TripleStr);
324  }
325  llvm::Triple Triple(TripleStr);
326 
327  // create target machine from info for merged modules
328  std::string ErrMsg;
329  MArch = TargetRegistry::lookupTarget(TripleStr, ErrMsg);
330  if (!MArch) {
331  emitError(ErrMsg);
332  return false;
333  }
334 
335  // Construct LTOModule, hand over ownership of module and target. Use MAttr as
336  // the default set of features.
337  SubtargetFeatures Features(join(Config.MAttrs, ""));
338  Features.getDefaultSubtargetFeatures(Triple);
339  FeatureStr = Features.getString();
340  // Set a default CPU for Darwin triples.
341  if (Config.CPU.empty() && Triple.isOSDarwin()) {
343  Config.CPU = "core2";
344  else if (Triple.getArch() == llvm::Triple::x86)
345  Config.CPU = "yonah";
346  else if (Triple.isArm64e())
347  Config.CPU = "apple-a12";
348  else if (Triple.getArch() == llvm::Triple::aarch64 ||
350  Config.CPU = "cyclone";
351  }
352 
353  TargetMach = createTargetMachine();
354  assert(TargetMach && "Unable to create target machine");
355 
356  return true;
357 }
358 
359 std::unique_ptr<TargetMachine> LTOCodeGenerator::createTargetMachine() {
360  assert(MArch && "MArch is not set!");
361  return std::unique_ptr<TargetMachine>(MArch->createTargetMachine(
362  TripleStr, Config.CPU, FeatureStr, Config.Options, Config.RelocModel,
363  None, Config.CGOptLevel));
364 }
365 
366 // If a linkonce global is present in the MustPreserveSymbols, we need to make
367 // sure we honor this. To force the compiler to not drop it, we add it to the
368 // "llvm.compiler.used" global.
369 void LTOCodeGenerator::preserveDiscardableGVs(
370  Module &TheModule,
372  std::vector<GlobalValue *> Used;
373  auto mayPreserveGlobal = [&](GlobalValue &GV) {
374  if (!GV.isDiscardableIfUnused() || GV.isDeclaration() ||
375  !mustPreserveGV(GV))
376  return;
377  if (GV.hasAvailableExternallyLinkage())
378  return emitWarning(
379  (Twine("Linker asked to preserve available_externally global: '") +
380  GV.getName() + "'").str());
381  if (GV.hasInternalLinkage())
382  return emitWarning((Twine("Linker asked to preserve internal global: '") +
383  GV.getName() + "'").str());
384  Used.push_back(&GV);
385  };
386  for (auto &GV : TheModule)
387  mayPreserveGlobal(GV);
388  for (auto &GV : TheModule.globals())
389  mayPreserveGlobal(GV);
390  for (auto &GV : TheModule.aliases())
391  mayPreserveGlobal(GV);
392 
393  if (Used.empty())
394  return;
395 
396  appendToCompilerUsed(TheModule, Used);
397 }
398 
399 void LTOCodeGenerator::applyScopeRestrictions() {
400  if (ScopeRestrictionsDone)
401  return;
402 
403  // Declare a callback for the internalize pass that will ask for every
404  // candidate GlobalValue if it can be internalized or not.
405  Mangler Mang;
406  SmallString<64> MangledName;
407  auto mustPreserveGV = [&](const GlobalValue &GV) -> bool {
408  // Unnamed globals can't be mangled, but they can't be preserved either.
409  if (!GV.hasName())
410  return false;
411 
412  // Need to mangle the GV as the "MustPreserveSymbols" StringSet is filled
413  // with the linker supplied name, which on Darwin includes a leading
414  // underscore.
415  MangledName.clear();
416  MangledName.reserve(GV.getName().size() + 1);
417  Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
418  return MustPreserveSymbols.count(MangledName);
419  };
420 
421  // Preserve linkonce value on linker request
422  preserveDiscardableGVs(*MergedModule, mustPreserveGV);
423 
424  if (!ShouldInternalize)
425  return;
426 
427  if (ShouldRestoreGlobalsLinkage) {
428  // Record the linkage type of non-local symbols so they can be restored
429  // prior
430  // to module splitting.
431  auto RecordLinkage = [&](const GlobalValue &GV) {
432  if (!GV.hasAvailableExternallyLinkage() && !GV.hasLocalLinkage() &&
433  GV.hasName())
434  ExternalSymbols.insert(std::make_pair(GV.getName(), GV.getLinkage()));
435  };
436  for (auto &GV : *MergedModule)
437  RecordLinkage(GV);
438  for (auto &GV : MergedModule->globals())
439  RecordLinkage(GV);
440  for (auto &GV : MergedModule->aliases())
441  RecordLinkage(GV);
442  }
443 
444  // Update the llvm.compiler_used globals to force preserving libcalls and
445  // symbols referenced from asm
446  updateCompilerUsed(*MergedModule, *TargetMach, AsmUndefinedRefs);
447 
448  internalizeModule(*MergedModule, mustPreserveGV);
449 
450  ScopeRestrictionsDone = true;
451 }
452 
453 /// Restore original linkage for symbols that may have been internalized
454 void LTOCodeGenerator::restoreLinkageForExternals() {
455  if (!ShouldInternalize || !ShouldRestoreGlobalsLinkage)
456  return;
457 
458  assert(ScopeRestrictionsDone &&
459  "Cannot externalize without internalization!");
460 
461  if (ExternalSymbols.empty())
462  return;
463 
464  auto externalize = [this](GlobalValue &GV) {
465  if (!GV.hasLocalLinkage() || !GV.hasName())
466  return;
467 
468  auto I = ExternalSymbols.find(GV.getName());
469  if (I == ExternalSymbols.end())
470  return;
471 
472  GV.setLinkage(I->second);
473  };
474 
475  llvm::for_each(MergedModule->functions(), externalize);
476  llvm::for_each(MergedModule->globals(), externalize);
477  llvm::for_each(MergedModule->aliases(), externalize);
478 }
479 
480 void LTOCodeGenerator::verifyMergedModuleOnce() {
481  // Only run on the first call.
482  if (HasVerifiedInput)
483  return;
484  HasVerifiedInput = true;
485 
486  bool BrokenDebugInfo = false;
487  if (verifyModule(*MergedModule, &dbgs(), &BrokenDebugInfo))
488  report_fatal_error("Broken module found, compilation aborted!");
489  if (BrokenDebugInfo) {
490  emitWarning("Invalid debug info found, debug info will be stripped");
491  StripDebugInfo(*MergedModule);
492  }
493 }
494 
495 void LTOCodeGenerator::finishOptimizationRemarks() {
496  if (DiagnosticOutputFile) {
497  DiagnosticOutputFile->keep();
498  // FIXME: LTOCodeGenerator dtor is not invoked on Darwin
499  DiagnosticOutputFile->os().flush();
500  }
501 }
502 
503 /// Optimize merged modules using various IPO passes
505  if (!this->determineTarget())
506  return false;
507 
508  auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
511  if (!DiagFileOrErr) {
512  errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
513  report_fatal_error("Can't get an output file for the remarks");
514  }
515  DiagnosticOutputFile = std::move(*DiagFileOrErr);
516 
517  // Setup output file to emit statistics.
518  auto StatsFileOrErr = lto::setupStatsFile(LTOStatsFile);
519  if (!StatsFileOrErr) {
520  errs() << "Error: " << toString(StatsFileOrErr.takeError()) << "\n";
521  report_fatal_error("Can't get an output file for the statistics");
522  }
523  StatsFile = std::move(StatsFileOrErr.get());
524 
525  // Currently there is no support for enabling whole program visibility via a
526  // linker option in the old LTO API, but this call allows it to be specified
527  // via the internal option. Must be done before WPD invoked via the optimizer
528  // pipeline run below.
529  updateVCallVisibilityInModule(*MergedModule,
530  /* WholeProgramVisibilityEnabledInLTO */ false,
531  // FIXME: This needs linker information via a
532  // TBD new interface.
533  /* DynamicExportSymbols */ {});
534 
535  // We always run the verifier once on the merged module, the `DisableVerify`
536  // parameter only applies to subsequent verify.
537  verifyMergedModuleOnce();
538 
539  // Mark which symbols can not be internalized
540  this->applyScopeRestrictions();
541 
542  // Write LTOPostLink flag for passes that require all the modules.
543  MergedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
544 
545  // Add an appropriate DataLayout instance for this module...
546  MergedModule->setDataLayout(TargetMach->createDataLayout());
547 
548  ModuleSummaryIndex CombinedIndex(false);
549  TargetMach = createTargetMachine();
550  if (!opt(Config, TargetMach.get(), 0, *MergedModule, /*IsThinLTO=*/false,
551  /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
552  /*CmdArgs*/ std::vector<uint8_t>())) {
553  emitError("LTO middle-end optimizations failed");
554  return false;
555  }
556 
557  return true;
558 }
559 
561  unsigned ParallelismLevel) {
562  if (!this->determineTarget())
563  return false;
564 
565  // We always run the verifier once on the merged module. If it has already
566  // been called in optimize(), this call will return early.
567  verifyMergedModuleOnce();
568 
569  // Re-externalize globals that may have been internalized to increase scope
570  // for splitting
571  restoreLinkageForExternals();
572 
573  ModuleSummaryIndex CombinedIndex(false);
574 
575  Config.CodeGenOnly = true;
576  Error Err = backend(Config, AddStream, ParallelismLevel, *MergedModule,
577  CombinedIndex);
578  assert(!Err && "unexpected code-generation failure");
579  (void)Err;
580 
581  // If statistics were requested, save them to the specified file or
582  // print them out after codegen.
583  if (StatsFile)
584  PrintStatisticsJSON(StatsFile->os());
585  else if (AreStatisticsEnabled())
586  PrintStatistics();
587 
589 
590  finishOptimizationRemarks();
591 
592  return true;
593 }
594 
596  for (StringRef Option : Options)
597  CodegenOptions.push_back(Option.str());
598 }
599 
601  if (!CodegenOptions.empty())
602  llvm::parseCommandLineOptions(CodegenOptions);
603 }
604 
605 void llvm::parseCommandLineOptions(std::vector<std::string> &Options) {
606  if (!Options.empty()) {
607  // ParseCommandLineOptions() expects argv[0] to be program name.
608  std::vector<const char *> CodegenArgv(1, "libLLVMLTO");
609  for (std::string &Arg : Options)
610  CodegenArgv.push_back(Arg.c_str());
611  cl::ParseCommandLineOptions(CodegenArgv.size(), CodegenArgv.data());
612  }
613 }
614 
616  // Map the LLVM internal diagnostic severity to the LTO diagnostic severity.
618  switch (DI.getSeverity()) {
619  case DS_Error:
620  Severity = LTO_DS_ERROR;
621  break;
622  case DS_Warning:
623  Severity = LTO_DS_WARNING;
624  break;
625  case DS_Remark:
626  Severity = LTO_DS_REMARK;
627  break;
628  case DS_Note:
629  Severity = LTO_DS_NOTE;
630  break;
631  }
632  // Create the string that will be reported to the external diagnostic handler.
633  std::string MsgStorage;
634  raw_string_ostream Stream(MsgStorage);
636  DI.print(DP);
637  Stream.flush();
638 
639  // If this method has been called it means someone has set up an external
640  // diagnostic handler. Assert on that.
641  assert(DiagHandler && "Invalid diagnostic handler");
642  (*DiagHandler)(Severity, MsgStorage.c_str(), DiagContext);
643 }
644 
645 namespace {
646 struct LTODiagnosticHandler : public DiagnosticHandler {
647  LTOCodeGenerator *CodeGenerator;
648  LTODiagnosticHandler(LTOCodeGenerator *CodeGenPtr)
649  : CodeGenerator(CodeGenPtr) {}
650  bool handleDiagnostics(const DiagnosticInfo &DI) override {
651  CodeGenerator->DiagnosticHandler(DI);
652  return true;
653  }
654 };
655 }
656 
657 void
659  void *Ctxt) {
660  this->DiagHandler = DiagHandler;
661  this->DiagContext = Ctxt;
662  if (!DiagHandler)
663  return Context.setDiagnosticHandler(nullptr);
664  // Register the LTOCodeGenerator stub in the LLVMContext to forward the
665  // diagnostic to the external DiagHandler.
666  Context.setDiagnosticHandler(std::make_unique<LTODiagnosticHandler>(this),
667  true);
668 }
669 
670 namespace {
671 class LTODiagnosticInfo : public DiagnosticInfo {
672  const Twine &Msg;
673 public:
674  LTODiagnosticInfo(const Twine &DiagMsg, DiagnosticSeverity Severity=DS_Error)
675  : DiagnosticInfo(DK_Linker, Severity), Msg(DiagMsg) {}
676  void print(DiagnosticPrinter &DP) const override { DP << Msg; }
677 };
678 }
679 
680 void LTOCodeGenerator::emitError(const std::string &ErrMsg) {
681  if (DiagHandler)
682  (*DiagHandler)(LTO_DS_ERROR, ErrMsg.c_str(), DiagContext);
683  else
684  Context.diagnose(LTODiagnosticInfo(ErrMsg));
685 }
686 
687 void LTOCodeGenerator::emitWarning(const std::string &ErrMsg) {
688  if (DiagHandler)
689  (*DiagHandler)(LTO_DS_WARNING, ErrMsg.c_str(), DiagContext);
690  else
691  Context.diagnose(LTODiagnosticInfo(ErrMsg, DS_Warning));
692 }
llvm::RemarksPasses
cl::opt< std::string > RemarksPasses("lto-pass-remarks-filter", cl::desc("Only record optimization remarks from passes whose " "names match the given regular expression"), cl::value_desc("regex"))
Definition: ThinLTOCodeGenerator.cpp:81
i
i
Definition: README.txt:29
MemoryBuffer.h
llvm::LLVMContext::enableDebugTypeODRUniquing
void enableDebugTypeODRUniquing()
Definition: LLVMContext.cpp:322
lto_codegen_diagnostic_severity_t
lto_codegen_diagnostic_severity_t
Diagnostic severity.
Definition: lto.h:330
llvm::LTOCodeGenerator::setCodeGenDebugOptions
void setCodeGenDebugOptions(ArrayRef< StringRef > Opts)
Pass options to the driver and optimization passes.
Definition: LTOCodeGenerator.cpp:595
Signals.h
llvm::StripDebugInfo
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:476
llvm::LTOCodeGenerator::setDiagnosticHandler
void setDiagnosticHandler(lto_diagnostic_handler_t, void *)
Definition: LTOCodeGenerator.cpp:658
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::reportAndResetTimings
void reportAndResetTimings(raw_ostream *OutStream=nullptr)
If -time-passes has been specified, report the timings immediately and then reset the timers to zero.
Definition: PassTimingInfo.cpp:162
llvm::raw_fd_ostream::close
void close()
Manually flush the stream and close the file.
Definition: raw_ostream.cpp:792
mustPreserveGV
static bool mustPreserveGV(const GlobalValue &GV)
Predicate for Internalize pass.
Definition: AMDGPUTargetMachine.cpp:518
FileSystem.h
llvm::sys::fs::OF_None
@ OF_None
Definition: FileSystem.h:757
llvm::ToolOutputFile
This class contains a raw_fd_ostream and adds a few extra features commonly needed for compiler-like ...
Definition: ToolOutputFile.h:26
LTO_DEBUG_MODEL_NONE
@ LTO_DEBUG_MODEL_NONE
Definition: lto.h:80
print
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
Definition: ArchiveWriter.cpp:147
llvm::LTOCodeGenerator::parseCodeGenDebugOptions
void parseCodeGenDebugOptions()
Parse the options set in setCodeGenDebugOptions.
Definition: LTOCodeGenerator.cpp:600
llvm::TargetOptions
Definition: TargetOptions.h:124
LTO_DS_NOTE
@ LTO_DS_NOTE
Definition: lto.h:334
LTO_DS_REMARK
@ LTO_DS_REMARK
Definition: lto.h:333
llvm::lto::Config::CGOptLevel
CodeGenOpt::Level CGOptLevel
Definition: Config.h:55
llvm::LTOStatsFile
cl::opt< std::string > LTOStatsFile("lto-stats-file", cl::desc("Save statistics to the specified file"), cl::Hidden)
llvm::DiagnosticPrinterRawOStream
Basic diagnostic printer that uses an underlying raw_ostream.
Definition: DiagnosticPrinter.h:61
llvm::lto::Config::CodeModel
Optional< CodeModel::Model > CodeModel
Definition: Config.h:54
llvm::Triple::x86
@ x86
Definition: Triple.h:83
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:625
llvm::toString
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:1020
Host.h
Statistic.h
llvm::RemarksFilename
cl::opt< std::string > RemarksFilename("lto-pass-remarks-output", cl::desc("Output filename for pass remarks"), cl::value_desc("filename"))
Definition: ThinLTOCodeGenerator.cpp:80
llvm::LTOCodeGenerator::LTOCodeGenerator
LTOCodeGenerator(LLVMContext &Context)
Definition: LTOCodeGenerator.cpp:122
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
llvm::LTOCodeGenerator::setDebugInfo
void setDebugInfo(lto_debug_model)
Definition: LTOCodeGenerator.cpp:174
llvm::DiagnosticInfo::print
virtual void print(DiagnosticPrinter &DP) const =0
Print using the given DP a user-friendly message.
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::LTOCodeGenerator::setTargetOptions
void setTargetOptions(const TargetOptions &Options)
Definition: LTOCodeGenerator.cpp:170
externalize
static void externalize(GlobalValue *GV)
Definition: SplitModule.cpp:214
llvm::DK_Linker
@ DK_Linker
Definition: DiagnosticInfo.h:59
llvm::StringMap::end
iterator end()
Definition: StringMap.h:203
ParallelCG.h
Module.h
llvm::Triple::x86_64
@ x86_64
Definition: Triple.h:84
llvm::RemarksHotnessThreshold
cl::opt< Optional< uint64_t >, false, remarks::HotnessThresholdParser > RemarksHotnessThreshold("lto-pass-remarks-hotness-threshold", cl::desc("Minimum profile count required for an " "optimization remark to be output." " Use 'auto' to apply the threshold from profile summary."), cl::value_desc("uint or 'auto'"), cl::init(0), cl::Hidden)
Definition: ThinLTOCodeGenerator.cpp:84
llvm::DiagnosticHandler
This is the base class for diagnostic handling in LLVM.
Definition: DiagnosticHandler.h:24
llvm::ToolOutputFile::keep
void keep()
Indicate that the tool's job wrt this output file has been successful and the file should not be dele...
Definition: ToolOutputFile.h:66
UpdateCompilerUsed.h
ret
to esp esp setne al movzbw ax esp setg cl movzbw cx cmove cx cl jne LBB1_2 esp ret(also really horrible code on ppc). This is due to the expand code for 64-bit compares. GCC produces multiple branches
llvm::LTOCodeGenerator::compile_to_file
bool compile_to_file(const char **Name)
Compile the merged module into a single output file; the path to output file is returned to the calle...
Definition: LTOCodeGenerator.cpp:302
llvm::RemarksWithHotness
cl::opt< bool > RemarksWithHotness("lto-pass-remarks-with-hotness", cl::desc("With PGO, include profile count in optimization remarks"), cl::Hidden)
Definition: ThinLTOCodeGenerator.cpp:82
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
llvm::StringSet::insert
std::pair< typename Base::iterator, bool > insert(StringRef key)
Definition: StringSet.h:33
llvm::lto::setupLLVMOptimizationRemarks
Expected< std::unique_ptr< ToolOutputFile > > setupLLVMOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses, StringRef RemarksFormat, bool RemarksWithHotness, Optional< uint64_t > RemarksHotnessThreshold=0, int Count=-1)
Setup optimization remarks.
Definition: LTO.cpp:1572
llvm::StringMap::find
iterator find(StringRef Key)
Definition: StringMap.h:216
llvm::Mangler
Definition: Mangler.h:27
llvm::Triple::aarch64_32
@ aarch64_32
Definition: Triple.h:54
llvm::lto::Config::CodeGenOnly
bool CodeGenOnly
Disable entirely the optimizer, including importing for ThinLTO.
Definition: Config.h:68
llvm::LTOCodeGenerator::setOptLevel
void setOptLevel(unsigned OptLevel)
Definition: LTOCodeGenerator.cpp:187
llvm::TargetRegistry::lookupTarget
static const Target * lookupTarget(const std::string &Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
Definition: TargetRegistry.cpp:62
LTO_DS_WARNING
@ LTO_DS_WARNING
Definition: lto.h:332
LegacyPassManager.h
PassManagerBuilder.h
Internalize.h
endif
__FakeVCSRevision h endif() endif() set(generated_files "$
Definition: CMakeLists.txt:16
llvm::lto::setupStatsFile
Expected< std::unique_ptr< ToolOutputFile > > setupStatsFile(StringRef StatsFilename)
Setups the output file for saving statistics.
Definition: LTO.cpp:1597
new
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM ID Predecessors according to mbb< bb27, 0x8b0a7c0 > Note ADDri is not a two address instruction its result reg1037 is an operand of the PHI node in bb76 and its operand reg1039 is the result of the PHI node We should treat it as a two address code and make sure the ADDri is scheduled after any node that reads reg1039 Use info(i.e. register scavenger) to assign it a free register to allow reuse the collector could move the objects and invalidate the derived pointer This is bad enough in the first but safe points can crop up unpredictably **array_addr i32 n y store obj * new
Definition: README.txt:125
llvm::LTOCodeGenerator::addModule
bool addModule(struct LTOModule *)
Merge given module.
Definition: LTOCodeGenerator.cpp:143
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
PassTimingInfo.h
CommandLine.h
llvm::MemoryBuffer::getFile
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Definition: MemoryBuffer.cpp:246
llvm::AreStatisticsEnabled
bool AreStatisticsEnabled()
Check if statistics are enabled.
Definition: Statistic.cpp:138
llvm::LTOCodeGenerator::compile
std::unique_ptr< MemoryBuffer > compile()
As with compile_to_file(), this function compiles the merged module into single output file.
Definition: LTOCodeGenerator.cpp:309
SubtargetFeature.h
Constants.h
llvm::raw_fd_ostream::has_error
bool has_error() const
Return the value of the flag in this raw_fd_ostream indicating whether an output error has been encou...
Definition: raw_ostream.h:531
llvm::Triple::isOSDarwin
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (macOS, iOS, tvOS or watchOS).
Definition: Triple.h:484
llvm::DS_Warning
@ DS_Warning
Definition: DiagnosticInfo.h:46
Linker.h
BitcodeWriter.h
llvm::raw_fd_ostream::clear_error
void clear_error()
Set the flag read by has_error() to false.
Definition: raw_ostream.h:542
llvm::LTODiscardValueNames
cl::opt< bool > LTODiscardValueNames("lto-discard-value-names", cl::desc("Strip names from Value during LTO (other than GlobalValue)."), cl::init(false), cl::Hidden)
Definition: ThinLTOCodeGenerator.cpp:79
llvm::StringMap::insert
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:274
MCContext.h
llvm::lto::Config::Options
TargetOptions Options
Definition: Config.h:48
llvm::lto::Config::PreCodeGenPassesHook
std::function< void(legacy::PassManager &)> PreCodeGenPassesHook
For adding passes that run right before codegen.
Definition: Config.h:52
llvm::cl::ParseCommandLineOptions
bool ParseCommandLineOptions(int argc, const char *const *argv, StringRef Overview="", raw_ostream *Errs=nullptr, const char *EnvVar=nullptr, bool LongOptionsUseDoubleDash=false)
Definition: CommandLine.cpp:1297
llvm::SubtargetFeatures
Manages the enabling and disabling of subtarget specific features.
Definition: SubtargetFeature.h:183
HotnessThresholdParser.h
TargetLibraryInfo.h
llvm::ErrorOr::getError
std::error_code getError() const
Definition: ErrorOr.h:153
llvm::Mangler::getNameWithPrefix
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
Definition: Mangler.cpp:114
llvm::LTOCodeGenerator::compileOptimized
std::unique_ptr< MemoryBuffer > compileOptimized()
Compiles the merged optimized module into a single output file.
Definition: LTOCodeGenerator.cpp:282
opt
arm prera ldst opt
Definition: ARMLoadStoreOptimizer.cpp:2191
llvm::DiagnosticSeverity
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
Definition: DiagnosticInfo.h:44
LTOModule.h
llvm::StringMap::clear
void clear()
Definition: StringMap.h:346
llvm::appendToCompilerUsed
void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.compiler.used list.
Definition: ModuleUtils.cpp:110
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:186
llvm::DiagnosticInfo::getSeverity
DiagnosticSeverity getSeverity() const
Definition: DiagnosticInfo.h:117
llvm::LTOCodeGenerator::optimize
bool optimize()
Optimizes the merged module.
Definition: LTOCodeGenerator.cpp:504
llvm::DiagnosticInfo
This is the base abstract class for diagnostic reporting in the backend.
Definition: DiagnosticInfo.h:102
llvm::DiagnosticPrinter
Interface for custom diagnostic printing.
Definition: DiagnosticPrinter.h:31
llvm::LLVMContext::setDiagnosticHandler
void setDiagnosticHandler(std::unique_ptr< DiagnosticHandler > &&DH, bool RespectFilters=false)
setDiagnosticHandler - This method sets unique_ptr to object of DiagnosticHandler to provide custom d...
Definition: LLVMContext.cpp:122
llvm::Triple::getArch
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:307
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:245
llvm::None
const NoneType None
Definition: None.h:23
llvm::lto::Config::StatsFile
std::string StatsFile
Statistics output file path.
Definition: Config.h:163
lto_debug_model
lto_debug_model
Definition: lto.h:79
llvm::SmallString< 128 >
llvm::RemarksFormat
cl::opt< std::string > RemarksFormat("lto-pass-remarks-format", cl::desc("The format used for serializing remarks (default: YAML)"), cl::value_desc("format"), cl::init("yaml"))
Definition: ThinLTOCodeGenerator.cpp:85
LTOBackend.h
llvm::lto::Config::OptLevel
unsigned OptLevel
Definition: Config.h:57
llvm::LTOCodeGenerator::DiagnosticHandler
void DiagnosticHandler(const DiagnosticInfo &DI)
Definition: LTOCodeGenerator.cpp:615
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:168
llvm::LTOCodeGenerator::getVersionString
static const char * getVersionString()
Definition: LTOCodeGenerator.cpp:68
llvm::cl::opt< bool >
llvm::SmallString::c_str
const char * c_str()
Definition: SmallString.h:262
llvm::PrintStatisticsJSON
void PrintStatisticsJSON(raw_ostream &OS)
Print statistics in JSON format.
Definition: Statistic.cpp:205
llvm::lto::backend
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:505
llvm::parseCommandLineOptions
void parseCommandLineOptions(std::vector< std::string > &Options)
A convenience function that calls cl::ParseCommandLineOptions on the given set of options.
Definition: LTOCodeGenerator.cpp:605
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::CodeGenOpt::Default
@ Default
Definition: CodeGen.h:55
llvm::LTOCodeGenerator::~LTOCodeGenerator
~LTOCodeGenerator()
Definition: LTOCodeGenerator.cpp:135
llvm::for_each
UnaryFunction for_each(R &&Range, UnaryFunction F)
Provide wrappers to std::for_each which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1544
llvm::DS_Remark
@ DS_Remark
Definition: DiagnosticInfo.h:47
llvm::remarks::HotnessThresholdParser
Definition: HotnessThresholdParser.h:45
IPO.h
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
DebugInfo.h
llvm::LTOCodeGenerator
C++ class which implements the opaque lto_code_gen_t type.
Definition: LTOCodeGenerator.h:72
I
#define I(x, y, z)
Definition: MD5.cpp:59
Debug
bool Debug
Definition: PassBuilderBindings.cpp:51
StringExtras.h
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
ToolOutputFile.h
LTO_DS_ERROR
@ LTO_DS_ERROR
Definition: lto.h:331
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::PipelineTuningOptions::SLPVectorization
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition: PassBuilder.h:52
lto_diagnostic_handler_t
void(* lto_diagnostic_handler_t)(lto_codegen_diagnostic_severity_t severity, const char *diag, void *ctxt)
Diagnostic handler type.
Definition: lto.h:346
PreferPredicateTy::Option
Option
Definition: LoopVectorize.cpp:212
llvm::lto::Config::MAttrs
std::vector< std::string > MAttrs
Definition: Config.h:49
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
NDEBUG
#define NDEBUG
Definition: regutils.h:48
llvm::updateCompilerUsed
void updateCompilerUsed(Module &TheModule, const TargetMachine &TM, const StringSet<> &AsmUndefinedRefs)
Find all globals in TheModule that are referenced in AsmUndefinedRefs, as well as the user-supplied f...
Definition: UpdateCompilerUsed.cpp:123
llvm::CodeGenOpt::Aggressive
@ Aggressive
Definition: CodeGen.h:56
llvm::PrintStatistics
void PrintStatistics()
Print statistics to the file returned by CreateInfoOutputFile().
Definition: Statistic.cpp:231
llvm::Linker
This class provides the core functionality of linking in LLVM.
Definition: Linker.h:24
llvm::internalizeModule
bool internalizeModule(Module &TheModule, std::function< bool(const GlobalValue &)> MustPreserveGV, CallGraph *CG=nullptr)
Helper function to internalize functions and variables in a Module.
Definition: Internalize.h:80
Mangler.h
YAMLTraits.h
llvm::CodeGenOpt::None
@ None
Definition: CodeGen.h:53
llvm::WriteBitcodeToFile
void WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false, ModuleHash *ModHash=nullptr)
Write the specified module to the specified raw output stream.
Definition: BitcodeWriter.cpp:4639
llvm::sys::fs::remove
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
TargetOptions.h
llvm::raw_fd_ostream::error
std::error_code error() const
Definition: raw_ostream.h:525
llvm::sys::fs::createTemporaryFile
std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD, SmallVectorImpl< char > &ResultPath, OpenFlags Flags=OF_None)
Create a file in the system temporary directory.
Definition: Path.cpp:858
llvm::sys::getDefaultTargetTriple
std::string getDefaultTargetTriple()
getDefaultTargetTriple() - Return the default target triple the compiler has been configured to produ...
llvm::LTOCodeGenerator::setModule
void setModule(std::unique_ptr< LTOModule > M)
Set the destination module.
Definition: LTOCodeGenerator.cpp:156
Extension
Definition: AArch64AsmParser.cpp:3254
llvm::lto::Config::RelocModel
Optional< Reloc::Model > RelocModel
Definition: Config.h:53
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::updateVCallVisibilityInModule
void updateVCallVisibilityInModule(Module &M, bool WholeProgramVisibilityEnabledInLTO, const DenseSet< GlobalValue::GUID > &DynamicExportSymbols)
If whole program visibility asserted, then upgrade all public vcall visibility metadata on vtable def...
Definition: WholeProgramDevirt.cpp:794
DiagHandler
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
Definition: TextStub.cpp:1095
MCAsmInfo.h
DataLayout.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
TargetSubtargetInfo.h
llvm::PipelineTuningOptions::LoopVectorization
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition: PassBuilder.h:48
llvm::PICLevel::Level
Level
Definition: CodeGen.h:33
llvm::Module::Error
@ Error
Emits an error if two values disagree, otherwise the resulting value is that of the operands.
Definition: Module.h:120
llvm::LTOCodeGenerator::writeMergedModules
bool writeMergedModules(StringRef Path)
Write the merged module to the file specified by the given path.
Definition: LTOCodeGenerator.cpp:208
name
static const char * name
Definition: SVEIntrinsicOpts.cpp:78
llvm::LLVMContext::diagnose
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
Definition: LLVMContext.cpp:228
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
Verifier.h
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::lto::AddStreamFn
std::function< std::unique_ptr< NativeObjectStream >(unsigned Task)> AddStreamFn
This type defines the callback to add a native object that is generated on the fly.
Definition: LTO.h:206
LLVMRemarkStreamer.h
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::legacy::PassManager
PassManager manages ModulePassManagers.
Definition: LegacyPassManager.h:52
llvm::ToolOutputFile::os
raw_fd_ostream & os()
Return the contained raw_fd_ostream.
Definition: ToolOutputFile.h:59
llvm::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:261
DiagnosticInfo.h
llvm::Triple::isArm64e
bool isArm64e() const
Tests whether the target is the Apple "arm64e" AArch64 subarch.
Definition: Triple.h:803
llvm::LLVMContext::setDiscardValueNames
void setDiscardValueNames(bool Discard)
Set the Context runtime configuration to discard all value name (but GlobalValue).
Definition: LLVMContext.cpp:331
DP
So we should use XX3Form_Rcr to implement instrinsic Convert DP outs ins xscvdpsp No builtin are required Round &Convert QP DP(dword[1] is set to zero) No builtin are required Round to Quad Precision because you need to assign rounding mode in instruction Provide builtin(set f128:$vT,(int_ppc_vsx_xsrqpi f128:$vB))(set f128 yields< n x< ty > >< result > yields< ty >< result > No builtin are required Load Store load store see def memrix16 in PPCInstrInfo td Load Store Vector load store outs ins lxsdx set load store with conversion from to DP
Definition: README_P9.txt:520
llvm::cl::value_desc
Definition: CommandLine.h:424
llvm::lto::Config::PTO
PipelineTuningOptions PTO
Tunable parameters for passes in the default pipelines.
Definition: Config.h:187
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:585
llvm::StringMap::count
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:244
LTO_DEBUG_MODEL_DWARF
@ LTO_DEBUG_MODEL_DWARF
Definition: lto.h:81
WholeProgramDevirt.h
llvm::lto::Config::CGFileType
CodeGenFileType CGFileType
Definition: Config.h:56
llvm::StringMapImpl::empty
bool empty() const
Definition: StringMap.h:92
ObjCARC.h
LTO.h
llvm::ModuleSummaryIndex
Class to hold module path string table and global value map, and encapsulate methods for operating on...
Definition: ModuleSummaryIndex.h:1028
ModuleUtils.h
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
TargetTransformInfo.h
DerivedTypes.h
TargetSelect.h
llvm::lto::Config::CPU
std::string CPU
Definition: Config.h:47
LLVMContext.h
llvm::LTOCodeGenerator::setAsmUndefinedRefs
void setAsmUndefinedRefs(struct LTOModule *)
Definition: LTOCodeGenerator.cpp:137
llvm::createObjCARCContractPass
Pass * createObjCARCContractPass()
Definition: ObjCARCContract.cpp:731
llvm::cl::desc
Definition: CommandLine.h:414
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
llvm::CGFT_AssemblyFile
@ CGFT_AssemblyFile
Definition: CodeGen.h:64
raw_ostream.h
llvm::CodeGenOpt::Less
@ Less
Definition: CodeGen.h:54
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:624
DiagnosticPrinter.h
TargetRegistry.h
InitializePasses.h
llvm::LTOModule
C++ class which implements the opaque lto_module_t type.
Definition: LTOModule.h:38
llvm::DS_Error
@ DS_Error
Definition: DiagnosticInfo.h:45
llvm::Triple::aarch64
@ aarch64
Definition: Triple.h:52
llvm::verifyModule
bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
Definition: Verifier.cpp:5826
Passes.h
llvm::Target::createTargetMachine
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM=None, CodeGenOpt::Level OL=CodeGenOpt::Default, bool JIT=false) const
createTargetMachine - Create a target specific machine implementation for the specified Triple.
Definition: TargetRegistry.h:449
llvm::DS_Note
@ DS_Note
Definition: DiagnosticInfo.h:50
LTOCodeGenerator.h