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