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