LLVM  7.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), CombinedModule(llvm::make_unique<Module>("ld-temp.o", Ctx)),
389  Mover(llvm::make_unique<IRMover>(*CombinedModule)) {}
390 
391 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend) : Backend(Backend) {
392  if (!Backend)
393  this->Backend =
395 }
396 
398  unsigned ParallelCodeGenParallelismLevel)
399  : Conf(std::move(Conf)),
400  RegularLTO(ParallelCodeGenParallelismLevel, this->Conf),
401  ThinLTO(std::move(Backend)) {}
402 
403 // Requires a destructor for MapVector<BitcodeModule>.
404 LTO::~LTO() = default;
405 
406 // Add the symbols in the given module to the GlobalResolutions map, and resolve
407 // their partitions.
408 void LTO::addModuleToGlobalRes(ArrayRef<InputFile::Symbol> Syms,
410  unsigned Partition, bool InSummary) {
411  auto *ResI = Res.begin();
412  auto *ResE = Res.end();
413  (void)ResE;
414  for (const InputFile::Symbol &Sym : Syms) {
415  assert(ResI != ResE);
416  SymbolResolution Res = *ResI++;
417 
418  auto &GlobalRes = GlobalResolutions[Sym.getName()];
419  GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
420  if (Res.Prevailing) {
421  assert(GlobalRes.IRName.empty() &&
422  "Multiple prevailing defs are not allowed");
423  GlobalRes.IRName = Sym.getIRName();
424  }
425 
426  // Set the partition to external if we know it is re-defined by the linker
427  // with -defsym or -wrap options, used elsewhere, e.g. it is visible to a
428  // regular object, is referenced from llvm.compiler_used, or was already
429  // recorded as being referenced from a different partition.
430  if (Res.LinkerRedefined || Res.VisibleToRegularObj || Sym.isUsed() ||
431  (GlobalRes.Partition != GlobalResolution::Unknown &&
432  GlobalRes.Partition != Partition)) {
433  GlobalRes.Partition = GlobalResolution::External;
434  } else
435  // First recorded reference, save the current partition.
436  GlobalRes.Partition = Partition;
437 
438  // Flag as visible outside of summary if visible from a regular object or
439  // from a module that does not have a summary.
440  GlobalRes.VisibleOutsideSummary |=
441  (Res.VisibleToRegularObj || Sym.isUsed() || !InSummary);
442  }
443 }
444 
447  StringRef Path = Input->getName();
448  OS << Path << '\n';
449  auto ResI = Res.begin();
450  for (const InputFile::Symbol &Sym : Input->symbols()) {
451  assert(ResI != Res.end());
452  SymbolResolution Res = *ResI++;
453 
454  OS << "-r=" << Path << ',' << Sym.getName() << ',';
455  if (Res.Prevailing)
456  OS << 'p';
457  if (Res.FinalDefinitionInLinkageUnit)
458  OS << 'l';
459  if (Res.VisibleToRegularObj)
460  OS << 'x';
461  if (Res.LinkerRedefined)
462  OS << 'r';
463  OS << '\n';
464  }
465  OS.flush();
466  assert(ResI == Res.end());
467 }
468 
469 Error LTO::add(std::unique_ptr<InputFile> Input,
471  assert(!CalledGetMaxTasks);
472 
473  if (Conf.ResolutionFile)
474  writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
475 
476  if (RegularLTO.CombinedModule->getTargetTriple().empty())
477  RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple());
478 
479  const SymbolResolution *ResI = Res.begin();
480  for (unsigned I = 0; I != Input->Mods.size(); ++I)
481  if (Error Err = addModule(*Input, I, ResI, Res.end()))
482  return Err;
483 
484  assert(ResI == Res.end());
485  return Error::success();
486 }
487 
488 Error LTO::addModule(InputFile &Input, unsigned ModI,
489  const SymbolResolution *&ResI,
490  const SymbolResolution *ResE) {
491  Expected<BitcodeLTOInfo> LTOInfo = Input.Mods[ModI].getLTOInfo();
492  if (!LTOInfo)
493  return LTOInfo.takeError();
494 
495  BitcodeModule BM = Input.Mods[ModI];
496  auto ModSyms = Input.module_symbols(ModI);
497  addModuleToGlobalRes(ModSyms, {ResI, ResE},
498  LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
499  LTOInfo->HasSummary);
500 
501  if (LTOInfo->IsThinLTO)
502  return addThinLTO(BM, ModSyms, ResI, ResE);
503 
505  addRegularLTO(BM, ModSyms, ResI, ResE);
506  if (!ModOrErr)
507  return ModOrErr.takeError();
508 
509  if (!LTOInfo->HasSummary)
510  return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
511 
512  // Regular LTO module summaries are added to a dummy module that represents
513  // the combined regular LTO module.
514  if (Error Err = BM.readSummary(ThinLTO.CombinedIndex, "", -1ull))
515  return Err;
516  RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
517  return Error::success();
518 }
519 
520 // Checks whether the given global value is in a non-prevailing comdat
521 // (comdat containing values the linker indicated were not prevailing,
522 // which we then dropped to available_externally), and if so, removes
523 // it from the comdat. This is called for all global values to ensure the
524 // comdat is empty rather than leaving an incomplete comdat. It is needed for
525 // regular LTO modules, in case we are in a mixed-LTO mode (both regular
526 // and thin LTO modules) compilation. Since the regular LTO module will be
527 // linked first in the final native link, we want to make sure the linker
528 // doesn't select any of these incomplete comdats that would be left
529 // in the regular LTO module without this cleanup.
530 static void
532  std::set<const Comdat *> &NonPrevailingComdats) {
533  Comdat *C = GV.getComdat();
534  if (!C)
535  return;
536 
537  if (!NonPrevailingComdats.count(C))
538  return;
539 
540  // Additionally need to drop externally visible global values from the comdat
541  // to available_externally, so that there aren't multiply defined linker
542  // errors.
543  if (!GV.hasLocalLinkage())
545 
546  if (auto GO = dyn_cast<GlobalObject>(&GV))
547  GO->setComdat(nullptr);
548 }
549 
550 // Add a regular LTO object to the link.
551 // The resulting module needs to be linked into the combined LTO module with
552 // linkRegularLTO.
554 LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
555  const SymbolResolution *&ResI,
556  const SymbolResolution *ResE) {
557  RegularLTOState::AddedModule Mod;
559  BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true,
560  /*IsImporting*/ false);
561  if (!MOrErr)
562  return MOrErr.takeError();
563  Module &M = **MOrErr;
564  Mod.M = std::move(*MOrErr);
565 
566  if (Error Err = M.materializeMetadata())
567  return std::move(Err);
568  UpgradeDebugInfo(M);
569 
570  ModuleSymbolTable SymTab;
571  SymTab.addModule(&M);
572 
573  for (GlobalVariable &GV : M.globals())
574  if (GV.hasAppendingLinkage())
575  Mod.Keep.push_back(&GV);
576 
577  DenseSet<GlobalObject *> AliasedGlobals;
578  for (auto &GA : M.aliases())
579  if (GlobalObject *GO = GA.getBaseObject())
580  AliasedGlobals.insert(GO);
581 
582  // In this function we need IR GlobalValues matching the symbols in Syms
583  // (which is not backed by a module), so we need to enumerate them in the same
584  // order. The symbol enumeration order of a ModuleSymbolTable intentionally
585  // matches the order of an irsymtab, but when we read the irsymtab in
586  // InputFile::create we omit some symbols that are irrelevant to LTO. The
587  // Skip() function skips the same symbols from the module as InputFile does
588  // from the symbol table.
589  auto MsymI = SymTab.symbols().begin(), MsymE = SymTab.symbols().end();
590  auto Skip = [&]() {
591  while (MsymI != MsymE) {
592  auto Flags = SymTab.getSymbolFlags(*MsymI);
593  if ((Flags & object::BasicSymbolRef::SF_Global) &&
595  return;
596  ++MsymI;
597  }
598  };
599  Skip();
600 
601  std::set<const Comdat *> NonPrevailingComdats;
602  for (const InputFile::Symbol &Sym : Syms) {
603  assert(ResI != ResE);
604  SymbolResolution Res = *ResI++;
605 
606  assert(MsymI != MsymE);
607  ModuleSymbolTable::Symbol Msym = *MsymI++;
608  Skip();
609 
610  if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
611  if (Res.Prevailing) {
612  if (Sym.isUndefined())
613  continue;
614  Mod.Keep.push_back(GV);
615  // For symbols re-defined with linker -wrap and -defsym options,
616  // set the linkage to weak to inhibit IPO. The linkage will be
617  // restored by the linker.
618  if (Res.LinkerRedefined)
619  GV->setLinkage(GlobalValue::WeakAnyLinkage);
620 
621  GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage();
622  if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
623  GV->setLinkage(GlobalValue::getWeakLinkage(
624  GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
625  } else if (isa<GlobalObject>(GV) &&
626  (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage() ||
627  GV->hasAvailableExternallyLinkage()) &&
628  !AliasedGlobals.count(cast<GlobalObject>(GV))) {
629  // Any of the above three types of linkage indicates that the
630  // chosen prevailing symbol will have the same semantics as this copy of
631  // the symbol, so we may be able to link it with available_externally
632  // linkage. We will decide later whether to do that when we link this
633  // module (in linkRegularLTO), based on whether it is undefined.
634  Mod.Keep.push_back(GV);
636  if (GV->hasComdat())
637  NonPrevailingComdats.insert(GV->getComdat());
638  cast<GlobalObject>(GV)->setComdat(nullptr);
639  }
640 
641  // Set the 'local' flag based on the linker resolution for this symbol.
643  GV->setDSOLocal(Res.FinalDefinitionInLinkageUnit);
644  }
645  // Common resolution: collect the maximum size/alignment over all commons.
646  // We also record if we see an instance of a common as prevailing, so that
647  // if none is prevailing we can ignore it later.
648  if (Sym.isCommon()) {
649  // FIXME: We should figure out what to do about commons defined by asm.
650  // For now they aren't reported correctly by ModuleSymbolTable.
651  auto &CommonRes = RegularLTO.Commons[Sym.getIRName()];
652  CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
653  CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment());
654  CommonRes.Prevailing |= Res.Prevailing;
655  }
656 
657  }
658  if (!M.getComdatSymbolTable().empty())
659  for (GlobalValue &GV : M.global_values())
660  handleNonPrevailingComdat(GV, NonPrevailingComdats);
661  assert(MsymI == MsymE);
662  return std::move(Mod);
663 }
664 
665 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
666  bool LivenessFromIndex) {
667  std::vector<GlobalValue *> Keep;
668  for (GlobalValue *GV : Mod.Keep) {
669  if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
670  continue;
671 
672  if (!GV->hasAvailableExternallyLinkage()) {
673  Keep.push_back(GV);
674  continue;
675  }
676 
677  // Only link available_externally definitions if we don't already have a
678  // definition.
679  GlobalValue *CombinedGV =
680  RegularLTO.CombinedModule->getNamedValue(GV->getName());
681  if (CombinedGV && !CombinedGV->isDeclaration())
682  continue;
683 
684  Keep.push_back(GV);
685  }
686 
687  return RegularLTO.Mover->move(std::move(Mod.M), Keep,
689  /* IsPerformingImport */ false);
690 }
691 
692 // Add a ThinLTO module to the link.
693 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
694  const SymbolResolution *&ResI,
695  const SymbolResolution *ResE) {
696  if (Error Err =
697  BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(),
698  ThinLTO.ModuleMap.size()))
699  return Err;
700 
701  for (const InputFile::Symbol &Sym : Syms) {
702  assert(ResI != ResE);
703  SymbolResolution Res = *ResI++;
704 
705  if (!Sym.getIRName().empty()) {
707  Sym.getIRName(), GlobalValue::ExternalLinkage, ""));
708  if (Res.Prevailing) {
709  ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier();
710 
711  // For linker redefined symbols (via --wrap or --defsym) we want to
712  // switch the linkage to `weak` to prevent IPOs from happening.
713  // Find the summary in the module for this very GV and record the new
714  // linkage so that we can switch it when we import the GV.
715  if (Res.LinkerRedefined)
716  if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
717  GUID, BM.getModuleIdentifier()))
718  S->setLinkage(GlobalValue::WeakAnyLinkage);
719  }
720 
721  // If the linker resolved the symbol to a local definition then mark it
722  // as local in the summary for the module we are adding.
724  if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
725  GUID, BM.getModuleIdentifier())) {
726  S->setDSOLocal(true);
727  }
728  }
729  }
730  }
731 
732  if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
733  return make_error<StringError>(
734  "Expected at most one ThinLTO module per bitcode file",
736 
737  return Error::success();
738 }
739 
740 unsigned LTO::getMaxTasks() const {
741  CalledGetMaxTasks = true;
742  return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
743 }
744 
746  // Compute "dead" symbols, we don't want to import/export these!
747  DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
748  for (auto &Res : GlobalResolutions) {
749  if (Res.second.VisibleOutsideSummary &&
750  // IRName will be defined if we have seen the prevailing copy of
751  // this value. If not, no need to preserve any ThinLTO copies.
752  !Res.second.IRName.empty())
753  GUIDPreservedSymbols.insert(GlobalValue::getGUID(
754  GlobalValue::dropLLVMManglingEscape(Res.second.IRName)));
755  }
756 
757  computeDeadSymbols(ThinLTO.CombinedIndex, GUIDPreservedSymbols);
758 
759  if (auto E = runRegularLTO(AddStream))
760  return E;
761  return runThinLTO(AddStream, Cache);
762 }
763 
764 Error LTO::runRegularLTO(AddStreamFn AddStream) {
765  for (auto &M : RegularLTO.ModsWithSummaries)
766  if (Error Err = linkRegularLTO(std::move(M),
767  /*LivenessFromIndex=*/true))
768  return Err;
769 
770  // Make sure commons have the right size/alignment: we kept the largest from
771  // all the prevailing when adding the inputs, and we apply it here.
772  const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
773  for (auto &I : RegularLTO.Commons) {
774  if (!I.second.Prevailing)
775  // Don't do anything if no instance of this common was prevailing.
776  continue;
777  GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);
778  if (OldGV && DL.getTypeAllocSize(OldGV->getValueType()) == I.second.Size) {
779  // Don't create a new global if the type is already correct, just make
780  // sure the alignment is correct.
781  OldGV->setAlignment(I.second.Align);
782  continue;
783  }
784  ArrayType *Ty =
785  ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size);
786  auto *GV = new GlobalVariable(*RegularLTO.CombinedModule, Ty, false,
789  GV->setAlignment(I.second.Align);
790  if (OldGV) {
792  GV->takeName(OldGV);
793  OldGV->eraseFromParent();
794  } else {
795  GV->setName(I.first);
796  }
797  }
798 
799  if (Conf.PreOptModuleHook &&
800  !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
801  return Error::success();
802 
803  if (!Conf.CodeGenOnly) {
804  for (const auto &R : GlobalResolutions) {
805  if (R.second.IRName.empty())
806  continue;
807  if (R.second.Partition != 0 &&
808  R.second.Partition != GlobalResolution::External)
809  continue;
810 
811  GlobalValue *GV =
812  RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
813  // Ignore symbols defined in other partitions.
814  if (!GV || GV->hasLocalLinkage())
815  continue;
816  GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
818  if (R.second.Partition == 0)
820  }
821 
822  if (Conf.PostInternalizeModuleHook &&
823  !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
824  return Error::success();
825  }
826  return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
827  std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);
828 }
829 
830 /// This class defines the interface to the ThinLTO backend.
832 protected:
836 
837 public:
839  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries)
840  : Conf(Conf), CombinedIndex(CombinedIndex),
841  ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {}
842 
843  virtual ~ThinBackendProc() {}
844  virtual Error start(
845  unsigned Task, BitcodeModule BM,
846  const FunctionImporter::ImportMapTy &ImportList,
847  const FunctionImporter::ExportSetTy &ExportList,
848  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
849  MapVector<StringRef, BitcodeModule> &ModuleMap) = 0;
850  virtual Error wait() = 0;
851 };
852 
853 namespace {
854 class InProcessThinBackend : public ThinBackendProc {
855  ThreadPool BackendThreadPool;
856  AddStreamFn AddStream;
857  NativeObjectCache Cache;
858  TypeIdSummariesByGuidTy TypeIdSummariesByGuid;
859  std::set<GlobalValue::GUID> CfiFunctionDefs;
860  std::set<GlobalValue::GUID> CfiFunctionDecls;
861 
862  Optional<Error> Err;
863  std::mutex ErrMu;
864 
865 public:
866  InProcessThinBackend(
867  Config &Conf, ModuleSummaryIndex &CombinedIndex,
868  unsigned ThinLTOParallelismLevel,
869  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
870  AddStreamFn AddStream, NativeObjectCache Cache)
871  : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
872  BackendThreadPool(ThinLTOParallelismLevel),
873  AddStream(std::move(AddStream)), Cache(std::move(Cache)) {
874  // Create a mapping from type identifier GUIDs to type identifier summaries.
875  // This allows backends to use the type identifier GUIDs stored in the
876  // function summaries to determine which type identifier summaries affect
877  // each function without needing to compute GUIDs in each backend.
878  for (auto &TId : CombinedIndex.typeIds())
879  TypeIdSummariesByGuid[GlobalValue::getGUID(TId.first)].push_back(&TId);
880  for (auto &Name : CombinedIndex.cfiFunctionDefs())
881  CfiFunctionDefs.insert(
883  for (auto &Name : CombinedIndex.cfiFunctionDecls())
884  CfiFunctionDecls.insert(
886  }
887 
888  Error runThinLTOBackendThread(
889  AddStreamFn AddStream, NativeObjectCache Cache, unsigned Task,
890  BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
891  const FunctionImporter::ImportMapTy &ImportList,
892  const FunctionImporter::ExportSetTy &ExportList,
893  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
894  const GVSummaryMapTy &DefinedGlobals,
896  const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
897  auto RunThinBackend = [&](AddStreamFn AddStream) {
898  LTOLLVMContext BackendContext(Conf);
899  Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext);
900  if (!MOrErr)
901  return MOrErr.takeError();
902 
903  return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
904  ImportList, DefinedGlobals, ModuleMap);
905  };
906 
907  auto ModuleID = BM.getModuleIdentifier();
908 
909  if (!Cache || !CombinedIndex.modulePaths().count(ModuleID) ||
910  all_of(CombinedIndex.getModuleHash(ModuleID),
911  [](uint32_t V) { return V == 0; }))
912  // Cache disabled or no entry for this module in the combined index or
913  // no module hash.
914  return RunThinBackend(AddStream);
915 
917  // The module may be cached, this helps handling it.
918  computeCacheKey(Key, Conf, CombinedIndex, ModuleID, ImportList, ExportList,
919  ResolvedODR, DefinedGlobals, TypeIdSummariesByGuid,
920  CfiFunctionDefs, CfiFunctionDecls);
921  if (AddStreamFn CacheAddStream = Cache(Task, Key))
922  return RunThinBackend(CacheAddStream);
923 
924  return Error::success();
925  }
926 
927  Error start(
928  unsigned Task, BitcodeModule BM,
929  const FunctionImporter::ImportMapTy &ImportList,
930  const FunctionImporter::ExportSetTy &ExportList,
931  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
932  MapVector<StringRef, BitcodeModule> &ModuleMap) override {
933  StringRef ModulePath = BM.getModuleIdentifier();
934  assert(ModuleToDefinedGVSummaries.count(ModulePath));
935  const GVSummaryMapTy &DefinedGlobals =
936  ModuleToDefinedGVSummaries.find(ModulePath)->second;
937  BackendThreadPool.async(
938  [=](BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
939  const FunctionImporter::ImportMapTy &ImportList,
940  const FunctionImporter::ExportSetTy &ExportList,
941  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>
942  &ResolvedODR,
943  const GVSummaryMapTy &DefinedGlobals,
945  const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
946  Error E = runThinLTOBackendThread(
947  AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
948  ResolvedODR, DefinedGlobals, ModuleMap, TypeIdSummariesByGuid);
949  if (E) {
950  std::unique_lock<std::mutex> L(ErrMu);
951  if (Err)
952  Err = joinErrors(std::move(*Err), std::move(E));
953  else
954  Err = std::move(E);
955  }
956  },
957  BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
958  std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap),
959  std::ref(TypeIdSummariesByGuid));
960  return Error::success();
961  }
962 
963  Error wait() override {
964  BackendThreadPool.wait();
965  if (Err)
966  return std::move(*Err);
967  else
968  return Error::success();
969  }
970 };
971 } // end anonymous namespace
972 
973 ThinBackend lto::createInProcessThinBackend(unsigned ParallelismLevel) {
974  return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
975  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
976  AddStreamFn AddStream, NativeObjectCache Cache) {
977  return llvm::make_unique<InProcessThinBackend>(
978  Conf, CombinedIndex, ParallelismLevel, ModuleToDefinedGVSummaries,
979  AddStream, Cache);
980  };
981 }
982 
983 // Given the original \p Path to an output file, replace any path
984 // prefix matching \p OldPrefix with \p NewPrefix. Also, create the
985 // resulting directory if it does not yet exist.
986 std::string lto::getThinLTOOutputFile(const std::string &Path,
987  const std::string &OldPrefix,
988  const std::string &NewPrefix) {
989  if (OldPrefix.empty() && NewPrefix.empty())
990  return Path;
991  SmallString<128> NewPath(Path);
992  llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
993  StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
994  if (!ParentPath.empty()) {
995  // Make sure the new directory exists, creating it if necessary.
996  if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
997  llvm::errs() << "warning: could not create directory '" << ParentPath
998  << "': " << EC.message() << '\n';
999  }
1000  return NewPath.str();
1001 }
1002 
1003 namespace {
1004 class WriteIndexesThinBackend : public ThinBackendProc {
1005  std::string OldPrefix, NewPrefix;
1006  bool ShouldEmitImportsFiles;
1007 
1008  std::string LinkedObjectsFileName;
1009  std::unique_ptr<llvm::raw_fd_ostream> LinkedObjectsFile;
1010 
1011 public:
1012  WriteIndexesThinBackend(
1013  Config &Conf, ModuleSummaryIndex &CombinedIndex,
1014  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1015  std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1016  std::string LinkedObjectsFileName)
1017  : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
1018  OldPrefix(OldPrefix), NewPrefix(NewPrefix),
1019  ShouldEmitImportsFiles(ShouldEmitImportsFiles),
1020  LinkedObjectsFileName(LinkedObjectsFileName) {}
1021 
1022  Error start(
1023  unsigned Task, BitcodeModule BM,
1024  const FunctionImporter::ImportMapTy &ImportList,
1025  const FunctionImporter::ExportSetTy &ExportList,
1026  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1027  MapVector<StringRef, BitcodeModule> &ModuleMap) override {
1028  StringRef ModulePath = BM.getModuleIdentifier();
1029  std::string NewModulePath =
1030  getThinLTOOutputFile(ModulePath, OldPrefix, NewPrefix);
1031 
1032  std::error_code EC;
1033  if (!LinkedObjectsFileName.empty()) {
1034  if (!LinkedObjectsFile) {
1035  LinkedObjectsFile = llvm::make_unique<raw_fd_ostream>(
1036  LinkedObjectsFileName, EC, sys::fs::OpenFlags::F_None);
1037  if (EC)
1038  return errorCodeToError(EC);
1039  }
1040  *LinkedObjectsFile << NewModulePath << '\n';
1041  }
1042 
1043  std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
1044  gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
1045  ImportList, ModuleToSummariesForIndex);
1046 
1047  raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
1049  if (EC)
1050  return errorCodeToError(EC);
1051  WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
1052 
1053  if (ShouldEmitImportsFiles)
1054  return errorCodeToError(
1055  EmitImportsFiles(ModulePath, NewModulePath + ".imports", ImportList));
1056  return Error::success();
1057  }
1058 
1059  Error wait() override { return Error::success(); }
1060 };
1061 } // end anonymous namespace
1062 
1064  std::string NewPrefix,
1065  bool ShouldEmitImportsFiles,
1066  std::string LinkedObjectsFile) {
1067  return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1068  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1069  AddStreamFn AddStream, NativeObjectCache Cache) {
1070  return llvm::make_unique<WriteIndexesThinBackend>(
1071  Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
1072  ShouldEmitImportsFiles, LinkedObjectsFile);
1073  };
1074 }
1075 
1076 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache) {
1077  if (ThinLTO.ModuleMap.empty())
1078  return Error::success();
1079 
1080  if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
1081  return Error::success();
1082 
1083  // Collect for each module the list of function it defines (GUID ->
1084  // Summary).
1086  ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
1087  ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
1088  ModuleToDefinedGVSummaries);
1089  // Create entries for any modules that didn't have any GV summaries
1090  // (either they didn't have any GVs to start with, or we suppressed
1091  // generation of the summaries because they e.g. had inline assembly
1092  // uses that couldn't be promoted/renamed on export). This is so
1093  // InProcessThinBackend::start can still launch a backend thread, which
1094  // is passed the map of summaries for the module, without any special
1095  // handling for this case.
1096  for (auto &Mod : ThinLTO.ModuleMap)
1097  if (!ModuleToDefinedGVSummaries.count(Mod.first))
1098  ModuleToDefinedGVSummaries.try_emplace(Mod.first);
1099 
1101  ThinLTO.ModuleMap.size());
1103  ThinLTO.ModuleMap.size());
1105 
1106  if (Conf.OptLevel > 0)
1107  ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1108  ImportLists, ExportLists);
1109 
1110  // Figure out which symbols need to be internalized. This also needs to happen
1111  // at -O0 because summary-based DCE is implemented using internalization, and
1112  // we must apply DCE consistently with the full LTO module in order to avoid
1113  // undefined references during the final link.
1114  std::set<GlobalValue::GUID> ExportedGUIDs;
1115  for (auto &Res : GlobalResolutions) {
1116  // First check if the symbol was flagged as having external references.
1117  if (Res.second.Partition != GlobalResolution::External)
1118  continue;
1119  // IRName will be defined if we have seen the prevailing copy of
1120  // this value. If not, no need to mark as exported from a ThinLTO
1121  // partition (and we can't get the GUID).
1122  if (Res.second.IRName.empty())
1123  continue;
1124  auto GUID = GlobalValue::getGUID(
1125  GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
1126  // Mark exported unless index-based analysis determined it to be dead.
1127  if (ThinLTO.CombinedIndex.isGUIDLive(GUID))
1128  ExportedGUIDs.insert(GUID);
1129  }
1130 
1131  // Any functions referenced by the jump table in the regular LTO object must
1132  // be exported.
1133  for (auto &Def : ThinLTO.CombinedIndex.cfiFunctionDefs())
1134  ExportedGUIDs.insert(
1136 
1137  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
1138  const auto &ExportList = ExportLists.find(ModuleIdentifier);
1139  return (ExportList != ExportLists.end() &&
1140  ExportList->second.count(GUID)) ||
1141  ExportedGUIDs.count(GUID);
1142  };
1143  thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported);
1144 
1145  auto isPrevailing = [&](GlobalValue::GUID GUID,
1146  const GlobalValueSummary *S) {
1147  return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
1148  };
1149  auto recordNewLinkage = [&](StringRef ModuleIdentifier,
1150  GlobalValue::GUID GUID,
1151  GlobalValue::LinkageTypes NewLinkage) {
1152  ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
1153  };
1154  thinLTOResolveWeakForLinkerInIndex(ThinLTO.CombinedIndex, isPrevailing,
1155  recordNewLinkage);
1156 
1157  std::unique_ptr<ThinBackendProc> BackendProc =
1158  ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1159  AddStream, Cache);
1160 
1161  // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined
1162  // module and parallel code generation partitions.
1163  unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel;
1164  for (auto &Mod : ThinLTO.ModuleMap) {
1165  if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
1166  ExportLists[Mod.first],
1167  ResolvedODR[Mod.first], ThinLTO.ModuleMap))
1168  return E;
1169  ++Task;
1170  }
1171 
1172  return BackendProc->wait();
1173 }
1174 
1178  bool LTOPassRemarksWithHotness, int Count) {
1179  if (LTORemarksFilename.empty())
1180  return nullptr;
1181 
1182  std::string Filename = LTORemarksFilename;
1183  if (Count != -1)
1184  Filename += ".thin." + llvm::utostr(Count) + ".yaml";
1185 
1186  std::error_code EC;
1187  auto DiagnosticFile =
1188  llvm::make_unique<ToolOutputFile>(Filename, EC, sys::fs::F_None);
1189  if (EC)
1190  return errorCodeToError(EC);
1191  Context.setDiagnosticsOutputFile(
1192  llvm::make_unique<yaml::Output>(DiagnosticFile->os()));
1193  if (LTOPassRemarksWithHotness)
1194  Context.setDiagnosticsHotnessRequested(true);
1195  DiagnosticFile->keep();
1196  return std::move(DiagnosticFile);
1197 }
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:874
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:1176
This class defines the interface to the ThinLTO backend.
Definition: LTO.cpp:831
bool hasLocalLinkage() const
Definition: GlobalValue.h:430
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:387
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:510
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:488
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:1236
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:417
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:398
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:335
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:381
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:814
F(f)
const StringMap< GVSummaryMapTy > & ModuleToDefinedGVSummaries
Definition: LTO.cpp:835
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:315
static bool isLinkOnceLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:294
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:834
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:291
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:439
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:397
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:1677
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:469
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:361
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:1063
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:838
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:452
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:477
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:492
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:281
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:445
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:740
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:843
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:193
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:439
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:222
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:467
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:112
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:496
unsigned RelaxELFRelocations
ThinBackend createInProcessThinBackend(unsigned ParallelismLevel)
This ThinBackend runs the individual backend jobs in-process.
Definition: LTO.cpp:973
The access may modify the value stored in memory.
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:397
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:209
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:531
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:224
#define I(x, y, z)
Definition: MD5.cpp:58
Error run(AddStreamFn AddStream, NativeObjectCache Cache=nullptr)
Runs the LTO pipeline.
Definition: LTO.cpp:745
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:270
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:394
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:391
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:268
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:986
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