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