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) {
388  for (auto &S : GVSummaryList) {
389  if (isExported(S->modulePath(), GUID)) {
390  if (GlobalValue::isLocalLinkage(S->linkage()))
391  S->setLinkage(GlobalValue::ExternalLinkage);
392  } else if (EnableLTOInternalization &&
393  // Ignore local and appending linkage values since the linker
394  // doesn't resolve them.
395  !GlobalValue::isLocalLinkage(S->linkage()) &&
396  S->linkage() != GlobalValue::AppendingLinkage &&
397  // We can't internalize available_externally globals because this
398  // can break function pointer equality.
399  S->linkage() != GlobalValue::AvailableExternallyLinkage &&
400  // Functions and read-only variables with linkonce_odr and
401  // weak_odr linkage can be internalized. We can't internalize
402  // linkonce_odr and weak_odr variables which are both modified
403  // and read somewhere in the program because reads and writes
404  // will become inconsistent.
405  !isWeakObjectWithRWAccess(S.get()))
406  S->setLinkage(GlobalValue::InternalLinkage);
407  }
408 }
409 
410 // Update the linkages in the given \p Index to mark exported values
411 // as external and non-exported values as internal.
413  ModuleSummaryIndex &Index,
414  function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
415  for (auto &I : Index)
416  thinLTOInternalizeAndPromoteGUID(I.second.SummaryList, I.first, isExported);
417 }
418 
419 // Requires a destructor for std::vector<InputModule>.
420 InputFile::~InputFile() = default;
421 
423  std::unique_ptr<InputFile> File(new InputFile);
424 
425  Expected<IRSymtabFile> FOrErr = readIRSymtab(Object);
426  if (!FOrErr)
427  return FOrErr.takeError();
428 
429  File->TargetTriple = FOrErr->TheReader.getTargetTriple();
430  File->SourceFileName = FOrErr->TheReader.getSourceFileName();
431  File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts();
432  File->DependentLibraries = FOrErr->TheReader.getDependentLibraries();
433  File->ComdatTable = FOrErr->TheReader.getComdatTable();
434 
435  for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) {
436  size_t Begin = File->Symbols.size();
437  for (const irsymtab::Reader::SymbolRef &Sym :
438  FOrErr->TheReader.module_symbols(I))
439  // Skip symbols that are irrelevant to LTO. Note that this condition needs
440  // to match the one in Skip() in LTO::addRegularLTO().
441  if (Sym.isGlobal() && !Sym.isFormatSpecific())
442  File->Symbols.push_back(Sym);
443  File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
444  }
445 
446  File->Mods = FOrErr->Mods;
447  File->Strtab = std::move(FOrErr->Strtab);
448  return std::move(File);
449 }
450 
452  return Mods[0].getModuleIdentifier();
453 }
454 
456  assert(Mods.size() == 1 && "Expect only one bitcode module");
457  return Mods[0];
458 }
459 
460 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
461  Config &Conf)
462  : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
463  Ctx(Conf), CombinedModule(std::make_unique<Module>("ld-temp.o", Ctx)),
464  Mover(std::make_unique<IRMover>(*CombinedModule)) {}
465 
466 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend)
467  : Backend(Backend), CombinedIndex(/*HaveGVs*/ false) {
468  if (!Backend)
469  this->Backend =
471 }
472 
474  unsigned ParallelCodeGenParallelismLevel)
475  : Conf(std::move(Conf)),
476  RegularLTO(ParallelCodeGenParallelismLevel, this->Conf),
477  ThinLTO(std::move(Backend)) {}
478 
479 // Requires a destructor for MapVector<BitcodeModule>.
480 LTO::~LTO() = default;
481 
482 // Add the symbols in the given module to the GlobalResolutions map, and resolve
483 // their partitions.
484 void LTO::addModuleToGlobalRes(ArrayRef<InputFile::Symbol> Syms,
486  unsigned Partition, bool InSummary) {
487  auto *ResI = Res.begin();
488  auto *ResE = Res.end();
489  (void)ResE;
490  for (const InputFile::Symbol &Sym : Syms) {
491  assert(ResI != ResE);
492  SymbolResolution Res = *ResI++;
493 
494  StringRef Name = Sym.getName();
495  Triple TT(RegularLTO.CombinedModule->getTargetTriple());
496  // Strip the __imp_ prefix from COFF dllimport symbols (similar to the
497  // way they are handled by lld), otherwise we can end up with two
498  // global resolutions (one with and one for a copy of the symbol without).
499  if (TT.isOSBinFormatCOFF() && Name.startswith("__imp_"))
500  Name = Name.substr(strlen("__imp_"));
501  auto &GlobalRes = GlobalResolutions[Name];
502  GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
503  if (Res.Prevailing) {
504  assert(!GlobalRes.Prevailing &&
505  "Multiple prevailing defs are not allowed");
506  GlobalRes.Prevailing = true;
507  GlobalRes.IRName = Sym.getIRName();
508  } else if (!GlobalRes.Prevailing && GlobalRes.IRName.empty()) {
509  // Sometimes it can be two copies of symbol in a module and prevailing
510  // symbol can have no IR name. That might happen if symbol is defined in
511  // module level inline asm block. In case we have multiple modules with
512  // the same symbol we want to use IR name of the prevailing symbol.
513  // Otherwise, if we haven't seen a prevailing symbol, set the name so that
514  // we can later use it to check if there is any prevailing copy in IR.
515  GlobalRes.IRName = Sym.getIRName();
516  }
517 
518  // Set the partition to external if we know it is re-defined by the linker
519  // with -defsym or -wrap options, used elsewhere, e.g. it is visible to a
520  // regular object, is referenced from llvm.compiler_used, or was already
521  // recorded as being referenced from a different partition.
522  if (Res.LinkerRedefined || Res.VisibleToRegularObj || Sym.isUsed() ||
523  (GlobalRes.Partition != GlobalResolution::Unknown &&
524  GlobalRes.Partition != Partition)) {
525  GlobalRes.Partition = GlobalResolution::External;
526  } else
527  // First recorded reference, save the current partition.
528  GlobalRes.Partition = Partition;
529 
530  // Flag as visible outside of summary if visible from a regular object or
531  // from a module that does not have a summary.
532  GlobalRes.VisibleOutsideSummary |=
533  (Res.VisibleToRegularObj || Sym.isUsed() || !InSummary);
534  }
535 }
536 
539  StringRef Path = Input->getName();
540  OS << Path << '\n';
541  auto ResI = Res.begin();
542  for (const InputFile::Symbol &Sym : Input->symbols()) {
543  assert(ResI != Res.end());
544  SymbolResolution Res = *ResI++;
545 
546  OS << "-r=" << Path << ',' << Sym.getName() << ',';
547  if (Res.Prevailing)
548  OS << 'p';
549  if (Res.FinalDefinitionInLinkageUnit)
550  OS << 'l';
551  if (Res.VisibleToRegularObj)
552  OS << 'x';
553  if (Res.LinkerRedefined)
554  OS << 'r';
555  OS << '\n';
556  }
557  OS.flush();
558  assert(ResI == Res.end());
559 }
560 
561 Error LTO::add(std::unique_ptr<InputFile> Input,
563  assert(!CalledGetMaxTasks);
564 
565  if (Conf.ResolutionFile)
566  writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
567 
568  if (RegularLTO.CombinedModule->getTargetTriple().empty())
569  RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple());
570 
571  const SymbolResolution *ResI = Res.begin();
572  for (unsigned I = 0; I != Input->Mods.size(); ++I)
573  if (Error Err = addModule(*Input, I, ResI, Res.end()))
574  return Err;
575 
576  assert(ResI == Res.end());
577  return Error::success();
578 }
579 
580 Error LTO::addModule(InputFile &Input, unsigned ModI,
581  const SymbolResolution *&ResI,
582  const SymbolResolution *ResE) {
583  Expected<BitcodeLTOInfo> LTOInfo = Input.Mods[ModI].getLTOInfo();
584  if (!LTOInfo)
585  return LTOInfo.takeError();
586 
587  if (EnableSplitLTOUnit.hasValue()) {
588  // If only some modules were split, flag this in the index so that
589  // we can skip or error on optimizations that need consistently split
590  // modules (whole program devirt and lower type tests).
591  if (EnableSplitLTOUnit.getValue() != LTOInfo->EnableSplitLTOUnit)
592  ThinLTO.CombinedIndex.setPartiallySplitLTOUnits();
593  } else
594  EnableSplitLTOUnit = LTOInfo->EnableSplitLTOUnit;
595 
596  BitcodeModule BM = Input.Mods[ModI];
597  auto ModSyms = Input.module_symbols(ModI);
598  addModuleToGlobalRes(ModSyms, {ResI, ResE},
599  LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
600  LTOInfo->HasSummary);
601 
602  if (LTOInfo->IsThinLTO)
603  return addThinLTO(BM, ModSyms, ResI, ResE);
604 
606  addRegularLTO(BM, ModSyms, ResI, ResE);
607  if (!ModOrErr)
608  return ModOrErr.takeError();
609 
610  if (!LTOInfo->HasSummary)
611  return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
612 
613  // Regular LTO module summaries are added to a dummy module that represents
614  // the combined regular LTO module.
615  if (Error Err = BM.readSummary(ThinLTO.CombinedIndex, "", -1ull))
616  return Err;
617  RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
618  return Error::success();
619 }
620 
621 // Checks whether the given global value is in a non-prevailing comdat
622 // (comdat containing values the linker indicated were not prevailing,
623 // which we then dropped to available_externally), and if so, removes
624 // it from the comdat. This is called for all global values to ensure the
625 // comdat is empty rather than leaving an incomplete comdat. It is needed for
626 // regular LTO modules, in case we are in a mixed-LTO mode (both regular
627 // and thin LTO modules) compilation. Since the regular LTO module will be
628 // linked first in the final native link, we want to make sure the linker
629 // doesn't select any of these incomplete comdats that would be left
630 // in the regular LTO module without this cleanup.
631 static void
633  std::set<const Comdat *> &NonPrevailingComdats) {
634  Comdat *C = GV.getComdat();
635  if (!C)
636  return;
637 
638  if (!NonPrevailingComdats.count(C))
639  return;
640 
641  // Additionally need to drop externally visible global values from the comdat
642  // to available_externally, so that there aren't multiply defined linker
643  // errors.
644  if (!GV.hasLocalLinkage())
646 
647  if (auto GO = dyn_cast<GlobalObject>(&GV))
648  GO->setComdat(nullptr);
649 }
650 
651 // Add a regular LTO object to the link.
652 // The resulting module needs to be linked into the combined LTO module with
653 // linkRegularLTO.
655 LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
656  const SymbolResolution *&ResI,
657  const SymbolResolution *ResE) {
658  RegularLTOState::AddedModule Mod;
660  BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true,
661  /*IsImporting*/ false);
662  if (!MOrErr)
663  return MOrErr.takeError();
664  Module &M = **MOrErr;
665  Mod.M = std::move(*MOrErr);
666 
667  if (Error Err = M.materializeMetadata())
668  return std::move(Err);
669  UpgradeDebugInfo(M);
670 
671  ModuleSymbolTable SymTab;
672  SymTab.addModule(&M);
673 
674  for (GlobalVariable &GV : M.globals())
675  if (GV.hasAppendingLinkage())
676  Mod.Keep.push_back(&GV);
677 
678  DenseSet<GlobalObject *> AliasedGlobals;
679  for (auto &GA : M.aliases())
680  if (GlobalObject *GO = GA.getBaseObject())
681  AliasedGlobals.insert(GO);
682 
683  // In this function we need IR GlobalValues matching the symbols in Syms
684  // (which is not backed by a module), so we need to enumerate them in the same
685  // order. The symbol enumeration order of a ModuleSymbolTable intentionally
686  // matches the order of an irsymtab, but when we read the irsymtab in
687  // InputFile::create we omit some symbols that are irrelevant to LTO. The
688  // Skip() function skips the same symbols from the module as InputFile does
689  // from the symbol table.
690  auto MsymI = SymTab.symbols().begin(), MsymE = SymTab.symbols().end();
691  auto Skip = [&]() {
692  while (MsymI != MsymE) {
693  auto Flags = SymTab.getSymbolFlags(*MsymI);
694  if ((Flags & object::BasicSymbolRef::SF_Global) &&
696  return;
697  ++MsymI;
698  }
699  };
700  Skip();
701 
702  std::set<const Comdat *> NonPrevailingComdats;
703  for (const InputFile::Symbol &Sym : Syms) {
704  assert(ResI != ResE);
705  SymbolResolution Res = *ResI++;
706 
707  assert(MsymI != MsymE);
708  ModuleSymbolTable::Symbol Msym = *MsymI++;
709  Skip();
710 
711  if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
712  if (Res.Prevailing) {
713  if (Sym.isUndefined())
714  continue;
715  Mod.Keep.push_back(GV);
716  // For symbols re-defined with linker -wrap and -defsym options,
717  // set the linkage to weak to inhibit IPO. The linkage will be
718  // restored by the linker.
719  if (Res.LinkerRedefined)
720  GV->setLinkage(GlobalValue::WeakAnyLinkage);
721 
722  GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage();
723  if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
724  GV->setLinkage(GlobalValue::getWeakLinkage(
725  GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
726  } else if (isa<GlobalObject>(GV) &&
727  (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage() ||
728  GV->hasAvailableExternallyLinkage()) &&
729  !AliasedGlobals.count(cast<GlobalObject>(GV))) {
730  // Any of the above three types of linkage indicates that the
731  // chosen prevailing symbol will have the same semantics as this copy of
732  // the symbol, so we may be able to link it with available_externally
733  // linkage. We will decide later whether to do that when we link this
734  // module (in linkRegularLTO), based on whether it is undefined.
735  Mod.Keep.push_back(GV);
737  if (GV->hasComdat())
738  NonPrevailingComdats.insert(GV->getComdat());
739  cast<GlobalObject>(GV)->setComdat(nullptr);
740  }
741 
742  // Set the 'local' flag based on the linker resolution for this symbol.
744  GV->setDSOLocal(true);
745  if (GV->hasDLLImportStorageClass())
746  GV->setDLLStorageClass(GlobalValue::DLLStorageClassTypes::
747  DefaultStorageClass);
748  }
749  }
750  // Common resolution: collect the maximum size/alignment over all commons.
751  // We also record if we see an instance of a common as prevailing, so that
752  // if none is prevailing we can ignore it later.
753  if (Sym.isCommon()) {
754  // FIXME: We should figure out what to do about commons defined by asm.
755  // For now they aren't reported correctly by ModuleSymbolTable.
756  auto &CommonRes = RegularLTO.Commons[Sym.getIRName()];
757  CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
758  CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment());
759  CommonRes.Prevailing |= Res.Prevailing;
760  }
761 
762  }
763  if (!M.getComdatSymbolTable().empty())
764  for (GlobalValue &GV : M.global_values())
765  handleNonPrevailingComdat(GV, NonPrevailingComdats);
766  assert(MsymI == MsymE);
767  return std::move(Mod);
768 }
769 
770 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
771  bool LivenessFromIndex) {
772  std::vector<GlobalValue *> Keep;
773  for (GlobalValue *GV : Mod.Keep) {
774  if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
775  continue;
776 
777  if (!GV->hasAvailableExternallyLinkage()) {
778  Keep.push_back(GV);
779  continue;
780  }
781 
782  // Only link available_externally definitions if we don't already have a
783  // definition.
784  GlobalValue *CombinedGV =
785  RegularLTO.CombinedModule->getNamedValue(GV->getName());
786  if (CombinedGV && !CombinedGV->isDeclaration())
787  continue;
788 
789  Keep.push_back(GV);
790  }
791 
792  return RegularLTO.Mover->move(std::move(Mod.M), Keep,
794  /* IsPerformingImport */ false);
795 }
796 
797 // Add a ThinLTO module to the link.
798 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
799  const SymbolResolution *&ResI,
800  const SymbolResolution *ResE) {
801  if (Error Err =
802  BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(),
803  ThinLTO.ModuleMap.size()))
804  return Err;
805 
806  for (const InputFile::Symbol &Sym : Syms) {
807  assert(ResI != ResE);
808  SymbolResolution Res = *ResI++;
809 
810  if (!Sym.getIRName().empty()) {
812  Sym.getIRName(), GlobalValue::ExternalLinkage, ""));
813  if (Res.Prevailing) {
814  ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier();
815 
816  // For linker redefined symbols (via --wrap or --defsym) we want to
817  // switch the linkage to `weak` to prevent IPOs from happening.
818  // Find the summary in the module for this very GV and record the new
819  // linkage so that we can switch it when we import the GV.
820  if (Res.LinkerRedefined)
821  if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
822  GUID, BM.getModuleIdentifier()))
823  S->setLinkage(GlobalValue::WeakAnyLinkage);
824  }
825 
826  // If the linker resolved the symbol to a local definition then mark it
827  // as local in the summary for the module we are adding.
829  if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
830  GUID, BM.getModuleIdentifier())) {
831  S->setDSOLocal(true);
832  }
833  }
834  }
835  }
836 
837  if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
838  return make_error<StringError>(
839  "Expected at most one ThinLTO module per bitcode file",
841 
842  return Error::success();
843 }
844 
845 unsigned LTO::getMaxTasks() const {
846  CalledGetMaxTasks = true;
847  return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
848 }
849 
850 // If only some of the modules were split, we cannot correctly handle
851 // code that contains type tests or type checked loads.
852 Error LTO::checkPartiallySplit() {
853  if (!ThinLTO.CombinedIndex.partiallySplitLTOUnits())
854  return Error::success();
855 
856  Function *TypeTestFunc = RegularLTO.CombinedModule->getFunction(
857  Intrinsic::getName(Intrinsic::type_test));
858  Function *TypeCheckedLoadFunc = RegularLTO.CombinedModule->getFunction(
859  Intrinsic::getName(Intrinsic::type_checked_load));
860 
861  // First check if there are type tests / type checked loads in the
862  // merged regular LTO module IR.
863  if ((TypeTestFunc && !TypeTestFunc->use_empty()) ||
864  (TypeCheckedLoadFunc && !TypeCheckedLoadFunc->use_empty()))
865  return make_error<StringError>(
866  "inconsistent LTO Unit splitting (recompile with -fsplit-lto-unit)",
868 
869  // Otherwise check if there are any recorded in the combined summary from the
870  // ThinLTO modules.
871  for (auto &P : ThinLTO.CombinedIndex) {
872  for (auto &S : P.second.SummaryList) {
873  auto *FS = dyn_cast<FunctionSummary>(S.get());
874  if (!FS)
875  continue;
876  if (!FS->type_test_assume_vcalls().empty() ||
877  !FS->type_checked_load_vcalls().empty() ||
878  !FS->type_test_assume_const_vcalls().empty() ||
879  !FS->type_checked_load_const_vcalls().empty() ||
880  !FS->type_tests().empty())
881  return make_error<StringError>(
882  "inconsistent LTO Unit splitting (recompile with -fsplit-lto-unit)",
884  }
885  }
886  return Error::success();
887 }
888 
890  // Compute "dead" symbols, we don't want to import/export these!
891  DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
892  DenseMap<GlobalValue::GUID, PrevailingType> GUIDPrevailingResolutions;
893  for (auto &Res : GlobalResolutions) {
894  // Normally resolution have IR name of symbol. We can do nothing here
895  // otherwise. See comments in GlobalResolution struct for more details.
896  if (Res.second.IRName.empty())
897  continue;
898 
900  GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
901 
902  if (Res.second.VisibleOutsideSummary && Res.second.Prevailing)
903  GUIDPreservedSymbols.insert(GlobalValue::getGUID(
904  GlobalValue::dropLLVMManglingEscape(Res.second.IRName)));
905 
906  GUIDPrevailingResolutions[GUID] =
907  Res.second.Prevailing ? PrevailingType::Yes : PrevailingType::No;
908  }
909 
910  auto isPrevailing = [&](GlobalValue::GUID G) {
911  auto It = GUIDPrevailingResolutions.find(G);
912  if (It == GUIDPrevailingResolutions.end())
914  return It->second;
915  };
916  computeDeadSymbolsWithConstProp(ThinLTO.CombinedIndex, GUIDPreservedSymbols,
917  isPrevailing, Conf.OptLevel > 0);
918 
919  // Setup output file to emit statistics.
920  auto StatsFileOrErr = setupStatsFile(Conf.StatsFile);
921  if (!StatsFileOrErr)
922  return StatsFileOrErr.takeError();
923  std::unique_ptr<ToolOutputFile> StatsFile = std::move(StatsFileOrErr.get());
924 
925  // Finalize linking of regular LTO modules containing summaries now that
926  // we have computed liveness information.
927  for (auto &M : RegularLTO.ModsWithSummaries)
928  if (Error Err = linkRegularLTO(std::move(M),
929  /*LivenessFromIndex=*/true))
930  return Err;
931 
932  // Ensure we don't have inconsistently split LTO units with type tests.
933  if (Error Err = checkPartiallySplit())
934  return Err;
935 
936  Error Result = runRegularLTO(AddStream);
937  if (!Result)
938  Result = runThinLTO(AddStream, Cache, GUIDPreservedSymbols);
939 
940  if (StatsFile)
941  PrintStatisticsJSON(StatsFile->os());
942 
943  return Result;
944 }
945 
946 Error LTO::runRegularLTO(AddStreamFn AddStream) {
947  // Make sure commons have the right size/alignment: we kept the largest from
948  // all the prevailing when adding the inputs, and we apply it here.
949  const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
950  for (auto &I : RegularLTO.Commons) {
951  if (!I.second.Prevailing)
952  // Don't do anything if no instance of this common was prevailing.
953  continue;
954  GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);
955  if (OldGV && DL.getTypeAllocSize(OldGV->getValueType()) == I.second.Size) {
956  // Don't create a new global if the type is already correct, just make
957  // sure the alignment is correct.
958  OldGV->setAlignment(I.second.Align);
959  continue;
960  }
961  ArrayType *Ty =
962  ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size);
963  auto *GV = new GlobalVariable(*RegularLTO.CombinedModule, Ty, false,
966  GV->setAlignment(I.second.Align);
967  if (OldGV) {
969  GV->takeName(OldGV);
970  OldGV->eraseFromParent();
971  } else {
972  GV->setName(I.first);
973  }
974  }
975 
976  if (Conf.PreOptModuleHook &&
977  !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
978  return Error::success();
979 
980  if (!Conf.CodeGenOnly) {
981  for (const auto &R : GlobalResolutions) {
982  if (!R.second.isPrevailingIRSymbol())
983  continue;
984  if (R.second.Partition != 0 &&
985  R.second.Partition != GlobalResolution::External)
986  continue;
987 
988  GlobalValue *GV =
989  RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
990  // Ignore symbols defined in other partitions.
991  // Also skip declarations, which are not allowed to have internal linkage.
992  if (!GV || GV->hasLocalLinkage() || GV->isDeclaration())
993  continue;
994  GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
996  if (EnableLTOInternalization && R.second.Partition == 0)
998  }
999 
1000  if (Conf.PostInternalizeModuleHook &&
1001  !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
1002  return Error::success();
1003  }
1004  return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
1005  std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);
1006 }
1007 
1008 /// This class defines the interface to the ThinLTO backend.
1010 protected:
1014 
1015 public:
1017  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries)
1018  : Conf(Conf), CombinedIndex(CombinedIndex),
1019  ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {}
1020 
1021  virtual ~ThinBackendProc() {}
1022  virtual Error start(
1023  unsigned Task, BitcodeModule BM,
1024  const FunctionImporter::ImportMapTy &ImportList,
1025  const FunctionImporter::ExportSetTy &ExportList,
1026  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1027  MapVector<StringRef, BitcodeModule> &ModuleMap) = 0;
1028  virtual Error wait() = 0;
1029 };
1030 
1031 namespace {
1032 class InProcessThinBackend : public ThinBackendProc {
1033  ThreadPool BackendThreadPool;
1034  AddStreamFn AddStream;
1035  NativeObjectCache Cache;
1036  std::set<GlobalValue::GUID> CfiFunctionDefs;
1037  std::set<GlobalValue::GUID> CfiFunctionDecls;
1038 
1039  Optional<Error> Err;
1040  std::mutex ErrMu;
1041 
1042 public:
1043  InProcessThinBackend(
1044  Config &Conf, ModuleSummaryIndex &CombinedIndex,
1045  unsigned ThinLTOParallelismLevel,
1046  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1047  AddStreamFn AddStream, NativeObjectCache Cache)
1048  : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
1049  BackendThreadPool(ThinLTOParallelismLevel),
1050  AddStream(std::move(AddStream)), Cache(std::move(Cache)) {
1051  for (auto &Name : CombinedIndex.cfiFunctionDefs())
1052  CfiFunctionDefs.insert(
1054  for (auto &Name : CombinedIndex.cfiFunctionDecls())
1055  CfiFunctionDecls.insert(
1057  }
1058 
1059  Error runThinLTOBackendThread(
1060  AddStreamFn AddStream, NativeObjectCache Cache, unsigned Task,
1061  BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
1062  const FunctionImporter::ImportMapTy &ImportList,
1063  const FunctionImporter::ExportSetTy &ExportList,
1064  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1065  const GVSummaryMapTy &DefinedGlobals,
1067  auto RunThinBackend = [&](AddStreamFn AddStream) {
1068  LTOLLVMContext BackendContext(Conf);
1069  Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext);
1070  if (!MOrErr)
1071  return MOrErr.takeError();
1072 
1073  return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
1074  ImportList, DefinedGlobals, ModuleMap);
1075  };
1076 
1077  auto ModuleID = BM.getModuleIdentifier();
1078 
1079  if (!Cache || !CombinedIndex.modulePaths().count(ModuleID) ||
1080  all_of(CombinedIndex.getModuleHash(ModuleID),
1081  [](uint32_t V) { return V == 0; }))
1082  // Cache disabled or no entry for this module in the combined index or
1083  // no module hash.
1084  return RunThinBackend(AddStream);
1085 
1087  // The module may be cached, this helps handling it.
1088  computeLTOCacheKey(Key, Conf, CombinedIndex, ModuleID, ImportList,
1089  ExportList, ResolvedODR, DefinedGlobals, CfiFunctionDefs,
1090  CfiFunctionDecls);
1091  if (AddStreamFn CacheAddStream = Cache(Task, Key))
1092  return RunThinBackend(CacheAddStream);
1093 
1094  return Error::success();
1095  }
1096 
1097  Error start(
1098  unsigned Task, BitcodeModule BM,
1099  const FunctionImporter::ImportMapTy &ImportList,
1100  const FunctionImporter::ExportSetTy &ExportList,
1101  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1102  MapVector<StringRef, BitcodeModule> &ModuleMap) override {
1103  StringRef ModulePath = BM.getModuleIdentifier();
1104  assert(ModuleToDefinedGVSummaries.count(ModulePath));
1105  const GVSummaryMapTy &DefinedGlobals =
1106  ModuleToDefinedGVSummaries.find(ModulePath)->second;
1107  BackendThreadPool.async(
1108  [=](BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
1109  const FunctionImporter::ImportMapTy &ImportList,
1110  const FunctionImporter::ExportSetTy &ExportList,
1111  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>
1112  &ResolvedODR,
1113  const GVSummaryMapTy &DefinedGlobals,
1115  Error E = runThinLTOBackendThread(
1116  AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
1117  ResolvedODR, DefinedGlobals, ModuleMap);
1118  if (E) {
1119  std::unique_lock<std::mutex> L(ErrMu);
1120  if (Err)
1121  Err = joinErrors(std::move(*Err), std::move(E));
1122  else
1123  Err = std::move(E);
1124  }
1125  },
1126  BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
1127  std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap));
1128  return Error::success();
1129  }
1130 
1131  Error wait() override {
1132  BackendThreadPool.wait();
1133  if (Err)
1134  return std::move(*Err);
1135  else
1136  return Error::success();
1137  }
1138 };
1139 } // end anonymous namespace
1140 
1141 ThinBackend lto::createInProcessThinBackend(unsigned ParallelismLevel) {
1142  return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1143  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1144  AddStreamFn AddStream, NativeObjectCache Cache) {
1145  return std::make_unique<InProcessThinBackend>(
1146  Conf, CombinedIndex, ParallelismLevel, ModuleToDefinedGVSummaries,
1147  AddStream, Cache);
1148  };
1149 }
1150 
1151 // Given the original \p Path to an output file, replace any path
1152 // prefix matching \p OldPrefix with \p NewPrefix. Also, create the
1153 // resulting directory if it does not yet exist.
1154 std::string lto::getThinLTOOutputFile(const std::string &Path,
1155  const std::string &OldPrefix,
1156  const std::string &NewPrefix) {
1157  if (OldPrefix.empty() && NewPrefix.empty())
1158  return Path;
1159  SmallString<128> NewPath(Path);
1160  llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
1161  StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
1162  if (!ParentPath.empty()) {
1163  // Make sure the new directory exists, creating it if necessary.
1164  if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
1165  llvm::errs() << "warning: could not create directory '" << ParentPath
1166  << "': " << EC.message() << '\n';
1167  }
1168  return NewPath.str();
1169 }
1170 
1171 namespace {
1172 class WriteIndexesThinBackend : public ThinBackendProc {
1173  std::string OldPrefix, NewPrefix;
1174  bool ShouldEmitImportsFiles;
1175  raw_fd_ostream *LinkedObjectsFile;
1176  lto::IndexWriteCallback OnWrite;
1177 
1178 public:
1179  WriteIndexesThinBackend(
1180  Config &Conf, ModuleSummaryIndex &CombinedIndex,
1181  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1182  std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1183  raw_fd_ostream *LinkedObjectsFile, lto::IndexWriteCallback OnWrite)
1184  : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
1185  OldPrefix(OldPrefix), NewPrefix(NewPrefix),
1186  ShouldEmitImportsFiles(ShouldEmitImportsFiles),
1187  LinkedObjectsFile(LinkedObjectsFile), OnWrite(OnWrite) {}
1188 
1189  Error start(
1190  unsigned Task, BitcodeModule BM,
1191  const FunctionImporter::ImportMapTy &ImportList,
1192  const FunctionImporter::ExportSetTy &ExportList,
1193  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1194  MapVector<StringRef, BitcodeModule> &ModuleMap) override {
1195  StringRef ModulePath = BM.getModuleIdentifier();
1196  std::string NewModulePath =
1197  getThinLTOOutputFile(ModulePath, OldPrefix, NewPrefix);
1198 
1199  if (LinkedObjectsFile)
1200  *LinkedObjectsFile << NewModulePath << '\n';
1201 
1202  std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
1203  gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
1204  ImportList, ModuleToSummariesForIndex);
1205 
1206  std::error_code EC;
1207  raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
1209  if (EC)
1210  return errorCodeToError(EC);
1211  WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
1212 
1213  if (ShouldEmitImportsFiles) {
1214  EC = EmitImportsFiles(ModulePath, NewModulePath + ".imports",
1215  ModuleToSummariesForIndex);
1216  if (EC)
1217  return errorCodeToError(EC);
1218  }
1219 
1220  if (OnWrite)
1221  OnWrite(ModulePath);
1222  return Error::success();
1223  }
1224 
1225  Error wait() override { return Error::success(); }
1226 };
1227 } // end anonymous namespace
1228 
1230  std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1231  raw_fd_ostream *LinkedObjectsFile, IndexWriteCallback OnWrite) {
1232  return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1233  const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1234  AddStreamFn AddStream, NativeObjectCache Cache) {
1235  return std::make_unique<WriteIndexesThinBackend>(
1236  Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
1237  ShouldEmitImportsFiles, LinkedObjectsFile, OnWrite);
1238  };
1239 }
1240 
1241 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
1242  const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
1243  if (ThinLTO.ModuleMap.empty())
1244  return Error::success();
1245 
1246  if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
1247  return Error::success();
1248 
1249  // Collect for each module the list of function it defines (GUID ->
1250  // Summary).
1252  ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
1253  ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
1254  ModuleToDefinedGVSummaries);
1255  // Create entries for any modules that didn't have any GV summaries
1256  // (either they didn't have any GVs to start with, or we suppressed
1257  // generation of the summaries because they e.g. had inline assembly
1258  // uses that couldn't be promoted/renamed on export). This is so
1259  // InProcessThinBackend::start can still launch a backend thread, which
1260  // is passed the map of summaries for the module, without any special
1261  // handling for this case.
1262  for (auto &Mod : ThinLTO.ModuleMap)
1263  if (!ModuleToDefinedGVSummaries.count(Mod.first))
1264  ModuleToDefinedGVSummaries.try_emplace(Mod.first);
1265 
1266  // Synthesize entry counts for functions in the CombinedIndex.
1267  computeSyntheticCounts(ThinLTO.CombinedIndex);
1268 
1270  ThinLTO.ModuleMap.size());
1272  ThinLTO.ModuleMap.size());
1274 
1275  if (DumpThinCGSCCs)
1276  ThinLTO.CombinedIndex.dumpSCCs(outs());
1277 
1278  std::set<GlobalValue::GUID> ExportedGUIDs;
1279 
1280  // Perform index-based WPD. This will return immediately if there are
1281  // no index entries in the typeIdMetadata map (e.g. if we are instead
1282  // performing IR-based WPD in hybrid regular/thin LTO mode).
1283  std::map<ValueInfo, std::vector<VTableSlotSummary>> LocalWPDTargetsMap;
1284  runWholeProgramDevirtOnIndex(ThinLTO.CombinedIndex, ExportedGUIDs,
1285  LocalWPDTargetsMap);
1286 
1287  if (Conf.OptLevel > 0)
1288  ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1289  ImportLists, ExportLists);
1290 
1291  // Update local devirtualized targets that were exported by cross-module
1292  // importing
1293  updateIndexWPDForExports(ThinLTO.CombinedIndex, ExportLists,
1294  LocalWPDTargetsMap);
1295 
1296  // Figure out which symbols need to be internalized. This also needs to happen
1297  // at -O0 because summary-based DCE is implemented using internalization, and
1298  // we must apply DCE consistently with the full LTO module in order to avoid
1299  // undefined references during the final link.
1300  for (auto &Res : GlobalResolutions) {
1301  // If the symbol does not have external references or it is not prevailing,
1302  // then not need to mark it as exported from a ThinLTO partition.
1303  if (Res.second.Partition != GlobalResolution::External ||
1304  !Res.second.isPrevailingIRSymbol())
1305  continue;
1306  auto GUID = GlobalValue::getGUID(
1307  GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
1308  // Mark exported unless index-based analysis determined it to be dead.
1309  if (ThinLTO.CombinedIndex.isGUIDLive(GUID))
1310  ExportedGUIDs.insert(GUID);
1311  }
1312 
1313  // Any functions referenced by the jump table in the regular LTO object must
1314  // be exported.
1315  for (auto &Def : ThinLTO.CombinedIndex.cfiFunctionDefs())
1316  ExportedGUIDs.insert(
1318 
1319  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
1320  const auto &ExportList = ExportLists.find(ModuleIdentifier);
1321  return (ExportList != ExportLists.end() &&
1322  ExportList->second.count(GUID)) ||
1323  ExportedGUIDs.count(GUID);
1324  };
1325  thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported);
1326 
1327  auto isPrevailing = [&](GlobalValue::GUID GUID,
1328  const GlobalValueSummary *S) {
1329  return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
1330  };
1331  auto recordNewLinkage = [&](StringRef ModuleIdentifier,
1332  GlobalValue::GUID GUID,
1333  GlobalValue::LinkageTypes NewLinkage) {
1334  ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
1335  };
1336  thinLTOResolvePrevailingInIndex(ThinLTO.CombinedIndex, isPrevailing,
1337  recordNewLinkage, GUIDPreservedSymbols);
1338 
1339  std::unique_ptr<ThinBackendProc> BackendProc =
1340  ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1341  AddStream, Cache);
1342 
1343  // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined
1344  // module and parallel code generation partitions.
1345  unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel;
1346  for (auto &Mod : ThinLTO.ModuleMap) {
1347  if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
1348  ExportLists[Mod.first],
1349  ResolvedODR[Mod.first], ThinLTO.ModuleMap))
1350  return E;
1351  ++Task;
1352  }
1353 
1354  return BackendProc->wait();
1355 }
1356 
1360  bool RemarksWithHotness, int Count) {
1361  std::string Filename = RemarksFilename;
1362  if (!Filename.empty() && Count != -1)
1363  Filename += ".thin." + llvm::utostr(Count) + ".yaml";
1364 
1365  auto ResultOrErr = llvm::setupOptimizationRemarks(
1366  Context, Filename, RemarksPasses, RemarksFormat, RemarksWithHotness);
1367  if (Error E = ResultOrErr.takeError())
1368  return std::move(E);
1369 
1370  if (*ResultOrErr)
1371  (*ResultOrErr)->keep();
1372 
1373  return ResultOrErr;
1374 }
1375 
1378  // Setup output file to emit statistics.
1379  if (StatsFilename.empty())
1380  return nullptr;
1381 
1382  llvm::EnableStatistics(false);
1383  std::error_code EC;
1384  auto StatsFile =
1385  std::make_unique<ToolOutputFile>(StatsFilename, EC, sys::fs::OF_None);
1386  if (EC)
1387  return errorCodeToError(EC);
1388 
1389  StatsFile->keep();
1390  return std::move(StatsFile);
1391 }
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:155
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:1009
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
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:433
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:455
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:65
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:130
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:1350
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:444
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: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:427
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:1177
F(f)
const StringMap< GVSummaryMapTy > & ModuleToDefinedGVSummaries
Definition: LTO.cpp:1013
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:422
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
void setAlignment(unsigned Align)
FIXME: Remove this setter once the migration to MaybeAlign is over.
Definition: Globals.cpp:116
std::function< void(const std::string &)> IndexWriteCallback
This ThinBackend writes individual module indexes to files, instead of running the individual backend...
Definition: LTO.h:243
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:1229
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:451
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:637
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:1012
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: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:306
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:266
Key
PAL metadata keys.
const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:255
Class to represent array types.
Definition: DerivedTypes.h:403
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:102
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
std::pair< iterator, bool > try_emplace(StringRef Key, ArgsTy &&... Args)
Emplace a new element for the specified key into the map if the key isn&#39;t already in the map...
Definition: StringMap.h:399
Class to hold module path string table and global value map, and encapsulate methods for operating on...
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:1377
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:1791
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:561
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
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:225
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
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
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:1016
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:217
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:202
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:537
void computeSyntheticCounts(ModuleSummaryIndex &Index)
Compute synthetic function entry counts.
void PrintStatisticsJSON(raw_ostream &OS)
Print statistics in JSON format.
Definition: Statistic.cpp:201
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...
unsigned getMaxTasks() const
Returns an upper bound on the number of tasks that the client may expect.
Definition: LTO.cpp:845
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
static void thinLTOInternalizeAndPromoteGUID(GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID, function_ref< bool(StringRef, GlobalValue::GUID)> isExported)
Definition: LTO.cpp:385
void updateIndexWPDForExports(ModuleSummaryIndex &Summary, StringMap< FunctionImporter::ExportSetTy > &ExportLists, std::map< ValueInfo, std::vector< VTableSlotSummary >> &LocalWPDTargetsMap)
Call after cross-module importing to update the recorded single impl devirt target names for any loca...
iterator end() const
Definition: ArrayRef.h:137
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
virtual ~ThinBackendProc()
Definition: LTO.cpp:1021
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:219
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:1141
Expected< std::unique_ptr< ToolOutputFile > > setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses, StringRef RemarksFormat, bool RemarksWithHotness, unsigned RemarksHotnessThreshold=0)
Setup optimization remarks.
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:470
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
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:473
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:219
static void handleNonPrevailingComdat(GlobalValue &GV, std::set< const Comdat *> &NonPrevailingComdats)
Definition: LTO.cpp:632
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:889
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:582
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:440
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:1358
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:587
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:437
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:342
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:1154
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:412
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:627