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 // The values are (type identifier, summary) pairs.
60 typedef DenseMap<
64 
65 // Returns a unique hash for the Module considering the current list of
66 // export/import and other global analysis results.
67 // The hash is produced in \p Key.
68 static void computeCacheKey(
69  SmallString<40> &Key, const Config &Conf, const ModuleSummaryIndex &Index,
70  StringRef ModuleID, const FunctionImporter::ImportMapTy &ImportList,
71  const FunctionImporter::ExportSetTy &ExportList,
72  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
73  const GVSummaryMapTy &DefinedGlobals,
74  const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid,
75  const std::set<GlobalValue::GUID> &CfiFunctionDefs,
76  const std::set<GlobalValue::GUID> &CfiFunctionDecls) {
77  // Compute the unique hash for this entry.
78  // This is based on the current compiler version, the module itself, the
79  // export list, the hash for every single module in the import list, the
80  // list of ResolvedODR for the module, and the list of preserved symbols.
81  SHA1 Hasher;
82 
83  // Start with the compiler revision
84  Hasher.update(LLVM_VERSION_STRING);
85 #ifdef LLVM_REVISION
86  Hasher.update(LLVM_REVISION);
87 #endif
88 
89  // Include the parts of the LTO configuration that affect code generation.
90  auto AddString = [&](StringRef Str) {
91  Hasher.update(Str);
92  Hasher.update(ArrayRef<uint8_t>{0});
93  };
94  auto AddUnsigned = [&](unsigned I) {
95  uint8_t Data[4];
96  Data[0] = I;
97  Data[1] = I >> 8;
98  Data[2] = I >> 16;
99  Data[3] = I >> 24;
100  Hasher.update(ArrayRef<uint8_t>{Data, 4});
101  };
102  auto AddUint64 = [&](uint64_t I) {
103  uint8_t Data[8];
104  Data[0] = I;
105  Data[1] = I >> 8;
106  Data[2] = I >> 16;
107  Data[3] = I >> 24;
108  Data[4] = I >> 32;
109  Data[5] = I >> 40;
110  Data[6] = I >> 48;
111  Data[7] = I >> 56;
112  Hasher.update(ArrayRef<uint8_t>{Data, 8});
113  };
114  AddString(Conf.CPU);
115  // FIXME: Hash more of Options. For now all clients initialize Options from
116  // command-line flags (which is unsupported in production), but may set
117  // RelaxELFRelocations. The clang driver can also pass FunctionSections,
118  // DataSections and DebuggerTuning via command line flags.
119  AddUnsigned(Conf.Options.RelaxELFRelocations);
120  AddUnsigned(Conf.Options.FunctionSections);
121  AddUnsigned(Conf.Options.DataSections);
122  AddUnsigned((unsigned)Conf.Options.DebuggerTuning);
123  for (auto &A : Conf.MAttrs)
124  AddString(A);
125  if (Conf.RelocModel)
126  AddUnsigned(*Conf.RelocModel);
127  else
128  AddUnsigned(-1);
129  if (Conf.CodeModel)
130  AddUnsigned(*Conf.CodeModel);
131  else
132  AddUnsigned(-1);
133  AddUnsigned(Conf.CGOptLevel);
134  AddUnsigned(Conf.CGFileType);
135  AddUnsigned(Conf.OptLevel);
136  AddUnsigned(Conf.UseNewPM);
137  AddString(Conf.OptPipeline);
138  AddString(Conf.AAPipeline);
139  AddString(Conf.OverrideTriple);
140  AddString(Conf.DefaultTriple);
141  AddString(Conf.DwoDir);
142 
143  // Include the hash for the current module
144  auto ModHash = Index.getModuleHash(ModuleID);
145  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
146  for (auto F : ExportList)
147  // The export list can impact the internalization, be conservative here
148  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F)));
149 
150  // Include the hash for every module we import functions from. The set of
151  // imported symbols for each module may affect code generation and is
152  // sensitive to link order, so include that as well.
153  for (auto &Entry : ImportList) {
154  auto ModHash = Index.getModuleHash(Entry.first());
155  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
156 
157  AddUint64(Entry.second.size());
158  for (auto &Fn : Entry.second)
159  AddUint64(Fn);
160  }
161 
162  // Include the hash for the resolved ODR.
163  for (auto &Entry : ResolvedODR) {
164  Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first,
165  sizeof(GlobalValue::GUID)));
166  Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second,
167  sizeof(GlobalValue::LinkageTypes)));
168  }
169 
170  // Members of CfiFunctionDefs and CfiFunctionDecls that are referenced or
171  // defined in this module.
172  std::set<GlobalValue::GUID> UsedCfiDefs;
173  std::set<GlobalValue::GUID> UsedCfiDecls;
174 
175  // Typeids used in this module.
176  std::set<GlobalValue::GUID> UsedTypeIds;
177 
178  auto AddUsedCfiGlobal = [&](GlobalValue::GUID ValueGUID) {
179  if (CfiFunctionDefs.count(ValueGUID))
180  UsedCfiDefs.insert(ValueGUID);
181  if (CfiFunctionDecls.count(ValueGUID))
182  UsedCfiDecls.insert(ValueGUID);
183  };
184 
185  auto AddUsedThings = [&](GlobalValueSummary *GS) {
186  if (!GS) return;
187  AddUnsigned(GS->isLive());
188  for (const ValueInfo &VI : GS->refs()) {
189  AddUnsigned(VI.isDSOLocal());
190  AddUsedCfiGlobal(VI.getGUID());
191  }
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 SummariesI = TypeIdSummariesByGuid.find(TId);
259  if (SummariesI != TypeIdSummariesByGuid.end())
260  for (auto *Summary : SummariesI->second)
261  AddTypeIdSummary(Summary->first, Summary->second);
262  }
263 
264  AddUnsigned(UsedCfiDefs.size());
265  for (auto &V : UsedCfiDefs)
266  AddUint64(V);
267 
268  AddUnsigned(UsedCfiDecls.size());
269  for (auto &V : UsedCfiDecls)
270  AddUint64(V);
271 
272  if (!Conf.SampleProfile.empty()) {
273  auto FileOrErr = MemoryBuffer::getFile(Conf.SampleProfile);
274  if (FileOrErr)
275  Hasher.update(FileOrErr.get()->getBuffer());
276  }
277 
278  Key = toHex(Hasher.result());
279 }
280 
282  GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
283  DenseSet<GlobalValueSummary *> &GlobalInvolvedWithAlias,
284  function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
285  isPrevailing,
286  function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
287  recordNewLinkage) {
288  for (auto &S : GVSummaryList) {
289  GlobalValue::LinkageTypes OriginalLinkage = S->linkage();
290  if (!GlobalValue::isWeakForLinker(OriginalLinkage))
291  continue;
292  // We need to emit only one of these. The prevailing module will keep it,
293  // but turned into a weak, while the others will drop it when possible.
294  // This is both a compile-time optimization and a correctness
295  // transformation. This is necessary for correctness when we have exported
296  // a reference - we need to convert the linkonce to weak to
297  // ensure a copy is kept to satisfy the exported reference.
298  // FIXME: We may want to split the compile time and correctness
299  // aspects into separate routines.
300  if (isPrevailing(GUID, S.get())) {
301  if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
302  S->setLinkage(GlobalValue::getWeakLinkage(
303  GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
304  }
305  // Alias and aliasee can't be turned into available_externally.
306  else if (!isa<AliasSummary>(S.get()) &&
307  !GlobalInvolvedWithAlias.count(S.get()))
309  if (S->linkage() != OriginalLinkage)
310  recordNewLinkage(S->modulePath(), GUID, S->linkage());
311  }
312 }
313 
314 // Resolve Weak and LinkOnce values in the \p Index.
315 //
316 // We'd like to drop these functions if they are no longer referenced in the
317 // current module. However there is a chance that another module is still
318 // referencing them because of the import. We make sure we always emit at least
319 // one copy.
322  function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
323  isPrevailing,
324  function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
325  recordNewLinkage) {
326  // We won't optimize the globals that are referenced by an alias for now
327  // Ideally we should turn the alias into a global and duplicate the definition
328  // when needed.
329  DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias;
330  for (auto &I : Index)
331  for (auto &S : I.second.SummaryList)
332  if (auto AS = dyn_cast<AliasSummary>(S.get()))
333  GlobalInvolvedWithAlias.insert(&AS->getAliasee());
334 
335  for (auto &I : Index)
336  thinLTOResolveWeakForLinkerGUID(I.second.SummaryList, I.first,
337  GlobalInvolvedWithAlias, isPrevailing,
338  recordNewLinkage);
339 }
340 
342  GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
343  function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
344  for (auto &S : GVSummaryList) {
345  if (isExported(S->modulePath(), GUID)) {
346  if (GlobalValue::isLocalLinkage(S->linkage()))
347  S->setLinkage(GlobalValue::ExternalLinkage);
348  } else if (!GlobalValue::isLocalLinkage(S->linkage()))
349  S->setLinkage(GlobalValue::InternalLinkage);
350  }
351 }
352 
353 // Update the linkages in the given \p Index to mark exported values
354 // as external and non-exported values as internal.
356  ModuleSummaryIndex &Index,
357  function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
358  for (auto &I : Index)
359  thinLTOInternalizeAndPromoteGUID(I.second.SummaryList, I.first, isExported);
360 }
361 
362 // Requires a destructor for std::vector<InputModule>.
363 InputFile::~InputFile() = default;
364 
366  std::unique_ptr<InputFile> File(new InputFile);
367 
368  Expected<IRSymtabFile> FOrErr = readIRSymtab(Object);
369  if (!FOrErr)
370  return FOrErr.takeError();
371 
372  File->TargetTriple = FOrErr->TheReader.getTargetTriple();
373  File->SourceFileName = FOrErr->TheReader.getSourceFileName();
374  File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts();
375  File->ComdatTable = FOrErr->TheReader.getComdatTable();
376 
377  for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) {
378  size_t Begin = File->Symbols.size();
379  for (const irsymtab::Reader::SymbolRef &Sym :
380  FOrErr->TheReader.module_symbols(I))
381  // Skip symbols that are irrelevant to LTO. Note that this condition needs
382  // to match the one in Skip() in LTO::addRegularLTO().
383  if (Sym.isGlobal() && !Sym.isFormatSpecific())
384  File->Symbols.push_back(Sym);
385  File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
386  }
387 
388  File->Mods = FOrErr->Mods;
389  File->Strtab = std::move(FOrErr->Strtab);
390  return std::move(File);
391 }
392 
394  return Mods[0].getModuleIdentifier();
395 }
396 
397 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
398  Config &Conf)
399  : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
400  Ctx(Conf), CombinedModule(llvm::make_unique<Module>("ld-temp.o", Ctx)),
401  Mover(llvm::make_unique<IRMover>(*CombinedModule)) {}
402 
403 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend)
404  : Backend(Backend), CombinedIndex(/*HaveGVs*/ false) {
405  if (!Backend)
406  this->Backend =
408 }
409 
411  unsigned ParallelCodeGenParallelismLevel)
412  : Conf(std::move(Conf)),
413  RegularLTO(ParallelCodeGenParallelismLevel, this->Conf),
414  ThinLTO(std::move(Backend)) {}
415 
416 // Requires a destructor for MapVector<BitcodeModule>.
417 LTO::~LTO() = default;
418 
419 // Add the symbols in the given module to the GlobalResolutions map, and resolve
420 // their partitions.
421 void LTO::addModuleToGlobalRes(ArrayRef<InputFile::Symbol> Syms,
423  unsigned Partition, bool InSummary) {
424  auto *ResI = Res.begin();
425  auto *ResE = Res.end();
426  (void)ResE;
427  for (const InputFile::Symbol &Sym : Syms) {
428  assert(ResI != ResE);
429  SymbolResolution Res = *ResI++;
430 
431  StringRef Name = Sym.getName();
432  Triple TT(RegularLTO.CombinedModule->getTargetTriple());
433  // Strip the __imp_ prefix from COFF dllimport symbols (similar to the
434  // way they are handled by lld), otherwise we can end up with two
435  // global resolutions (one with and one for a copy of the symbol without).
436  if (TT.isOSBinFormatCOFF() && Name.startswith("__imp_"))
437  Name = Name.substr(strlen("__imp_"));
438  auto &GlobalRes = GlobalResolutions[Name];
439  GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
440  if (Res.Prevailing) {
441  assert(!GlobalRes.Prevailing &&
442  "Multiple prevailing defs are not allowed");
443  GlobalRes.Prevailing = true;
444  GlobalRes.IRName = Sym.getIRName();
445  } else if (!GlobalRes.Prevailing && GlobalRes.IRName.empty()) {
446  // Sometimes it can be two copies of symbol in a module and prevailing
447  // symbol can have no IR name. That might happen if symbol is defined in
448  // module level inline asm block. In case we have multiple modules with
449  // the same symbol we want to use IR name of the prevailing symbol.
450  // Otherwise, if we haven't seen a prevailing symbol, set the name so that
451  // we can later use it to check if there is any prevailing copy in IR.
452  GlobalRes.IRName = Sym.getIRName();
453  }
454 
455  // Set the partition to external if we know it is re-defined by the linker
456  // with -defsym or -wrap options, used elsewhere, e.g. it is visible to a
457  // regular object, is referenced from llvm.compiler_used, or was already
458  // recorded as being referenced from a different partition.
459  if (Res.LinkerRedefined || Res.VisibleToRegularObj || Sym.isUsed() ||
460  (GlobalRes.Partition != GlobalResolution::Unknown &&
461  GlobalRes.Partition != Partition)) {
462  GlobalRes.Partition = GlobalResolution::External;
463  } else
464  // First recorded reference, save the current partition.
465  GlobalRes.Partition = Partition;
466 
467  // Flag as visible outside of summary if visible from a regular object or
468  // from a module that does not have a summary.
469  GlobalRes.VisibleOutsideSummary |=
470  (Res.VisibleToRegularObj || Sym.isUsed() || !InSummary);
471  }
472 }
473 
476  StringRef Path = Input->getName();
477  OS << Path << '\n';
478  auto ResI = Res.begin();
479  for (const InputFile::Symbol &Sym : Input->symbols()) {
480  assert(ResI != Res.end());
481  SymbolResolution Res = *ResI++;
482 
483  OS << "-r=" << Path << ',' << Sym.getName() << ',';
484  if (Res.Prevailing)
485  OS << 'p';
486  if (Res.FinalDefinitionInLinkageUnit)
487  OS << 'l';
488  if (Res.VisibleToRegularObj)
489  OS << 'x';
490  if (Res.LinkerRedefined)
491  OS << 'r';
492  OS << '\n';
493  }
494  OS.flush();
495  assert(ResI == Res.end());
496 }
497 
498 Error LTO::add(std::unique_ptr<InputFile> Input,
500  assert(!CalledGetMaxTasks);
501 
502  if (Conf.ResolutionFile)
503  writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
504 
505  if (RegularLTO.CombinedModule->getTargetTriple().empty())
506  RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple());
507 
508  const SymbolResolution *ResI = Res.begin();
509  for (unsigned I = 0; I != Input->Mods.size(); ++I)
510  if (Error Err = addModule(*Input, I, ResI, Res.end()))
511  return Err;
512 
513  assert(ResI == Res.end());
514  return Error::success();
515 }
516 
517 Error LTO::addModule(InputFile &Input, unsigned ModI,
518  const SymbolResolution *&ResI,
519  const SymbolResolution *ResE) {
520  Expected<BitcodeLTOInfo> LTOInfo = Input.Mods[ModI].getLTOInfo();
521  if (!LTOInfo)
522  return LTOInfo.takeError();
523 
524  BitcodeModule BM = Input.Mods[ModI];
525  auto ModSyms = Input.module_symbols(ModI);
526  addModuleToGlobalRes(ModSyms, {ResI, ResE},
527  LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
528  LTOInfo->HasSummary);
529 
530  if (LTOInfo->IsThinLTO)
531  return addThinLTO(BM, ModSyms, ResI, ResE);
532 
534  addRegularLTO(BM, ModSyms, ResI, ResE);
535  if (!ModOrErr)
536  return ModOrErr.takeError();
537 
538  if (!LTOInfo->HasSummary)
539  return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
540 
541  // Regular LTO module summaries are added to a dummy module that represents
542  // the combined regular LTO module.
543  if (Error Err = BM.readSummary(ThinLTO.CombinedIndex, "", -1ull))
544  return Err;
545  RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
546  return Error::success();
547 }
548 
549 // Checks whether the given global value is in a non-prevailing comdat
550 // (comdat containing values the linker indicated were not prevailing,
551 // which we then dropped to available_externally), and if so, removes
552 // it from the comdat. This is called for all global values to ensure the
553 // comdat is empty rather than leaving an incomplete comdat. It is needed for
554 // regular LTO modules, in case we are in a mixed-LTO mode (both regular
555 // and thin LTO modules) compilation. Since the regular LTO module will be
556 // linked first in the final native link, we want to make sure the linker
557 // doesn't select any of these incomplete comdats that would be left
558 // in the regular LTO module without this cleanup.
559 static void
561  std::set<const Comdat *> &NonPrevailingComdats) {
562  Comdat *C = GV.getComdat();
563  if (!C)
564  return;
565 
566  if (!NonPrevailingComdats.count(C))
567  return;
568 
569  // Additionally need to drop externally visible global values from the comdat
570  // to available_externally, so that there aren't multiply defined linker
571  // errors.
572  if (!GV.hasLocalLinkage())
574 
575  if (auto GO = dyn_cast<GlobalObject>(&GV))
576  GO->setComdat(nullptr);
577 }
578 
579 // Add a regular LTO object to the link.
580 // The resulting module needs to be linked into the combined LTO module with
581 // linkRegularLTO.
583 LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
584  const SymbolResolution *&ResI,
585  const SymbolResolution *ResE) {
586  RegularLTOState::AddedModule Mod;
588  BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true,
589  /*IsImporting*/ false);
590  if (!MOrErr)
591  return MOrErr.takeError();
592  Module &M = **MOrErr;
593  Mod.M = std::move(*MOrErr);
594 
595  if (Error Err = M.materializeMetadata())
596  return std::move(Err);
597  UpgradeDebugInfo(M);
598 
599  ModuleSymbolTable SymTab;
600  SymTab.addModule(&M);
601 
602  for (GlobalVariable &GV : M.globals())
603  if (GV.hasAppendingLinkage())
604  Mod.Keep.push_back(&GV);
605 
606  DenseSet<GlobalObject *> AliasedGlobals;
607  for (auto &GA : M.aliases())
608  if (GlobalObject *GO = GA.getBaseObject())
609  AliasedGlobals.insert(GO);
610 
611  // In this function we need IR GlobalValues matching the symbols in Syms
612  // (which is not backed by a module), so we need to enumerate them in the same
613  // order. The symbol enumeration order of a ModuleSymbolTable intentionally
614  // matches the order of an irsymtab, but when we read the irsymtab in
615  // InputFile::create we omit some symbols that are irrelevant to LTO. The
616  // Skip() function skips the same symbols from the module as InputFile does
617  // from the symbol table.
618  auto MsymI = SymTab.symbols().begin(), MsymE = SymTab.symbols().end();
619  auto Skip = [&]() {
620  while (MsymI != MsymE) {
621  auto Flags = SymTab.getSymbolFlags(*MsymI);
622  if ((Flags & object::BasicSymbolRef::SF_Global) &&
624  return;
625  ++MsymI;
626  }
627  };
628  Skip();
629 
630  std::set<const Comdat *> NonPrevailingComdats;
631  for (const InputFile::Symbol &Sym : Syms) {
632  assert(ResI != ResE);
633  SymbolResolution Res = *ResI++;
634 
635  assert(MsymI != MsymE);
636  ModuleSymbolTable::Symbol Msym = *MsymI++;
637  Skip();
638 
639  if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
640  if (Res.Prevailing) {
641  if (Sym.isUndefined())
642  continue;
643  Mod.Keep.push_back(GV);
644  // For symbols re-defined with linker -wrap and -defsym options,
645  // set the linkage to weak to inhibit IPO. The linkage will be
646  // restored by the linker.
647  if (Res.LinkerRedefined)
648  GV->setLinkage(GlobalValue::WeakAnyLinkage);
649 
650  GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage();
651  if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
652  GV->setLinkage(GlobalValue::getWeakLinkage(
653  GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
654  } else if (isa<GlobalObject>(GV) &&
655  (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage() ||
656  GV->hasAvailableExternallyLinkage()) &&
657  !AliasedGlobals.count(cast<GlobalObject>(GV))) {
658  // Any of the above three types of linkage indicates that the
659  // chosen prevailing symbol will have the same semantics as this copy of
660  // the symbol, so we may be able to link it with available_externally
661  // linkage. We will decide later whether to do that when we link this
662  // module (in linkRegularLTO), based on whether it is undefined.
663  Mod.Keep.push_back(GV);
665  if (GV->hasComdat())
666  NonPrevailingComdats.insert(GV->getComdat());
667  cast<GlobalObject>(GV)->setComdat(nullptr);
668  }
669 
670  // Set the 'local' flag based on the linker resolution for this symbol.
672  GV->setDSOLocal(true);
673  }
674  // Common resolution: collect the maximum size/alignment over all commons.
675  // We also record if we see an instance of a common as prevailing, so that
676  // if none is prevailing we can ignore it later.
677  if (Sym.isCommon()) {
678  // FIXME: We should figure out what to do about commons defined by asm.
679  // For now they aren't reported correctly by ModuleSymbolTable.
680  auto &CommonRes = RegularLTO.Commons[Sym.getIRName()];
681  CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
682  CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment());
683  CommonRes.Prevailing |= Res.Prevailing;
684  }
685 
686  }
687  if (!M.getComdatSymbolTable().empty())
688  for (GlobalValue &GV : M.global_values())
689  handleNonPrevailingComdat(GV, NonPrevailingComdats);
690  assert(MsymI == MsymE);
691  return std::move(Mod);
692 }
693 
694 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
695  bool LivenessFromIndex) {
696  std::vector<GlobalValue *> Keep;
697  for (GlobalValue *GV : Mod.Keep) {
698  if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
699  continue;
700 
701  if (!GV->hasAvailableExternallyLinkage()) {
702  Keep.push_back(GV);
703  continue;
704  }
705 
706  // Only link available_externally definitions if we don't already have a
707  // definition.
708  GlobalValue *CombinedGV =
709  RegularLTO.CombinedModule->getNamedValue(GV->getName());
710  if (CombinedGV && !CombinedGV->isDeclaration())
711  continue;
712 
713  Keep.push_back(GV);
714  }
715 
716  return RegularLTO.Mover->move(std::move(Mod.M), Keep,
718  /* IsPerformingImport */ false);
719 }
720 
721 // Add a ThinLTO module to the link.
722 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
723  const SymbolResolution *&ResI,
724  const SymbolResolution *ResE) {
725  if (Error Err =
726  BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(),
727  ThinLTO.ModuleMap.size()))
728  return Err;
729 
730  for (const InputFile::Symbol &Sym : Syms) {
731  assert(ResI != ResE);
732  SymbolResolution Res = *ResI++;
733 
734  if (!Sym.getIRName().empty()) {
736  Sym.getIRName(), GlobalValue::ExternalLinkage, ""));
737  if (Res.Prevailing) {
738  ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier();
739 
740  // For linker redefined symbols (via --wrap or --defsym) we want to
741  // switch the linkage to `weak` to prevent IPOs from happening.
742  // Find the summary in the module for this very GV and record the new
743  // linkage so that we can switch it when we import the GV.
744  if (Res.LinkerRedefined)
745  if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
746  GUID, BM.getModuleIdentifier()))
747  S->setLinkage(GlobalValue::WeakAnyLinkage);
748  }
749 
750  // If the linker resolved the symbol to a local definition then mark it
751  // as local in the summary for the module we are adding.
753  if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
754  GUID, BM.getModuleIdentifier())) {
755  S->setDSOLocal(true);
756  }
757  }
758  }
759  }
760 
761  if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
762  return make_error<StringError>(
763  "Expected at most one ThinLTO module per bitcode file",
765 
766  return Error::success();
767 }
768 
769 unsigned LTO::getMaxTasks() const {
770  CalledGetMaxTasks = true;
771  return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
772 }
773 
775  // Compute "dead" symbols, we don't want to import/export these!
776  DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
777  DenseMap<GlobalValue::GUID, PrevailingType> GUIDPrevailingResolutions;
778  for (auto &Res : GlobalResolutions) {
779  // Normally resolution have IR name of symbol. We can do nothing here
780  // otherwise. See comments in GlobalResolution struct for more details.
781  if (Res.second.IRName.empty())
782  continue;
783 
784  GlobalValue::GUID GUID = GlobalValue::getGUID(
785  GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
786 
787  if (Res.second.VisibleOutsideSummary && Res.second.Prevailing)
788  GUIDPreservedSymbols.insert(GlobalValue::getGUID(
789  GlobalValue::dropLLVMManglingEscape(Res.second.IRName)));
790 
791  GUIDPrevailingResolutions[GUID] =
792  Res.second.Prevailing ? PrevailingType::Yes : PrevailingType::No;
793  }
794 
795  auto isPrevailing = [&](GlobalValue::GUID G) {
796  auto It = GUIDPrevailingResolutions.find(G);
797  if (It == GUIDPrevailingResolutions.end())
799  return It->second;
800  };
801  computeDeadSymbols(ThinLTO.CombinedIndex, GUIDPreservedSymbols, isPrevailing);
802 
803  // Setup output file to emit statistics.
804  std::unique_ptr<ToolOutputFile> StatsFile = nullptr;
805  if (!Conf.StatsFile.empty()) {
806  EnableStatistics(false);
807  std::error_code EC;
808  StatsFile =
809  llvm::make_unique<ToolOutputFile>(Conf.StatsFile, EC, sys::fs::F_None);
810  if (EC)
811  return errorCodeToError(EC);
812  StatsFile->keep();
813  }
814 
815  Error Result = runRegularLTO(AddStream);
816  if (!Result)
817  Result = runThinLTO(AddStream, Cache);
818 
819  if (StatsFile)
820  PrintStatisticsJSON(StatsFile->os());
821 
822  return Result;
823 }
824 
825 Error LTO::runRegularLTO(AddStreamFn AddStream) {
826  for (auto &M : RegularLTO.ModsWithSummaries)
827  if (Error Err = linkRegularLTO(std::move(M),
828  /*LivenessFromIndex=*/true))
829  return Err;
830 
831  // Make sure commons have the right size/alignment: we kept the largest from
832  // all the prevailing when adding the inputs, and we apply it here.
833  const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
834  for (auto &I : RegularLTO.Commons) {
835  if (!I.second.Prevailing)
836  // Don't do anything if no instance of this common was prevailing.
837  continue;
838  GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);
839  if (OldGV && DL.getTypeAllocSize(OldGV->getValueType()) == I.second.Size) {
840  // Don't create a new global if the type is already correct, just make
841  // sure the alignment is correct.
842  OldGV->setAlignment(I.second.Align);
843  continue;
844  }
845  ArrayType *Ty =
846  ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size);
847  auto *GV = new GlobalVariable(*RegularLTO.CombinedModule, Ty, false,
850  GV->setAlignment(I.second.Align);
851  if (OldGV) {
853  GV->takeName(OldGV);
854  OldGV->eraseFromParent();
855  } else {
856  GV->setName(I.first);
857  }
858  }
859 
860  if (Conf.PreOptModuleHook &&
861  !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
862  return Error::success();
863 
864  if (!Conf.CodeGenOnly) {
865  for (const auto &R : GlobalResolutions) {
866  if (!R.second.isPrevailingIRSymbol())
867  continue;
868  if (R.second.Partition != 0 &&
869  R.second.Partition != GlobalResolution::External)
870  continue;
871 
872  GlobalValue *GV =
873  RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
874  // Ignore symbols defined in other partitions.
875  // Also skip declarations, which are not allowed to have internal linkage.
876  if (!GV || GV->hasLocalLinkage() || GV->isDeclaration())
877  continue;
878  GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
880  if (R.second.Partition == 0)
882  }
883 
884  if (Conf.PostInternalizeModuleHook &&
885  !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
886  return Error::success();
887  }
888  return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
889  std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);
890 }
891 
892 /// This class defines the interface to the ThinLTO backend.
894 protected:
898 
899 public:
901  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries)
902  : Conf(Conf), CombinedIndex(CombinedIndex),
903  ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {}
904 
905  virtual ~ThinBackendProc() {}
906  virtual Error start(
907  unsigned Task, BitcodeModule BM,
908  const FunctionImporter::ImportMapTy &ImportList,
909  const FunctionImporter::ExportSetTy &ExportList,
910  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
911  MapVector<StringRef, BitcodeModule> &ModuleMap) = 0;
912  virtual Error wait() = 0;
913 };
914 
915 namespace {
916 class InProcessThinBackend : public ThinBackendProc {
917  ThreadPool BackendThreadPool;
918  AddStreamFn AddStream;
919  NativeObjectCache Cache;
920  TypeIdSummariesByGuidTy TypeIdSummariesByGuid;
921  std::set<GlobalValue::GUID> CfiFunctionDefs;
922  std::set<GlobalValue::GUID> CfiFunctionDecls;
923 
924  Optional<Error> Err;
925  std::mutex ErrMu;
926 
927 public:
928  InProcessThinBackend(
929  Config &Conf, ModuleSummaryIndex &CombinedIndex,
930  unsigned ThinLTOParallelismLevel,
931  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
932  AddStreamFn AddStream, NativeObjectCache Cache)
933  : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
934  BackendThreadPool(ThinLTOParallelismLevel),
935  AddStream(std::move(AddStream)), Cache(std::move(Cache)) {
936  // Create a mapping from type identifier GUIDs to type identifier summaries.
937  // This allows backends to use the type identifier GUIDs stored in the
938  // function summaries to determine which type identifier summaries affect
939  // each function without needing to compute GUIDs in each backend.
940  for (auto &TId : CombinedIndex.typeIds())
941  TypeIdSummariesByGuid[GlobalValue::getGUID(TId.first)].push_back(&TId);
942  for (auto &Name : CombinedIndex.cfiFunctionDefs())
943  CfiFunctionDefs.insert(
945  for (auto &Name : CombinedIndex.cfiFunctionDecls())
946  CfiFunctionDecls.insert(
948  }
949 
950  Error runThinLTOBackendThread(
951  AddStreamFn AddStream, NativeObjectCache Cache, unsigned Task,
952  BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
953  const FunctionImporter::ImportMapTy &ImportList,
954  const FunctionImporter::ExportSetTy &ExportList,
955  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
956  const GVSummaryMapTy &DefinedGlobals,
958  const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
959  auto RunThinBackend = [&](AddStreamFn AddStream) {
960  LTOLLVMContext BackendContext(Conf);
961  Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext);
962  if (!MOrErr)
963  return MOrErr.takeError();
964 
965  return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
966  ImportList, DefinedGlobals, ModuleMap);
967  };
968 
969  auto ModuleID = BM.getModuleIdentifier();
970 
971  if (!Cache || !CombinedIndex.modulePaths().count(ModuleID) ||
972  all_of(CombinedIndex.getModuleHash(ModuleID),
973  [](uint32_t V) { return V == 0; }))
974  // Cache disabled or no entry for this module in the combined index or
975  // no module hash.
976  return RunThinBackend(AddStream);
977 
979  // The module may be cached, this helps handling it.
980  computeCacheKey(Key, Conf, CombinedIndex, ModuleID, ImportList, ExportList,
981  ResolvedODR, DefinedGlobals, TypeIdSummariesByGuid,
982  CfiFunctionDefs, CfiFunctionDecls);
983  if (AddStreamFn CacheAddStream = Cache(Task, Key))
984  return RunThinBackend(CacheAddStream);
985 
986  return Error::success();
987  }
988 
989  Error start(
990  unsigned Task, BitcodeModule BM,
991  const FunctionImporter::ImportMapTy &ImportList,
992  const FunctionImporter::ExportSetTy &ExportList,
993  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
994  MapVector<StringRef, BitcodeModule> &ModuleMap) override {
995  StringRef ModulePath = BM.getModuleIdentifier();
996  assert(ModuleToDefinedGVSummaries.count(ModulePath));
997  const GVSummaryMapTy &DefinedGlobals =
998  ModuleToDefinedGVSummaries.find(ModulePath)->second;
999  BackendThreadPool.async(
1000  [=](BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
1001  const FunctionImporter::ImportMapTy &ImportList,
1002  const FunctionImporter::ExportSetTy &ExportList,
1003  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>
1004  &ResolvedODR,
1005  const GVSummaryMapTy &DefinedGlobals,
1007  const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
1008  Error E = runThinLTOBackendThread(
1009  AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
1010  ResolvedODR, DefinedGlobals, ModuleMap, TypeIdSummariesByGuid);
1011  if (E) {
1012  std::unique_lock<std::mutex> L(ErrMu);
1013  if (Err)
1014  Err = joinErrors(std::move(*Err), std::move(E));
1015  else
1016  Err = std::move(E);
1017  }
1018  },
1019  BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
1020  std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap),
1021  std::ref(TypeIdSummariesByGuid));
1022  return Error::success();
1023  }
1024 
1025  Error wait() override {
1026  BackendThreadPool.wait();
1027  if (Err)
1028  return std::move(*Err);
1029  else
1030  return Error::success();
1031  }
1032 };
1033 } // end anonymous namespace
1034 
1035 ThinBackend lto::createInProcessThinBackend(unsigned ParallelismLevel) {
1036  return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1037  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1038  AddStreamFn AddStream, NativeObjectCache Cache) {
1039  return llvm::make_unique<InProcessThinBackend>(
1040  Conf, CombinedIndex, ParallelismLevel, ModuleToDefinedGVSummaries,
1041  AddStream, Cache);
1042  };
1043 }
1044 
1045 // Given the original \p Path to an output file, replace any path
1046 // prefix matching \p OldPrefix with \p NewPrefix. Also, create the
1047 // resulting directory if it does not yet exist.
1048 std::string lto::getThinLTOOutputFile(const std::string &Path,
1049  const std::string &OldPrefix,
1050  const std::string &NewPrefix) {
1051  if (OldPrefix.empty() && NewPrefix.empty())
1052  return Path;
1053  SmallString<128> NewPath(Path);
1054  llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
1055  StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
1056  if (!ParentPath.empty()) {
1057  // Make sure the new directory exists, creating it if necessary.
1058  if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
1059  llvm::errs() << "warning: could not create directory '" << ParentPath
1060  << "': " << EC.message() << '\n';
1061  }
1062  return NewPath.str();
1063 }
1064 
1065 namespace {
1066 class WriteIndexesThinBackend : public ThinBackendProc {
1067  std::string OldPrefix, NewPrefix;
1068  bool ShouldEmitImportsFiles;
1069  raw_fd_ostream *LinkedObjectsFile;
1070  lto::IndexWriteCallback OnWrite;
1071 
1072 public:
1073  WriteIndexesThinBackend(
1074  Config &Conf, ModuleSummaryIndex &CombinedIndex,
1075  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1076  std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1077  raw_fd_ostream *LinkedObjectsFile, lto::IndexWriteCallback OnWrite)
1078  : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
1079  OldPrefix(OldPrefix), NewPrefix(NewPrefix),
1080  ShouldEmitImportsFiles(ShouldEmitImportsFiles),
1081  LinkedObjectsFile(LinkedObjectsFile), OnWrite(OnWrite) {}
1082 
1083  Error start(
1084  unsigned Task, BitcodeModule BM,
1085  const FunctionImporter::ImportMapTy &ImportList,
1086  const FunctionImporter::ExportSetTy &ExportList,
1087  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1088  MapVector<StringRef, BitcodeModule> &ModuleMap) override {
1089  StringRef ModulePath = BM.getModuleIdentifier();
1090  std::string NewModulePath =
1091  getThinLTOOutputFile(ModulePath, OldPrefix, NewPrefix);
1092 
1093  if (LinkedObjectsFile)
1094  *LinkedObjectsFile << NewModulePath << '\n';
1095 
1096  std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
1097  gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
1098  ImportList, ModuleToSummariesForIndex);
1099 
1100  std::error_code EC;
1101  raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
1103  if (EC)
1104  return errorCodeToError(EC);
1105  WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
1106 
1107  if (ShouldEmitImportsFiles) {
1108  EC = EmitImportsFiles(ModulePath, NewModulePath + ".imports",
1109  ModuleToSummariesForIndex);
1110  if (EC)
1111  return errorCodeToError(EC);
1112  }
1113 
1114  if (OnWrite)
1115  OnWrite(ModulePath);
1116  return Error::success();
1117  }
1118 
1119  Error wait() override { return Error::success(); }
1120 };
1121 } // end anonymous namespace
1122 
1124  std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1125  raw_fd_ostream *LinkedObjectsFile, IndexWriteCallback OnWrite) {
1126  return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1127  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1128  AddStreamFn AddStream, NativeObjectCache Cache) {
1129  return llvm::make_unique<WriteIndexesThinBackend>(
1130  Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
1131  ShouldEmitImportsFiles, LinkedObjectsFile, OnWrite);
1132  };
1133 }
1134 
1135 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache) {
1136  if (ThinLTO.ModuleMap.empty())
1137  return Error::success();
1138 
1139  if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
1140  return Error::success();
1141 
1142  // Collect for each module the list of function it defines (GUID ->
1143  // Summary).
1145  ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
1146  ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
1147  ModuleToDefinedGVSummaries);
1148  // Create entries for any modules that didn't have any GV summaries
1149  // (either they didn't have any GVs to start with, or we suppressed
1150  // generation of the summaries because they e.g. had inline assembly
1151  // uses that couldn't be promoted/renamed on export). This is so
1152  // InProcessThinBackend::start can still launch a backend thread, which
1153  // is passed the map of summaries for the module, without any special
1154  // handling for this case.
1155  for (auto &Mod : ThinLTO.ModuleMap)
1156  if (!ModuleToDefinedGVSummaries.count(Mod.first))
1157  ModuleToDefinedGVSummaries.try_emplace(Mod.first);
1158 
1160  ThinLTO.ModuleMap.size());
1162  ThinLTO.ModuleMap.size());
1164 
1165  if (DumpThinCGSCCs)
1166  ThinLTO.CombinedIndex.dumpSCCs(outs());
1167 
1168  if (Conf.OptLevel > 0)
1169  ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1170  ImportLists, ExportLists);
1171 
1172  // Figure out which symbols need to be internalized. This also needs to happen
1173  // at -O0 because summary-based DCE is implemented using internalization, and
1174  // we must apply DCE consistently with the full LTO module in order to avoid
1175  // undefined references during the final link.
1176  std::set<GlobalValue::GUID> ExportedGUIDs;
1177  for (auto &Res : GlobalResolutions) {
1178  // If the symbol does not have external references or it is not prevailing,
1179  // then not need to mark it as exported from a ThinLTO partition.
1180  if (Res.second.Partition != GlobalResolution::External ||
1181  !Res.second.isPrevailingIRSymbol())
1182  continue;
1183  auto GUID = GlobalValue::getGUID(
1184  GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
1185  // Mark exported unless index-based analysis determined it to be dead.
1186  if (ThinLTO.CombinedIndex.isGUIDLive(GUID))
1187  ExportedGUIDs.insert(GUID);
1188  }
1189 
1190  // Any functions referenced by the jump table in the regular LTO object must
1191  // be exported.
1192  for (auto &Def : ThinLTO.CombinedIndex.cfiFunctionDefs())
1193  ExportedGUIDs.insert(
1195 
1196  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
1197  const auto &ExportList = ExportLists.find(ModuleIdentifier);
1198  return (ExportList != ExportLists.end() &&
1199  ExportList->second.count(GUID)) ||
1200  ExportedGUIDs.count(GUID);
1201  };
1202  thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported);
1203 
1204  auto isPrevailing = [&](GlobalValue::GUID GUID,
1205  const GlobalValueSummary *S) {
1206  return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
1207  };
1208  auto recordNewLinkage = [&](StringRef ModuleIdentifier,
1209  GlobalValue::GUID GUID,
1210  GlobalValue::LinkageTypes NewLinkage) {
1211  ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
1212  };
1213  thinLTOResolveWeakForLinkerInIndex(ThinLTO.CombinedIndex, isPrevailing,
1214  recordNewLinkage);
1215 
1216  std::unique_ptr<ThinBackendProc> BackendProc =
1217  ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1218  AddStream, Cache);
1219 
1220  // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined
1221  // module and parallel code generation partitions.
1222  unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel;
1223  for (auto &Mod : ThinLTO.ModuleMap) {
1224  if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
1225  ExportLists[Mod.first],
1226  ResolvedODR[Mod.first], ThinLTO.ModuleMap))
1227  return E;
1228  ++Task;
1229  }
1230 
1231  return BackendProc->wait();
1232 }
1233 
1237  bool LTOPassRemarksWithHotness, int Count) {
1238  if (LTOPassRemarksWithHotness)
1239  Context.setDiagnosticsHotnessRequested(true);
1240  if (LTORemarksFilename.empty())
1241  return nullptr;
1242 
1243  std::string Filename = LTORemarksFilename;
1244  if (Count != -1)
1245  Filename += ".thin." + llvm::utostr(Count) + ".yaml";
1246 
1247  std::error_code EC;
1248  auto DiagnosticFile =
1249  llvm::make_unique<ToolOutputFile>(Filename, EC, sys::fs::F_None);
1250  if (EC)
1251  return errorCodeToError(EC);
1252  Context.setDiagnosticsOutputFile(
1253  llvm::make_unique<yaml::Output>(DiagnosticFile->os()));
1254  DiagnosticFile->keep();
1255  return std::move(DiagnosticFile);
1256 }
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
static void thinLTOResolveWeakForLinkerGUID(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:281
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:1235
This class defines the interface to the ThinLTO backend.
Definition: LTO.cpp:893
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:221
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:103
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 TypeIdSummariesByGuidTy &TypeIdSummariesByGuid, const std::set< GlobalValue::GUID > &CfiFunctionDefs, const std::set< GlobalValue::GUID > &CfiFunctionDecls)
Definition: LTO.cpp:68
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:1042
F(f)
const StringMap< GVSummaryMapTy > & ModuleToDefinedGVSummaries
Definition: LTO.cpp:897
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:365
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
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
Definition: TinyPtrVector.h:31
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:1123
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:321
static bool isLinkOnceLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:300
CombinedIndexHookFn CombinedIndexHook
Definition: Config.h:164
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:191
StringRef getName() const
Returns the path to the InputFile.
Definition: LTO.cpp:393
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
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:77
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
ModuleSummaryIndex & CombinedIndex
Definition: LTO.cpp:896
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
const std::map< std::string, TypeIdSummary > & typeIds() const
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
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
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:146
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:498
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:410
ModuleHookFn PreOptModuleHook
This module hook is called after linking (regular LTO) or loading (ThinLTO) the module, before modifying it.
Definition: Config.h:133
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:900
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
DenseMap< GlobalValue::GUID, TinyPtrVector< const std::pair< const std::string, TypeIdSummary > * > > TypeIdSummariesByGuidTy
Definition: LTO.cpp:63
bool isWeakForLinker() const
Definition: GlobalValue.h:457
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:94
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:140
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:474
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:769
static void thinLTOInternalizeAndPromoteGUID(GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID, function_ref< bool(StringRef, GlobalValue::GUID)> isExported)
Definition: LTO.cpp:341
iterator end() const
Definition: ArrayRef.h:138
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
virtual ~ThinBackendProc()
Definition: LTO.cpp:905
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:1035
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:462
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:410
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:216
void thinLTOResolveWeakForLinkerInIndex(ModuleSummaryIndex &Index, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, function_ref< void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> recordNewLinkage)
Resolve Weak and LinkOnce values in the Index.
Definition: LTO.cpp:320
static void handleNonPrevailingComdat(GlobalValue &GV, std::set< const Comdat *> &NonPrevailingComdats)
Definition: LTO.cpp:560
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:774
iterator end()
Definition: DenseMap.h:79
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:568
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:91
unsigned VisibleToRegularObj
The definition of this symbol is visible outside of the LTO unit.
Definition: LTO.h:407
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 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.
Error backend(Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, std::unique_ptr< Module > M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:409
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
void computeDeadSymbols(ModuleSummaryIndex &Index, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols, function_ref< PrevailingType(GlobalValue::GUID)> isPrevailing)
Compute all the symbols that are "dead": i.e these that can&#39;t be reached in the graph from any of the...
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:199
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:1048
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:355
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