LLVM  14.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"
30 #include "llvm/MC/TargetRegistry.h"
33 #include "llvm/Passes/PassPlugin.h"
35 #include "llvm/Support/Error.h"
38 #include "llvm/Support/Path.h"
39 #include "llvm/Support/Program.h"
43 #include "llvm/Transforms/IPO.h"
48 
49 using namespace llvm;
50 using namespace lto;
51 
52 #define DEBUG_TYPE "lto-backend"
53 
54 enum class LTOBitcodeEmbedding {
55  DoNotEmbed = 0,
56  EmbedOptimized = 1,
58 };
59 
61  "lto-embed-bitcode", cl::init(LTOBitcodeEmbedding::DoNotEmbed),
63  "Do not embed"),
65  "Embed after all optimization passes"),
67  "post-merge-pre-opt",
68  "Embed post merge, but before optimizations")),
69  cl::desc("Embed LLVM bitcode in object files produced by LTO"));
70 
72  "thinlto-assume-merged", cl::init(false),
73  cl::desc("Assume the input has already undergone ThinLTO function "
74  "importing and the other pre-optimization pipeline changes."));
75 
76 namespace llvm {
78 }
79 
80 [[noreturn]] static void reportOpenError(StringRef Path, Twine Msg) {
81  errs() << "failed to open " << Path << ": " << Msg << '\n';
82  errs().flush();
83  exit(1);
84 }
85 
86 Error Config::addSaveTemps(std::string OutputFileName,
87  bool UseInputModulePath) {
89 
90  std::error_code EC;
92  std::make_unique<raw_fd_ostream>(OutputFileName + "resolution.txt", EC,
94  if (EC) {
95  ResolutionFile.reset();
96  return errorCodeToError(EC);
97  }
98 
99  auto setHook = [&](std::string PathSuffix, ModuleHookFn &Hook) {
100  // Keep track of the hook provided by the linker, which also needs to run.
101  ModuleHookFn LinkerHook = Hook;
102  Hook = [=](unsigned Task, const Module &M) {
103  // If the linker's hook returned false, we need to pass that result
104  // through.
105  if (LinkerHook && !LinkerHook(Task, M))
106  return false;
107 
108  std::string PathPrefix;
109  // If this is the combined module (not a ThinLTO backend compile) or the
110  // user hasn't requested using the input module's path, emit to a file
111  // named from the provided OutputFileName with the Task ID appended.
112  if (M.getModuleIdentifier() == "ld-temp.o" || !UseInputModulePath) {
113  PathPrefix = OutputFileName;
114  if (Task != (unsigned)-1)
115  PathPrefix += utostr(Task) + ".";
116  } else
117  PathPrefix = M.getModuleIdentifier() + ".";
118  std::string Path = PathPrefix + PathSuffix + ".bc";
119  std::error_code EC;
121  // Because -save-temps is a debugging feature, we report the error
122  // directly and exit.
123  if (EC)
124  reportOpenError(Path, EC.message());
125  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false);
126  return true;
127  };
128  };
129 
130  setHook("0.preopt", PreOptModuleHook);
131  setHook("1.promote", PostPromoteModuleHook);
132  setHook("2.internalize", PostInternalizeModuleHook);
133  setHook("3.import", PostImportModuleHook);
134  setHook("4.opt", PostOptModuleHook);
135  setHook("5.precodegen", PreCodeGenModuleHook);
136 
138  [=](const ModuleSummaryIndex &Index,
139  const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
140  std::string Path = OutputFileName + "index.bc";
141  std::error_code EC;
143  // Because -save-temps is a debugging feature, we report the error
144  // directly and exit.
145  if (EC)
146  reportOpenError(Path, EC.message());
147  WriteIndexToFile(Index, OS);
148 
149  Path = OutputFileName + "index.dot";
151  if (EC)
152  reportOpenError(Path, EC.message());
153  Index.exportToDot(OSDot, GUIDPreservedSymbols);
154  return true;
155  };
156 
157  return Error::success();
158 }
159 
160 #define HANDLE_EXTENSION(Ext) \
161  llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
162 #include "llvm/Support/Extension.def"
163 
165  PassBuilder &PB) {
166 #define HANDLE_EXTENSION(Ext) \
167  get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
168 #include "llvm/Support/Extension.def"
169 
170  // Load requested pass plugins and let them register pass builder callbacks
171  for (auto &PluginFN : PassPlugins) {
172  auto PassPlugin = PassPlugin::Load(PluginFN);
173  if (!PassPlugin) {
174  errs() << "Failed to load passes from '" << PluginFN
175  << "'. Request ignored.\n";
176  continue;
177  }
178 
180  }
181 }
182 
183 static std::unique_ptr<TargetMachine>
184 createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M) {
185  StringRef TheTriple = M.getTargetTriple();
186  SubtargetFeatures Features;
187  Features.getDefaultSubtargetFeatures(Triple(TheTriple));
188  for (const std::string &A : Conf.MAttrs)
189  Features.AddFeature(A);
190 
191  Optional<Reloc::Model> RelocModel = None;
192  if (Conf.RelocModel)
193  RelocModel = *Conf.RelocModel;
194  else if (M.getModuleFlag("PIC Level"))
195  RelocModel =
196  M.getPICLevel() == PICLevel::NotPIC ? Reloc::Static : Reloc::PIC_;
197 
199  if (Conf.CodeModel)
200  CodeModel = *Conf.CodeModel;
201  else
202  CodeModel = M.getCodeModel();
203 
204  std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
205  TheTriple, Conf.CPU, Features.getString(), Conf.Options, RelocModel,
206  CodeModel, Conf.CGOptLevel));
207  assert(TM && "Failed to create target machine");
208  return TM;
209 }
210 
211 static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
212  unsigned OptLevel, bool IsThinLTO,
213  ModuleSummaryIndex *ExportSummary,
214  const ModuleSummaryIndex *ImportSummary) {
215  Optional<PGOOptions> PGOOpt;
216  if (!Conf.SampleProfile.empty())
217  PGOOpt = PGOOptions(Conf.SampleProfile, "", Conf.ProfileRemapping,
219  else if (Conf.RunCSIRInstr) {
220  PGOOpt = PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping,
222  Conf.AddFSDiscriminator);
223  } else if (!Conf.CSIRProfile.empty()) {
224  PGOOpt = PGOOptions(Conf.CSIRProfile, "", Conf.ProfileRemapping,
226  Conf.AddFSDiscriminator);
228  } else if (Conf.AddFSDiscriminator) {
229  PGOOpt = PGOOptions("", "", "", PGOOptions::NoAction,
230  PGOOptions::NoCSAction, true);
231  }
232  TM->setPGOOption(PGOOpt);
233 
238 
242  PassBuilder PB(TM, Conf.PTO, PGOOpt, &PIC);
243 
245 
246  std::unique_ptr<TargetLibraryInfoImpl> TLII(
247  new TargetLibraryInfoImpl(Triple(TM->getTargetTriple())));
248  if (Conf.Freestanding)
249  TLII->disableAllFunctions();
250  FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
251 
252  // Parse a custom AA pipeline if asked to.
253  if (!Conf.AAPipeline.empty()) {
254  AAManager AA;
255  if (auto Err = PB.parseAAPipeline(AA, Conf.AAPipeline)) {
256  report_fatal_error(Twine("unable to parse AA pipeline description '") +
257  Conf.AAPipeline + "': " + toString(std::move(Err)));
258  }
259  // Register the AA manager first so that our version is the one used.
260  FAM.registerPass([&] { return std::move(AA); });
261  }
262 
263  // Register all the basic analyses with the managers.
269 
271 
272  if (!Conf.DisableVerify)
274 
276 
277  switch (OptLevel) {
278  default:
279  llvm_unreachable("Invalid optimization level");
280  case 0:
282  break;
283  case 1:
285  break;
286  case 2:
288  break;
289  case 3:
291  break;
292  }
293 
294  // Parse a custom pipeline if asked to.
295  if (!Conf.OptPipeline.empty()) {
296  if (auto Err = PB.parsePassPipeline(MPM, Conf.OptPipeline)) {
297  report_fatal_error(Twine("unable to parse pass pipeline description '") +
298  Conf.OptPipeline + "': " + toString(std::move(Err)));
299  }
300  } else if (IsThinLTO) {
301  MPM.addPass(PB.buildThinLTODefaultPipeline(OL, ImportSummary));
302  } else {
303  MPM.addPass(PB.buildLTODefaultPipeline(OL, ExportSummary));
304  }
305 
306  if (!Conf.DisableVerify)
308 
309  MPM.run(Mod, MAM);
310 }
311 
312 static void runOldPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
313  bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
314  const ModuleSummaryIndex *ImportSummary) {
315  legacy::PassManager passes;
316  passes.add(createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis()));
317 
318  PassManagerBuilder PMB;
319  PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM->getTargetTriple()));
320  if (Conf.Freestanding)
323  PMB.ExportSummary = ExportSummary;
324  PMB.ImportSummary = ImportSummary;
325  // Unconditionally verify input since it is not verified before this
326  // point and has unknown origin.
327  PMB.VerifyInput = true;
328  PMB.VerifyOutput = !Conf.DisableVerify;
329  PMB.LoopVectorize = true;
330  PMB.SLPVectorize = true;
331  PMB.OptLevel = Conf.OptLevel;
332  PMB.PGOSampleUse = Conf.SampleProfile;
334  if (!Conf.RunCSIRInstr && !Conf.CSIRProfile.empty()) {
335  PMB.EnablePGOCSInstrUse = true;
336  PMB.PGOInstrUse = Conf.CSIRProfile;
337  }
338  if (IsThinLTO)
339  PMB.populateThinLTOPassManager(passes);
340  else
341  PMB.populateLTOPassManager(passes);
342  passes.run(Mod);
343 }
344 
345 bool lto::opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
346  bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
347  const ModuleSummaryIndex *ImportSummary,
348  const std::vector<uint8_t> &CmdArgs) {
350  // FIXME: the motivation for capturing post-merge bitcode and command line
351  // is replicating the compilation environment from bitcode, without needing
352  // to understand the dependencies (the functions to be imported). This
353  // assumes a clang - based invocation, case in which we have the command
354  // line.
355  // It's not very clear how the above motivation would map in the
356  // linker-based case, so we currently don't plumb the command line args in
357  // that case.
358  if (CmdArgs.empty())
359  LLVM_DEBUG(
360  dbgs() << "Post-(Thin)LTO merge bitcode embedding was requested, but "
361  "command line arguments are not available");
363  /*EmbedBitcode*/ true, /*EmbedCmdline*/ true,
364  /*Cmdline*/ CmdArgs);
365  }
366  // FIXME: Plumb the combined index into the new pass manager.
367  if (Conf.UseNewPM || !Conf.OptPipeline.empty()) {
368  runNewPMPasses(Conf, Mod, TM, Conf.OptLevel, IsThinLTO, ExportSummary,
369  ImportSummary);
370  } else {
371  runOldPMPasses(Conf, Mod, TM, IsThinLTO, ExportSummary, ImportSummary);
372  }
373  return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
374 }
375 
376 static void codegen(const Config &Conf, TargetMachine *TM,
377  AddStreamFn AddStream, unsigned Task, Module &Mod,
378  const ModuleSummaryIndex &CombinedIndex) {
379  if (Conf.PreCodeGenModuleHook && !Conf.PreCodeGenModuleHook(Task, Mod))
380  return;
381 
384  /*EmbedBitcode*/ true,
385  /*EmbedCmdline*/ false,
386  /*CmdArgs*/ std::vector<uint8_t>());
387 
388  std::unique_ptr<ToolOutputFile> DwoOut;
389  SmallString<1024> DwoFile(Conf.SplitDwarfOutput);
390  if (!Conf.DwoDir.empty()) {
391  std::error_code EC;
392  if (auto EC = llvm::sys::fs::create_directories(Conf.DwoDir))
393  report_fatal_error(Twine("Failed to create directory ") + Conf.DwoDir +
394  ": " + EC.message());
395 
396  DwoFile = Conf.DwoDir;
397  sys::path::append(DwoFile, std::to_string(Task) + ".dwo");
398  TM->Options.MCOptions.SplitDwarfFile = std::string(DwoFile);
399  } else
400  TM->Options.MCOptions.SplitDwarfFile = Conf.SplitDwarfFile;
401 
402  if (!DwoFile.empty()) {
403  std::error_code EC;
404  DwoOut = std::make_unique<ToolOutputFile>(DwoFile, EC, sys::fs::OF_None);
405  if (EC)
406  report_fatal_error(Twine("Failed to open ") + DwoFile + ": " +
407  EC.message());
408  }
409 
410  Expected<std::unique_ptr<CachedFileStream>> StreamOrErr = AddStream(Task);
411  if (Error Err = StreamOrErr.takeError())
413  std::unique_ptr<CachedFileStream> &Stream = *StreamOrErr;
414  TM->Options.ObjectFilenameForDebug = Stream->ObjectPathName;
415 
416  legacy::PassManager CodeGenPasses;
418  CodeGenPasses.add(new TargetLibraryInfoWrapperPass(TLII));
419  CodeGenPasses.add(
421  if (Conf.PreCodeGenPassesHook)
422  Conf.PreCodeGenPassesHook(CodeGenPasses);
423  if (TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS,
424  DwoOut ? &DwoOut->os() : nullptr,
425  Conf.CGFileType))
426  report_fatal_error("Failed to setup codegen");
427  CodeGenPasses.run(Mod);
428 
429  if (DwoOut)
430  DwoOut->keep();
431 }
432 
433 static void splitCodeGen(const Config &C, TargetMachine *TM,
434  AddStreamFn AddStream,
435  unsigned ParallelCodeGenParallelismLevel, Module &Mod,
436  const ModuleSummaryIndex &CombinedIndex) {
437  ThreadPool CodegenThreadPool(
438  heavyweight_hardware_concurrency(ParallelCodeGenParallelismLevel));
439  unsigned ThreadCount = 0;
440  const Target *T = &TM->getTarget();
441 
442  SplitModule(
443  Mod, ParallelCodeGenParallelismLevel,
444  [&](std::unique_ptr<Module> MPart) {
445  // We want to clone the module in a new context to multi-thread the
446  // codegen. We do it by serializing partition modules to bitcode
447  // (while still on the main thread, in order to avoid data races) and
448  // spinning up new threads which deserialize the partitions into
449  // separate contexts.
450  // FIXME: Provide a more direct way to do this in LLVM.
451  SmallString<0> BC;
452  raw_svector_ostream BCOS(BC);
453  WriteBitcodeToFile(*MPart, BCOS);
454 
455  // Enqueue the task
456  CodegenThreadPool.async(
457  [&](const SmallString<0> &BC, unsigned ThreadId) {
458  LTOLLVMContext Ctx(C);
460  MemoryBufferRef(StringRef(BC.data(), BC.size()), "ld-temp.o"),
461  Ctx);
462  if (!MOrErr)
463  report_fatal_error("Failed to read bitcode");
464  std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
465 
466  std::unique_ptr<TargetMachine> TM =
467  createTargetMachine(C, T, *MPartInCtx);
468 
469  codegen(C, TM.get(), AddStream, ThreadId, *MPartInCtx,
470  CombinedIndex);
471  },
472  // Pass BC using std::move to ensure that it get moved rather than
473  // copied into the thread's context.
474  std::move(BC), ThreadCount++);
475  },
476  false);
477 
478  // Because the inner lambda (which runs in a worker thread) captures our local
479  // variables, we need to wait for the worker threads to terminate before we
480  // can leave the function scope.
481  CodegenThreadPool.wait();
482 }
483 
485  Module &Mod) {
486  if (!C.OverrideTriple.empty())
487  Mod.setTargetTriple(C.OverrideTriple);
488  else if (Mod.getTargetTriple().empty())
489  Mod.setTargetTriple(C.DefaultTriple);
490 
491  std::string Msg;
493  if (!T)
494  return make_error<StringError>(Msg, inconvertibleErrorCode());
495  return T;
496 }
497 
499  std::unique_ptr<ToolOutputFile> DiagOutputFile) {
500  // Make sure we flush the diagnostic remarks file in case the linker doesn't
501  // call the global destructors before exiting.
502  if (!DiagOutputFile)
503  return Error::success();
504  DiagOutputFile->keep();
505  DiagOutputFile->os().flush();
506  return Error::success();
507 }
508 
510  unsigned ParallelCodeGenParallelismLevel, Module &Mod,
511  ModuleSummaryIndex &CombinedIndex) {
513  if (!TOrErr)
514  return TOrErr.takeError();
515 
516  std::unique_ptr<TargetMachine> TM = createTargetMachine(C, *TOrErr, Mod);
517 
518  if (!C.CodeGenOnly) {
519  if (!opt(C, TM.get(), 0, Mod, /*IsThinLTO=*/false,
520  /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
521  /*CmdArgs*/ std::vector<uint8_t>()))
522  return Error::success();
523  }
524 
525  if (ParallelCodeGenParallelismLevel == 1) {
526  codegen(C, TM.get(), AddStream, 0, Mod, CombinedIndex);
527  } else {
528  splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel, Mod,
529  CombinedIndex);
530  }
531  return Error::success();
532 }
533 
534 static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals,
535  const ModuleSummaryIndex &Index) {
536  std::vector<GlobalValue*> DeadGVs;
537  for (auto &GV : Mod.global_values())
538  if (GlobalValueSummary *GVS = DefinedGlobals.lookup(GV.getGUID()))
539  if (!Index.isGlobalValueLive(GVS)) {
540  DeadGVs.push_back(&GV);
542  }
543 
544  // Now that all dead bodies have been dropped, delete the actual objects
545  // themselves when possible.
546  for (GlobalValue *GV : DeadGVs) {
547  GV->removeDeadConstantUsers();
548  // Might reference something defined in native object (i.e. dropped a
549  // non-prevailing IR def, but we need to keep the declaration).
550  if (GV->use_empty())
551  GV->eraseFromParent();
552  }
553 }
554 
555 Error lto::thinBackend(const Config &Conf, unsigned Task, AddStreamFn AddStream,
556  Module &Mod, const ModuleSummaryIndex &CombinedIndex,
557  const FunctionImporter::ImportMapTy &ImportList,
558  const GVSummaryMapTy &DefinedGlobals,
560  const std::vector<uint8_t> &CmdArgs) {
562  if (!TOrErr)
563  return TOrErr.takeError();
564 
565  std::unique_ptr<TargetMachine> TM = createTargetMachine(Conf, *TOrErr, Mod);
566 
567  // Setup optimization remarks.
568  auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
571  Task);
572  if (!DiagFileOrErr)
573  return DiagFileOrErr.takeError();
574  auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
575 
576  // Set the partial sample profile ratio in the profile summary module flag of
577  // the module, if applicable.
578  Mod.setPartialSampleProfileRatio(CombinedIndex);
579 
580  if (Conf.CodeGenOnly) {
581  codegen(Conf, TM.get(), AddStream, Task, Mod, CombinedIndex);
582  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
583  }
584 
585  if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
586  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
587 
588  auto OptimizeAndCodegen =
589  [&](Module &Mod, TargetMachine *TM,
590  std::unique_ptr<ToolOutputFile> DiagnosticOutputFile) {
591  if (!opt(Conf, TM, Task, Mod, /*IsThinLTO=*/true,
592  /*ExportSummary=*/nullptr, /*ImportSummary=*/&CombinedIndex,
593  CmdArgs))
594  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
595 
596  codegen(Conf, TM, AddStream, Task, Mod, CombinedIndex);
597  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
598  };
599 
601  return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
602 
603  // When linking an ELF shared object, dso_local should be dropped. We
604  // conservatively do this for -fpic.
605  bool ClearDSOLocalOnDeclarations =
606  TM->getTargetTriple().isOSBinFormatELF() &&
607  TM->getRelocationModel() != Reloc::Static &&
609  renameModuleForThinLTO(Mod, CombinedIndex, ClearDSOLocalOnDeclarations);
610 
611  dropDeadSymbols(Mod, DefinedGlobals, CombinedIndex);
612 
613  thinLTOFinalizeInModule(Mod, DefinedGlobals, /*PropagateAttrs=*/true);
614 
615  if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
616  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
617 
618  if (!DefinedGlobals.empty())
619  thinLTOInternalizeModule(Mod, DefinedGlobals);
620 
621  if (Conf.PostInternalizeModuleHook &&
622  !Conf.PostInternalizeModuleHook(Task, Mod))
623  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
624 
625  auto ModuleLoader = [&](StringRef Identifier) {
627  "ODR Type uniquing should be enabled on the context");
628  if (ModuleMap) {
629  auto I = ModuleMap->find(Identifier);
630  assert(I != ModuleMap->end());
631  return I->second.getLazyModule(Mod.getContext(),
632  /*ShouldLazyLoadMetadata=*/true,
633  /*IsImporting*/ true);
634  }
635 
637  llvm::MemoryBuffer::getFile(Identifier);
638  if (!MBOrErr)
639  return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
640  Twine("Error loading imported file ") + Identifier + " : ",
641  MBOrErr.getError()));
642 
643  Expected<BitcodeModule> BMOrErr = findThinLTOModule(**MBOrErr);
644  if (!BMOrErr)
645  return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
646  Twine("Error loading imported file ") + Identifier + " : " +
647  toString(BMOrErr.takeError()),
649 
651  BMOrErr->getLazyModule(Mod.getContext(),
652  /*ShouldLazyLoadMetadata=*/true,
653  /*IsImporting*/ true);
654  if (MOrErr)
655  (*MOrErr)->setOwnedMemoryBuffer(std::move(*MBOrErr));
656  return MOrErr;
657  };
658 
659  FunctionImporter Importer(CombinedIndex, ModuleLoader,
660  ClearDSOLocalOnDeclarations);
661  if (Error Err = Importer.importFunctions(Mod, ImportList).takeError())
662  return Err;
663 
664  if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
665  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
666 
667  return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
668 }
669 
671  if (ThinLTOAssumeMerged && BMs.size() == 1)
672  return BMs.begin();
673 
674  for (BitcodeModule &BM : BMs) {
675  Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
676  if (LTOInfo && LTOInfo->IsThinLTO)
677  return &BM;
678  }
679  return nullptr;
680 }
681 
684  if (!BMsOrErr)
685  return BMsOrErr.takeError();
686 
687  // The bitcode file may contain multiple modules, we want the one that is
688  // marked as being the ThinLTO module.
689  if (const BitcodeModule *Bm = lto::findThinLTOModule(*BMsOrErr))
690  return *Bm;
691 
692  return make_error<StringError>("Could not find module summary",
694 }
695 
697  const ModuleSummaryIndex &CombinedIndex,
698  FunctionImporter::ImportMapTy &ImportList) {
700  return true;
701  // We can simply import the values mentioned in the combined index, since
702  // we should only invoke this using the individual indexes written out
703  // via a WriteIndexesThinBackend.
704  for (const auto &GlobalList : CombinedIndex) {
705  // Ignore entries for undefined references.
706  if (GlobalList.second.SummaryList.empty())
707  continue;
708 
709  auto GUID = GlobalList.first;
710  for (const auto &Summary : GlobalList.second.SummaryList) {
711  // Skip the summaries for the importing module. These are included to
712  // e.g. record required linkage changes.
713  if (Summary->modulePath() == M.getModuleIdentifier())
714  continue;
715  // Add an entry to provoke importing by thinBackend.
716  ImportList[Summary->modulePath()].insert(GUID);
717  }
718  }
719  return true;
720 }
llvm::Module::global_values
iterator_range< global_value_iterator > global_values()
Definition: Module.cpp:424
MemoryBuffer.h
llvm::AAManager
A manager for alias analyses.
Definition: AliasAnalysis.h:1287
llvm::PassManagerBuilder::PGOSampleUse
std::string PGOSampleUse
Path of the sample Profile data file.
Definition: PassManagerBuilder.h:186
FunctionImportUtils.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
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:696
llvm::OptimizationLevel::O1
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
Definition: OptimizationLevel.h:57
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:1147
FileSystem.h
llvm::sys::fs::OF_None
@ OF_None
Definition: FileSystem.h:757
LTOBitcodeEmbedding::EmbedOptimized
@ EmbedOptimized
LTOBitcodeEmbedding
LTOBitcodeEmbedding
Definition: LTOBackend.cpp:54
llvm::lto::Config::DisableVerify
bool DisableVerify
Definition: Config.h:58
llvm::lto::finalizeOptimizationRemarks
Error finalizeOptimizationRemarks(std::unique_ptr< ToolOutputFile > DiagOutputFile)
Definition: LTOBackend.cpp:498
llvm::ThreadPool
A ThreadPool for asynchronous parallel execution on a defined number of threads.
Definition: ThreadPool.h:37
T
llvm::lto::Config::CGOptLevel
CodeGenOpt::Level CGOptLevel
Definition: Config.h:55
llvm::PassManagerBuilder::VerifyOutput
bool VerifyOutput
Definition: PassManagerBuilder.h:166
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::PassManager::addPass
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
Definition: PassManager.h:553
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:330
llvm::OptimizationLevel::O2
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
Definition: OptimizationLevel.h:74
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:157
llvm::lto::Config::CodeModel
Optional< CodeModel::Model > CodeModel
Definition: Config.h:54
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:137
RegisterPassPlugins
static void RegisterPassPlugins(ArrayRef< std::string > PassPlugins, PassBuilder &PB)
Definition: LTOBackend.cpp:164
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:1029
llvm::lto::Config::RemarksWithHotness
bool RemarksWithHotness
Whether to emit optimization remarks with hotness informations.
Definition: Config.h:139
Path.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::PassManagerBuilder::populateLTOPassManager
void populateLTOPassManager(legacy::PassManagerBase &PM)
Definition: PassManagerBuilder.cpp:1211
llvm::StandardInstrumentations::registerCallbacks
void registerCallbacks(PassInstrumentationCallbacks &PIC, FunctionAnalysisManager *FAM=nullptr)
Definition: StandardInstrumentations.cpp:2120
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
llvm::PassManagerBuilder::LoopVectorize
bool LoopVectorize
Definition: PassManagerBuilder.h:159
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:44
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:165
llvm::PassManagerBuilder::ImportSummary
const ModuleSummaryIndex * ImportSummary
The module summary index to use for importing information to the thin LTO backends,...
Definition: PassManagerBuilder.h:154
PIC
PassInstrumentationCallbacks PIC
Definition: PassBuilderBindings.cpp:55
llvm::createImmutableModuleSummaryIndexWrapperPass
ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)
Definition: ModuleSummaryAnalysis.cpp:964
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
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:149
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:893
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:1578
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::lto::Config::ShouldDiscardValueNames
bool ShouldDiscardValueNames
Definition: Config.h:174
ModuleSummaryAnalysis.h
llvm::lto::Config::PostImportModuleHook
ModuleHookFn PostImportModuleHook
This hook is called after importing from other modules (ThinLTO-specific).
Definition: Config.h:227
llvm::lto::Config::CodeGenOnly
bool CodeGenOnly
Disable entirely the optimizer, including importing for ThinLTO.
Definition: Config.h:68
llvm::PGOOptions::SampleUse
@ SampleUse
Definition: PGOOptions.h:23
llvm::OptimizationLevel::O0
static const OptimizationLevel O0
Disable as many optimizations as possible.
Definition: OptimizationLevel.h:41
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
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:211
llvm::lto::findThinLTOModule
BitcodeModule * findThinLTOModule(MutableArrayRef< BitcodeModule > BMs)
Returns the BitcodeModule that is ThinLTO.
Definition: LTOBackend.cpp:670
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::lto::Config::CombinedIndexHook
CombinedIndexHookFn CombinedIndexHook
Definition: Config.h:249
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
initAndLookupTarget
static Expected< const Target * > initAndLookupTarget(const Config &C, Module &Mod)
Definition: LTOBackend.cpp:484
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:457
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::PassBuilder::parsePassPipeline
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
Definition: PassBuilder.cpp:1590
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:125
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:1214
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:290
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:236
llvm::lto::Config::PostPromoteModuleHook
ModuleHookFn PostPromoteModuleHook
This hook is called after promoting any internal functions (ThinLTO-specific).
Definition: Config.h:221
SubtargetFeature.h
llvm::MSP430Attrs::CodeModel
CodeModel
Definition: MSP430Attributes.h:37
TargetMachine.h
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:305
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:345
llvm::PassManagerBuilder::LibraryInfo
TargetLibraryInfoImpl * LibraryInfo
LibraryInfo - Specifies information about the runtime library for the optimizer.
Definition: PassManagerBuilder.h:140
llvm::lto::Config::SampleProfile
std::string SampleProfile
Sample PGO profile path.
Definition: Config.h:113
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:274
llvm::errorCodeToError
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:90
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:94
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: PGOOptions.h:23
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
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:964
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:4671
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:184
llvm::thinLTOFinalizeInModule
void thinLTOFinalizeInModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals, bool PropagateAttrs)
Based on the information recorded in the summaries during global summary-based analysis:
Definition: FunctionImport.cpp:1054
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
LTOBitcodeEmbedding::DoNotEmbed
@ DoNotEmbed
llvm::PassManagerBuilder::Inliner
Pass * Inliner
Inliner - Specifies the inliner to use.
Definition: PassManagerBuilder.h:144
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:186
llvm::PGOOptions::CSIRInstr
@ CSIRInstr
Definition: PGOOptions.h:24
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:213
llvm::lto::Config::DebugPassManager
bool DebugPassManager
Whether to emit the pass manager debuggging informations.
Definition: Config.h:160
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:4883
llvm::Module::setTargetTriple
void setTargetTriple(StringRef T)
Set the target triple.
Definition: Module.h:298
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:224
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:770
LTOBackend.h
llvm::PassManagerBuilder
PassManagerBuilder - This class is used to set up a standard optimization sequence for languages like...
Definition: PassManagerBuilder.h:58
llvm::lto::Config::PreCodeGenModuleHook
ModuleHookFn PreCodeGenModuleHook
This module hook is called before code generation.
Definition: Config.h:235
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:1019
llvm::createTargetTransformInfoWrapperPass
ImmutablePass * createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA)
Create an analysis pass wrapper around a TTI object.
Definition: TargetTransformInfo.cpp:1204
llvm::PGOOptions::NoCSAction
@ NoCSAction
Definition: PGOOptions.h:24
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
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
ThreadPool.h
llvm::lto::Config::RemarksFilename
std::string RemarksFilename
Optimization remarks file path.
Definition: Config.h:133
llvm::cl::opt
Definition: CommandLine.h:1432
llvm::lto::backend
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:509
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::PassBuilder::registerFunctionAnalyses
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
Definition: PassBuilder.cpp:430
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:697
llvm::StandardInstrumentations
This class provides an interface to register all the standard pass instrumentations and manages their...
Definition: StandardInstrumentations.h:496
llvm::MapVector::find
iterator find(const KeyT &Key)
Definition: MapVector.h:148
Index
uint32_t Index
Definition: ELFObjHandler.cpp:83
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:465
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:7080
IPO.h
llvm::lto::Config::DwoDir
std::string DwoDir
The directory to store .dwo files.
Definition: Config.h:119
llvm::lto::Config::AddFSDiscriminator
bool AddFSDiscriminator
Add FSAFDO discriminators.
Definition: Config.h:178
llvm::PassBuilder::registerModuleAnalyses
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
Definition: PassBuilder.cpp:412
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: PassBuilderPipelines.cpp:1421
llvm::lto::LTOLLVMContext
A derived class of LLVMContext that initializes itself according to a given Config object.
Definition: Config.h:284
I
#define I(x, y, z)
Definition: MD5.cpp:58
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: PassBuilderPipelines.cpp:1356
createTargetMachine
static std::unique_ptr< TargetMachine > createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M)
Definition: LTOBackend.cpp:184
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:441
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:86
llvm::PassManagerBuilder::OptLevel
unsigned OptLevel
The Optimization Level - Specify the basic optimization level.
Definition: PassManagerBuilder.h:131
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::PassManagerBuilder::PGOInstrUse
std::string PGOInstrUse
Path of the profile data file.
Definition: PassManagerBuilder.h:184
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:80
llvm::lto::Config::SplitDwarfOutput
std::string SplitDwarfOutput
The path to write a .dwo file to.
Definition: Config.h:130
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::PassManagerBuilder::VerifyInput
bool VerifyInput
Definition: PassManagerBuilder.h:165
llvm::lto::Config::MAttrs
std::vector< std::string > MAttrs
Definition: Config.h:49
llvm::MutableArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:354
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
LoopPassManager.h
llvm::lto::Config::ProfileRemapping
std::string ProfileRemapping
Name remapping file for profile data.
Definition: Config.h:116
llvm::PGOOptions::NoAction
@ NoAction
Definition: PGOOptions.h:23
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:4626
ModuleSymbolTable.h
llvm::lto::Config::RelocModel
Optional< Reloc::Model > RelocModel
Definition: Config.h:53
llvm::ArrayRef< std::string >
llvm::lto::Config::PostOptModuleHook
ModuleHookFn PostOptModuleHook
This module hook is called after optimization is complete.
Definition: Config.h:230
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:154
llvm::PassManagerBuilder::SLPVectorize
bool SLPVectorize
Definition: PassManagerBuilder.h:158
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:555
llvm::PIELevel::Default
@ Default
Definition: CodeGen.h:37
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
LTOBitcodeEmbedding::EmbedPostMergePreOptimized
@ EmbedPostMergePreOptimized
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::ThreadPool::async
auto async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
Definition: ThreadPool.h:51
llvm::Reloc::Static
@ Static
Definition: CodeGen.h:22
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:568
PassPlugin.h
llvm::PGOOptions
A struct capturing PGO tunables.
Definition: PGOOptions.h:22
llvm::OptimizationLevel::O3
static const OptimizationLevel O3
Optimize for fast execution as much as possible.
Definition: OptimizationLevel.h:89
clEnumValN
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:672
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:94
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::NoPGOWarnMismatch
cl::opt< bool > NoPGOWarnMismatch
llvm::raw_fd_ostream
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:443
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:1697
llvm::MapVector::end
iterator end()
Definition: MapVector.h:72
runOldPMPasses
static void runOldPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
Definition: LTOBackend.cpp:312
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:444
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
Verifier.h
llvm::TargetLibraryInfoImpl::disableAllFunctions
void disableAllFunctions()
Disables all builtins.
Definition: TargetLibraryInfo.cpp:1818
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:156
llvm::legacy::PassManager
PassManager manages ModulePassManagers.
Definition: LegacyPassManager.h:52
llvm::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:259
dropDeadSymbols
static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals, const ModuleSummaryIndex &Index)
Definition: LTOBackend.cpp:534
llvm::PassBuilder::registerCGSCCAnalyses
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
Definition: PassBuilder.cpp:421
llvm::OptimizationLevel
Definition: OptimizationLevel.h:22
llvm::lto::Config::AAPipeline
std::string AAPipeline
Definition: Config.h:99
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:217
llvm::PGOOptions::CSIRUse
@ CSIRUse
Definition: PGOOptions.h:24
llvm::lto::Config::PTO
PipelineTuningOptions PTO
Tunable parameters for passes in the default pipelines.
Definition: Config.h:187
llvm::legacy::PassManager::add
void add(Pass *P) override
Add a pass to the queue of passes to run.
Definition: LegacyPassManager.cpp:1670
llvm::lto::Config::CSIRProfile
std::string CSIRProfile
Context Sensitive PGO profile path.
Definition: Config.h:110
reportOpenError
static void reportOpenError(StringRef Path, Twine Msg)
Definition: LTOBackend.cpp:80
llvm::AnalysisManager::registerPass
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:845
llvm::PassManagerBuilder::EnablePGOCSInstrGen
bool EnablePGOCSInstrGen
Enable profile context sensitive instrumentation pass.
Definition: PassManagerBuilder.h:178
llvm::Module::getPIELevel
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
Definition: Module.cpp:605
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:501
llvm::PassManagerBuilder::EnablePGOCSInstrUse
bool EnablePGOCSInstrUse
Enable profile context sensitive profile use pass.
Definition: PassManagerBuilder.h:180
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:797
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:598
llvm::ThreadPool::wait
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
Definition: ThreadPool.cpp:73
codegen
static void codegen(const Config &Conf, TargetMachine *TM, AddStreamFn AddStream, unsigned Task, Module &Mod, const ModuleSummaryIndex &CombinedIndex)
Definition: LTOBackend.cpp:376
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:1088
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:255
llvm::PassBuilder::crossRegisterProxies
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM)
Cross register the analysis managers through their proxies.
Definition: PassBuilder.cpp:1565
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:87
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
TargetTransformInfo.h
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:661
llvm::legacy::PassManager::run
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
Definition: LegacyPassManager.cpp:1676
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:1178
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:6739
llvm::BitcodeModule
Represents a module in a bitcode file.
Definition: BitcodeReader.h:60
llvm::cl::desc
Definition: CommandLine.h:412
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:251
MPM
ModulePassManager MPM
Definition: PassBuilderBindings.cpp:70
CGAM
CGSCCAnalysisManager CGAM
Definition: PassBuilderBindings.cpp:60
llvm::TargetLibraryAnalysis
Analysis pass providing the TargetLibraryInfo.
Definition: TargetLibraryInfo.h:440
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::lto::Config::RemarksPasses
std::string RemarksPasses
Optimization remarks pass filter.
Definition: Config.h:136
llvm::lto::Config::PGOWarnMismatch
bool PGOWarnMismatch
Turn on/off the warning about a hash mismatch in the PGO profile data.
Definition: Config.h:74
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:449