LLVM  15.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"
25 #include "llvm/IR/PassManager.h"
26 #include "llvm/IR/Verifier.h"
27 #include "llvm/LTO/LTO.h"
29 #include "llvm/MC/TargetRegistry.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"
46 
47 using namespace llvm;
48 using namespace lto;
49 
50 #define DEBUG_TYPE "lto-backend"
51 
52 enum class LTOBitcodeEmbedding {
53  DoNotEmbed = 0,
54  EmbedOptimized = 1,
56 };
57 
59  "lto-embed-bitcode", cl::init(LTOBitcodeEmbedding::DoNotEmbed),
61  "Do not embed"),
63  "Embed after all optimization passes"),
65  "post-merge-pre-opt",
66  "Embed post merge, but before optimizations")),
67  cl::desc("Embed LLVM bitcode in object files produced by LTO"));
68 
70  "thinlto-assume-merged", cl::init(false),
71  cl::desc("Assume the input has already undergone ThinLTO function "
72  "importing and the other pre-optimization pipeline changes."));
73 
74 namespace llvm {
76 }
77 
78 [[noreturn]] static void reportOpenError(StringRef Path, Twine Msg) {
79  errs() << "failed to open " << Path << ": " << Msg << '\n';
80  errs().flush();
81  exit(1);
82 }
83 
84 Error Config::addSaveTemps(std::string OutputFileName,
85  bool UseInputModulePath) {
87 
88  std::error_code EC;
90  std::make_unique<raw_fd_ostream>(OutputFileName + "resolution.txt", EC,
92  if (EC) {
93  ResolutionFile.reset();
94  return errorCodeToError(EC);
95  }
96 
97  auto setHook = [&](std::string PathSuffix, ModuleHookFn &Hook) {
98  // Keep track of the hook provided by the linker, which also needs to run.
99  ModuleHookFn LinkerHook = Hook;
100  Hook = [=](unsigned Task, const Module &M) {
101  // If the linker's hook returned false, we need to pass that result
102  // through.
103  if (LinkerHook && !LinkerHook(Task, M))
104  return false;
105 
106  std::string PathPrefix;
107  // If this is the combined module (not a ThinLTO backend compile) or the
108  // user hasn't requested using the input module's path, emit to a file
109  // named from the provided OutputFileName with the Task ID appended.
110  if (M.getModuleIdentifier() == "ld-temp.o" || !UseInputModulePath) {
111  PathPrefix = OutputFileName;
112  if (Task != (unsigned)-1)
113  PathPrefix += utostr(Task) + ".";
114  } else
115  PathPrefix = M.getModuleIdentifier() + ".";
116  std::string Path = PathPrefix + PathSuffix + ".bc";
117  std::error_code EC;
119  // Because -save-temps is a debugging feature, we report the error
120  // directly and exit.
121  if (EC)
122  reportOpenError(Path, EC.message());
123  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false);
124  return true;
125  };
126  };
127 
128  setHook("0.preopt", PreOptModuleHook);
129  setHook("1.promote", PostPromoteModuleHook);
130  setHook("2.internalize", PostInternalizeModuleHook);
131  setHook("3.import", PostImportModuleHook);
132  setHook("4.opt", PostOptModuleHook);
133  setHook("5.precodegen", PreCodeGenModuleHook);
134 
136  [=](const ModuleSummaryIndex &Index,
137  const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
138  std::string Path = OutputFileName + "index.bc";
139  std::error_code EC;
141  // Because -save-temps is a debugging feature, we report the error
142  // directly and exit.
143  if (EC)
144  reportOpenError(Path, EC.message());
145  writeIndexToFile(Index, OS);
146 
147  Path = OutputFileName + "index.dot";
149  if (EC)
150  reportOpenError(Path, EC.message());
151  Index.exportToDot(OSDot, GUIDPreservedSymbols);
152  return true;
153  };
154 
155  return Error::success();
156 }
157 
158 #define HANDLE_EXTENSION(Ext) \
159  llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
160 #include "llvm/Support/Extension.def"
161 
163  PassBuilder &PB) {
164 #define HANDLE_EXTENSION(Ext) \
165  get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
166 #include "llvm/Support/Extension.def"
167 
168  // Load requested pass plugins and let them register pass builder callbacks
169  for (auto &PluginFN : PassPlugins) {
170  auto PassPlugin = PassPlugin::Load(PluginFN);
171  if (!PassPlugin) {
172  errs() << "Failed to load passes from '" << PluginFN
173  << "'. Request ignored.\n";
174  continue;
175  }
176 
178  }
179 }
180 
181 static std::unique_ptr<TargetMachine>
182 createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M) {
183  StringRef TheTriple = M.getTargetTriple();
184  SubtargetFeatures Features;
185  Features.getDefaultSubtargetFeatures(Triple(TheTriple));
186  for (const std::string &A : Conf.MAttrs)
187  Features.AddFeature(A);
188 
189  Optional<Reloc::Model> RelocModel = None;
190  if (Conf.RelocModel)
191  RelocModel = *Conf.RelocModel;
192  else if (M.getModuleFlag("PIC Level"))
193  RelocModel =
194  M.getPICLevel() == PICLevel::NotPIC ? Reloc::Static : Reloc::PIC_;
195 
197  if (Conf.CodeModel)
198  CodeModel = *Conf.CodeModel;
199  else
200  CodeModel = M.getCodeModel();
201 
202  std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
203  TheTriple, Conf.CPU, Features.getString(), Conf.Options, RelocModel,
204  CodeModel, Conf.CGOptLevel));
205  assert(TM && "Failed to create target machine");
206  return TM;
207 }
208 
209 static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
210  unsigned OptLevel, bool IsThinLTO,
211  ModuleSummaryIndex *ExportSummary,
212  const ModuleSummaryIndex *ImportSummary) {
213  Optional<PGOOptions> PGOOpt;
214  if (!Conf.SampleProfile.empty())
215  PGOOpt = PGOOptions(Conf.SampleProfile, "", Conf.ProfileRemapping,
217  else if (Conf.RunCSIRInstr) {
218  PGOOpt = PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping,
220  Conf.AddFSDiscriminator);
221  } else if (!Conf.CSIRProfile.empty()) {
222  PGOOpt = PGOOptions(Conf.CSIRProfile, "", Conf.ProfileRemapping,
224  Conf.AddFSDiscriminator);
226  } else if (Conf.AddFSDiscriminator) {
227  PGOOpt = PGOOptions("", "", "", PGOOptions::NoAction,
228  PGOOptions::NoCSAction, true);
229  }
230  TM->setPGOOption(PGOOpt);
231 
236 
240  PassBuilder PB(TM, Conf.PTO, PGOOpt, &PIC);
241 
243 
244  std::unique_ptr<TargetLibraryInfoImpl> TLII(
245  new TargetLibraryInfoImpl(Triple(TM->getTargetTriple())));
246  if (Conf.Freestanding)
247  TLII->disableAllFunctions();
248  FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
249 
250  // Parse a custom AA pipeline if asked to.
251  if (!Conf.AAPipeline.empty()) {
252  AAManager AA;
253  if (auto Err = PB.parseAAPipeline(AA, Conf.AAPipeline)) {
254  report_fatal_error(Twine("unable to parse AA pipeline description '") +
255  Conf.AAPipeline + "': " + toString(std::move(Err)));
256  }
257  // Register the AA manager first so that our version is the one used.
258  FAM.registerPass([&] { return std::move(AA); });
259  }
260 
261  // Register all the basic analyses with the managers.
267 
269 
270  if (!Conf.DisableVerify)
272 
274 
275  switch (OptLevel) {
276  default:
277  llvm_unreachable("Invalid optimization level");
278  case 0:
280  break;
281  case 1:
283  break;
284  case 2:
286  break;
287  case 3:
289  break;
290  }
291 
292  // Parse a custom pipeline if asked to.
293  if (!Conf.OptPipeline.empty()) {
294  if (auto Err = PB.parsePassPipeline(MPM, Conf.OptPipeline)) {
295  report_fatal_error(Twine("unable to parse pass pipeline description '") +
296  Conf.OptPipeline + "': " + toString(std::move(Err)));
297  }
298  } else if (Conf.UseDefaultPipeline) {
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 bool lto::opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
313  bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
314  const ModuleSummaryIndex *ImportSummary,
315  const std::vector<uint8_t> &CmdArgs) {
317  // FIXME: the motivation for capturing post-merge bitcode and command line
318  // is replicating the compilation environment from bitcode, without needing
319  // to understand the dependencies (the functions to be imported). This
320  // assumes a clang - based invocation, case in which we have the command
321  // line.
322  // It's not very clear how the above motivation would map in the
323  // linker-based case, so we currently don't plumb the command line args in
324  // that case.
325  if (CmdArgs.empty())
326  LLVM_DEBUG(
327  dbgs() << "Post-(Thin)LTO merge bitcode embedding was requested, but "
328  "command line arguments are not available");
330  /*EmbedBitcode*/ true, /*EmbedCmdline*/ true,
331  /*Cmdline*/ CmdArgs);
332  }
333  // FIXME: Plumb the combined index into the new pass manager.
334  runNewPMPasses(Conf, Mod, TM, Conf.OptLevel, IsThinLTO, ExportSummary,
335  ImportSummary);
336  return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
337 }
338 
339 static void codegen(const Config &Conf, TargetMachine *TM,
340  AddStreamFn AddStream, unsigned Task, Module &Mod,
341  const ModuleSummaryIndex &CombinedIndex) {
342  if (Conf.PreCodeGenModuleHook && !Conf.PreCodeGenModuleHook(Task, Mod))
343  return;
344 
347  /*EmbedBitcode*/ true,
348  /*EmbedCmdline*/ false,
349  /*CmdArgs*/ std::vector<uint8_t>());
350 
351  std::unique_ptr<ToolOutputFile> DwoOut;
352  SmallString<1024> DwoFile(Conf.SplitDwarfOutput);
353  if (!Conf.DwoDir.empty()) {
354  std::error_code EC;
355  if (auto EC = llvm::sys::fs::create_directories(Conf.DwoDir))
356  report_fatal_error(Twine("Failed to create directory ") + Conf.DwoDir +
357  ": " + EC.message());
358 
359  DwoFile = Conf.DwoDir;
360  sys::path::append(DwoFile, std::to_string(Task) + ".dwo");
361  TM->Options.MCOptions.SplitDwarfFile = std::string(DwoFile);
362  } else
363  TM->Options.MCOptions.SplitDwarfFile = Conf.SplitDwarfFile;
364 
365  if (!DwoFile.empty()) {
366  std::error_code EC;
367  DwoOut = std::make_unique<ToolOutputFile>(DwoFile, EC, sys::fs::OF_None);
368  if (EC)
369  report_fatal_error(Twine("Failed to open ") + DwoFile + ": " +
370  EC.message());
371  }
372 
373  Expected<std::unique_ptr<CachedFileStream>> StreamOrErr = AddStream(Task);
374  if (Error Err = StreamOrErr.takeError())
376  std::unique_ptr<CachedFileStream> &Stream = *StreamOrErr;
377  TM->Options.ObjectFilenameForDebug = Stream->ObjectPathName;
378 
379  legacy::PassManager CodeGenPasses;
381  CodeGenPasses.add(new TargetLibraryInfoWrapperPass(TLII));
382  CodeGenPasses.add(
384  if (Conf.PreCodeGenPassesHook)
385  Conf.PreCodeGenPassesHook(CodeGenPasses);
386  if (TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS,
387  DwoOut ? &DwoOut->os() : nullptr,
388  Conf.CGFileType))
389  report_fatal_error("Failed to setup codegen");
390  CodeGenPasses.run(Mod);
391 
392  if (DwoOut)
393  DwoOut->keep();
394 }
395 
396 static void splitCodeGen(const Config &C, TargetMachine *TM,
397  AddStreamFn AddStream,
398  unsigned ParallelCodeGenParallelismLevel, Module &Mod,
399  const ModuleSummaryIndex &CombinedIndex) {
400  ThreadPool CodegenThreadPool(
401  heavyweight_hardware_concurrency(ParallelCodeGenParallelismLevel));
402  unsigned ThreadCount = 0;
403  const Target *T = &TM->getTarget();
404 
405  SplitModule(
406  Mod, ParallelCodeGenParallelismLevel,
407  [&](std::unique_ptr<Module> MPart) {
408  // We want to clone the module in a new context to multi-thread the
409  // codegen. We do it by serializing partition modules to bitcode
410  // (while still on the main thread, in order to avoid data races) and
411  // spinning up new threads which deserialize the partitions into
412  // separate contexts.
413  // FIXME: Provide a more direct way to do this in LLVM.
414  SmallString<0> BC;
415  raw_svector_ostream BCOS(BC);
416  WriteBitcodeToFile(*MPart, BCOS);
417 
418  // Enqueue the task
419  CodegenThreadPool.async(
420  [&](const SmallString<0> &BC, unsigned ThreadId) {
421  LTOLLVMContext Ctx(C);
423  MemoryBufferRef(StringRef(BC.data(), BC.size()), "ld-temp.o"),
424  Ctx);
425  if (!MOrErr)
426  report_fatal_error("Failed to read bitcode");
427  std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
428 
429  std::unique_ptr<TargetMachine> TM =
430  createTargetMachine(C, T, *MPartInCtx);
431 
432  codegen(C, TM.get(), AddStream, ThreadId, *MPartInCtx,
433  CombinedIndex);
434  },
435  // Pass BC using std::move to ensure that it get moved rather than
436  // copied into the thread's context.
437  std::move(BC), ThreadCount++);
438  },
439  false);
440 
441  // Because the inner lambda (which runs in a worker thread) captures our local
442  // variables, we need to wait for the worker threads to terminate before we
443  // can leave the function scope.
444  CodegenThreadPool.wait();
445 }
446 
448  Module &Mod) {
449  if (!C.OverrideTriple.empty())
450  Mod.setTargetTriple(C.OverrideTriple);
451  else if (Mod.getTargetTriple().empty())
452  Mod.setTargetTriple(C.DefaultTriple);
453 
454  std::string Msg;
456  if (!T)
457  return make_error<StringError>(Msg, inconvertibleErrorCode());
458  return T;
459 }
460 
462  std::unique_ptr<ToolOutputFile> DiagOutputFile) {
463  // Make sure we flush the diagnostic remarks file in case the linker doesn't
464  // call the global destructors before exiting.
465  if (!DiagOutputFile)
466  return Error::success();
467  DiagOutputFile->keep();
468  DiagOutputFile->os().flush();
469  return Error::success();
470 }
471 
473  unsigned ParallelCodeGenParallelismLevel, Module &Mod,
474  ModuleSummaryIndex &CombinedIndex) {
476  if (!TOrErr)
477  return TOrErr.takeError();
478 
479  std::unique_ptr<TargetMachine> TM = createTargetMachine(C, *TOrErr, Mod);
480 
481  if (!C.CodeGenOnly) {
482  if (!opt(C, TM.get(), 0, Mod, /*IsThinLTO=*/false,
483  /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
484  /*CmdArgs*/ std::vector<uint8_t>()))
485  return Error::success();
486  }
487 
488  if (ParallelCodeGenParallelismLevel == 1) {
489  codegen(C, TM.get(), AddStream, 0, Mod, CombinedIndex);
490  } else {
491  splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel, Mod,
492  CombinedIndex);
493  }
494  return Error::success();
495 }
496 
497 static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals,
498  const ModuleSummaryIndex &Index) {
499  std::vector<GlobalValue*> DeadGVs;
500  for (auto &GV : Mod.global_values())
501  if (GlobalValueSummary *GVS = DefinedGlobals.lookup(GV.getGUID()))
502  if (!Index.isGlobalValueLive(GVS)) {
503  DeadGVs.push_back(&GV);
505  }
506 
507  // Now that all dead bodies have been dropped, delete the actual objects
508  // themselves when possible.
509  for (GlobalValue *GV : DeadGVs) {
510  GV->removeDeadConstantUsers();
511  // Might reference something defined in native object (i.e. dropped a
512  // non-prevailing IR def, but we need to keep the declaration).
513  if (GV->use_empty())
514  GV->eraseFromParent();
515  }
516 }
517 
518 Error lto::thinBackend(const Config &Conf, unsigned Task, AddStreamFn AddStream,
519  Module &Mod, const ModuleSummaryIndex &CombinedIndex,
520  const FunctionImporter::ImportMapTy &ImportList,
521  const GVSummaryMapTy &DefinedGlobals,
523  const std::vector<uint8_t> &CmdArgs) {
525  if (!TOrErr)
526  return TOrErr.takeError();
527 
528  std::unique_ptr<TargetMachine> TM = createTargetMachine(Conf, *TOrErr, Mod);
529 
530  // Setup optimization remarks.
531  auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
534  Task);
535  if (!DiagFileOrErr)
536  return DiagFileOrErr.takeError();
537  auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
538 
539  // Set the partial sample profile ratio in the profile summary module flag of
540  // the module, if applicable.
541  Mod.setPartialSampleProfileRatio(CombinedIndex);
542 
543  if (Conf.CodeGenOnly) {
544  codegen(Conf, TM.get(), AddStream, Task, Mod, CombinedIndex);
545  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
546  }
547 
548  if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
549  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
550 
551  auto OptimizeAndCodegen =
552  [&](Module &Mod, TargetMachine *TM,
553  std::unique_ptr<ToolOutputFile> DiagnosticOutputFile) {
554  if (!opt(Conf, TM, Task, Mod, /*IsThinLTO=*/true,
555  /*ExportSummary=*/nullptr, /*ImportSummary=*/&CombinedIndex,
556  CmdArgs))
557  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
558 
559  codegen(Conf, TM, AddStream, Task, Mod, CombinedIndex);
560  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
561  };
562 
564  return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
565 
566  // When linking an ELF shared object, dso_local should be dropped. We
567  // conservatively do this for -fpic.
568  bool ClearDSOLocalOnDeclarations =
569  TM->getTargetTriple().isOSBinFormatELF() &&
570  TM->getRelocationModel() != Reloc::Static &&
572  renameModuleForThinLTO(Mod, CombinedIndex, ClearDSOLocalOnDeclarations);
573 
574  dropDeadSymbols(Mod, DefinedGlobals, CombinedIndex);
575 
576  thinLTOFinalizeInModule(Mod, DefinedGlobals, /*PropagateAttrs=*/true);
577 
578  if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
579  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
580 
581  if (!DefinedGlobals.empty())
582  thinLTOInternalizeModule(Mod, DefinedGlobals);
583 
584  if (Conf.PostInternalizeModuleHook &&
585  !Conf.PostInternalizeModuleHook(Task, Mod))
586  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
587 
588  auto ModuleLoader = [&](StringRef Identifier) {
590  "ODR Type uniquing should be enabled on the context");
591  if (ModuleMap) {
592  auto I = ModuleMap->find(Identifier);
593  assert(I != ModuleMap->end());
594  return I->second.getLazyModule(Mod.getContext(),
595  /*ShouldLazyLoadMetadata=*/true,
596  /*IsImporting*/ true);
597  }
598 
600  llvm::MemoryBuffer::getFile(Identifier);
601  if (!MBOrErr)
602  return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
603  Twine("Error loading imported file ") + Identifier + " : ",
604  MBOrErr.getError()));
605 
606  Expected<BitcodeModule> BMOrErr = findThinLTOModule(**MBOrErr);
607  if (!BMOrErr)
608  return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
609  Twine("Error loading imported file ") + Identifier + " : " +
610  toString(BMOrErr.takeError()),
612 
614  BMOrErr->getLazyModule(Mod.getContext(),
615  /*ShouldLazyLoadMetadata=*/true,
616  /*IsImporting*/ true);
617  if (MOrErr)
618  (*MOrErr)->setOwnedMemoryBuffer(std::move(*MBOrErr));
619  return MOrErr;
620  };
621 
622  FunctionImporter Importer(CombinedIndex, ModuleLoader,
623  ClearDSOLocalOnDeclarations);
624  if (Error Err = Importer.importFunctions(Mod, ImportList).takeError())
625  return Err;
626 
627  if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
628  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
629 
630  return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
631 }
632 
634  if (ThinLTOAssumeMerged && BMs.size() == 1)
635  return BMs.begin();
636 
637  for (BitcodeModule &BM : BMs) {
638  Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
639  if (LTOInfo && LTOInfo->IsThinLTO)
640  return &BM;
641  }
642  return nullptr;
643 }
644 
647  if (!BMsOrErr)
648  return BMsOrErr.takeError();
649 
650  // The bitcode file may contain multiple modules, we want the one that is
651  // marked as being the ThinLTO module.
652  if (const BitcodeModule *Bm = lto::findThinLTOModule(*BMsOrErr))
653  return *Bm;
654 
655  return make_error<StringError>("Could not find module summary",
657 }
658 
660  const ModuleSummaryIndex &CombinedIndex,
661  FunctionImporter::ImportMapTy &ImportList) {
663  return true;
664  // We can simply import the values mentioned in the combined index, since
665  // we should only invoke this using the individual indexes written out
666  // via a WriteIndexesThinBackend.
667  for (const auto &GlobalList : CombinedIndex) {
668  // Ignore entries for undefined references.
669  if (GlobalList.second.SummaryList.empty())
670  continue;
671 
672  auto GUID = GlobalList.first;
673  for (const auto &Summary : GlobalList.second.SummaryList) {
674  // Skip the summaries for the importing module. These are included to
675  // e.g. record required linkage changes.
676  if (Summary->modulePath() == M.getModuleIdentifier())
677  continue;
678  // Add an entry to provoke importing by thinBackend.
679  ImportList[Summary->modulePath()].insert(GUID);
680  }
681  }
682  return true;
683 }
llvm::Module::global_values
iterator_range< global_value_iterator > global_values()
Definition: Module.cpp:421
MemoryBuffer.h
llvm::AAManager
A manager for alias analyses.
Definition: AliasAnalysis.h:1303
FunctionImportUtils.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::lto::Config::UseDefaultPipeline
bool UseDefaultPipeline
Use the standard optimization pipeline.
Definition: Config.h:61
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:659
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:1145
FileSystem.h
llvm::sys::fs::OF_None
@ OF_None
Definition: FileSystem.h:757
LTOBitcodeEmbedding::EmbedOptimized
@ EmbedOptimized
LTOBitcodeEmbedding
LTOBitcodeEmbedding
Definition: LTOBackend.cpp:52
llvm::lto::Config::DisableVerify
bool DisableVerify
Definition: Config.h:58
llvm::lto::finalizeOptimizationRemarks
Error finalizeOptimizationRemarks(std::unique_ptr< ToolOutputFile > DiagOutputFile)
Definition: LTOBackend.cpp:461
llvm::ThreadPool
A ThreadPool for asynchronous parallel execution on a defined number of threads.
Definition: ThreadPool.h:52
T
llvm::lto::Config::CGOptLevel
CodeGenOpt::Level CGOptLevel
Definition: Config.h:55
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:199
llvm::PassManager::addPass
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
Definition: PassManager.h:550
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::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:145
RegisterPassPlugins
static void RegisterPassPlugins(ArrayRef< std::string > PassPlugins, PassBuilder &PB)
Definition: LTOBackend.cpp:162
llvm::SubtargetFeatures::AddFeature
void AddFeature(StringRef String, bool Enable=true)
Adds Features.
Definition: SubtargetFeature.cpp:37
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::StandardInstrumentations::registerCallbacks
void registerCallbacks(PassInstrumentationCallbacks &PIC, FunctionAnalysisManager *FAM=nullptr)
Definition: StandardInstrumentations.cpp:2171
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
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:162
PIC
PassInstrumentationCallbacks PIC
Definition: PassBuilderBindings.cpp:55
llvm::createImmutableModuleSummaryIndexWrapperPass
ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)
Definition: ModuleSummaryAnalysis.cpp:959
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:49
llvm::MapVector< StringRef, BitcodeModule >
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:1604
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
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:231
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
runNewPMPasses
static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM, unsigned OptLevel, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
Definition: LTOBackend.cpp:209
llvm::lto::findThinLTOModule
BitcodeModule * findThinLTOModule(MutableArrayRef< BitcodeModule > BMs)
Returns the BitcodeModule that is ThinLTO.
Definition: LTOBackend.cpp:633
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::lto::Config::CombinedIndexHook
CombinedIndexHookFn CombinedIndexHook
Definition: Config.h:253
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
initAndLookupTarget
static Expected< const Target * > initAndLookupTarget(const Config &C, Module &Mod)
Definition: LTOBackend.cpp:447
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:456
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:1630
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:1212
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:289
llvm::MemoryBuffer::getFile
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Definition: MemoryBuffer.cpp:239
llvm::lto::Config::PostPromoteModuleHook
ModuleHookFn PostPromoteModuleHook
This hook is called after promoting any internal functions (ThinLTO-specific).
Definition: Config.h:225
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:306
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:312
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:276
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::dwarf::Index
Index
Definition: Dwarf.h:472
llvm::LLVMContext::isODRUniquingDebugTypes
bool isODRUniquingDebugTypes() const
Whether there is a string map for uniquing debug info identifiers across the context.
Definition: LLVMContext.cpp:335
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:967
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:188
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:1051
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::raw_ostream::flush
void flush()
Definition: raw_ostream.h:187
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:217
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:66
llvm::Module::setTargetTriple
void setTargetTriple(StringRef T)
Set the target triple.
Definition: Module.h:301
llvm::None
const NoneType None
Definition: None.h:24
llvm::lto::Config::PostInternalizeModuleHook
ModuleHookFn PostInternalizeModuleHook
This hook is called after internalizing the module.
Definition: Config.h:228
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:110
llvm::SmallString
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
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::lto::Config::PreCodeGenModuleHook
ModuleHookFn PreCodeGenModuleHook
This module hook is called before code generation.
Definition: Config.h:239
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:1016
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:50
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:1392
llvm::lto::backend
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:472
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::PassBuilder::registerFunctionAnalyses
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
Definition: PassBuilder.cpp:446
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:685
llvm::StandardInstrumentations
This class provides an interface to register all the standard pass instrumentations and manages their...
Definition: StandardInstrumentations.h:504
llvm::MapVector::find
iterator find(const KeyT &Key)
Definition: MapVector.h:148
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:468
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:7834
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:428
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:716
CGSCCPassManager.h
llvm::PassBuilder::buildLTODefaultPipeline
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
Definition: PassBuilderPipelines.cpp:1466
llvm::lto::LTOLLVMContext
A derived class of LLVMContext that initializes itself according to a given Config object.
Definition: Config.h:288
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:1400
createTargetMachine
static std::unique_ptr< TargetMachine > createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M)
Definition: LTOBackend.cpp:182
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
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:84
ToolOutputFile.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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:130
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::lto::Config::MAttrs
std::vector< std::string > MAttrs
Definition: Config.h:49
llvm::MutableArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:355
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:4684
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:234
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::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:518
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:143
llvm::ThreadPool::async
auto async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
Definition: ThreadPool.h:66
llvm::Reloc::Static
@ Static
Definition: CodeGen.h:22
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:567
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:660
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:444
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:1737
llvm::MapVector::end
iterator end()
Definition: MapVector.h:72
llvm::AMDGPU::SendMsg::Msg
const CustomOperand< const MCSubtargetInfo & > Msg[]
Definition: AMDGPUAsmUtils.cpp:39
llvm::PassManager< Module >
llvm::DenseMapBase::empty
LLVM_NODISCARD bool empty() const
Definition: DenseMap.h:98
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:460
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
Verifier.h
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:4729
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::toString
const char * toString(DWARFSectionKind Kind)
Definition: DWARFUnitIndex.h:67
llvm::PassBuilder::buildPerModuleDefaultPipeline
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, bool LTOPreLink=false)
Build a per-module default optimization pipeline.
Definition: PassBuilderPipelines.cpp:1301
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::legacy::PassManager
PassManager manages ModulePassManagers.
Definition: LegacyPassManager.h:52
llvm::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:262
dropDeadSymbols
static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals, const ModuleSummaryIndex &Index)
Definition: LTOBackend.cpp:497
llvm::PassBuilder::registerCGSCCAnalyses
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
Definition: PassBuilder.cpp:437
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:221
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:191
llvm::legacy::PassManager::add
void add(Pass *P) override
Add a pass to the queue of passes to run.
Definition: LegacyPassManager.cpp:1665
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:78
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:4953
llvm::AnalysisManager::registerPass
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:842
llvm::Module::getPIELevel
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
Definition: Module.cpp:602
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:498
AA
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:801
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:597
llvm::ThreadPool::wait
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
Definition: ThreadPool.cpp:143
codegen
static void codegen(const Config &Conf, TargetMachine *TM, AddStreamFn AddStream, unsigned Task, Module &Mod, const ModuleSummaryIndex &CombinedIndex)
Definition: LTOBackend.cpp:339
llvm::lto::Config::CGFileType
CodeGenFileType CGFileType
Definition: Config.h:56
LTO.h
llvm::ModuleSummaryIndex
Class to hold module path string table and global value map, and encapsulate methods for operating on...
Definition: ModuleSummaryIndex.h:1087
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:258
llvm::PassBuilder::crossRegisterProxies
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM)
Cross register the analysis managers through their proxies.
Definition: PassBuilder.cpp:1605
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:85
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:662
llvm::legacy::PassManager::run
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
Definition: LegacyPassManager.cpp:1671
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
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:7493
llvm::BitcodeModule
Represents a module in a bitcode file.
Definition: BitcodeReader.h:61
llvm::cl::desc
Definition: CommandLine.h:405
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:443
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:38
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:469