LLVM  15.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"
47 #include "llvm/MC/TargetRegistry.h"
51 #include "llvm/Support/Host.h"
53 #include "llvm/Support/Signals.h"
59 #include "llvm/Transforms/IPO.h"
65 #include <system_error>
66 using namespace llvm;
67 
69  return PACKAGE_NAME " version " PACKAGE_VERSION;
70 }
71 
72 namespace llvm {
74  "lto-discard-value-names",
75  cl::desc("Strip names from Value during LTO (other than GlobalValue)."),
76 #ifdef NDEBUG
77  cl::init(true),
78 #else
79  cl::init(false),
80 #endif
81  cl::Hidden);
82 
84  "lto-pass-remarks-with-hotness",
85  cl::desc("With PGO, include profile count in optimization remarks"),
86  cl::Hidden);
87 
90  "lto-pass-remarks-hotness-threshold",
91  cl::desc("Minimum profile count required for an "
92  "optimization remark to be output."
93  " Use 'auto' to apply the threshold from profile summary."),
94  cl::value_desc("uint or 'auto'"), cl::init(0), cl::Hidden);
95 
97  RemarksFilename("lto-pass-remarks-output",
98  cl::desc("Output filename for pass remarks"),
99  cl::value_desc("filename"));
100 
102  RemarksPasses("lto-pass-remarks-filter",
103  cl::desc("Only record optimization remarks from passes whose "
104  "names match the given regular expression"),
105  cl::value_desc("regex"));
106 
108  "lto-pass-remarks-format",
109  cl::desc("The format used for serializing remarks (default: YAML)"),
110  cl::value_desc("format"), cl::init("yaml"));
111 
113  "lto-stats-file",
114  cl::desc("Save statistics to the specified file"),
115  cl::Hidden);
116 }
117 
119  : Context(Context), MergedModule(new Module("ld-temp.o", Context)),
120  TheLinker(new Linker(*MergedModule)) {
123 
124  Config.CodeModel = None;
125  Config.StatsFile = LTOStatsFile;
126  Config.PreCodeGenPassesHook = [](legacy::PassManager &PM) {
127  PM.add(createObjCARCContractPass());
128  };
129 }
130 
132 
134  for (const StringRef &Undef : Mod->getAsmUndefinedRefs())
135  AsmUndefinedRefs.insert(Undef);
136 }
137 
139  assert(&Mod->getModule().getContext() == &Context &&
140  "Expected module in same context");
141 
142  bool ret = TheLinker->linkInModule(Mod->takeModule());
144 
145  // We've just changed the input, so let's make sure we verify it.
146  HasVerifiedInput = false;
147 
148  return !ret;
149 }
150 
151 void LTOCodeGenerator::setModule(std::unique_ptr<LTOModule> Mod) {
152  assert(&Mod->getModule().getContext() == &Context &&
153  "Expected module in same context");
154 
155  AsmUndefinedRefs.clear();
156 
157  MergedModule = Mod->takeModule();
158  TheLinker = std::make_unique<Linker>(*MergedModule);
160 
161  // We've just changed the input, so let's make sure we verify it.
162  HasVerifiedInput = false;
163 }
164 
166  Config.Options = Options;
167 }
168 
170  switch (Debug) {
172  EmitDwarfDebugInfo = false;
173  return;
174 
176  EmitDwarfDebugInfo = true;
177  return;
178  }
179  llvm_unreachable("Unknown debug format!");
180 }
181 
183  Config.OptLevel = Level;
184  Config.PTO.LoopVectorization = Config.OptLevel > 1;
185  Config.PTO.SLPVectorization = Config.OptLevel > 1;
186  switch (Config.OptLevel) {
187  case 0:
188  Config.CGOptLevel = CodeGenOpt::None;
189  return;
190  case 1:
191  Config.CGOptLevel = CodeGenOpt::Less;
192  return;
193  case 2:
195  return;
196  case 3:
198  return;
199  }
200  llvm_unreachable("Unknown optimization level!");
201 }
202 
204  if (!determineTarget())
205  return false;
206 
207  // We always run the verifier once on the merged module.
208  verifyMergedModuleOnce();
209 
210  // mark which symbols can not be internalized
211  applyScopeRestrictions();
212 
213  // create output file
214  std::error_code EC;
215  ToolOutputFile Out(Path, EC, sys::fs::OF_None);
216  if (EC) {
217  std::string ErrMsg = "could not open bitcode file for writing: ";
218  ErrMsg += Path.str() + ": " + EC.message();
219  emitError(ErrMsg);
220  return false;
221  }
222 
223  // write bitcode to it
224  WriteBitcodeToFile(*MergedModule, Out.os(), ShouldEmbedUselists);
225  Out.os().close();
226 
227  if (Out.os().has_error()) {
228  std::string ErrMsg = "could not write bitcode file: ";
229  ErrMsg += Path.str() + ": " + Out.os().error().message();
230  emitError(ErrMsg);
231  Out.os().clear_error();
232  return false;
233  }
234 
235  Out.keep();
236  return true;
237 }
238 
239 bool LTOCodeGenerator::compileOptimizedToFile(const char **Name) {
240  // make unique temp output file to put generated code
241  SmallString<128> Filename;
242 
243  auto AddStream = [&](size_t Task) -> std::unique_ptr<CachedFileStream> {
244  StringRef Extension(Config.CGFileType == CGFT_AssemblyFile ? "s" : "o");
245 
246  int FD;
247  std::error_code EC =
248  sys::fs::createTemporaryFile("lto-llvm", Extension, FD, Filename);
249  if (EC)
250  emitError(EC.message());
251 
252  return std::make_unique<CachedFileStream>(
253  std::make_unique<llvm::raw_fd_ostream>(FD, true));
254  };
255 
256  bool genResult = compileOptimized(AddStream, 1);
257 
258  if (!genResult) {
259  sys::fs::remove(Twine(Filename));
260  return false;
261  }
262 
263  // If statistics were requested, save them to the specified file or
264  // print them out after codegen.
265  if (StatsFile)
266  PrintStatisticsJSON(StatsFile->os());
267  else if (AreStatisticsEnabled())
268  PrintStatistics();
269 
270  NativeObjectPath = Filename.c_str();
271  *Name = NativeObjectPath.c_str();
272  return true;
273 }
274 
275 std::unique_ptr<MemoryBuffer>
277  const char *name;
278  if (!compileOptimizedToFile(&name))
279  return nullptr;
280 
281  // read .o file into memory buffer
283  name, /*IsText=*/false, /*RequiresNullTerminator=*/false);
284  if (std::error_code EC = BufferOrErr.getError()) {
285  emitError(EC.message());
286  sys::fs::remove(NativeObjectPath);
287  return nullptr;
288  }
289 
290  // remove temp files
291  sys::fs::remove(NativeObjectPath);
292 
293  return std::move(*BufferOrErr);
294 }
295 
297  if (!optimize())
298  return false;
299 
300  return compileOptimizedToFile(Name);
301 }
302 
303 std::unique_ptr<MemoryBuffer> LTOCodeGenerator::compile() {
304  if (!optimize())
305  return nullptr;
306 
307  return compileOptimized();
308 }
309 
310 bool LTOCodeGenerator::determineTarget() {
311  if (TargetMach)
312  return true;
313 
314  TripleStr = MergedModule->getTargetTriple();
315  if (TripleStr.empty()) {
316  TripleStr = sys::getDefaultTargetTriple();
317  MergedModule->setTargetTriple(TripleStr);
318  }
319  llvm::Triple Triple(TripleStr);
320 
321  // create target machine from info for merged modules
322  std::string ErrMsg;
323  MArch = TargetRegistry::lookupTarget(TripleStr, ErrMsg);
324  if (!MArch) {
325  emitError(ErrMsg);
326  return false;
327  }
328 
329  // Construct LTOModule, hand over ownership of module and target. Use MAttr as
330  // the default set of features.
331  SubtargetFeatures Features(join(Config.MAttrs, ""));
332  Features.getDefaultSubtargetFeatures(Triple);
333  FeatureStr = Features.getString();
334  // Set a default CPU for Darwin triples.
335  if (Config.CPU.empty() && Triple.isOSDarwin()) {
337  Config.CPU = "core2";
338  else if (Triple.getArch() == llvm::Triple::x86)
339  Config.CPU = "yonah";
340  else if (Triple.isArm64e())
341  Config.CPU = "apple-a12";
342  else if (Triple.getArch() == llvm::Triple::aarch64 ||
344  Config.CPU = "cyclone";
345  }
346 
347  TargetMach = createTargetMachine();
348  assert(TargetMach && "Unable to create target machine");
349 
350  return true;
351 }
352 
353 std::unique_ptr<TargetMachine> LTOCodeGenerator::createTargetMachine() {
354  assert(MArch && "MArch is not set!");
355  return std::unique_ptr<TargetMachine>(MArch->createTargetMachine(
356  TripleStr, Config.CPU, FeatureStr, Config.Options, Config.RelocModel,
357  None, Config.CGOptLevel));
358 }
359 
360 // If a linkonce global is present in the MustPreserveSymbols, we need to make
361 // sure we honor this. To force the compiler to not drop it, we add it to the
362 // "llvm.compiler.used" global.
363 void LTOCodeGenerator::preserveDiscardableGVs(
364  Module &TheModule,
366  std::vector<GlobalValue *> Used;
367  auto mayPreserveGlobal = [&](GlobalValue &GV) {
368  if (!GV.isDiscardableIfUnused() || GV.isDeclaration() ||
369  !mustPreserveGV(GV))
370  return;
371  if (GV.hasAvailableExternallyLinkage())
372  return emitWarning(
373  (Twine("Linker asked to preserve available_externally global: '") +
374  GV.getName() + "'").str());
375  if (GV.hasInternalLinkage())
376  return emitWarning((Twine("Linker asked to preserve internal global: '") +
377  GV.getName() + "'").str());
378  Used.push_back(&GV);
379  };
380  for (auto &GV : TheModule)
381  mayPreserveGlobal(GV);
382  for (auto &GV : TheModule.globals())
383  mayPreserveGlobal(GV);
384  for (auto &GV : TheModule.aliases())
385  mayPreserveGlobal(GV);
386 
387  if (Used.empty())
388  return;
389 
390  appendToCompilerUsed(TheModule, Used);
391 }
392 
393 void LTOCodeGenerator::applyScopeRestrictions() {
394  if (ScopeRestrictionsDone)
395  return;
396 
397  // Declare a callback for the internalize pass that will ask for every
398  // candidate GlobalValue if it can be internalized or not.
399  Mangler Mang;
400  SmallString<64> MangledName;
401  auto mustPreserveGV = [&](const GlobalValue &GV) -> bool {
402  // Unnamed globals can't be mangled, but they can't be preserved either.
403  if (!GV.hasName())
404  return false;
405 
406  // Need to mangle the GV as the "MustPreserveSymbols" StringSet is filled
407  // with the linker supplied name, which on Darwin includes a leading
408  // underscore.
409  MangledName.clear();
410  MangledName.reserve(GV.getName().size() + 1);
411  Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
412  return MustPreserveSymbols.count(MangledName);
413  };
414 
415  // Preserve linkonce value on linker request
416  preserveDiscardableGVs(*MergedModule, mustPreserveGV);
417 
418  if (!ShouldInternalize)
419  return;
420 
421  if (ShouldRestoreGlobalsLinkage) {
422  // Record the linkage type of non-local symbols so they can be restored
423  // prior
424  // to module splitting.
425  auto RecordLinkage = [&](const GlobalValue &GV) {
426  if (!GV.hasAvailableExternallyLinkage() && !GV.hasLocalLinkage() &&
427  GV.hasName())
428  ExternalSymbols.insert(std::make_pair(GV.getName(), GV.getLinkage()));
429  };
430  for (auto &GV : *MergedModule)
431  RecordLinkage(GV);
432  for (auto &GV : MergedModule->globals())
433  RecordLinkage(GV);
434  for (auto &GV : MergedModule->aliases())
435  RecordLinkage(GV);
436  }
437 
438  // Update the llvm.compiler_used globals to force preserving libcalls and
439  // symbols referenced from asm
440  updateCompilerUsed(*MergedModule, *TargetMach, AsmUndefinedRefs);
441 
442  internalizeModule(*MergedModule, mustPreserveGV);
443 
444  ScopeRestrictionsDone = true;
445 }
446 
447 /// Restore original linkage for symbols that may have been internalized
448 void LTOCodeGenerator::restoreLinkageForExternals() {
449  if (!ShouldInternalize || !ShouldRestoreGlobalsLinkage)
450  return;
451 
452  assert(ScopeRestrictionsDone &&
453  "Cannot externalize without internalization!");
454 
455  if (ExternalSymbols.empty())
456  return;
457 
458  auto externalize = [this](GlobalValue &GV) {
459  if (!GV.hasLocalLinkage() || !GV.hasName())
460  return;
461 
462  auto I = ExternalSymbols.find(GV.getName());
463  if (I == ExternalSymbols.end())
464  return;
465 
466  GV.setLinkage(I->second);
467  };
468 
469  llvm::for_each(MergedModule->functions(), externalize);
470  llvm::for_each(MergedModule->globals(), externalize);
471  llvm::for_each(MergedModule->aliases(), externalize);
472 }
473 
474 void LTOCodeGenerator::verifyMergedModuleOnce() {
475  // Only run on the first call.
476  if (HasVerifiedInput)
477  return;
478  HasVerifiedInput = true;
479 
480  bool BrokenDebugInfo = false;
481  if (verifyModule(*MergedModule, &dbgs(), &BrokenDebugInfo))
482  report_fatal_error("Broken module found, compilation aborted!");
483  if (BrokenDebugInfo) {
484  emitWarning("Invalid debug info found, debug info will be stripped");
485  StripDebugInfo(*MergedModule);
486  }
487 }
488 
489 void LTOCodeGenerator::finishOptimizationRemarks() {
490  if (DiagnosticOutputFile) {
491  DiagnosticOutputFile->keep();
492  // FIXME: LTOCodeGenerator dtor is not invoked on Darwin
493  DiagnosticOutputFile->os().flush();
494  }
495 }
496 
497 /// Optimize merged modules using various IPO passes
499  if (!this->determineTarget())
500  return false;
501 
502  auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
505  if (!DiagFileOrErr) {
506  errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
507  report_fatal_error("Can't get an output file for the remarks");
508  }
509  DiagnosticOutputFile = std::move(*DiagFileOrErr);
510 
511  // Setup output file to emit statistics.
512  auto StatsFileOrErr = lto::setupStatsFile(LTOStatsFile);
513  if (!StatsFileOrErr) {
514  errs() << "Error: " << toString(StatsFileOrErr.takeError()) << "\n";
515  report_fatal_error("Can't get an output file for the statistics");
516  }
517  StatsFile = std::move(StatsFileOrErr.get());
518 
519  // Currently there is no support for enabling whole program visibility via a
520  // linker option in the old LTO API, but this call allows it to be specified
521  // via the internal option. Must be done before WPD invoked via the optimizer
522  // pipeline run below.
523  updateVCallVisibilityInModule(*MergedModule,
524  /* WholeProgramVisibilityEnabledInLTO */ false,
525  // FIXME: This needs linker information via a
526  // TBD new interface.
527  /* DynamicExportSymbols */ {});
528 
529  // We always run the verifier once on the merged module, the `DisableVerify`
530  // parameter only applies to subsequent verify.
531  verifyMergedModuleOnce();
532 
533  // Mark which symbols can not be internalized
534  this->applyScopeRestrictions();
535 
536  // Write LTOPostLink flag for passes that require all the modules.
537  MergedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
538 
539  // Add an appropriate DataLayout instance for this module...
540  MergedModule->setDataLayout(TargetMach->createDataLayout());
541 
542  ModuleSummaryIndex CombinedIndex(false);
543  TargetMach = createTargetMachine();
544  if (!opt(Config, TargetMach.get(), 0, *MergedModule, /*IsThinLTO=*/false,
545  /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
546  /*CmdArgs*/ std::vector<uint8_t>())) {
547  emitError("LTO middle-end optimizations failed");
548  return false;
549  }
550 
551  return true;
552 }
553 
555  unsigned ParallelismLevel) {
556  if (!this->determineTarget())
557  return false;
558 
559  // We always run the verifier once on the merged module. If it has already
560  // been called in optimize(), this call will return early.
561  verifyMergedModuleOnce();
562 
563  // Re-externalize globals that may have been internalized to increase scope
564  // for splitting
565  restoreLinkageForExternals();
566 
567  ModuleSummaryIndex CombinedIndex(false);
568 
569  Config.CodeGenOnly = true;
570  Error Err = backend(Config, AddStream, ParallelismLevel, *MergedModule,
571  CombinedIndex);
572  assert(!Err && "unexpected code-generation failure");
573  (void)Err;
574 
575  // If statistics were requested, save them to the specified file or
576  // print them out after codegen.
577  if (StatsFile)
578  PrintStatisticsJSON(StatsFile->os());
579  else if (AreStatisticsEnabled())
580  PrintStatistics();
581 
583 
584  finishOptimizationRemarks();
585 
586  return true;
587 }
588 
590  for (StringRef Option : Options)
591  CodegenOptions.push_back(Option.str());
592 }
593 
595  if (!CodegenOptions.empty())
596  llvm::parseCommandLineOptions(CodegenOptions);
597 }
598 
599 void llvm::parseCommandLineOptions(std::vector<std::string> &Options) {
600  if (!Options.empty()) {
601  // ParseCommandLineOptions() expects argv[0] to be program name.
602  std::vector<const char *> CodegenArgv(1, "libLLVMLTO");
603  for (std::string &Arg : Options)
604  CodegenArgv.push_back(Arg.c_str());
605  cl::ParseCommandLineOptions(CodegenArgv.size(), CodegenArgv.data());
606  }
607 }
608 
610  // Map the LLVM internal diagnostic severity to the LTO diagnostic severity.
612  switch (DI.getSeverity()) {
613  case DS_Error:
614  Severity = LTO_DS_ERROR;
615  break;
616  case DS_Warning:
617  Severity = LTO_DS_WARNING;
618  break;
619  case DS_Remark:
620  Severity = LTO_DS_REMARK;
621  break;
622  case DS_Note:
623  Severity = LTO_DS_NOTE;
624  break;
625  }
626  // Create the string that will be reported to the external diagnostic handler.
627  std::string MsgStorage;
628  raw_string_ostream Stream(MsgStorage);
630  DI.print(DP);
631  Stream.flush();
632 
633  // If this method has been called it means someone has set up an external
634  // diagnostic handler. Assert on that.
635  assert(DiagHandler && "Invalid diagnostic handler");
636  (*DiagHandler)(Severity, MsgStorage.c_str(), DiagContext);
637 }
638 
639 namespace {
640 struct LTODiagnosticHandler : public DiagnosticHandler {
641  LTOCodeGenerator *CodeGenerator;
642  LTODiagnosticHandler(LTOCodeGenerator *CodeGenPtr)
643  : CodeGenerator(CodeGenPtr) {}
644  bool handleDiagnostics(const DiagnosticInfo &DI) override {
645  CodeGenerator->DiagnosticHandler(DI);
646  return true;
647  }
648 };
649 }
650 
651 void
653  void *Ctxt) {
654  this->DiagHandler = DiagHandler;
655  this->DiagContext = Ctxt;
656  if (!DiagHandler)
657  return Context.setDiagnosticHandler(nullptr);
658  // Register the LTOCodeGenerator stub in the LLVMContext to forward the
659  // diagnostic to the external DiagHandler.
660  Context.setDiagnosticHandler(std::make_unique<LTODiagnosticHandler>(this),
661  true);
662 }
663 
664 namespace {
665 class LTODiagnosticInfo : public DiagnosticInfo {
666  const Twine &Msg;
667 public:
668  LTODiagnosticInfo(const Twine &DiagMsg, DiagnosticSeverity Severity=DS_Error)
669  : DiagnosticInfo(DK_Linker, Severity), Msg(DiagMsg) {}
670  void print(DiagnosticPrinter &DP) const override { DP << Msg; }
671 };
672 }
673 
674 void LTOCodeGenerator::emitError(const std::string &ErrMsg) {
675  if (DiagHandler)
676  (*DiagHandler)(LTO_DS_ERROR, ErrMsg.c_str(), DiagContext);
677  else
678  Context.diagnose(LTODiagnosticInfo(ErrMsg));
679 }
680 
681 void LTOCodeGenerator::emitWarning(const std::string &ErrMsg) {
682  if (DiagHandler)
683  (*DiagHandler)(LTO_DS_WARNING, ErrMsg.c_str(), DiagContext);
684  else
685  Context.diagnose(LTODiagnosticInfo(ErrMsg, DS_Warning));
686 }
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:79
MemoryBuffer.h
llvm::LLVMContext::enableDebugTypeODRUniquing
void enableDebugTypeODRUniquing()
Definition: LLVMContext.cpp:337
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:589
Signals.h
llvm::StripDebugInfo
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:474
llvm::LTOCodeGenerator::setDiagnosticHandler
void setDiagnosticHandler(lto_diagnostic_handler_t, void *)
Definition: LTOCodeGenerator.cpp:652
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
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:793
mustPreserveGV
static bool mustPreserveGV(const GlobalValue &GV)
Predicate for Internalize pass.
Definition: AMDGPUTargetMachine.cpp:526
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:189
llvm::LTOCodeGenerator::parseCodeGenDebugOptions
void parseCodeGenDebugOptions()
Parse the options set in setCodeGenDebugOptions.
Definition: LTOCodeGenerator.cpp:594
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:85
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:632
Host.h
Statistic.h
llvm::AddStreamFn
std::function< Expected< std::unique_ptr< CachedFileStream > >(unsigned Task)> AddStreamFn
This type defines the callback to add a file that is generated on the fly.
Definition: Caching.h:42
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:78
llvm::LTOCodeGenerator::LTOCodeGenerator
LTOCodeGenerator(LLVMContext &Context)
Definition: LTOCodeGenerator.cpp:118
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
llvm::LTOCodeGenerator::setDebugInfo
void setDebugInfo(lto_debug_model)
Definition: LTOCodeGenerator.cpp:169
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:139
llvm::LTOCodeGenerator::setTargetOptions
void setTargetOptions(const TargetOptions &Options)
Definition: LTOCodeGenerator.cpp:165
externalize
static void externalize(GlobalValue *GV)
Definition: SplitModule.cpp:218
llvm::DK_Linker
@ DK_Linker
Definition: DiagnosticInfo.h:64
llvm::StringMap::end
iterator end()
Definition: StringMap.h:205
ParallelCG.h
llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Used
@ Used
Module.h
llvm::Triple::x86_64
@ x86_64
Definition: Triple.h:86
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:82
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:67
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:296
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:80
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:893
llvm::StringSet::insert
std::pair< typename Base::iterator, bool > insert(StringRef key)
Definition: StringSet.h:34
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:1604
llvm::StringMap::find
iterator find(StringRef Key)
Definition: StringMap.h:218
llvm::Mangler
Definition: Mangler.h:27
llvm::Triple::aarch64_32
@ aarch64_32
Definition: Triple.h:53
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:182
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:1629
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:138
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:186
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:239
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:303
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:535
llvm::Triple::isOSDarwin
bool isOSDarwin() const
Is this a "Darwin" OS (macOS, iOS, tvOS, watchOS, or DriverKit).
Definition: Triple.h:508
llvm::DS_Warning
@ DS_Warning
Definition: DiagnosticInfo.h:51
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:546
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:77
llvm::StringMap::insert
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:276
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:1377
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:119
llvm::LTOCodeGenerator::compileOptimized
std::unique_ptr< MemoryBuffer > compileOptimized()
Compiles the merged optimized module into a single output file.
Definition: LTOCodeGenerator.cpp:276
opt
arm prera ldst opt
Definition: ARMLoadStoreOptimizer.cpp:2191
llvm::DiagnosticSeverity
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
Definition: DiagnosticInfo.h:49
LTOModule.h
llvm::StringMap::clear
void clear()
Definition: StringMap.h:348
llvm::appendToCompilerUsed
void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.compiler.used list.
Definition: ModuleUtils.cpp:109
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:143
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::DiagnosticInfo::getSeverity
DiagnosticSeverity getSeverity() const
Definition: DiagnosticInfo.h:123
llvm::LTOCodeGenerator::optimize
bool optimize()
Optimizes the merged module.
Definition: LTOCodeGenerator.cpp:498
llvm::DiagnosticInfo
This is the base abstract class for diagnostic reporting in the backend.
Definition: DiagnosticInfo.h:108
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:125
llvm::Triple::getArch
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:345
llvm::None
const NoneType None
Definition: None.h:24
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:83
LTOBackend.h
llvm::lto::Config::OptLevel
unsigned OptLevel
Definition: Config.h:57
llvm::LTOCodeGenerator::DiagnosticHandler
void DiagnosticHandler(const DiagnosticInfo &DI)
Definition: LTOCodeGenerator.cpp:609
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLFunctionalExtras.h:36
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:263
llvm::PrintStatisticsJSON
void PrintStatisticsJSON(raw_ostream &OS)
Print statistics in JSON format.
Definition: Statistic.cpp:202
llvm::lto::backend
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:472
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:599
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::CodeGenOpt::Default
@ Default
Definition: CodeGen.h:55
llvm::LTOCodeGenerator::~LTOCodeGenerator
~LTOCodeGenerator()
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:1610
llvm::DS_Remark
@ DS_Remark
Definition: DiagnosticInfo.h:52
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
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:58
StringExtras.h
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
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:53
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:210
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:65
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:228
llvm::Linker
This class provides the core functionality of linking in LLVM.
Definition: Linker.h:22
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:79
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:4688
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:529
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:863
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:151
Extension
Definition: AArch64AsmParser.cpp:3262
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:858
DiagHandler
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
Definition: TextStub.cpp:1094
MCAsmInfo.h
DataLayout.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
DP
So we should use XX3Form_Rcr to implement intrinsic 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_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
TargetSubtargetInfo.h
llvm::PipelineTuningOptions::LoopVectorization
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition: PassBuilder.h:49
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:118
llvm::AMDGPU::SendMsg::Msg
const CustomOperand< const MCSubtargetInfo & > Msg[]
Definition: AMDGPUAsmUtils.cpp:39
llvm::LTOCodeGenerator::writeMergedModules
bool writeMergedModules(StringRef Path)
Write the merged module to the file specified by the given path.
Definition: LTOCodeGenerator.cpp:203
name
static const char * name
Definition: SVEIntrinsicOpts.cpp:74
llvm::LLVMContext::diagnose
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
Definition: LLVMContext.cpp:243
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:50
LLVMRemarkStreamer.h
llvm::toString
const char * toString(DWARFSectionKind Kind)
Definition: DWARFUnitIndex.h:67
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
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:60
llvm::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:262
DiagnosticInfo.h
llvm::Triple::isArm64e
bool isArm64e() const
Tests whether the target is the Apple "arm64e" AArch64 subarch.
Definition: Triple.h:904
llvm::LLVMContext::setDiscardValueNames
void setDiscardValueNames(bool Discard)
Set the Context runtime configuration to discard all value name (but GlobalValue).
Definition: LLVMContext.cpp:346
llvm::cl::value_desc
Definition: CommandLine.h:414
llvm::lto::Config::PTO
PipelineTuningOptions PTO
Tunable parameters for passes in the default pipelines.
Definition: Config.h:191
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:591
llvm::StringMap::count
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:246
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:94
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:1087
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:133
llvm::createObjCARCContractPass
Pass * createObjCARCContractPass()
Definition: ObjCARCContract.cpp:733
llvm::cl::desc
Definition: CommandLine.h:405
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:644
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:50
llvm::Triple::aarch64
@ aarch64
Definition: Triple.h:51
llvm::verifyModule
bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
Definition: Verifier.cpp:6161
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:469
llvm::DS_Note
@ DS_Note
Definition: DiagnosticInfo.h:55
LTOCodeGenerator.h
llvm::RegState::Undef
@ Undef
Value of the register doesn't matter.
Definition: MachineInstrBuilder.h:52