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