LLVM  13.0.0git
LTOBackend.cpp
Go to the documentation of this file.
1 //===-LTOBackend.cpp - LLVM Link Time Optimizer Backend -------------------===//
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 "backend" phase of LTO, i.e. it performs
10 // optimization and code generation on a loaded module. It is generally used
11 // internally by the LTO class but can also be used independently, for example
12 // to implement a standalone ThinLTO backend.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "llvm/LTO/LTOBackend.h"
26 #include "llvm/IR/PassManager.h"
27 #include "llvm/IR/Verifier.h"
28 #include "llvm/LTO/LTO.h"
32 #include "llvm/Passes/PassPlugin.h"
34 #include "llvm/Support/Error.h"
37 #include "llvm/Support/Path.h"
38 #include "llvm/Support/Program.h"
44 #include "llvm/Transforms/IPO.h"
49 
50 using namespace llvm;
51 using namespace lto;
52 
53 #define DEBUG_TYPE "lto-backend"
54 
55 enum class LTOBitcodeEmbedding {
56  DoNotEmbed = 0,
57  EmbedOptimized = 1,
59 };
60 
62  "lto-embed-bitcode", cl::init(LTOBitcodeEmbedding::DoNotEmbed),
64  "Do not embed"),
66  "Embed after all optimization passes"),
68  "post-merge-pre-opt",
69  "Embed post merge, but before optimizations")),
70  cl::desc("Embed LLVM bitcode in object files produced by LTO"));
71 
73  "thinlto-assume-merged", cl::init(false),
74  cl::desc("Assume the input has already undergone ThinLTO function "
75  "importing and the other pre-optimization pipeline changes."));
76 
78  errs() << "failed to open " << Path << ": " << Msg << '\n';
79  errs().flush();
80  exit(1);
81 }
82 
83 Error Config::addSaveTemps(std::string OutputFileName,
84  bool UseInputModulePath) {
86 
87  std::error_code EC;
89  std::make_unique<raw_fd_ostream>(OutputFileName + "resolution.txt", EC,
91  if (EC) {
92  ResolutionFile.reset();
93  return errorCodeToError(EC);
94  }
95 
96  auto setHook = [&](std::string PathSuffix, ModuleHookFn &Hook) {
97  // Keep track of the hook provided by the linker, which also needs to run.
98  ModuleHookFn LinkerHook = Hook;
99  Hook = [=](unsigned Task, const Module &M) {
100  // If the linker's hook returned false, we need to pass that result
101  // through.
102  if (LinkerHook && !LinkerHook(Task, M))
103  return false;
104 
105  std::string PathPrefix;
106  // If this is the combined module (not a ThinLTO backend compile) or the
107  // user hasn't requested using the input module's path, emit to a file
108  // named from the provided OutputFileName with the Task ID appended.
109  if (M.getModuleIdentifier() == "ld-temp.o" || !UseInputModulePath) {
110  PathPrefix = OutputFileName;
111  if (Task != (unsigned)-1)
112  PathPrefix += utostr(Task) + ".";
113  } else
114  PathPrefix = M.getModuleIdentifier() + ".";
115  std::string Path = PathPrefix + PathSuffix + ".bc";
116  std::error_code EC;
118  // Because -save-temps is a debugging feature, we report the error
119  // directly and exit.
120  if (EC)
121  reportOpenError(Path, EC.message());
122  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false);
123  return true;
124  };
125  };
126 
127  setHook("0.preopt", PreOptModuleHook);
128  setHook("1.promote", PostPromoteModuleHook);
129  setHook("2.internalize", PostInternalizeModuleHook);
130  setHook("3.import", PostImportModuleHook);
131  setHook("4.opt", PostOptModuleHook);
132  setHook("5.precodegen", PreCodeGenModuleHook);
133 
135  [=](const ModuleSummaryIndex &Index,
136  const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
137  std::string Path = OutputFileName + "index.bc";
138  std::error_code EC;
140  // Because -save-temps is a debugging feature, we report the error
141  // directly and exit.
142  if (EC)
143  reportOpenError(Path, EC.message());
144  WriteIndexToFile(Index, OS);
145 
146  Path = OutputFileName + "index.dot";
148  if (EC)
149  reportOpenError(Path, EC.message());
150  Index.exportToDot(OSDot, GUIDPreservedSymbols);
151  return true;
152  };
153 
154  return Error::success();
155 }
156 
157 #define HANDLE_EXTENSION(Ext) \
158  llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
159 #include "llvm/Support/Extension.def"
160 
162  PassBuilder &PB) {
163 #define HANDLE_EXTENSION(Ext) \
164  get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
165 #include "llvm/Support/Extension.def"
166 
167  // Load requested pass plugins and let them register pass builder callbacks
168  for (auto &PluginFN : PassPlugins) {
169  auto PassPlugin = PassPlugin::Load(PluginFN);
170  if (!PassPlugin) {
171  errs() << "Failed to load passes from '" << PluginFN
172  << "'. Request ignored.\n";
173  continue;
174  }
175 
177  }
178 }
179 
180 static std::unique_ptr<TargetMachine>
181 createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M) {
182  StringRef TheTriple = M.getTargetTriple();
183  SubtargetFeatures Features;
184  Features.getDefaultSubtargetFeatures(Triple(TheTriple));
185  for (const std::string &A : Conf.MAttrs)
186  Features.AddFeature(A);
187 
188  Optional<Reloc::Model> RelocModel = None;
189  if (Conf.RelocModel)
190  RelocModel = *Conf.RelocModel;
191  else if (M.getModuleFlag("PIC Level"))
192  RelocModel =
193  M.getPICLevel() == PICLevel::NotPIC ? Reloc::Static : Reloc::PIC_;
194 
195  Optional<CodeModel::Model> CodeModel;
196  if (Conf.CodeModel)
197  CodeModel = *Conf.CodeModel;
198  else
199  CodeModel = M.getCodeModel();
200 
201  std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
202  TheTriple, Conf.CPU, Features.getString(), Conf.Options, RelocModel,
203  CodeModel, Conf.CGOptLevel));
204  assert(TM && "Failed to create target machine");
205  return TM;
206 }
207 
208 static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
209  unsigned OptLevel, bool IsThinLTO,
210  ModuleSummaryIndex *ExportSummary,
211  const ModuleSummaryIndex *ImportSummary) {
212  Optional<PGOOptions> PGOOpt;
213  if (!Conf.SampleProfile.empty())
214  PGOOpt = PGOOptions(Conf.SampleProfile, "", Conf.ProfileRemapping,
216  else if (Conf.RunCSIRInstr) {
217  PGOOpt = PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping,
219  Conf.AddFSDiscriminator);
220  } else if (!Conf.CSIRProfile.empty()) {
221  PGOOpt = PGOOptions(Conf.CSIRProfile, "", Conf.ProfileRemapping,
223  Conf.AddFSDiscriminator);
224  } else if (Conf.AddFSDiscriminator) {
225  PGOOpt = PGOOptions("", "", "", PGOOptions::NoAction,
226  PGOOptions::NoCSAction, true);
227  }
228 
233 
237  PassBuilder PB(TM, Conf.PTO, PGOOpt, &PIC);
238 
240 
241  std::unique_ptr<TargetLibraryInfoImpl> TLII(
242  new TargetLibraryInfoImpl(Triple(TM->getTargetTriple())));
243  if (Conf.Freestanding)
244  TLII->disableAllFunctions();
245  FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
246 
247  AAManager AA;
248  // Parse a custom AA pipeline if asked to.
249  if (!Conf.AAPipeline.empty()) {
250  if (auto Err = PB.parseAAPipeline(AA, Conf.AAPipeline)) {
251  report_fatal_error("unable to parse AA pipeline description '" +
252  Conf.AAPipeline + "': " + toString(std::move(Err)));
253  }
254  } else {
255  AA = PB.buildDefaultAAPipeline();
256  }
257  // Register the AA manager first so that our version is the one used.
258  FAM.registerPass([&] { return std::move(AA); });
259 
260  // Register all the basic analyses with the managers.
266 
268 
269  if (!Conf.DisableVerify)
271 
273 
274  switch (OptLevel) {
275  default:
276  llvm_unreachable("Invalid optimization level");
277  case 0:
279  break;
280  case 1:
282  break;
283  case 2:
285  break;
286  case 3:
288  break;
289  }
290 
291  // Parse a custom pipeline if asked to.
292  if (!Conf.OptPipeline.empty()) {
293  if (auto Err = PB.parsePassPipeline(MPM, Conf.OptPipeline)) {
294  report_fatal_error("unable to parse pass pipeline description '" +
295  Conf.OptPipeline + "': " + toString(std::move(Err)));
296  }
297  } else if (IsThinLTO) {
298  MPM.addPass(PB.buildThinLTODefaultPipeline(OL, ImportSummary));
299  } else {
300  MPM.addPass(PB.buildLTODefaultPipeline(OL, ExportSummary));
301  }
302 
303  if (!Conf.DisableVerify)
305 
306  MPM.run(Mod, MAM);
307 }
308 
309 static void runOldPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
310  bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
311  const ModuleSummaryIndex *ImportSummary) {
312  legacy::PassManager passes;
313  passes.add(createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis()));
314 
315  PassManagerBuilder PMB;
316  PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM->getTargetTriple()));
317  if (Conf.Freestanding)
320  PMB.ExportSummary = ExportSummary;
321  PMB.ImportSummary = ImportSummary;
322  // Unconditionally verify input since it is not verified before this
323  // point and has unknown origin.
324  PMB.VerifyInput = true;
325  PMB.VerifyOutput = !Conf.DisableVerify;
326  PMB.LoopVectorize = true;
327  PMB.SLPVectorize = true;
328  PMB.OptLevel = Conf.OptLevel;
329  PMB.PGOSampleUse = Conf.SampleProfile;
331  if (!Conf.RunCSIRInstr && !Conf.CSIRProfile.empty()) {
332  PMB.EnablePGOCSInstrUse = true;
333  PMB.PGOInstrUse = Conf.CSIRProfile;
334  }
335  if (IsThinLTO)
336  PMB.populateThinLTOPassManager(passes);
337  else
338  PMB.populateLTOPassManager(passes);
339  passes.run(Mod);
340 }
341 
342 bool lto::opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
343  bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
344  const ModuleSummaryIndex *ImportSummary,
345  const std::vector<uint8_t> &CmdArgs) {
347  // FIXME: the motivation for capturing post-merge bitcode and command line
348  // is replicating the compilation environment from bitcode, without needing
349  // to understand the dependencies (the functions to be imported). This
350  // assumes a clang - based invocation, case in which we have the command
351  // line.
352  // It's not very clear how the above motivation would map in the
353  // linker-based case, so we currently don't plumb the command line args in
354  // that case.
355  if (CmdArgs.empty())
356  LLVM_DEBUG(
357  dbgs() << "Post-(Thin)LTO merge bitcode embedding was requested, but "
358  "command line arguments are not available");
360  /*EmbedBitcode*/ true, /*EmbedCmdline*/ true,
361  /*Cmdline*/ CmdArgs);
362  }
363  // FIXME: Plumb the combined index into the new pass manager.
364  if (Conf.UseNewPM || !Conf.OptPipeline.empty()) {
365  runNewPMPasses(Conf, Mod, TM, Conf.OptLevel, IsThinLTO, ExportSummary,
366  ImportSummary);
367  } else {
368  runOldPMPasses(Conf, Mod, TM, IsThinLTO, ExportSummary, ImportSummary);
369  }
370  return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
371 }
372 
373 static void codegen(const Config &Conf, TargetMachine *TM,
374  AddStreamFn AddStream, unsigned Task, Module &Mod,
375  const ModuleSummaryIndex &CombinedIndex) {
376  if (Conf.PreCodeGenModuleHook && !Conf.PreCodeGenModuleHook(Task, Mod))
377  return;
378 
381  /*EmbedBitcode*/ true,
382  /*EmbedCmdline*/ false,
383  /*CmdArgs*/ std::vector<uint8_t>());
384 
385  std::unique_ptr<ToolOutputFile> DwoOut;
386  SmallString<1024> DwoFile(Conf.SplitDwarfOutput);
387  if (!Conf.DwoDir.empty()) {
388  std::error_code EC;
389  if (auto EC = llvm::sys::fs::create_directories(Conf.DwoDir))
390  report_fatal_error("Failed to create directory " + Conf.DwoDir + ": " +
391  EC.message());
392 
393  DwoFile = Conf.DwoDir;
394  sys::path::append(DwoFile, std::to_string(Task) + ".dwo");
395  TM->Options.MCOptions.SplitDwarfFile = std::string(DwoFile);
396  } else
397  TM->Options.MCOptions.SplitDwarfFile = Conf.SplitDwarfFile;
398 
399  if (!DwoFile.empty()) {
400  std::error_code EC;
401  DwoOut = std::make_unique<ToolOutputFile>(DwoFile, EC, sys::fs::OF_None);
402  if (EC)
403  report_fatal_error("Failed to open " + DwoFile + ": " + EC.message());
404  }
405 
406  auto Stream = AddStream(Task);
407  legacy::PassManager CodeGenPasses;
408  CodeGenPasses.add(
410  if (Conf.PreCodeGenPassesHook)
411  Conf.PreCodeGenPassesHook(CodeGenPasses);
412  if (TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS,
413  DwoOut ? &DwoOut->os() : nullptr,
414  Conf.CGFileType))
415  report_fatal_error("Failed to setup codegen");
416  CodeGenPasses.run(Mod);
417 
418  if (DwoOut)
419  DwoOut->keep();
420 }
421 
422 static void splitCodeGen(const Config &C, TargetMachine *TM,
423  AddStreamFn AddStream,
424  unsigned ParallelCodeGenParallelismLevel, Module &Mod,
425  const ModuleSummaryIndex &CombinedIndex) {
426  ThreadPool CodegenThreadPool(
427  heavyweight_hardware_concurrency(ParallelCodeGenParallelismLevel));
428  unsigned ThreadCount = 0;
429  const Target *T = &TM->getTarget();
430 
431  SplitModule(
432  Mod, ParallelCodeGenParallelismLevel,
433  [&](std::unique_ptr<Module> MPart) {
434  // We want to clone the module in a new context to multi-thread the
435  // codegen. We do it by serializing partition modules to bitcode
436  // (while still on the main thread, in order to avoid data races) and
437  // spinning up new threads which deserialize the partitions into
438  // separate contexts.
439  // FIXME: Provide a more direct way to do this in LLVM.
440  SmallString<0> BC;
441  raw_svector_ostream BCOS(BC);
442  WriteBitcodeToFile(*MPart, BCOS);
443 
444  // Enqueue the task
445  CodegenThreadPool.async(
446  [&](const SmallString<0> &BC, unsigned ThreadId) {
447  LTOLLVMContext Ctx(C);
449  MemoryBufferRef(StringRef(BC.data(), BC.size()), "ld-temp.o"),
450  Ctx);
451  if (!MOrErr)
452  report_fatal_error("Failed to read bitcode");
453  std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
454 
455  std::unique_ptr<TargetMachine> TM =
456  createTargetMachine(C, T, *MPartInCtx);
457 
458  codegen(C, TM.get(), AddStream, ThreadId, *MPartInCtx,
459  CombinedIndex);
460  },
461  // Pass BC using std::move to ensure that it get moved rather than
462  // copied into the thread's context.
463  std::move(BC), ThreadCount++);
464  },
465  false);
466 
467  // Because the inner lambda (which runs in a worker thread) captures our local
468  // variables, we need to wait for the worker threads to terminate before we
469  // can leave the function scope.
470  CodegenThreadPool.wait();
471 }
472 
474  Module &Mod) {
475  if (!C.OverrideTriple.empty())
476  Mod.setTargetTriple(C.OverrideTriple);
477  else if (Mod.getTargetTriple().empty())
478  Mod.setTargetTriple(C.DefaultTriple);
479 
480  std::string Msg;
482  if (!T)
483  return make_error<StringError>(Msg, inconvertibleErrorCode());
484  return T;
485 }
486 
488  std::unique_ptr<ToolOutputFile> DiagOutputFile) {
489  // Make sure we flush the diagnostic remarks file in case the linker doesn't
490  // call the global destructors before exiting.
491  if (!DiagOutputFile)
492  return Error::success();
493  DiagOutputFile->keep();
494  DiagOutputFile->os().flush();
495  return Error::success();
496 }
497 
499  unsigned ParallelCodeGenParallelismLevel, Module &Mod,
500  ModuleSummaryIndex &CombinedIndex) {
502  if (!TOrErr)
503  return TOrErr.takeError();
504 
505  std::unique_ptr<TargetMachine> TM = createTargetMachine(C, *TOrErr, Mod);
506 
507  if (!C.CodeGenOnly) {
508  if (!opt(C, TM.get(), 0, Mod, /*IsThinLTO=*/false,
509  /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
510  /*CmdArgs*/ std::vector<uint8_t>()))
511  return Error::success();
512  }
513 
514  if (ParallelCodeGenParallelismLevel == 1) {
515  codegen(C, TM.get(), AddStream, 0, Mod, CombinedIndex);
516  } else {
517  splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel, Mod,
518  CombinedIndex);
519  }
520  return Error::success();
521 }
522 
523 static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals,
524  const ModuleSummaryIndex &Index) {
525  std::vector<GlobalValue*> DeadGVs;
526  for (auto &GV : Mod.global_values())
527  if (GlobalValueSummary *GVS = DefinedGlobals.lookup(GV.getGUID()))
528  if (!Index.isGlobalValueLive(GVS)) {
529  DeadGVs.push_back(&GV);
531  }
532 
533  // Now that all dead bodies have been dropped, delete the actual objects
534  // themselves when possible.
535  for (GlobalValue *GV : DeadGVs) {
536  GV->removeDeadConstantUsers();
537  // Might reference something defined in native object (i.e. dropped a
538  // non-prevailing IR def, but we need to keep the declaration).
539  if (GV->use_empty())
540  GV->eraseFromParent();
541  }
542 }
543 
544 Error lto::thinBackend(const Config &Conf, unsigned Task, AddStreamFn AddStream,
545  Module &Mod, const ModuleSummaryIndex &CombinedIndex,
546  const FunctionImporter::ImportMapTy &ImportList,
547  const GVSummaryMapTy &DefinedGlobals,
549  const std::vector<uint8_t> &CmdArgs) {
551  if (!TOrErr)
552  return TOrErr.takeError();
553 
554  std::unique_ptr<TargetMachine> TM = createTargetMachine(Conf, *TOrErr, Mod);
555 
556  // Setup optimization remarks.
557  auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
560  Task);
561  if (!DiagFileOrErr)
562  return DiagFileOrErr.takeError();
563  auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
564 
565  // Set the partial sample profile ratio in the profile summary module flag of
566  // the module, if applicable.
567  Mod.setPartialSampleProfileRatio(CombinedIndex);
568 
569  if (Conf.CodeGenOnly) {
570  codegen(Conf, TM.get(), AddStream, Task, Mod, CombinedIndex);
571  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
572  }
573 
574  if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
575  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
576 
577  auto OptimizeAndCodegen =
578  [&](Module &Mod, TargetMachine *TM,
579  std::unique_ptr<ToolOutputFile> DiagnosticOutputFile) {
580  if (!opt(Conf, TM, Task, Mod, /*IsThinLTO=*/true,
581  /*ExportSummary=*/nullptr, /*ImportSummary=*/&CombinedIndex,
582  CmdArgs))
583  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
584 
585  codegen(Conf, TM, AddStream, Task, Mod, CombinedIndex);
586  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
587  };
588 
590  return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
591 
592  // When linking an ELF shared object, dso_local should be dropped. We
593  // conservatively do this for -fpic.
594  bool ClearDSOLocalOnDeclarations =
595  TM->getTargetTriple().isOSBinFormatELF() &&
596  TM->getRelocationModel() != Reloc::Static &&
598  renameModuleForThinLTO(Mod, CombinedIndex, ClearDSOLocalOnDeclarations);
599 
600  dropDeadSymbols(Mod, DefinedGlobals, CombinedIndex);
601 
602  thinLTOResolvePrevailingInModule(Mod, DefinedGlobals);
603 
604  if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
605  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
606 
607  if (!DefinedGlobals.empty())
608  thinLTOInternalizeModule(Mod, DefinedGlobals);
609 
610  if (Conf.PostInternalizeModuleHook &&
611  !Conf.PostInternalizeModuleHook(Task, Mod))
612  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
613 
614  auto ModuleLoader = [&](StringRef Identifier) {
616  "ODR Type uniquing should be enabled on the context");
617  if (ModuleMap) {
618  auto I = ModuleMap->find(Identifier);
619  assert(I != ModuleMap->end());
620  return I->second.getLazyModule(Mod.getContext(),
621  /*ShouldLazyLoadMetadata=*/true,
622  /*IsImporting*/ true);
623  }
624 
626  llvm::MemoryBuffer::getFile(Identifier);
627  if (!MBOrErr)
628  return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
629  Twine("Error loading imported file ") + Identifier + " : ",
630  MBOrErr.getError()));
631 
632  Expected<BitcodeModule> BMOrErr = findThinLTOModule(**MBOrErr);
633  if (!BMOrErr)
634  return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
635  Twine("Error loading imported file ") + Identifier + " : " +
636  toString(BMOrErr.takeError()),
638 
640  BMOrErr->getLazyModule(Mod.getContext(),
641  /*ShouldLazyLoadMetadata=*/true,
642  /*IsImporting*/ true);
643  if (MOrErr)
644  (*MOrErr)->setOwnedMemoryBuffer(std::move(*MBOrErr));
645  return MOrErr;
646  };
647 
648  FunctionImporter Importer(CombinedIndex, ModuleLoader,
649  ClearDSOLocalOnDeclarations);
650  if (Error Err = Importer.importFunctions(Mod, ImportList).takeError())
651  return Err;
652 
653  if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
654  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
655 
656  return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
657 }
658 
660  if (ThinLTOAssumeMerged && BMs.size() == 1)
661  return BMs.begin();
662 
663  for (BitcodeModule &BM : BMs) {
664  Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
665  if (LTOInfo && LTOInfo->IsThinLTO)
666  return &BM;
667  }
668  return nullptr;
669 }
670 
673  if (!BMsOrErr)
674  return BMsOrErr.takeError();
675 
676  // The bitcode file may contain multiple modules, we want the one that is
677  // marked as being the ThinLTO module.
678  if (const BitcodeModule *Bm = lto::findThinLTOModule(*BMsOrErr))
679  return *Bm;
680 
681  return make_error<StringError>("Could not find module summary",
683 }
684 
686  const ModuleSummaryIndex &CombinedIndex,
687  FunctionImporter::ImportMapTy &ImportList) {
689  return true;
690  // We can simply import the values mentioned in the combined index, since
691  // we should only invoke this using the individual indexes written out
692  // via a WriteIndexesThinBackend.
693  for (const auto &GlobalList : CombinedIndex) {
694  // Ignore entries for undefined references.
695  if (GlobalList.second.SummaryList.empty())
696  continue;
697 
698  auto GUID = GlobalList.first;
699  for (const auto &Summary : GlobalList.second.SummaryList) {
700  // Skip the summaries for the importing module. These are included to
701  // e.g. record required linkage changes.
702  if (Summary->modulePath() == M.getModuleIdentifier())
703  continue;
704  // Add an entry to provoke importing by thinBackend.
705  ImportList[Summary->modulePath()].insert(GUID);
706  }
707  }
708  return true;
709 }
llvm::Module::global_values
iterator_range< global_value_iterator > global_values()
Definition: Module.cpp:420
MemoryBuffer.h
llvm::AAManager
A manager for alias analyses.
Definition: AliasAnalysis.h:1233
llvm::PassBuilder::OptimizationLevel::O1
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
Definition: PassBuilder.h:198
llvm::PassManagerBuilder::PGOSampleUse
std::string PGOSampleUse
Path of the sample Profile data file.
Definition: PassManagerBuilder.h:188
FunctionImportUtils.h
llvm
Definition: AllocatorList.h:23
PassBuilder.h
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::lto::initImportList
bool initImportList(const Module &M, const ModuleSummaryIndex &CombinedIndex, FunctionImporter::ImportMapTy &ImportList)
Distributed ThinLTO: collect the referenced modules based on module summary and initialize ImportList...
Definition: LTOBackend.cpp:685
llvm::thinLTOInternalizeModule
void thinLTOInternalizeModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals)
Internalize TheModule based on the information recorded in the summaries during global summary-based ...
Definition: FunctionImport.cpp:1116
FileSystem.h
llvm::sys::fs::OF_None
@ OF_None
Definition: FileSystem.h:757
LTOBitcodeEmbedding::EmbedOptimized
@ EmbedOptimized
LTOBitcodeEmbedding
LTOBitcodeEmbedding
Definition: LTOBackend.cpp:55
llvm::lto::Config::DisableVerify
bool DisableVerify
Definition: Config.h:58
llvm::lto::finalizeOptimizationRemarks
Error finalizeOptimizationRemarks(std::unique_ptr< ToolOutputFile > DiagOutputFile)
Definition: LTOBackend.cpp:487
llvm::ThreadPool
A ThreadPool for asynchronous parallel execution on a defined number of threads.
Definition: ThreadPool.h:37
llvm::lto::Config::CGOptLevel
CodeGenOpt::Level CGOptLevel
Definition: Config.h:55
llvm::PassManagerBuilder::VerifyOutput
bool VerifyOutput
Definition: PassManagerBuilder.h:168
llvm::DenseMapBase::lookup
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:197
llvm::renameModuleForThinLTO
bool renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index, bool ClearDSOLocalOnDeclarations, SetVector< GlobalValue * > *GlobalsToImport=nullptr)
Perform in-place global value handling on the given Module for exported local functions renamed and p...
Definition: FunctionImportUtils.cpp:328
llvm::PassPlugin
A loaded pass plugin.
Definition: PassPlugin.h:60
llvm::lto::Config::RemarksFormat
std::string RemarksFormat
The format used for serializing remarks (default: YAML).
Definition: Config.h:154
llvm::lto::Config::CodeModel
Optional< CodeModel::Model > CodeModel
Definition: Config.h:54
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:125
RegisterPassPlugins
static void RegisterPassPlugins(ArrayRef< std::string > PassPlugins, PassBuilder &PB)
Definition: LTOBackend.cpp:161
llvm::SubtargetFeatures::AddFeature
void AddFeature(StringRef String, bool Enable=true)
Adds Features.
Definition: SubtargetFeature.cpp:41
llvm::toString
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:991
llvm::lto::Config::RemarksWithHotness
bool RemarksWithHotness
Whether to emit optimization remarks with hotness informations.
Definition: Config.h:136
Path.h
llvm::PassManagerBuilder::populateLTOPassManager
void populateLTOPassManager(legacy::PassManagerBase &PM)
Definition: PassManagerBuilder.cpp:1185
SmallVectorMemoryBuffer.h
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:332
llvm::PassManagerBuilder::LoopVectorize
bool LoopVectorize
Definition: PassManagerBuilder.h:161
Error.h
llvm::VerifierPass
Create a verifier pass.
Definition: Verifier.h:137
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
llvm::heavyweight_hardware_concurrency
ThreadPoolStrategy heavyweight_hardware_concurrency(unsigned ThreadCount=0)
Returns a thread strategy for tasks requiring significant memory or other resources.
Definition: Threading.h:195
llvm::PassManagerBuilder::ImportSummary
const ModuleSummaryIndex * ImportSummary
The module summary index to use for importing information to the thin LTO backends,...
Definition: PassManagerBuilder.h:155
PIC
PassInstrumentationCallbacks PIC
Definition: PassBuilderBindings.cpp:55
llvm::createImmutableModuleSummaryIndexWrapperPass
ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)
Definition: ModuleSummaryAnalysis.cpp:924
llvm::lto::Config
LTO configuration.
Definition: Config.h:40
llvm::Optional< Reloc::Model >
llvm::lto::Config::Freestanding
bool Freestanding
Flag to indicate that the optimizer should not assume builtins are present on the target.
Definition: Config.h:65
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::TargetLibraryInfoImpl
Implementation of the target library information.
Definition: TargetLibraryInfo.h:48
llvm::MapVector< StringRef, BitcodeModule >
llvm::PassManagerBuilder::ExportSummary
ModuleSummaryIndex * ExportSummary
The module summary index to use for exporting information from the regular LTO phase,...
Definition: PassManagerBuilder.h:150
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
llvm::FunctionImporter
The function importer is automatically importing function from other modules based on the provided su...
Definition: FunctionImport.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:1553
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::lto::Config::ShouldDiscardValueNames
bool ShouldDiscardValueNames
Definition: Config.h:171
ModuleSummaryAnalysis.h
llvm::lto::Config::PostImportModuleHook
ModuleHookFn PostImportModuleHook
This hook is called after importing from other modules (ThinLTO-specific).
Definition: Config.h:224
llvm::lto::Config::CodeGenOnly
bool CodeGenOnly
Disable entirely the optimizer, including importing for ThinLTO.
Definition: Config.h:68
llvm::PGOOptions::SampleUse
@ SampleUse
Definition: PassBuilder.h:36
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
LegacyPassManager.h
llvm::PassBuilder::OptimizationLevel::O2
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
Definition: PassBuilder.h:215
PassManagerBuilder.h
runNewPMPasses
static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM, unsigned OptLevel, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
Definition: LTOBackend.cpp:208
llvm::lto::findThinLTOModule
BitcodeModule * findThinLTOModule(MutableArrayRef< BitcodeModule > BMs)
Returns the BitcodeModule that is ThinLTO.
Definition: LTOBackend.cpp:659
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::lto::Config::CombinedIndexHook
CombinedIndexHookFn CombinedIndexHook
Definition: Config.h:246
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:122
initAndLookupTarget
static Expected< const Target * > initAndLookupTarget(const Config &C, Module &Mod)
Definition: LTOBackend.cpp:473
llvm::PassBuilder::OptimizationLevel::O0
static const OptimizationLevel O0
Disable as many optimizations as possible.
Definition: PassBuilder.h:182
AliasAnalysis.h
llvm::sys::path::append
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:454
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
llvm::PassBuilder::parsePassPipeline
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
Definition: PassBuilder.cpp:3002
llvm::lto::Config::SplitDwarfFile
std::string SplitDwarfFile
The name for the split debug info file used for the DW_AT_[GNU_]dwo_name attribute in the skeleton CU...
Definition: Config.h:122
llvm::FunctionImporter::importFunctions
Expected< bool > importFunctions(Module &M, const ImportMapTy &ImportList)
Import functions in Module M based on the supplied import list.
Definition: FunctionImport.cpp:1183
llvm::PassPlugin::Load
static Expected< PassPlugin > Load(const std::string &Filename)
Attempts to load a pass plugin from a given file.
Definition: PassPlugin.cpp:16
llvm::lto::Config::RunCSIRInstr
bool RunCSIRInstr
Run PGO context sensitive IR instrumentation.
Definition: Config.h:71
llvm::GlobalValueSummary
Function and variable summary information to aid decisions and implementation of importing.
Definition: ModuleSummaryIndex.h:288
llvm::StandardInstrumentations::registerCallbacks
void registerCallbacks(PassInstrumentationCallbacks &PIC, FunctionAnalysisManager *FAM=nullptr)
Definition: StandardInstrumentations.cpp:1226
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::lto::Config::PostPromoteModuleHook
ModuleHookFn PostPromoteModuleHook
This hook is called after promoting any internal functions (ThinLTO-specific).
Definition: Config.h:218
SubtargetFeature.h
TargetMachine.h
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
llvm::lto::opt
bool opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary, const std::vector< uint8_t > &CmdArgs)
Runs middle-end LTO optimizations on Mod.
Definition: LTOBackend.cpp:342
llvm::PassManagerBuilder::LibraryInfo
TargetLibraryInfoImpl * LibraryInfo
LibraryInfo - Specifies information about the runtime library for the optimizer.
Definition: PassManagerBuilder.h:141
llvm::lto::Config::SampleProfile
std::string SampleProfile
Sample PGO profile path.
Definition: Config.h:110
BitcodeWriter.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::StringMap::insert
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:276
llvm::errorCodeToError
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
MAM
ModuleAnalysisManager MAM
Definition: PassBuilderBindings.cpp:61
llvm::lto::Config::Options
TargetOptions Options
Definition: Config.h:48
llvm::PassBuilder
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:139
llvm::lto::Config::PreCodeGenPassesHook
std::function< void(legacy::PassManager &)> PreCodeGenPassesHook
For adding passes that run right before codegen.
Definition: Config.h:52
llvm::SubtargetFeatures
Manages the enabling and disabling of subtarget specific features.
Definition: SubtargetFeature.h:183
llvm::PGOOptions::IRUse
@ IRUse
Definition: PassBuilder.h:36
TargetLibraryInfo.h
SplitModule.h
llvm::ErrorOr::getError
std::error_code getError() const
Definition: ErrorOr.h:153
llvm::LLVMContext::isODRUniquingDebugTypes
bool isODRUniquingDebugTypes() const
Whether there is a string map for uniquing debug info identifiers across the context.
Definition: LLVMContext.cpp:320
reportOpenError
static LLVM_ATTRIBUTE_NORETURN void reportOpenError(StringRef Path, Twine Msg)
Definition: LTOBackend.cpp:77
llvm::sys::fs::create_directories
std::error_code create_directories(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create all the non-existent directories in path.
Definition: Path.cpp:963
llvm::WriteIndexToFile
void WriteIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out, const std::map< std::string, GVSummaryMapTy > *ModuleToSummariesForIndex=nullptr)
Write the specified module summary index to the given raw output stream, where it will be written in ...
Definition: BitcodeWriter.cpp:4675
llvm::lto::Config::ResolutionFile
std::unique_ptr< raw_ostream > ResolutionFile
If this field is set, LTO will write input file paths and symbol resolutions here in llvm-lto2 comman...
Definition: Config.h:181
llvm::report_fatal_error
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
LTOBitcodeEmbedding::DoNotEmbed
@ DoNotEmbed
llvm::PassManagerBuilder::Inliner
Pass * Inliner
Inliner - Specifies the inliner to use.
Definition: PassManagerBuilder.h:145
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:183
llvm::PGOOptions::CSIRInstr
@ CSIRInstr
Definition: PassBuilder.h:37
llvm::lto::Config::ModuleHookFn
std::function< bool(unsigned Task, const Module &)> ModuleHookFn
The following callbacks deal with tasks, which normally represent the entire optimization and code ge...
Definition: Config.h:210
llvm::lto::Config::DebugPassManager
bool DebugPassManager
Whether to emit the pass manager debuggging informations.
Definition: Config.h:157
llvm::SubtargetFeatures::getDefaultSubtargetFeatures
void getDefaultSubtargetFeatures(const Triple &Triple)
Adds the default features for the specified target triple.
Definition: SubtargetFeature.cpp:70
llvm::EmbedBitcodeInModule
void EmbedBitcodeInModule(Module &M, MemoryBufferRef Buf, bool EmbedBitcode, bool EmbedCmdline, const std::vector< uint8_t > &CmdArgs)
If EmbedBitcode is set, save a copy of the llvm IR as data in the __LLVM,__bitcode section (....
Definition: BitcodeWriter.cpp:4887
llvm::Module::setTargetTriple
void setTargetTriple(StringRef T)
Set the target triple.
Definition: Module.h:300
llvm::None
const NoneType None
Definition: None.h:23
llvm::lto::Config::PostInternalizeModuleHook
ModuleHookFn PostInternalizeModuleHook
This hook is called after internalizing the module.
Definition: Config.h:221
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::SmallString
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
llvm::createFunctionInliningPass
Pass * createFunctionInliningPass()
createFunctionInliningPass - Return a new pass object that uses a heuristic to inline direct function...
Definition: InlineSimple.cpp:97
llvm::sys::fs::OF_TextWithCRLF
@ OF_TextWithCRLF
The file should be opened in text mode and use a carriage linefeed '\r '.
Definition: FileSystem.h:772
LTOBackend.h
llvm::PassManagerBuilder
PassManagerBuilder - This class is used to set up a standard optimization sequence for languages like...
Definition: PassManagerBuilder.h:59
llvm::lto::Config::PreCodeGenModuleHook
ModuleHookFn PreCodeGenModuleHook
This module hook is called before code generation.
Definition: Config.h:232
llvm::lto::Config::OptLevel
unsigned OptLevel
Definition: Config.h:57
llvm::convertToDeclaration
bool convertToDeclaration(GlobalValue &GV)
Converts value GV to declaration, or replaces with a declaration if it is an alias.
Definition: FunctionImport.cpp:1008
llvm::createTargetTransformInfoWrapperPass
ImmutablePass * createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA)
Create an analysis pass wrapper around a TTI object.
Definition: TargetTransformInfo.cpp:1446
llvm::PGOOptions::NoCSAction
@ NoCSAction
Definition: PassBuilder.h:37
PB
PassBuilder PB(Machine, PassOpts->PTO, None, &PIC)
llvm::PassPlugin::registerPassBuilderCallbacks
void registerPassBuilderCallbacks(PassBuilder &PB) const
Invoke the PassBuilder callback registration.
Definition: PassPlugin.h:82
llvm::SubtargetFeatures::getString
std::string getString() const
Returns features as a string.
Definition: SubtargetFeature.cpp:54
llvm::DenseSet< GlobalValue::GUID >
ThreadPool.h
llvm::lto::Config::RemarksFilename
std::string RemarksFilename
Optimization remarks file path.
Definition: Config.h:130
llvm::cl::opt
Definition: CommandLine.h:1422
llvm::lto::backend
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:498
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::PassBuilder::registerFunctionAnalyses
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
Definition: PassBuilder.cpp:497
llvm::cl::values
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:699
llvm::StandardInstrumentations
This class provides an interface to register all the standard pass instrumentations and manages their...
Definition: StandardInstrumentations.h:415
llvm::MapVector::find
iterator find(const KeyT &Key)
Definition: MapVector.h:147
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::parseBitcodeFile
Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, DataLayoutCallbackTy DataLayoutCallback=[](StringRef) { return None;})
Read the specified bitcode file, returning the module.
Definition: BitcodeReader.cpp:7060
IPO.h
llvm::lto::Config::DwoDir
std::string DwoDir
The directory to store .dwo files.
Definition: Config.h:116
llvm::lto::Config::AddFSDiscriminator
bool AddFSDiscriminator
Add FSAFDO discriminators.
Definition: Config.h:175
llvm::PassBuilder::registerModuleAnalyses
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
Definition: PassBuilder.cpp:479
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::DenseMap
Definition: DenseMap.h:714
CGSCCPassManager.h
llvm::PassBuilder::buildLTODefaultPipeline
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
Definition: PassBuilder.cpp:1645
llvm::lto::LTOLLVMContext
A derived class of LLVMContext that initializes itself according to a given Config object.
Definition: Config.h:281
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::PICLevel::NotPIC
@ NotPIC
Definition: CodeGen.h:33
llvm::PassBuilder::buildThinLTODefaultPipeline
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build an ThinLTO default optimization pipeline to a pass manager.
Definition: PassBuilder.cpp:1580
createTargetMachine
static std::unique_ptr< TargetMachine > createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M)
Definition: LTOBackend.cpp:181
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::PassBuilder::buildDefaultAAPipeline
AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
Definition: PassBuilder.cpp:2000
llvm::lto::Config::addSaveTemps
Error addSaveTemps(std::string OutputFileName, bool UseInputModulePath=false)
This is a convenience function that configures this Config object to write temporary files named afte...
Definition: LTOBackend.cpp:83
llvm::PassManagerBuilder::OptLevel
unsigned OptLevel
The Optimization Level - Specify the basic optimization level.
Definition: PassManagerBuilder.h:132
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::PassManagerBuilder::PGOInstrUse
std::string PGOInstrUse
Path of the profile data file.
Definition: PassManagerBuilder.h:186
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
llvm::lto::Config::SplitDwarfOutput
std::string SplitDwarfOutput
The path to write a .dwo file to.
Definition: Config.h:127
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::PassManagerBuilder::VerifyInput
bool VerifyInput
Definition: PassManagerBuilder.h:167
llvm::lto::Config::MAttrs
std::vector< std::string > MAttrs
Definition: Config.h:49
llvm::MutableArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:356
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
LoopPassManager.h
llvm::lto::Config::ProfileRemapping
std::string ProfileRemapping
Name remapping file for profile data.
Definition: Config.h:113
llvm::PGOOptions::NoAction
@ NoAction
Definition: PassBuilder.h:36
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:4630
ModuleSymbolTable.h
llvm::lto::Config::RelocModel
Optional< Reloc::Model > RelocModel
Definition: Config.h:53
LLVM_ATTRIBUTE_NORETURN
#define LLVM_ATTRIBUTE_NORETURN
Definition: Compiler.h:250
llvm::ArrayRef< std::string >
llvm::lto::Config::PostOptModuleHook
ModuleHookFn PostOptModuleHook
This module hook is called after optimization is complete.
Definition: Config.h:227
llvm::lto::Config::RemarksHotnessThreshold
llvm::Optional< uint64_t > RemarksHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
Definition: Config.h:151
llvm::PassManagerBuilder::SLPVectorize
bool SLPVectorize
Definition: PassManagerBuilder.h:160
llvm::Reloc::PIC_
@ PIC_
Definition: CodeGen.h:22
llvm::lto::thinBackend
Error thinBackend(const Config &C, unsigned Task, AddStreamFn AddStream, Module &M, const ModuleSummaryIndex &CombinedIndex, const FunctionImporter::ImportMapTy &ImportList, const GVSummaryMapTy &DefinedGlobals, MapVector< StringRef, BitcodeModule > *ModuleMap, const std::vector< uint8_t > &CmdArgs=std::vector< uint8_t >())
Runs a ThinLTO backend.
Definition: LTOBackend.cpp:544
llvm::PIELevel::Default
@ Default
Definition: CodeGen.h:37
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
LTOBitcodeEmbedding::EmbedPostMergePreOptimized
@ EmbedPostMergePreOptimized
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::Reloc::Static
@ Static
Definition: CodeGen.h:22
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:537
PassPlugin.h
llvm::PGOOptions
A struct capturing PGO tunables.
Definition: PassBuilder.h:35
llvm::ThreadPool::async
std::shared_future< void > async(Function &&F, Args &&... ArgList)
Asynchronous submission of a task to the pool.
Definition: ThreadPool.h:54
clEnumValN
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:674
llvm::lto::Config::OptPipeline
std::string OptPipeline
If this field is set, the set of passes run in the middle-end optimizer will be the one specified by ...
Definition: Config.h:91
ThinLTOAssumeMerged
static cl::opt< bool > ThinLTOAssumeMerged("thinlto-assume-merged", cl::init(false), cl::desc("Assume the input has already undergone ThinLTO function " "importing and the other pre-optimization pipeline changes."))
llvm::thinLTOResolvePrevailingInModule
void thinLTOResolvePrevailingInModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals)
Resolve prevailing symbol linkages and constrain visibility (1.
Definition: FunctionImport.cpp:1043
llvm::raw_fd_ostream
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:432
LAM
LoopAnalysisManager LAM
Definition: PassBuilderBindings.cpp:58
llvm::PassBuilder::parseAAPipeline
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
Definition: PassBuilder.cpp:3102
llvm::MapVector::end
iterator end()
Definition: MapVector.h:71
runOldPMPasses
static void runOldPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
Definition: LTOBackend.cpp:309
llvm::PassManager< Module >
llvm::DenseMapBase::empty
LLVM_NODISCARD bool empty() const
Definition: DenseMap.h:97
EmbedBitcode
static cl::opt< LTOBitcodeEmbedding > EmbedBitcode("lto-embed-bitcode", cl::init(LTOBitcodeEmbedding::DoNotEmbed), cl::values(clEnumValN(LTOBitcodeEmbedding::DoNotEmbed, "none", "Do not embed"), clEnumValN(LTOBitcodeEmbedding::EmbedOptimized, "optimized", "Embed after all optimization passes"), clEnumValN(LTOBitcodeEmbedding::EmbedPostMergePreOptimized, "post-merge-pre-opt", "Embed post merge, but before optimizations")), cl::desc("Embed LLVM bitcode in object files produced by LTO"))
llvm::PassBuilder::registerLoopAnalyses
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
Definition: PassBuilder.cpp:506
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
Verifier.h
llvm::TargetLibraryInfoImpl::disableAllFunctions
void disableAllFunctions()
Disables all builtins.
Definition: TargetLibraryInfo.cpp:1605
llvm::PassBuilder::OptimizationLevel
LLVM-provided high-level optimization levels.
Definition: PassBuilder.h:163
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:204
llvm::inconvertibleErrorCode
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77
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::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:261
dropDeadSymbols
static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals, const ModuleSummaryIndex &Index)
Definition: LTOBackend.cpp:523
llvm::PassBuilder::registerCGSCCAnalyses
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
Definition: PassBuilder.cpp:488
llvm::PassBuilder::OptimizationLevel::O3
static const OptimizationLevel O3
Optimize for fast execution as much as possible.
Definition: PassBuilder.h:230
llvm::lto::Config::AAPipeline
std::string AAPipeline
Definition: Config.h:96
PassManager.h
llvm::lto::Config::PreOptModuleHook
ModuleHookFn PreOptModuleHook
This module hook is called after linking (regular LTO) or loading (ThinLTO) the module,...
Definition: Config.h:214
llvm::PGOOptions::CSIRUse
@ CSIRUse
Definition: PassBuilder.h:37
llvm::lto::Config::PTO
PipelineTuningOptions PTO
Tunable parameters for passes in the default pipelines.
Definition: Config.h:184
llvm::legacy::PassManager::add
void add(Pass *P) override
Add a pass to the queue of passes to run.
Definition: LegacyPassManager.cpp:1674
llvm::lto::Config::CSIRProfile
std::string CSIRProfile
Context Sensitive PGO profile path.
Definition: Config.h:107
llvm::AnalysisManager::registerPass
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:831
llvm::PassManagerBuilder::EnablePGOCSInstrGen
bool EnablePGOCSInstrGen
Enable profile context sensitive instrumentation pass.
Definition: PassManagerBuilder.h:180
llvm::Module::getPIELevel
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
Definition: Module.cpp:601
llvm::PassManager::run
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
Definition: PassManager.h:485
llvm::PassManagerBuilder::EnablePGOCSInstrUse
bool EnablePGOCSInstrUse
Enable profile context sensitive profile use pass.
Definition: PassManagerBuilder.h:182
llvm::Module::setPartialSampleProfileRatio
void setPartialSampleProfileRatio(const ModuleSummaryIndex &Index)
Set the partial sample profile ratio in the profile summary module flag, if applicable.
Definition: Module.cpp:778
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:557
llvm::ThreadPool::wait
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
Definition: ThreadPool.cpp:69
codegen
static void codegen(const Config &Conf, TargetMachine *TM, AddStreamFn AddStream, unsigned Task, Module &Mod, const ModuleSummaryIndex &CombinedIndex)
Definition: LTOBackend.cpp:373
llvm::lto::Config::CGFileType
CodeGenFileType CGFileType
Definition: Config.h:56
llvm::lto::Config::UseNewPM
bool UseNewPM
Use the new pass manager.
Definition: Config.h:61
LTO.h
llvm::ModuleSummaryIndex
Class to hold module path string table and global value map, and encapsulate methods for operating on...
Definition: ModuleSummaryIndex.h:1026
llvm::PassInstrumentationCallbacks
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
Definition: PassInstrumentation.h:66
exit
declare void exit(i32) noreturn nounwind This compiles into
Definition: README.txt:1072
llvm::Module::getTargetTriple
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:257
llvm::PassBuilder::crossRegisterProxies
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM)
Cross register the analysis managers through their proxies.
Definition: PassBuilder.cpp:2977
Program.h
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::to_string
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:62
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
TargetTransformInfo.h
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:647
llvm::legacy::PassManager::run
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
Definition: LegacyPassManager.cpp:1680
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::PassManagerBuilder::populateThinLTOPassManager
void populateThinLTOPassManager(legacy::PassManagerBase &PM)
Definition: PassManagerBuilder.cpp:1152
llvm::lto::Config::PassPlugins
std::vector< std::string > PassPlugins
Definition: Config.h:50
llvm::lto::Config::CPU
std::string CPU
Definition: Config.h:47
llvm::getBitcodeModuleList
Expected< std::vector< BitcodeModule > > getBitcodeModuleList(MemoryBufferRef Buffer)
Returns a list of modules in the specified bitcode buffer.
Definition: BitcodeReader.cpp:6713
llvm::BitcodeModule
Represents a module in a bitcode file.
Definition: BitcodeReader.h:60
llvm::cl::desc
Definition: CommandLine.h:414
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
BitcodeReader.h
raw_ostream.h
TargetRegistry.h
llvm::SplitModule
void SplitModule(Module &M, unsigned N, function_ref< void(std::unique_ptr< Module > MPart)> ModuleCallback, bool PreserveLocals=false)
Splits the module M into N linkable partitions.
Definition: SplitModule.cpp:248
MPM
ModulePassManager MPM
Definition: PassBuilderBindings.cpp:70
CGAM
CGSCCAnalysisManager CGAM
Definition: PassBuilderBindings.cpp:60
llvm::TargetLibraryAnalysis
Analysis pass providing the TargetLibraryInfo.
Definition: TargetLibraryInfo.h:438
llvm::splitCodeGen
void splitCodeGen(Module &M, ArrayRef< raw_pwrite_stream * > OSs, ArrayRef< llvm::raw_pwrite_stream * > BCOSs, const std::function< std::unique_ptr< TargetMachine >()> &TMFactory, CodeGenFileType FileType=CGFT_ObjectFile, bool PreserveLocals=false)
Split M into OSs.size() partitions, and generate code for each.
Definition: ParallelCG.cpp:39
llvm::PassManager::addPass
std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT Pass)
Definition: PassManager.h:542
llvm::lto::Config::RemarksPasses
std::string RemarksPasses
Optimization remarks pass filter.
Definition: Config.h:133
StandardInstrumentations.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:420