LLVM  8.0.0svn
LTO.cpp
Go to the documentation of this file.
1 //===-LTO.cpp - LLVM Link Time Optimizer ----------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements functions and classes used to support LTO.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/LTO/LTO.h"
15 #include "llvm/ADT/Statistic.h"
20 #include "llvm/CodeGen/Analysis.h"
21 #include "llvm/Config/llvm-config.h"
22 #include "llvm/IR/AutoUpgrade.h"
25 #include "llvm/IR/Mangler.h"
26 #include "llvm/IR/Metadata.h"
27 #include "llvm/LTO/LTOBackend.h"
28 #include "llvm/Linker/IRMover.h"
30 #include "llvm/Support/Error.h"
33 #include "llvm/Support/Path.h"
34 #include "llvm/Support/SHA1.h"
35 #include "llvm/Support/SourceMgr.h"
38 #include "llvm/Support/Threading.h"
39 #include "llvm/Support/VCSRevision.h"
43 #include "llvm/Transforms/IPO.h"
46 
47 #include <set>
48 
49 using namespace llvm;
50 using namespace lto;
51 using namespace object;
52 
53 #define DEBUG_TYPE "lto"
54 
55 static cl::opt<bool>
56  DumpThinCGSCCs("dump-thin-cg-sccs", cl::init(false), cl::Hidden,
57  cl::desc("Dump the SCCs in the ThinLTO index's callgraph"));
58 
59 /// Enable global value internalization in LTO.
61  "enable-lto-internalization", cl::init(true), cl::Hidden,
62  cl::desc("Enable global value internalization in LTO"));
63 
64 // Returns a unique hash for the Module considering the current list of
65 // export/import and other global analysis results.
66 // The hash is produced in \p Key.
67 static void computeCacheKey(
68  SmallString<40> &Key, const Config &Conf, const ModuleSummaryIndex &Index,
69  StringRef ModuleID, const FunctionImporter::ImportMapTy &ImportList,
70  const FunctionImporter::ExportSetTy &ExportList,
71  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
72  const GVSummaryMapTy &DefinedGlobals,
73  const std::set<GlobalValue::GUID> &CfiFunctionDefs,
74  const std::set<GlobalValue::GUID> &CfiFunctionDecls) {
75  // Compute the unique hash for this entry.
76  // This is based on the current compiler version, the module itself, the
77  // export list, the hash for every single module in the import list, the
78  // list of ResolvedODR for the module, and the list of preserved symbols.
79  SHA1 Hasher;
80 
81  // Start with the compiler revision
82  Hasher.update(LLVM_VERSION_STRING);
83 #ifdef LLVM_REVISION
84  Hasher.update(LLVM_REVISION);
85 #endif
86 
87  // Include the parts of the LTO configuration that affect code generation.
88  auto AddString = [&](StringRef Str) {
89  Hasher.update(Str);
90  Hasher.update(ArrayRef<uint8_t>{0});
91  };
92  auto AddUnsigned = [&](unsigned I) {
93  uint8_t Data[4];
94  Data[0] = I;
95  Data[1] = I >> 8;
96  Data[2] = I >> 16;
97  Data[3] = I >> 24;
98  Hasher.update(ArrayRef<uint8_t>{Data, 4});
99  };
100  auto AddUint64 = [&](uint64_t I) {
101  uint8_t Data[8];
102  Data[0] = I;
103  Data[1] = I >> 8;
104  Data[2] = I >> 16;
105  Data[3] = I >> 24;
106  Data[4] = I >> 32;
107  Data[5] = I >> 40;
108  Data[6] = I >> 48;
109  Data[7] = I >> 56;
110  Hasher.update(ArrayRef<uint8_t>{Data, 8});
111  };
112  AddString(Conf.CPU);
113  // FIXME: Hash more of Options. For now all clients initialize Options from
114  // command-line flags (which is unsupported in production), but may set
115  // RelaxELFRelocations. The clang driver can also pass FunctionSections,
116  // DataSections and DebuggerTuning via command line flags.
117  AddUnsigned(Conf.Options.RelaxELFRelocations);
118  AddUnsigned(Conf.Options.FunctionSections);
119  AddUnsigned(Conf.Options.DataSections);
120  AddUnsigned((unsigned)Conf.Options.DebuggerTuning);
121  for (auto &A : Conf.MAttrs)
122  AddString(A);
123  if (Conf.RelocModel)
124  AddUnsigned(*Conf.RelocModel);
125  else
126  AddUnsigned(-1);
127  if (Conf.CodeModel)
128  AddUnsigned(*Conf.CodeModel);
129  else
130  AddUnsigned(-1);
131  AddUnsigned(Conf.CGOptLevel);
132  AddUnsigned(Conf.CGFileType);
133  AddUnsigned(Conf.OptLevel);
134  AddUnsigned(Conf.UseNewPM);
135  AddString(Conf.OptPipeline);
136  AddString(Conf.AAPipeline);
137  AddString(Conf.OverrideTriple);
138  AddString(Conf.DefaultTriple);
139  AddString(Conf.DwoDir);
140 
141  // Include the hash for the current module
142  auto ModHash = Index.getModuleHash(ModuleID);
143  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
144  for (auto F : ExportList)
145  // The export list can impact the internalization, be conservative here
146  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F)));
147 
148  // Include the hash for every module we import functions from. The set of
149  // imported symbols for each module may affect code generation and is
150  // sensitive to link order, so include that as well.
151  for (auto &Entry : ImportList) {
152  auto ModHash = Index.getModuleHash(Entry.first());
153  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
154 
155  AddUint64(Entry.second.size());
156  for (auto &Fn : Entry.second)
157  AddUint64(Fn);
158  }
159 
160  // Include the hash for the resolved ODR.
161  for (auto &Entry : ResolvedODR) {
162  Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first,
163  sizeof(GlobalValue::GUID)));
164  Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second,
165  sizeof(GlobalValue::LinkageTypes)));
166  }
167 
168  // Members of CfiFunctionDefs and CfiFunctionDecls that are referenced or
169  // defined in this module.
170  std::set<GlobalValue::GUID> UsedCfiDefs;
171  std::set<GlobalValue::GUID> UsedCfiDecls;
172 
173  // Typeids used in this module.
174  std::set<GlobalValue::GUID> UsedTypeIds;
175 
176  auto AddUsedCfiGlobal = [&](GlobalValue::GUID ValueGUID) {
177  if (CfiFunctionDefs.count(ValueGUID))
178  UsedCfiDefs.insert(ValueGUID);
179  if (CfiFunctionDecls.count(ValueGUID))
180  UsedCfiDecls.insert(ValueGUID);
181  };
182 
183  auto AddUsedThings = [&](GlobalValueSummary *GS) {
184  if (!GS) return;
185  AddUnsigned(GS->isLive());
186  for (const ValueInfo &VI : GS->refs()) {
187  AddUnsigned(VI.isDSOLocal());
188  AddUsedCfiGlobal(VI.getGUID());
189  }
190  if (auto *GVS = dyn_cast<GlobalVarSummary>(GS))
191  AddUnsigned(GVS->isReadOnly());
192  if (auto *FS = dyn_cast<FunctionSummary>(GS)) {
193  for (auto &TT : FS->type_tests())
194  UsedTypeIds.insert(TT);
195  for (auto &TT : FS->type_test_assume_vcalls())
196  UsedTypeIds.insert(TT.GUID);
197  for (auto &TT : FS->type_checked_load_vcalls())
198  UsedTypeIds.insert(TT.GUID);
199  for (auto &TT : FS->type_test_assume_const_vcalls())
200  UsedTypeIds.insert(TT.VFunc.GUID);
201  for (auto &TT : FS->type_checked_load_const_vcalls())
202  UsedTypeIds.insert(TT.VFunc.GUID);
203  for (auto &ET : FS->calls()) {
204  AddUnsigned(ET.first.isDSOLocal());
205  AddUsedCfiGlobal(ET.first.getGUID());
206  }
207  }
208  };
209 
210  // Include the hash for the linkage type to reflect internalization and weak
211  // resolution, and collect any used type identifier resolutions.
212  for (auto &GS : DefinedGlobals) {
213  GlobalValue::LinkageTypes Linkage = GS.second->linkage();
214  Hasher.update(
215  ArrayRef<uint8_t>((const uint8_t *)&Linkage, sizeof(Linkage)));
216  AddUsedCfiGlobal(GS.first);
217  AddUsedThings(GS.second);
218  }
219 
220  // Imported functions may introduce new uses of type identifier resolutions,
221  // so we need to collect their used resolutions as well.
222  for (auto &ImpM : ImportList)
223  for (auto &ImpF : ImpM.second)
224  AddUsedThings(Index.findSummaryInModule(ImpF, ImpM.first()));
225 
226  auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) {
227  AddString(TId);
228 
229  AddUnsigned(S.TTRes.TheKind);
230  AddUnsigned(S.TTRes.SizeM1BitWidth);
231 
232  AddUint64(S.TTRes.AlignLog2);
233  AddUint64(S.TTRes.SizeM1);
234  AddUint64(S.TTRes.BitMask);
235  AddUint64(S.TTRes.InlineBits);
236 
237  AddUint64(S.WPDRes.size());
238  for (auto &WPD : S.WPDRes) {
239  AddUnsigned(WPD.first);
240  AddUnsigned(WPD.second.TheKind);
241  AddString(WPD.second.SingleImplName);
242 
243  AddUint64(WPD.second.ResByArg.size());
244  for (auto &ByArg : WPD.second.ResByArg) {
245  AddUint64(ByArg.first.size());
246  for (uint64_t Arg : ByArg.first)
247  AddUint64(Arg);
248  AddUnsigned(ByArg.second.TheKind);
249  AddUint64(ByArg.second.Info);
250  AddUnsigned(ByArg.second.Byte);
251  AddUnsigned(ByArg.second.Bit);
252  }
253  }
254  };
255 
256  // Include the hash for all type identifiers used by this module.
257  for (GlobalValue::GUID TId : UsedTypeIds) {
258  auto TidIter = Index.typeIds().equal_range(TId);
259  for (auto It = TidIter.first; It != TidIter.second; ++It)
260  AddTypeIdSummary(It->second.first, It->second.second);
261  }
262 
263  AddUnsigned(UsedCfiDefs.size());
264  for (auto &V : UsedCfiDefs)
265  AddUint64(V);
266 
267  AddUnsigned(UsedCfiDecls.size());
268  for (auto &V : UsedCfiDecls)
269  AddUint64(V);
270 
271  if (!Conf.SampleProfile.empty()) {
272  auto FileOrErr = MemoryBuffer::getFile(Conf.SampleProfile);
273  if (FileOrErr) {
274  Hasher.update(FileOrErr.get()->getBuffer());
275 
276  if (!Conf.ProfileRemapping.empty()) {
277  FileOrErr = MemoryBuffer::getFile(Conf.ProfileRemapping);
278  if (FileOrErr)
279  Hasher.update(FileOrErr.get()->getBuffer());
280  }
281  }
282  }
283 
284  Key = toHex(Hasher.result());
285 }
286 
288  GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
289  DenseSet<GlobalValueSummary *> &GlobalInvolvedWithAlias,
291  isPrevailing,
293  recordNewLinkage) {
294  for (auto &S : GVSummaryList) {
295  GlobalValue::LinkageTypes OriginalLinkage = S->linkage();
296  // Ignore local and appending linkage values since the linker
297  // doesn't resolve them.
298  if (GlobalValue::isLocalLinkage(OriginalLinkage) ||
299  GlobalValue::isAppendingLinkage(S->linkage()))
300  continue;
301  // We need to emit only one of these. The prevailing module will keep it,
302  // but turned into a weak, while the others will drop it when possible.
303  // This is both a compile-time optimization and a correctness
304  // transformation. This is necessary for correctness when we have exported
305  // a reference - we need to convert the linkonce to weak to
306  // ensure a copy is kept to satisfy the exported reference.
307  // FIXME: We may want to split the compile time and correctness
308  // aspects into separate routines.
309  if (isPrevailing(GUID, S.get())) {
310  if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
311  S->setLinkage(GlobalValue::getWeakLinkage(
312  GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
313  }
314  // Alias and aliasee can't be turned into available_externally.
315  else if (!isa<AliasSummary>(S.get()) &&
316  !GlobalInvolvedWithAlias.count(S.get()))
318  if (S->linkage() != OriginalLinkage)
319  recordNewLinkage(S->modulePath(), GUID, S->linkage());
320  }
321 }
322 
323 /// Resolve linkage for prevailing symbols in the \p Index.
324 //
325 // We'd like to drop these functions if they are no longer referenced in the
326 // current module. However there is a chance that another module is still
327 // referencing them because of the import. We make sure we always emit at least
328 // one copy.
332  isPrevailing,
334  recordNewLinkage) {
335  // We won't optimize the globals that are referenced by an alias for now
336  // Ideally we should turn the alias into a global and duplicate the definition
337  // when needed.
338  DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias;
339  for (auto &I : Index)
340  for (auto &S : I.second.SummaryList)
341  if (auto AS = dyn_cast<AliasSummary>(S.get()))
342  GlobalInvolvedWithAlias.insert(&AS->getAliasee());
343 
344  for (auto &I : Index)
345  thinLTOResolvePrevailingGUID(I.second.SummaryList, I.first,
346  GlobalInvolvedWithAlias, isPrevailing,
347  recordNewLinkage);
348 }
349 
351  GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
352  function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
353  for (auto &S : GVSummaryList) {
354  if (isExported(S->modulePath(), GUID)) {
355  if (GlobalValue::isLocalLinkage(S->linkage()))
356  S->setLinkage(GlobalValue::ExternalLinkage);
357  } else if (EnableLTOInternalization &&
358  // Ignore local and appending linkage values since the linker
359  // doesn't resolve them.
360  !GlobalValue::isLocalLinkage(S->linkage()) &&
361  !GlobalValue::isAppendingLinkage(S->linkage()))
362  S->setLinkage(GlobalValue::InternalLinkage);
363  }
364 }
365 
366 // Update the linkages in the given \p Index to mark exported values
367 // as external and non-exported values as internal.
369  ModuleSummaryIndex &Index,
370  function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
371  for (auto &I : Index)
372  thinLTOInternalizeAndPromoteGUID(I.second.SummaryList, I.first, isExported);
373 }
374 
375 // Requires a destructor for std::vector<InputModule>.
376 InputFile::~InputFile() = default;
377 
379  std::unique_ptr<InputFile> File(new InputFile);
380 
381  Expected<IRSymtabFile> FOrErr = readIRSymtab(Object);
382  if (!FOrErr)
383  return FOrErr.takeError();
384 
385  File->TargetTriple = FOrErr->TheReader.getTargetTriple();
386  File->SourceFileName = FOrErr->TheReader.getSourceFileName();
387  File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts();
388  File->ComdatTable = FOrErr->TheReader.getComdatTable();
389 
390  for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) {
391  size_t Begin = File->Symbols.size();
392  for (const irsymtab::Reader::SymbolRef &Sym :
393  FOrErr->TheReader.module_symbols(I))
394  // Skip symbols that are irrelevant to LTO. Note that this condition needs
395  // to match the one in Skip() in LTO::addRegularLTO().
396  if (Sym.isGlobal() && !Sym.isFormatSpecific())
397  File->Symbols.push_back(Sym);
398  File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
399  }
400 
401  File->Mods = FOrErr->Mods;
402  File->Strtab = std::move(FOrErr->Strtab);
403  return std::move(File);
404 }
405 
407  return Mods[0].getModuleIdentifier();
408 }
409 
410 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
411  Config &Conf)
412  : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
413  Ctx(Conf), CombinedModule(llvm::make_unique<Module>("ld-temp.o", Ctx)),
414  Mover(llvm::make_unique<IRMover>(*CombinedModule)) {}
415 
416 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend)
417  : Backend(Backend), CombinedIndex(/*HaveGVs*/ false) {
418  if (!Backend)
419  this->Backend =
421 }
422 
424  unsigned ParallelCodeGenParallelismLevel)
425  : Conf(std::move(Conf)),
426  RegularLTO(ParallelCodeGenParallelismLevel, this->Conf),
427  ThinLTO(std::move(Backend)) {}
428 
429 // Requires a destructor for MapVector<BitcodeModule>.
430 LTO::~LTO() = default;
431 
432 // Add the symbols in the given module to the GlobalResolutions map, and resolve
433 // their partitions.
434 void LTO::addModuleToGlobalRes(ArrayRef<InputFile::Symbol> Syms,
436  unsigned Partition, bool InSummary) {
437  auto *ResI = Res.begin();
438  auto *ResE = Res.end();
439  (void)ResE;
440  for (const InputFile::Symbol &Sym : Syms) {
441  assert(ResI != ResE);
442  SymbolResolution Res = *ResI++;
443 
444  StringRef Name = Sym.getName();
445  Triple TT(RegularLTO.CombinedModule->getTargetTriple());
446  // Strip the __imp_ prefix from COFF dllimport symbols (similar to the
447  // way they are handled by lld), otherwise we can end up with two
448  // global resolutions (one with and one for a copy of the symbol without).
449  if (TT.isOSBinFormatCOFF() && Name.startswith("__imp_"))
450  Name = Name.substr(strlen("__imp_"));
451  auto &GlobalRes = GlobalResolutions[Name];
452  GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
453  if (Res.Prevailing) {
454  assert(!GlobalRes.Prevailing &&
455  "Multiple prevailing defs are not allowed");
456  GlobalRes.Prevailing = true;
457  GlobalRes.IRName = Sym.getIRName();
458  } else if (!GlobalRes.Prevailing && GlobalRes.IRName.empty()) {
459  // Sometimes it can be two copies of symbol in a module and prevailing
460  // symbol can have no IR name. That might happen if symbol is defined in
461  // module level inline asm block. In case we have multiple modules with
462  // the same symbol we want to use IR name of the prevailing symbol.
463  // Otherwise, if we haven't seen a prevailing symbol, set the name so that
464  // we can later use it to check if there is any prevailing copy in IR.
465  GlobalRes.IRName = Sym.getIRName();
466  }
467 
468  // Set the partition to external if we know it is re-defined by the linker
469  // with -defsym or -wrap options, used elsewhere, e.g. it is visible to a
470  // regular object, is referenced from llvm.compiler_used, or was already
471  // recorded as being referenced from a different partition.
472  if (Res.LinkerRedefined || Res.VisibleToRegularObj || Sym.isUsed() ||
473  (GlobalRes.Partition != GlobalResolution::Unknown &&
474  GlobalRes.Partition != Partition)) {
475  GlobalRes.Partition = GlobalResolution::External;
476  } else
477  // First recorded reference, save the current partition.
478  GlobalRes.Partition = Partition;
479 
480  // Flag as visible outside of summary if visible from a regular object or
481  // from a module that does not have a summary.
482  GlobalRes.VisibleOutsideSummary |=
483  (Res.VisibleToRegularObj || Sym.isUsed() || !InSummary);
484  }
485 }
486 
489  StringRef Path = Input->getName();
490  OS << Path << '\n';
491  auto ResI = Res.begin();
492  for (const InputFile::Symbol &Sym : Input->symbols()) {
493  assert(ResI != Res.end());
494  SymbolResolution Res = *ResI++;
495 
496  OS << "-r=" << Path << ',' << Sym.getName() << ',';
497  if (Res.Prevailing)
498  OS << 'p';
499  if (Res.FinalDefinitionInLinkageUnit)
500  OS << 'l';
501  if (Res.VisibleToRegularObj)
502  OS << 'x';
503  if (Res.LinkerRedefined)
504  OS << 'r';
505  OS << '\n';
506  }
507  OS.flush();
508  assert(ResI == Res.end());
509 }
510 
511 Error LTO::add(std::unique_ptr<InputFile> Input,
513  assert(!CalledGetMaxTasks);
514 
515  if (Conf.ResolutionFile)
516  writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
517 
518  if (RegularLTO.CombinedModule->getTargetTriple().empty())
519  RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple());
520 
521  const SymbolResolution *ResI = Res.begin();
522  for (unsigned I = 0; I != Input->Mods.size(); ++I)
523  if (Error Err = addModule(*Input, I, ResI, Res.end()))
524  return Err;
525 
526  assert(ResI == Res.end());
527  return Error::success();
528 }
529 
530 Error LTO::addModule(InputFile &Input, unsigned ModI,
531  const SymbolResolution *&ResI,
532  const SymbolResolution *ResE) {
533  Expected<BitcodeLTOInfo> LTOInfo = Input.Mods[ModI].getLTOInfo();
534  if (!LTOInfo)
535  return LTOInfo.takeError();
536 
537  BitcodeModule BM = Input.Mods[ModI];
538  auto ModSyms = Input.module_symbols(ModI);
539  addModuleToGlobalRes(ModSyms, {ResI, ResE},
540  LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
541  LTOInfo->HasSummary);
542 
543  if (LTOInfo->IsThinLTO)
544  return addThinLTO(BM, ModSyms, ResI, ResE);
545 
547  addRegularLTO(BM, ModSyms, ResI, ResE);
548  if (!ModOrErr)
549  return ModOrErr.takeError();
550 
551  if (!LTOInfo->HasSummary)
552  return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
553 
554  // Regular LTO module summaries are added to a dummy module that represents
555  // the combined regular LTO module.
556  if (Error Err = BM.readSummary(ThinLTO.CombinedIndex, "", -1ull))
557  return Err;
558  RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
559  return Error::success();
560 }
561 
562 // Checks whether the given global value is in a non-prevailing comdat
563 // (comdat containing values the linker indicated were not prevailing,
564 // which we then dropped to available_externally), and if so, removes
565 // it from the comdat. This is called for all global values to ensure the
566 // comdat is empty rather than leaving an incomplete comdat. It is needed for
567 // regular LTO modules, in case we are in a mixed-LTO mode (both regular
568 // and thin LTO modules) compilation. Since the regular LTO module will be
569 // linked first in the final native link, we want to make sure the linker
570 // doesn't select any of these incomplete comdats that would be left
571 // in the regular LTO module without this cleanup.
572 static void
574  std::set<const Comdat *> &NonPrevailingComdats) {
575  Comdat *C = GV.getComdat();
576  if (!C)
577  return;
578 
579  if (!NonPrevailingComdats.count(C))
580  return;
581 
582  // Additionally need to drop externally visible global values from the comdat
583  // to available_externally, so that there aren't multiply defined linker
584  // errors.
585  if (!GV.hasLocalLinkage())
587 
588  if (auto GO = dyn_cast<GlobalObject>(&GV))
589  GO->setComdat(nullptr);
590 }
591 
592 // Add a regular LTO object to the link.
593 // The resulting module needs to be linked into the combined LTO module with
594 // linkRegularLTO.
596 LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
597  const SymbolResolution *&ResI,
598  const SymbolResolution *ResE) {
599  RegularLTOState::AddedModule Mod;
601  BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true,
602  /*IsImporting*/ false);
603  if (!MOrErr)
604  return MOrErr.takeError();
605  Module &M = **MOrErr;
606  Mod.M = std::move(*MOrErr);
607 
608  if (Error Err = M.materializeMetadata())
609  return std::move(Err);
610  UpgradeDebugInfo(M);
611 
612  ModuleSymbolTable SymTab;
613  SymTab.addModule(&M);
614 
615  for (GlobalVariable &GV : M.globals())
616  if (GV.hasAppendingLinkage())
617  Mod.Keep.push_back(&GV);
618 
619  DenseSet<GlobalObject *> AliasedGlobals;
620  for (auto &GA : M.aliases())
621  if (GlobalObject *GO = GA.getBaseObject())
622  AliasedGlobals.insert(GO);
623 
624  // In this function we need IR GlobalValues matching the symbols in Syms
625  // (which is not backed by a module), so we need to enumerate them in the same
626  // order. The symbol enumeration order of a ModuleSymbolTable intentionally
627  // matches the order of an irsymtab, but when we read the irsymtab in
628  // InputFile::create we omit some symbols that are irrelevant to LTO. The
629  // Skip() function skips the same symbols from the module as InputFile does
630  // from the symbol table.
631  auto MsymI = SymTab.symbols().begin(), MsymE = SymTab.symbols().end();
632  auto Skip = [&]() {
633  while (MsymI != MsymE) {
634  auto Flags = SymTab.getSymbolFlags(*MsymI);
635  if ((Flags & object::BasicSymbolRef::SF_Global) &&
637  return;
638  ++MsymI;
639  }
640  };
641  Skip();
642 
643  std::set<const Comdat *> NonPrevailingComdats;
644  for (const InputFile::Symbol &Sym : Syms) {
645  assert(ResI != ResE);
646  SymbolResolution Res = *ResI++;
647 
648  assert(MsymI != MsymE);
649  ModuleSymbolTable::Symbol Msym = *MsymI++;
650  Skip();
651 
652  if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
653  if (Res.Prevailing) {
654  if (Sym.isUndefined())
655  continue;
656  Mod.Keep.push_back(GV);
657  // For symbols re-defined with linker -wrap and -defsym options,
658  // set the linkage to weak to inhibit IPO. The linkage will be
659  // restored by the linker.
660  if (Res.LinkerRedefined)
661  GV->setLinkage(GlobalValue::WeakAnyLinkage);
662 
663  GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage();
664  if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
665  GV->setLinkage(GlobalValue::getWeakLinkage(
666  GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
667  } else if (isa<GlobalObject>(GV) &&
668  (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage() ||
669  GV->hasAvailableExternallyLinkage()) &&
670  !AliasedGlobals.count(cast<GlobalObject>(GV))) {
671  // Any of the above three types of linkage indicates that the
672  // chosen prevailing symbol will have the same semantics as this copy of
673  // the symbol, so we may be able to link it with available_externally
674  // linkage. We will decide later whether to do that when we link this
675  // module (in linkRegularLTO), based on whether it is undefined.
676  Mod.Keep.push_back(GV);
678  if (GV->hasComdat())
679  NonPrevailingComdats.insert(GV->getComdat());
680  cast<GlobalObject>(GV)->setComdat(nullptr);
681  }
682 
683  // Set the 'local' flag based on the linker resolution for this symbol.
685  GV->setDSOLocal(true);
686  }
687  // Common resolution: collect the maximum size/alignment over all commons.
688  // We also record if we see an instance of a common as prevailing, so that
689  // if none is prevailing we can ignore it later.
690  if (Sym.isCommon()) {
691  // FIXME: We should figure out what to do about commons defined by asm.
692  // For now they aren't reported correctly by ModuleSymbolTable.
693  auto &CommonRes = RegularLTO.Commons[Sym.getIRName()];
694  CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
695  CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment());
696  CommonRes.Prevailing |= Res.Prevailing;
697  }
698 
699  }
700  if (!M.getComdatSymbolTable().empty())
701  for (GlobalValue &GV : M.global_values())
702  handleNonPrevailingComdat(GV, NonPrevailingComdats);
703  assert(MsymI == MsymE);
704  return std::move(Mod);
705 }
706 
707 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
708  bool LivenessFromIndex) {
709  std::vector<GlobalValue *> Keep;
710  for (GlobalValue *GV : Mod.Keep) {
711  if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
712  continue;
713 
714  if (!GV->hasAvailableExternallyLinkage()) {
715  Keep.push_back(GV);
716  continue;
717  }
718 
719  // Only link available_externally definitions if we don't already have a
720  // definition.
721  GlobalValue *CombinedGV =
722  RegularLTO.CombinedModule->getNamedValue(GV->getName());
723  if (CombinedGV && !CombinedGV->isDeclaration())
724  continue;
725 
726  Keep.push_back(GV);
727  }
728 
729  return RegularLTO.Mover->move(std::move(Mod.M), Keep,
731  /* IsPerformingImport */ false);
732 }
733 
734 // Add a ThinLTO module to the link.
735 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
736  const SymbolResolution *&ResI,
737  const SymbolResolution *ResE) {
738  if (Error Err =
739  BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(),
740  ThinLTO.ModuleMap.size()))
741  return Err;
742 
743  for (const InputFile::Symbol &Sym : Syms) {
744  assert(ResI != ResE);
745  SymbolResolution Res = *ResI++;
746 
747  if (!Sym.getIRName().empty()) {
749  Sym.getIRName(), GlobalValue::ExternalLinkage, ""));
750  if (Res.Prevailing) {
751  ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier();
752 
753  // For linker redefined symbols (via --wrap or --defsym) we want to
754  // switch the linkage to `weak` to prevent IPOs from happening.
755  // Find the summary in the module for this very GV and record the new
756  // linkage so that we can switch it when we import the GV.
757  if (Res.LinkerRedefined)
758  if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
759  GUID, BM.getModuleIdentifier()))
760  S->setLinkage(GlobalValue::WeakAnyLinkage);
761  }
762 
763  // If the linker resolved the symbol to a local definition then mark it
764  // as local in the summary for the module we are adding.
766  if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
767  GUID, BM.getModuleIdentifier())) {
768  S->setDSOLocal(true);
769  }
770  }
771  }
772  }
773 
774  if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
775  return make_error<StringError>(
776  "Expected at most one ThinLTO module per bitcode file",
778 
779  return Error::success();
780 }
781 
782 unsigned LTO::getMaxTasks() const {
783  CalledGetMaxTasks = true;
784  return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
785 }
786 
788  // Compute "dead" symbols, we don't want to import/export these!
789  DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
790  DenseMap<GlobalValue::GUID, PrevailingType> GUIDPrevailingResolutions;
791  for (auto &Res : GlobalResolutions) {
792  // Normally resolution have IR name of symbol. We can do nothing here
793  // otherwise. See comments in GlobalResolution struct for more details.
794  if (Res.second.IRName.empty())
795  continue;
796 
798  GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
799 
800  if (Res.second.VisibleOutsideSummary && Res.second.Prevailing)
801  GUIDPreservedSymbols.insert(GlobalValue::getGUID(
802  GlobalValue::dropLLVMManglingEscape(Res.second.IRName)));
803 
804  GUIDPrevailingResolutions[GUID] =
805  Res.second.Prevailing ? PrevailingType::Yes : PrevailingType::No;
806  }
807 
808  auto isPrevailing = [&](GlobalValue::GUID G) {
809  auto It = GUIDPrevailingResolutions.find(G);
810  if (It == GUIDPrevailingResolutions.end())
812  return It->second;
813  };
814  computeDeadSymbolsWithConstProp(ThinLTO.CombinedIndex, GUIDPreservedSymbols,
815  isPrevailing, Conf.OptLevel > 0);
816 
817  // Setup output file to emit statistics.
818  std::unique_ptr<ToolOutputFile> StatsFile = nullptr;
819  if (!Conf.StatsFile.empty()) {
820  EnableStatistics(false);
821  std::error_code EC;
822  StatsFile =
823  llvm::make_unique<ToolOutputFile>(Conf.StatsFile, EC, sys::fs::F_None);
824  if (EC)
825  return errorCodeToError(EC);
826  StatsFile->keep();
827  }
828 
829  Error Result = runRegularLTO(AddStream);
830  if (!Result)
831  Result = runThinLTO(AddStream, Cache);
832 
833  if (StatsFile)
834  PrintStatisticsJSON(StatsFile->os());
835 
836  return Result;
837 }
838 
839 Error LTO::runRegularLTO(AddStreamFn AddStream) {
840  for (auto &M : RegularLTO.ModsWithSummaries)
841  if (Error Err = linkRegularLTO(std::move(M),
842  /*LivenessFromIndex=*/true))
843  return Err;
844 
845  // Make sure commons have the right size/alignment: we kept the largest from
846  // all the prevailing when adding the inputs, and we apply it here.
847  const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
848  for (auto &I : RegularLTO.Commons) {
849  if (!I.second.Prevailing)
850  // Don't do anything if no instance of this common was prevailing.
851  continue;
852  GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);
853  if (OldGV && DL.getTypeAllocSize(OldGV->getValueType()) == I.second.Size) {
854  // Don't create a new global if the type is already correct, just make
855  // sure the alignment is correct.
856  OldGV->setAlignment(I.second.Align);
857  continue;
858  }
859  ArrayType *Ty =
860  ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size);
861  auto *GV = new GlobalVariable(*RegularLTO.CombinedModule, Ty, false,
864  GV->setAlignment(I.second.Align);
865  if (OldGV) {
867  GV->takeName(OldGV);
868  OldGV->eraseFromParent();
869  } else {
870  GV->setName(I.first);
871  }
872  }
873 
874  if (Conf.PreOptModuleHook &&
875  !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
876  return Error::success();
877 
878  if (!Conf.CodeGenOnly) {
879  for (const auto &R : GlobalResolutions) {
880  if (!R.second.isPrevailingIRSymbol())
881  continue;
882  if (R.second.Partition != 0 &&
883  R.second.Partition != GlobalResolution::External)
884  continue;
885 
886  GlobalValue *GV =
887  RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
888  // Ignore symbols defined in other partitions.
889  // Also skip declarations, which are not allowed to have internal linkage.
890  if (!GV || GV->hasLocalLinkage() || GV->isDeclaration())
891  continue;
892  GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
894  if (EnableLTOInternalization && R.second.Partition == 0)
896  }
897 
898  if (Conf.PostInternalizeModuleHook &&
899  !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
900  return Error::success();
901  }
902  return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
903  std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);
904 }
905 
906 /// This class defines the interface to the ThinLTO backend.
908 protected:
912 
913 public:
915  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries)
916  : Conf(Conf), CombinedIndex(CombinedIndex),
917  ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {}
918 
919  virtual ~ThinBackendProc() {}
920  virtual Error start(
921  unsigned Task, BitcodeModule BM,
922  const FunctionImporter::ImportMapTy &ImportList,
923  const FunctionImporter::ExportSetTy &ExportList,
924  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
925  MapVector<StringRef, BitcodeModule> &ModuleMap) = 0;
926  virtual Error wait() = 0;
927 };
928 
929 namespace {
930 class InProcessThinBackend : public ThinBackendProc {
931  ThreadPool BackendThreadPool;
932  AddStreamFn AddStream;
933  NativeObjectCache Cache;
934  std::set<GlobalValue::GUID> CfiFunctionDefs;
935  std::set<GlobalValue::GUID> CfiFunctionDecls;
936 
937  Optional<Error> Err;
938  std::mutex ErrMu;
939 
940 public:
941  InProcessThinBackend(
942  Config &Conf, ModuleSummaryIndex &CombinedIndex,
943  unsigned ThinLTOParallelismLevel,
944  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
945  AddStreamFn AddStream, NativeObjectCache Cache)
946  : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
947  BackendThreadPool(ThinLTOParallelismLevel),
948  AddStream(std::move(AddStream)), Cache(std::move(Cache)) {
949  for (auto &Name : CombinedIndex.cfiFunctionDefs())
950  CfiFunctionDefs.insert(
952  for (auto &Name : CombinedIndex.cfiFunctionDecls())
953  CfiFunctionDecls.insert(
955  }
956 
957  Error runThinLTOBackendThread(
958  AddStreamFn AddStream, NativeObjectCache Cache, unsigned Task,
959  BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
960  const FunctionImporter::ImportMapTy &ImportList,
961  const FunctionImporter::ExportSetTy &ExportList,
962  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
963  const GVSummaryMapTy &DefinedGlobals,
965  auto RunThinBackend = [&](AddStreamFn AddStream) {
966  LTOLLVMContext BackendContext(Conf);
967  Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext);
968  if (!MOrErr)
969  return MOrErr.takeError();
970 
971  return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
972  ImportList, DefinedGlobals, ModuleMap);
973  };
974 
975  auto ModuleID = BM.getModuleIdentifier();
976 
977  if (!Cache || !CombinedIndex.modulePaths().count(ModuleID) ||
978  all_of(CombinedIndex.getModuleHash(ModuleID),
979  [](uint32_t V) { return V == 0; }))
980  // Cache disabled or no entry for this module in the combined index or
981  // no module hash.
982  return RunThinBackend(AddStream);
983 
985  // The module may be cached, this helps handling it.
986  computeCacheKey(Key, Conf, CombinedIndex, ModuleID, ImportList, ExportList,
987  ResolvedODR, DefinedGlobals, CfiFunctionDefs,
988  CfiFunctionDecls);
989  if (AddStreamFn CacheAddStream = Cache(Task, Key))
990  return RunThinBackend(CacheAddStream);
991 
992  return Error::success();
993  }
994 
995  Error start(
996  unsigned Task, BitcodeModule BM,
997  const FunctionImporter::ImportMapTy &ImportList,
998  const FunctionImporter::ExportSetTy &ExportList,
999  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1000  MapVector<StringRef, BitcodeModule> &ModuleMap) override {
1001  StringRef ModulePath = BM.getModuleIdentifier();
1002  assert(ModuleToDefinedGVSummaries.count(ModulePath));
1003  const GVSummaryMapTy &DefinedGlobals =
1004  ModuleToDefinedGVSummaries.find(ModulePath)->second;
1005  BackendThreadPool.async(
1006  [=](BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
1007  const FunctionImporter::ImportMapTy &ImportList,
1008  const FunctionImporter::ExportSetTy &ExportList,
1009  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>
1010  &ResolvedODR,
1011  const GVSummaryMapTy &DefinedGlobals,
1013  Error E = runThinLTOBackendThread(
1014  AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
1015  ResolvedODR, DefinedGlobals, ModuleMap);
1016  if (E) {
1017  std::unique_lock<std::mutex> L(ErrMu);
1018  if (Err)
1019  Err = joinErrors(std::move(*Err), std::move(E));
1020  else
1021  Err = std::move(E);
1022  }
1023  },
1024  BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
1025  std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap));
1026  return Error::success();
1027  }
1028 
1029  Error wait() override {
1030  BackendThreadPool.wait();
1031  if (Err)
1032  return std::move(*Err);
1033  else
1034  return Error::success();
1035  }
1036 };
1037 } // end anonymous namespace
1038 
1039 ThinBackend lto::createInProcessThinBackend(unsigned ParallelismLevel) {
1040  return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1041  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1042  AddStreamFn AddStream, NativeObjectCache Cache) {
1043  return llvm::make_unique<InProcessThinBackend>(
1044  Conf, CombinedIndex, ParallelismLevel, ModuleToDefinedGVSummaries,
1045  AddStream, Cache);
1046  };
1047 }
1048 
1049 // Given the original \p Path to an output file, replace any path
1050 // prefix matching \p OldPrefix with \p NewPrefix. Also, create the
1051 // resulting directory if it does not yet exist.
1052 std::string lto::getThinLTOOutputFile(const std::string &Path,
1053  const std::string &OldPrefix,
1054  const std::string &NewPrefix) {
1055  if (OldPrefix.empty() && NewPrefix.empty())
1056  return Path;
1057  SmallString<128> NewPath(Path);
1058  llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
1059  StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
1060  if (!ParentPath.empty()) {
1061  // Make sure the new directory exists, creating it if necessary.
1062  if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
1063  llvm::errs() << "warning: could not create directory '" << ParentPath
1064  << "': " << EC.message() << '\n';
1065  }
1066  return NewPath.str();
1067 }
1068 
1069 namespace {
1070 class WriteIndexesThinBackend : public ThinBackendProc {
1071  std::string OldPrefix, NewPrefix;
1072  bool ShouldEmitImportsFiles;
1073  raw_fd_ostream *LinkedObjectsFile;
1074  lto::IndexWriteCallback OnWrite;
1075 
1076 public:
1077  WriteIndexesThinBackend(
1078  Config &Conf, ModuleSummaryIndex &CombinedIndex,
1079  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1080  std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1081  raw_fd_ostream *LinkedObjectsFile, lto::IndexWriteCallback OnWrite)
1082  : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
1083  OldPrefix(OldPrefix), NewPrefix(NewPrefix),
1084  ShouldEmitImportsFiles(ShouldEmitImportsFiles),
1085  LinkedObjectsFile(LinkedObjectsFile), OnWrite(OnWrite) {}
1086 
1087  Error start(
1088  unsigned Task, BitcodeModule BM,
1089  const FunctionImporter::ImportMapTy &ImportList,
1090  const FunctionImporter::ExportSetTy &ExportList,
1091  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1092  MapVector<StringRef, BitcodeModule> &ModuleMap) override {
1093  StringRef ModulePath = BM.getModuleIdentifier();
1094  std::string NewModulePath =
1095  getThinLTOOutputFile(ModulePath, OldPrefix, NewPrefix);
1096 
1097  if (LinkedObjectsFile)
1098  *LinkedObjectsFile << NewModulePath << '\n';
1099 
1100  std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
1101  gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
1102  ImportList, ModuleToSummariesForIndex);
1103 
1104  std::error_code EC;
1105  raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
1107  if (EC)
1108  return errorCodeToError(EC);
1109  WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
1110 
1111  if (ShouldEmitImportsFiles) {
1112  EC = EmitImportsFiles(ModulePath, NewModulePath + ".imports",
1113  ModuleToSummariesForIndex);
1114  if (EC)
1115  return errorCodeToError(EC);
1116  }
1117 
1118  if (OnWrite)
1119  OnWrite(ModulePath);
1120  return Error::success();
1121  }
1122 
1123  Error wait() override { return Error::success(); }
1124 };
1125 } // end anonymous namespace
1126 
1128  std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1129  raw_fd_ostream *LinkedObjectsFile, IndexWriteCallback OnWrite) {
1130  return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1131  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1132  AddStreamFn AddStream, NativeObjectCache Cache) {
1133  return llvm::make_unique<WriteIndexesThinBackend>(
1134  Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
1135  ShouldEmitImportsFiles, LinkedObjectsFile, OnWrite);
1136  };
1137 }
1138 
1139 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache) {
1140  if (ThinLTO.ModuleMap.empty())
1141  return Error::success();
1142 
1143  if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
1144  return Error::success();
1145 
1146  // Collect for each module the list of function it defines (GUID ->
1147  // Summary).
1149  ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
1150  ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
1151  ModuleToDefinedGVSummaries);
1152  // Create entries for any modules that didn't have any GV summaries
1153  // (either they didn't have any GVs to start with, or we suppressed
1154  // generation of the summaries because they e.g. had inline assembly
1155  // uses that couldn't be promoted/renamed on export). This is so
1156  // InProcessThinBackend::start can still launch a backend thread, which
1157  // is passed the map of summaries for the module, without any special
1158  // handling for this case.
1159  for (auto &Mod : ThinLTO.ModuleMap)
1160  if (!ModuleToDefinedGVSummaries.count(Mod.first))
1161  ModuleToDefinedGVSummaries.try_emplace(Mod.first);
1162 
1164  ThinLTO.ModuleMap.size());
1166  ThinLTO.ModuleMap.size());
1168 
1169  if (DumpThinCGSCCs)
1170  ThinLTO.CombinedIndex.dumpSCCs(outs());
1171 
1172  if (Conf.OptLevel > 0)
1173  ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1174  ImportLists, ExportLists);
1175 
1176  // Figure out which symbols need to be internalized. This also needs to happen
1177  // at -O0 because summary-based DCE is implemented using internalization, and
1178  // we must apply DCE consistently with the full LTO module in order to avoid
1179  // undefined references during the final link.
1180  std::set<GlobalValue::GUID> ExportedGUIDs;
1181  for (auto &Res : GlobalResolutions) {
1182  // If the symbol does not have external references or it is not prevailing,
1183  // then not need to mark it as exported from a ThinLTO partition.
1184  if (Res.second.Partition != GlobalResolution::External ||
1185  !Res.second.isPrevailingIRSymbol())
1186  continue;
1187  auto GUID = GlobalValue::getGUID(
1188  GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
1189  // Mark exported unless index-based analysis determined it to be dead.
1190  if (ThinLTO.CombinedIndex.isGUIDLive(GUID))
1191  ExportedGUIDs.insert(GUID);
1192  }
1193 
1194  // Any functions referenced by the jump table in the regular LTO object must
1195  // be exported.
1196  for (auto &Def : ThinLTO.CombinedIndex.cfiFunctionDefs())
1197  ExportedGUIDs.insert(
1199 
1200  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
1201  const auto &ExportList = ExportLists.find(ModuleIdentifier);
1202  return (ExportList != ExportLists.end() &&
1203  ExportList->second.count(GUID)) ||
1204  ExportedGUIDs.count(GUID);
1205  };
1206  thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported);
1207 
1208  auto isPrevailing = [&](GlobalValue::GUID GUID,
1209  const GlobalValueSummary *S) {
1210  return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
1211  };
1212  auto recordNewLinkage = [&](StringRef ModuleIdentifier,
1213  GlobalValue::GUID GUID,
1214  GlobalValue::LinkageTypes NewLinkage) {
1215  ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
1216  };
1217  thinLTOResolvePrevailingInIndex(ThinLTO.CombinedIndex, isPrevailing,
1218  recordNewLinkage);
1219 
1220  std::unique_ptr<ThinBackendProc> BackendProc =
1221  ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1222  AddStream, Cache);
1223 
1224  // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined
1225  // module and parallel code generation partitions.
1226  unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel;
1227  for (auto &Mod : ThinLTO.ModuleMap) {
1228  if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
1229  ExportLists[Mod.first],
1230  ResolvedODR[Mod.first], ThinLTO.ModuleMap))
1231  return E;
1232  ++Task;
1233  }
1234 
1235  return BackendProc->wait();
1236 }
1237 
1241  bool LTOPassRemarksWithHotness, int Count) {
1242  if (LTOPassRemarksWithHotness)
1243  Context.setDiagnosticsHotnessRequested(true);
1244  if (LTORemarksFilename.empty())
1245  return nullptr;
1246 
1247  std::string Filename = LTORemarksFilename;
1248  if (Count != -1)
1249  Filename += ".thin." + llvm::utostr(Count) + ".yaml";
1250 
1251  std::error_code EC;
1252  auto DiagnosticFile =
1253  llvm::make_unique<ToolOutputFile>(Filename, EC, sys::fs::F_None);
1254  if (EC)
1255  return errorCodeToError(EC);
1256  Context.setDiagnosticsOutputFile(
1257  llvm::make_unique<yaml::Output>(DiagnosticFile->os()));
1258  DiagnosticFile->keep();
1259  return std::move(DiagnosticFile);
1260 }
uint64_t CallInst * C
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:915
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
ArrayRef< Symbol > symbols() const
A range over the symbols in this InputFile.
Definition: LTO.h:133
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Expected< std::unique_ptr< ToolOutputFile > > setupOptimizationRemarks(LLVMContext &Context, StringRef LTORemarksFilename, bool LTOPassRemarksWithHotness, int Count=-1)
Setup optimization remarks.
Definition: LTO.cpp:1239
This class defines the interface to the ThinLTO backend.
Definition: LTO.cpp:907
bool hasLocalLinkage() const
Definition: GlobalValue.h:436
std::string CPU
Definition: Config.h:39
std::string AAPipeline
Definition: Config.h:63
uint32_t getSymbolFlags(Symbol S) const
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
void EnableStatistics(bool PrintOnExit=true)
Enable the collection and printing of statistics.
Definition: Statistic.cpp:129
LLVMContext & Context
unsigned Prevailing
The linker has chosen this definition of the symbol.
Definition: LTO.h:400
CodeGenOpt::Level CGOptLevel
Definition: Config.h:44
void replace_path_prefix(SmallVectorImpl< char > &Path, const StringRef &OldPrefix, const StringRef &NewPrefix, Style style=Style::native)
Replace matching path prefix with another path.
Definition: Path.cpp:524
std::vector< std::unique_ptr< GlobalValueSummary > > GlobalValueSummaryList
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
Definition: GlobalValue.h:493
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void setDiagnosticsOutputFile(std::unique_ptr< yaml::Output > F)
Set the diagnostics output file used for optimization diagnostics.
cl::opt< std::string > LTORemarksFilename("lto-pass-remarks-output", cl::desc("Output filename for pass remarks"), cl::value_desc("filename"))
unsigned heavyweight_hardware_concurrency()
Get the amount of currency to use for tasks requiring significant memory or other resources...
Definition: Threading.cpp:63
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
iterator begin() const
Definition: ArrayRef.h:137
GlobalValueSummary * findSummaryInModule(GlobalValue::GUID ValueGUID, StringRef ModuleId) const
Find the summary for global GUID in module ModuleId, or nullptr if not found.
The purpose of this class is to only expose the symbol information that an LTO client should need in ...
Definition: LTO.h:110
Implements a dense probed hash-table based set.
Definition: DenseSet.h:250
std::string OverrideTriple
Setting this field will replace target triples in input files with this triple.
Definition: Config.h:67
Available for inspection, not emission.
Definition: GlobalValue.h:50
unsigned DataSections
Emit data into separate sections.
static ConstantAggregateZero * get(Type *Ty)
Definition: Constants.cpp:1309
std::error_code EmitImportsFiles(StringRef ModulePath, StringRef OutputFilename, const std::map< std::string, GVSummaryMapTy > &ModuleToSummariesForIndex)
Emit into OutputFilename the files module ModulePath will import from.
bool CodeGenOnly
Disable entirely the optimizer, including importing for ThinLTO.
Definition: Config.h:53
Error readSummary(ModuleSummaryIndex &CombinedIndex, StringRef ModulePath, uint64_t ModuleId)
Parse the specified bitcode buffer and merge its module summary index into CombinedIndex.
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:423
This file contains the declarations for metadata subclasses.
unsigned LinkerRedefined
Linker redefined version of the symbol which appeared in -wrap or -defsym linker option.
Definition: LTO.h:411
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:106
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:107
iterator find(StringRef Key)
Definition: StringMap.h:333
const StringMap< std::pair< uint64_t, ModuleHash > > & modulePaths() const
Table of modules, containing module hash and id.
Externally visible function.
Definition: GlobalValue.h:49
The resolution for a symbol.
Definition: LTO.h:394
This class implements a map that also provides access to all stored values in a deterministic order...
Definition: MapVector.h:38
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1048
F(f)
const StringMap< GVSummaryMapTy > & ModuleToDefinedGVSummaries
Definition: LTO.cpp:911
A class that wrap the SHA1 algorithm.
Definition: SHA1.h:29
static Expected< std::unique_ptr< InputFile > > create(MemoryBufferRef Object)
Create an InputFile.
Definition: LTO.cpp:378
Error takeError()
Take ownership of the stored error.
Definition: Error.h:553
std::string getGlobalIdentifier() const
Return the modified name for this global value suitable to be used as the key for a global lookup (e...
Definition: Globals.cpp:156
void setAlignment(unsigned Align)
Definition: Globals.cpp:116
std::function< void(const std::string &)> IndexWriteCallback
This ThinBackend writes individual module indexes to files, instead of running the individual backend...
Definition: LTO.h:216
std::shared_future< void > async(Function &&F, Args &&... ArgList)
Asynchronous submission of a task to the pool.
Definition: ThreadPool.h:55
StringRef getModuleIdentifier() const
Definition: BitcodeReader.h:92
Tentative definitions.
Definition: GlobalValue.h:59
ThinBackend createWriteIndexesThinBackend(std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles, raw_fd_ostream *LinkedObjectsFile, IndexWriteCallback OnWrite)
Definition: LTO.cpp:1127
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:321
static bool isLinkOnceLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:300
CombinedIndexHookFn CombinedIndexHook
Definition: Config.h:167
StringRef getName() const
Returns the path to the InputFile.
Definition: LTO.cpp:406
std::function< std::unique_ptr< NativeObjectStream >unsigned Task)> AddStreamFn
This type defines the callback to add a native object that is generated on the fly.
Definition: LTO.h:174
amdgpu Simplify well known AMD library false Value Value const Twine & Name
Definition: BitVector.h:938
Represents a module in a bitcode file.
Definition: BitcodeReader.h:57
std::string DwoDir
The directory to store .dwo files.
Definition: Config.h:80
const ComdatSymTabType & getComdatSymbolTable() const
Get the Module&#39;s symbol table for COMDATs (constant).
Definition: Module.h:560
std::vector< std::string > MAttrs
Definition: Config.h:41
std::string ProfileRemapping
Name remapping file for profile data.
Definition: Config.h:77
ModuleSummaryIndex & CombinedIndex
Definition: LTO.cpp:910
const TypeIdSummaryMapTy & typeIds() const
std::unordered_set< GlobalValue::GUID > ExportSetTy
The set contains an entry for every global value the module exports.
ArrayRef< Symbol > symbols() const
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
StringRef result()
Return a reference to the current raw 160-bits SHA1 for the digested data since the last call to init...
Definition: SHA1.cpp:261
static bool isLinkOnceODRLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:297
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:267
Key
PAL metadata keys.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
cl::opt< bool > LTOPassRemarksWithHotness("lto-pass-remarks-with-hotness", cl::desc("With PGO, include profile count in optimization remarks"), cl::Hidden)
void setDiagnosticsHotnessRequested(bool Requested)
Set if a code hotness metric should be included in optimization diagnostics.
Class to represent array types.
Definition: DerivedTypes.h:369
std::string SampleProfile
Sample PGO profile path.
Definition: Config.h:74
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
TargetOptions Options
Definition: Config.h:40
unsigned FunctionSections
Emit functions into separate sections.
Optional< CodeModel::Model > CodeModel
Definition: Config.h:43
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
An input file.
Definition: LTO.h:83
A ThreadPool for asynchronous parallel execution on a defined number of threads.
Definition: ThreadPool.h:37
static bool isAppendingLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:312
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:439
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:598
std::pair< iterator, bool > try_emplace(StringRef Key, ArgsTy &&... Args)
Emplace a new element for the specified key into the map if the key isn&#39;t already in the map...
Definition: StringMap.h:395
Class to hold module path string table and global value map, and encapsulate methods for operating on...
void update(ArrayRef< uint8_t > Data)
Digest more data.
Definition: SHA1.cpp:213
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1750
Ephemeral symbols produced by Reader::symbols() and Reader::module_symbols().
Definition: IRSymtab.h:291
Error add(std::unique_ptr< InputFile > Obj, ArrayRef< SymbolResolution > Res)
Add an input file to the LTO link, using the provided symbol resolutions.
Definition: LTO.cpp:511
DebuggerKind DebuggerTuning
Which debugger to tune for.
raw_ostream & outs()
This returns a reference to a raw_ostream for standard output.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:419
ModuleHookFn PreOptModuleHook
This module hook is called after linking (regular LTO) or loading (ThinLTO) the module, before modifying it.
Definition: Config.h:136
static cl::opt< bool > DumpThinCGSCCs("dump-thin-cg-sccs", cl::init(false), cl::Hidden, cl::desc("Dump the SCCs in the ThinLTO index's callgraph"))
std::function< AddStreamFn(unsigned Task, StringRef Key)> NativeObjectCache
This is the type of a native object cache.
Definition: LTO.h:189
void gatherImportedSummariesForModule(StringRef ModulePath, const StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries, const FunctionImporter::ImportMapTy &ImportList, std::map< std::string, GVSummaryMapTy > &ModuleToSummariesForIndex)
Compute the set of summaries needed for a ThinLTO backend compilation of ModulePath.
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:359
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
bool UseNewPM
Use the new pass manager.
Definition: Config.h:50
bool UpgradeDebugInfo(Module &M)
Check the debug info version number, if it is out-dated, drop the debug info.
ThinBackendProc(Config &Conf, ModuleSummaryIndex &CombinedIndex, const StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries)
Definition: LTO.cpp:914
unsigned OptLevel
Definition: Config.h:46
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Globals.cpp:359
void thinLTOResolvePrevailingInIndex(ModuleSummaryIndex &Index, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, function_ref< void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> recordNewLinkage)
Resolve linkage for prevailing symbols in the Index.
Definition: LTO.cpp:329
LTO configuration.
Definition: Config.h:36
std::string DefaultTriple
Setting this field will replace unspecified target triples in input files with this triple...
Definition: Config.h:71
const ModuleHash & getModuleHash(const StringRef ModPath) const
Get the module SHA1 hash recorded for the given module path.
StringRef parent_path(StringRef path, Style style=Style::native)
Get parent path.
Definition: Path.cpp:491
Function and variable summary information to aid decisions and implementation of importing.
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:497
std::string StatsFile
Statistics output file path.
Definition: Config.h:97
T dyn_cast() const
Returns the current pointer if it is of the specified pointer type, otherwises returns null...
Definition: PointerUnion.h:142
ModuleHookFn PostInternalizeModuleHook
This hook is called after internalizing the module.
Definition: Config.h:143
TargetMachine::CodeGenFileType CGFileType
Definition: Config.h:45
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
static LinkageTypes getWeakLinkage(bool ODR)
Definition: GlobalValue.h:287
Struct that holds a reference to a particular GUID in a global value summary.
static void writeToResolutionFile(raw_ostream &OS, InputFile *Input, ArrayRef< SymbolResolution > Res)
Definition: LTO.cpp:487
void PrintStatisticsJSON(raw_ostream &OS)
Print statistics in JSON format.
Definition: Statistic.cpp:203
static ErrorSuccess success()
Create a success value.
Definition: Error.h:327
std::function< std::unique_ptr< ThinBackendProc > Config &C, ModuleSummaryIndex &CombinedIndex, StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries, AddStreamFn AddStream, NativeObjectCache Cache)> ThinBackend
A ThinBackend defines what happens after the thin-link phase during ThinLTO.
Definition: LTO.h:198
unsigned getMaxTasks() const
Returns an upper bound on the number of tasks that the client may expect.
Definition: LTO.cpp:782
static void thinLTOInternalizeAndPromoteGUID(GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID, function_ref< bool(StringRef, GlobalValue::GUID)> isExported)
Definition: LTO.cpp:350
iterator end() const
Definition: ArrayRef.h:138
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
virtual ~ThinBackendProc()
Definition: LTO.cpp:919
Optional< Reloc::Model > RelocModel
Definition: Config.h:42
std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:224
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:445
The access may modify the value stored in memory.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:220
const Comdat * getComdat() const
Definition: Globals.cpp:171
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character &#39;\1&#39;, drop it.
Definition: GlobalValue.h:472
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
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:58
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 ...
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:501
unsigned RelaxELFRelocations
ThinBackend createInProcessThinBackend(unsigned ParallelismLevel)
This ThinBackend runs the individual backend jobs in-process.
Definition: LTO.cpp:1039
amdgpu Simplify well known AMD library false Value Value * Arg
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:428
std::set< std::string > & cfiFunctionDefs()
Error thinBackend(Config &C, unsigned Task, AddStreamFn AddStream, Module &M, const ModuleSummaryIndex &CombinedIndex, const FunctionImporter::ImportMapTy &ImportList, const GVSummaryMapTy &DefinedGlobals, MapVector< StringRef, BitcodeModule > &ModuleMap)
Runs a ThinLTO backend.
Definition: LTOBackend.cpp:463
void ComputeCrossModuleImport(const ModuleSummaryIndex &Index, const StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries, StringMap< FunctionImporter::ImportMapTy > &ImportLists, StringMap< FunctionImporter::ExportSetTy > &ExportLists)
Compute all the imports and exports for every module in the Index.
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:366
LTO(Config Conf, ThinBackend Backend=nullptr, unsigned ParallelCodeGenParallelismLevel=1)
Create an LTO object.
Definition: LTO.cpp:423
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:216
static void handleNonPrevailingComdat(GlobalValue &GV, std::set< const Comdat *> &NonPrevailingComdats)
Definition: LTO.cpp:573
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:424
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
#define I(x, y, z)
Definition: MD5.cpp:58
Error run(AddStreamFn AddStream, NativeObjectCache Cache=nullptr)
Runs the LTO pipeline.
Definition: LTO.cpp:787
static void thinLTOResolvePrevailingGUID(GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID, DenseSet< GlobalValueSummary *> &GlobalInvolvedWithAlias, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, function_ref< void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> recordNewLinkage)
Definition: LTO.cpp:287
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:581
Type * getValueType() const
Definition: GlobalValue.h:276
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:53
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:92
unsigned VisibleToRegularObj
The definition of this symbol is visible outside of the LTO unit.
Definition: LTO.h:407
cl::opt< bool > EnableLTOInternalization("enable-lto-internalization", cl::init(true), cl::Hidden, cl::desc("Enable global value internalization in LTO"))
Enable global value internalization in LTO.
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:206
const GlobalObject * getBaseObject() const
Definition: Globals.cpp:261
static void computeCacheKey(SmallString< 40 > &Key, const Config &Conf, const ModuleSummaryIndex &Index, StringRef ModuleID, const FunctionImporter::ImportMapTy &ImportList, const FunctionImporter::ExportSetTy &ExportList, const std::map< GlobalValue::GUID, GlobalValue::LinkageTypes > &ResolvedODR, const GVSummaryMapTy &DefinedGlobals, const std::set< GlobalValue::GUID > &CfiFunctionDefs, const std::set< GlobalValue::GUID > &CfiFunctionDecls)
Definition: LTO.cpp:67
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
void computeDeadSymbolsWithConstProp(ModuleSummaryIndex &Index, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols, function_ref< PrevailingType(GlobalValue::GUID)> isPrevailing, bool ImportEnabled)
Compute dead symbols and run constant propagation in combined index after that.
Error backend(Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, std::unique_ptr< Module > M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:410
bool empty() const
Definition: StringMap.h:111
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
std::set< std::string > & cfiFunctionDecls()
std::function< void(GlobalValue &)> ValueAdder
Definition: IRMover.h:65
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
Expected< std::unique_ptr< Module > > getLazyModule(LLVMContext &Context, bool ShouldLazyLoadMetadata, bool IsImporting)
Read the bitcode module and prepare for lazy deserialization of function bodies.
Expected< std::unique_ptr< Module > > parseModule(LLVMContext &Context)
Read the entire bitcode module and return it.
iterator_range< global_iterator > globals()
Definition: Module.h:574
A derived class of LLVMContext that initializes itself according to a given Config object...
Definition: Config.h:202
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
This pass exposes codegen information to IR-level passes.
unsigned FinalDefinitionInLinkageUnit
The definition of this symbol is unpreemptable at runtime and is known to be in this linkage unit...
Definition: LTO.h:404
Expected< IRSymtabFile > readIRSymtab(MemoryBufferRef MBRef)
Reads a bitcode file, creating its irsymtab if necessary.
std::string toHex(StringRef Input, bool LowerCase=false)
Convert buffer Input to its hexadecimal representation.
Definition: StringExtras.h:142
iterator_range< global_value_iterator > global_values()
Definition: Module.h:675
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
Definition: ThreadPool.cpp:72
llvm::Error materializeMetadata()
Definition: Module.cpp:403
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:174
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:274
std::string getThinLTOOutputFile(const std::string &Path, const std::string &OldPrefix, const std::string &NewPrefix)
Given the original Path to an output file, replace any path prefix matching OldPrefix with NewPrefix...
Definition: LTO.cpp:1052
void thinLTOInternalizeAndPromoteInIndex(ModuleSummaryIndex &Index, function_ref< bool(StringRef, GlobalValue::GUID)> isExported)
Update the linkages in the given Index to mark exported values as external and non-exported values as...
Definition: LTO.cpp:368
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77
A discriminated union of two pointer types, with the discriminator in the low bit of the pointer...
Definition: PointerUnion.h:87
iterator_range< alias_iterator > aliases()
Definition: Module.h:614