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