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