LLVM  4.0.0
ThinLTOCodeGenerator.cpp
Go to the documentation of this file.
1 //===-ThinLTOCodeGenerator.cpp - LLVM Link Time Optimizer -----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Thin Link Time Optimization library. This library is
11 // intended to be used by linker to optimize code at link time.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 
17 #ifdef HAVE_LLVM_REVISION
18 #include "LLVMLTORevision.h"
19 #endif
20 
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
32 #include "llvm/IR/LLVMContext.h"
34 #include "llvm/IR/Mangler.h"
35 #include "llvm/IRReader/IRReader.h"
36 #include "llvm/LTO/LTO.h"
37 #include "llvm/Linker/Linker.h"
42 #include "llvm/Support/Debug.h"
43 #include "llvm/Support/Error.h"
44 #include "llvm/Support/Path.h"
45 #include "llvm/Support/SHA1.h"
48 #include "llvm/Support/Threading.h"
51 #include "llvm/Transforms/IPO.h"
57 
58 #include <numeric>
59 
60 using namespace llvm;
61 
62 #define DEBUG_TYPE "thinlto"
63 
64 namespace llvm {
65 // Flags -discard-value-names, defined in LTOCodeGenerator.cpp
69 }
70 
71 namespace {
72 
73 static cl::opt<int>
74  ThreadCount("threads", cl::init(llvm::heavyweight_hardware_concurrency()));
75 
77 setupOptimizationRemarks(LLVMContext &Ctx, int Count) {
80 
81  if (LTORemarksFilename.empty())
82  return nullptr;
83 
84  std::string FileName =
85  LTORemarksFilename + ".thin." + llvm::utostr(Count) + ".yaml";
86  std::error_code EC;
87  auto DiagnosticOutputFile =
88  llvm::make_unique<tool_output_file>(FileName, EC, sys::fs::F_None);
89  if (EC)
90  return errorCodeToError(EC);
92  llvm::make_unique<yaml::Output>(DiagnosticOutputFile->os()));
93  DiagnosticOutputFile->keep();
94  return std::move(DiagnosticOutputFile);
95 }
96 
97 // Simple helper to save temporary files for debug.
98 static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
99  unsigned count, StringRef Suffix) {
100  if (TempDir.empty())
101  return;
102  // User asked to save temps, let dump the bitcode file after import.
103  std::string SaveTempPath = (TempDir + llvm::utostr(count) + Suffix).str();
104  std::error_code EC;
105  raw_fd_ostream OS(SaveTempPath, EC, sys::fs::F_None);
106  if (EC)
107  report_fatal_error(Twine("Failed to open ") + SaveTempPath +
108  " to save optimized bitcode\n");
109  WriteBitcodeToFile(&TheModule, OS, /* ShouldPreserveUseListOrder */ true);
110 }
111 
112 static const GlobalValueSummary *
113 getFirstDefinitionForLinker(const GlobalValueSummaryList &GVSummaryList) {
114  // If there is any strong definition anywhere, get it.
115  auto StrongDefForLinker = llvm::find_if(
116  GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
117  auto Linkage = Summary->linkage();
120  });
121  if (StrongDefForLinker != GVSummaryList.end())
122  return StrongDefForLinker->get();
123  // Get the first *linker visible* definition for this global in the summary
124  // list.
125  auto FirstDefForLinker = llvm::find_if(
126  GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
127  auto Linkage = Summary->linkage();
129  });
130  // Extern templates can be emitted as available_externally.
131  if (FirstDefForLinker == GVSummaryList.end())
132  return nullptr;
133  return FirstDefForLinker->get();
134 }
135 
136 // Populate map of GUID to the prevailing copy for any multiply defined
137 // symbols. Currently assume first copy is prevailing, or any strong
138 // definition. Can be refined with Linker information in the future.
139 static void computePrevailingCopies(
140  const ModuleSummaryIndex &Index,
142  auto HasMultipleCopies = [&](const GlobalValueSummaryList &GVSummaryList) {
143  return GVSummaryList.size() > 1;
144  };
145 
146  for (auto &I : Index) {
147  if (HasMultipleCopies(I.second))
148  PrevailingCopy[I.first] = getFirstDefinitionForLinker(I.second);
149  }
150 }
151 
153 generateModuleMap(const std::vector<ThinLTOBuffer> &Modules) {
154  StringMap<MemoryBufferRef> ModuleMap;
155  for (auto &ModuleBuffer : Modules) {
156  assert(ModuleMap.find(ModuleBuffer.getBufferIdentifier()) ==
157  ModuleMap.end() &&
158  "Expect unique Buffer Identifier");
159  ModuleMap[ModuleBuffer.getBufferIdentifier()] = ModuleBuffer.getMemBuffer();
160  }
161  return ModuleMap;
162 }
163 
164 static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index) {
165  if (renameModuleForThinLTO(TheModule, Index))
166  report_fatal_error("renameModuleForThinLTO failed");
167 }
168 
169 static std::unique_ptr<Module>
170 loadModuleFromBuffer(const MemoryBufferRef &Buffer, LLVMContext &Context,
171  bool Lazy, bool IsImporting) {
172  SMDiagnostic Err;
173  Expected<std::unique_ptr<Module>> ModuleOrErr =
174  Lazy
175  ? getLazyBitcodeModule(Buffer, Context,
176  /* ShouldLazyLoadMetadata */ true, IsImporting)
177  : parseBitcodeFile(Buffer, Context);
178  if (!ModuleOrErr) {
179  handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
181  SourceMgr::DK_Error, EIB.message());
182  Err.print("ThinLTO", errs());
183  });
184  report_fatal_error("Can't load module, abort.");
185  }
186  return std::move(ModuleOrErr.get());
187 }
188 
189 static void
190 crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
191  StringMap<MemoryBufferRef> &ModuleMap,
192  const FunctionImporter::ImportMapTy &ImportList) {
193  auto Loader = [&](StringRef Identifier) {
194  return loadModuleFromBuffer(ModuleMap[Identifier], TheModule.getContext(),
195  /*Lazy=*/true, /*IsImporting*/ true);
196  };
197 
198  FunctionImporter Importer(Index, Loader);
199  Expected<bool> Result = Importer.importFunctions(TheModule, ImportList);
200  if (!Result) {
201  handleAllErrors(Result.takeError(), [&](ErrorInfoBase &EIB) {
203  SourceMgr::DK_Error, EIB.message());
204  Err.print("ThinLTO", errs());
205  });
206  report_fatal_error("importFunctions failed");
207  }
208 }
209 
210 static void optimizeModule(Module &TheModule, TargetMachine &TM,
211  unsigned OptLevel) {
212  // Populate the PassManager
213  PassManagerBuilder PMB;
216  // FIXME: should get it from the bitcode?
217  PMB.OptLevel = OptLevel;
218  PMB.LoopVectorize = true;
219  PMB.SLPVectorize = true;
220  PMB.VerifyInput = true;
221  PMB.VerifyOutput = false;
222 
224 
225  // Add the TTI (required to inform the vectorizer about register size for
226  // instance)
228 
229  // Add optimizations
231 
232  PM.run(TheModule);
233 }
234 
235 // Convert the PreservedSymbols map from "Name" based to "GUID" based.
237 computeGUIDPreservedSymbols(const StringSet<> &PreservedSymbols,
238  const Triple &TheTriple) {
239  DenseSet<GlobalValue::GUID> GUIDPreservedSymbols(PreservedSymbols.size());
240  for (auto &Entry : PreservedSymbols) {
241  StringRef Name = Entry.first();
242  if (TheTriple.isOSBinFormatMachO() && Name.size() > 0 && Name[0] == '_')
243  Name = Name.drop_front();
244  GUIDPreservedSymbols.insert(GlobalValue::getGUID(Name));
245  }
246  return GUIDPreservedSymbols;
247 }
248 
249 std::unique_ptr<MemoryBuffer> codegenModule(Module &TheModule,
250  TargetMachine &TM) {
251  SmallVector<char, 128> OutputBuffer;
252 
253  // CodeGen
254  {
255  raw_svector_ostream OS(OutputBuffer);
257 
258  // If the bitcode files contain ARC code and were compiled with optimization,
259  // the ObjCARCContractPass must be run, so do it unconditionally here.
261 
262  // Setup the codegen now.
264  /* DisableVerify */ true))
265  report_fatal_error("Failed to setup codegen");
266 
267  // Run codegen now. resulting binary is in OutputBuffer.
268  PM.run(TheModule);
269  }
270  return make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
271 }
272 
273 /// Manage caching for a single Module.
274 class ModuleCacheEntry {
275  SmallString<128> EntryPath;
276 
277 public:
278  // Create a cache entry. This compute a unique hash for the Module considering
279  // the current list of export/import, and offer an interface to query to
280  // access the content in the cache.
281  ModuleCacheEntry(
282  StringRef CachePath, const ModuleSummaryIndex &Index, StringRef ModuleID,
283  const FunctionImporter::ImportMapTy &ImportList,
284  const FunctionImporter::ExportSetTy &ExportList,
285  const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
286  const GVSummaryMapTy &DefinedFunctions,
287  const DenseSet<GlobalValue::GUID> &PreservedSymbols, unsigned OptLevel,
288  const TargetMachineBuilder &TMBuilder) {
289  if (CachePath.empty())
290  return;
291 
292  if (!Index.modulePaths().count(ModuleID))
293  // The module does not have an entry, it can't have a hash at all
294  return;
295 
296  // Compute the unique hash for this entry
297  // This is based on the current compiler version, the module itself, the
298  // export list, the hash for every single module in the import list, the
299  // list of ResolvedODR for the module, and the list of preserved symbols.
300 
301  // Include the hash for the current module
302  auto ModHash = Index.getModuleHash(ModuleID);
303 
304  if (all_of(ModHash, [](uint32_t V) { return V == 0; }))
305  // No hash entry, no caching!
306  return;
307 
308  SHA1 Hasher;
309 
310  // Include the parts of the LTO configuration that affect code generation.
311  auto AddString = [&](StringRef Str) {
312  Hasher.update(Str);
313  Hasher.update(ArrayRef<uint8_t>{0});
314  };
315  auto AddUnsigned = [&](unsigned I) {
316  uint8_t Data[4];
317  Data[0] = I;
318  Data[1] = I >> 8;
319  Data[2] = I >> 16;
320  Data[3] = I >> 24;
321  Hasher.update(ArrayRef<uint8_t>{Data, 4});
322  };
323 
324  // Start with the compiler revision
325  Hasher.update(LLVM_VERSION_STRING);
326 #ifdef HAVE_LLVM_REVISION
327  Hasher.update(LLVM_REVISION);
328 #endif
329 
330  // Hash the optimization level and the target machine settings.
331  AddString(TMBuilder.MCpu);
332  // FIXME: Hash more of Options. For now all clients initialize Options from
333  // command-line flags (which is unsupported in production), but may set
334  // RelaxELFRelocations. The clang driver can also pass FunctionSections,
335  // DataSections and DebuggerTuning via command line flags.
336  AddUnsigned(TMBuilder.Options.RelaxELFRelocations);
337  AddUnsigned(TMBuilder.Options.FunctionSections);
338  AddUnsigned(TMBuilder.Options.DataSections);
339  AddUnsigned((unsigned)TMBuilder.Options.DebuggerTuning);
340  AddString(TMBuilder.MAttr);
341  if (TMBuilder.RelocModel)
342  AddUnsigned(*TMBuilder.RelocModel);
343  AddUnsigned(TMBuilder.CGOptLevel);
344  AddUnsigned(OptLevel);
345 
346  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
347  for (auto F : ExportList)
348  // The export list can impact the internalization, be conservative here
349  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F)));
350 
351  // Include the hash for every module we import functions from
352  for (auto &Entry : ImportList) {
353  auto ModHash = Index.getModuleHash(Entry.first());
354  Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
355  }
356 
357  // Include the hash for the resolved ODR.
358  for (auto &Entry : ResolvedODR) {
359  Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first,
360  sizeof(GlobalValue::GUID)));
361  Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second,
362  sizeof(GlobalValue::LinkageTypes)));
363  }
364 
365  // Include the hash for the preserved symbols.
366  for (auto &Entry : PreservedSymbols) {
367  if (DefinedFunctions.count(Entry))
368  Hasher.update(
369  ArrayRef<uint8_t>((const uint8_t *)&Entry, sizeof(GlobalValue::GUID)));
370  }
371 
372  sys::path::append(EntryPath, CachePath, toHex(Hasher.result()));
373  }
374 
375  // Access the path to this entry in the cache.
376  StringRef getEntryPath() { return EntryPath; }
377 
378  // Try loading the buffer for this cache entry.
379  ErrorOr<std::unique_ptr<MemoryBuffer>> tryLoadingBuffer() {
380  if (EntryPath.empty())
381  return std::error_code();
382  return MemoryBuffer::getFile(EntryPath);
383  }
384 
385  // Cache the Produced object file
386  void write(const MemoryBuffer &OutputBuffer) {
387  if (EntryPath.empty())
388  return;
389 
390  // Write to a temporary to avoid race condition
391  SmallString<128> TempFilename;
392  int TempFD;
393  std::error_code EC =
394  sys::fs::createTemporaryFile("Thin", "tmp.o", TempFD, TempFilename);
395  if (EC) {
396  errs() << "Error: " << EC.message() << "\n";
397  report_fatal_error("ThinLTO: Can't get a temporary file");
398  }
399  {
400  raw_fd_ostream OS(TempFD, /* ShouldClose */ true);
401  OS << OutputBuffer.getBuffer();
402  }
403  // Rename to final destination (hopefully race condition won't matter here)
404  EC = sys::fs::rename(TempFilename, EntryPath);
405  if (EC) {
406  sys::fs::remove(TempFilename);
407  raw_fd_ostream OS(EntryPath, EC, sys::fs::F_None);
408  if (EC)
409  report_fatal_error(Twine("Failed to open ") + EntryPath +
410  " to save cached entry\n");
411  OS << OutputBuffer.getBuffer();
412  }
413  }
414 };
415 
416 static std::unique_ptr<MemoryBuffer>
417 ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
419  const FunctionImporter::ImportMapTy &ImportList,
420  const FunctionImporter::ExportSetTy &ExportList,
421  const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
422  const GVSummaryMapTy &DefinedGlobals,
423  const ThinLTOCodeGenerator::CachingOptions &CacheOptions,
424  bool DisableCodeGen, StringRef SaveTempsDir,
425  unsigned OptLevel, unsigned count) {
426 
427  // "Benchmark"-like optimization: single-source case
428  bool SingleModule = (ModuleMap.size() == 1);
429 
430  if (!SingleModule) {
431  promoteModule(TheModule, Index);
432 
433  // Apply summary-based LinkOnce/Weak resolution decisions.
434  thinLTOResolveWeakForLinkerModule(TheModule, DefinedGlobals);
435 
436  // Save temps: after promotion.
437  saveTempBitcode(TheModule, SaveTempsDir, count, ".1.promoted.bc");
438  }
439 
440  // Be friendly and don't nuke totally the module when the client didn't
441  // supply anything to preserve.
442  if (!ExportList.empty() || !GUIDPreservedSymbols.empty()) {
443  // Apply summary-based internalization decisions.
444  thinLTOInternalizeModule(TheModule, DefinedGlobals);
445  }
446 
447  // Save internalized bitcode
448  saveTempBitcode(TheModule, SaveTempsDir, count, ".2.internalized.bc");
449 
450  if (!SingleModule) {
451  crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
452 
453  // Save temps: after cross-module import.
454  saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
455  }
456 
457  optimizeModule(TheModule, TM, OptLevel);
458 
459  saveTempBitcode(TheModule, SaveTempsDir, count, ".4.opt.bc");
460 
461  if (DisableCodeGen) {
462  // Configured to stop before CodeGen, serialize the bitcode and return.
463  SmallVector<char, 128> OutputBuffer;
464  {
465  raw_svector_ostream OS(OutputBuffer);
466  ProfileSummaryInfo PSI(TheModule);
467  auto Index = buildModuleSummaryIndex(TheModule, nullptr, nullptr);
468  WriteBitcodeToFile(&TheModule, OS, true, &Index);
469  }
470  return make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
471  }
472 
473  return codegenModule(TheModule, TM);
474 }
475 
476 /// Resolve LinkOnce/Weak symbols. Record resolutions in the \p ResolvedODR map
477 /// for caching, and in the \p Index for application during the ThinLTO
478 /// backends. This is needed for correctness for exported symbols (ensure
479 /// at least one copy kept) and a compile-time optimization (to drop duplicate
480 /// copies when possible).
481 static void resolveWeakForLinkerInIndex(
482  ModuleSummaryIndex &Index,
483  StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>>
484  &ResolvedODR) {
485 
487  computePrevailingCopies(Index, PrevailingCopy);
488 
489  auto isPrevailing = [&](GlobalValue::GUID GUID, const GlobalValueSummary *S) {
490  const auto &Prevailing = PrevailingCopy.find(GUID);
491  // Not in map means that there was only one copy, which must be prevailing.
492  if (Prevailing == PrevailingCopy.end())
493  return true;
494  return Prevailing->second == S;
495  };
496 
497  auto recordNewLinkage = [&](StringRef ModuleIdentifier,
498  GlobalValue::GUID GUID,
499  GlobalValue::LinkageTypes NewLinkage) {
500  ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
501  };
502 
503  thinLTOResolveWeakForLinkerInIndex(Index, isPrevailing, recordNewLinkage);
504 }
505 
506 // Initialize the TargetMachine builder for a given Triple
507 static void initTMBuilder(TargetMachineBuilder &TMBuilder,
508  const Triple &TheTriple) {
509  // Set a default CPU for Darwin triples (copied from LTOCodeGenerator).
510  // FIXME this looks pretty terrible...
511  if (TMBuilder.MCpu.empty() && TheTriple.isOSDarwin()) {
512  if (TheTriple.getArch() == llvm::Triple::x86_64)
513  TMBuilder.MCpu = "core2";
514  else if (TheTriple.getArch() == llvm::Triple::x86)
515  TMBuilder.MCpu = "yonah";
516  else if (TheTriple.getArch() == llvm::Triple::aarch64)
517  TMBuilder.MCpu = "cyclone";
518  }
519  TMBuilder.TheTriple = std::move(TheTriple);
520 }
521 
522 } // end anonymous namespace
523 
525  ThinLTOBuffer Buffer(Data, Identifier);
526  if (Modules.empty()) {
527  // First module added, so initialize the triple and some options
529  StringRef TripleStr;
531  Context, getBitcodeTargetTriple(Buffer.getMemBuffer()));
532  if (TripleOrErr)
533  TripleStr = *TripleOrErr;
534  Triple TheTriple(TripleStr);
535  initTMBuilder(TMBuilder, Triple(TheTriple));
536  }
537 #ifndef NDEBUG
538  else {
540  StringRef TripleStr;
542  Context, getBitcodeTargetTriple(Buffer.getMemBuffer()));
543  if (TripleOrErr)
544  TripleStr = *TripleOrErr;
545  assert(TMBuilder.TheTriple.str() == TripleStr &&
546  "ThinLTO modules with different triple not supported");
547  }
548 #endif
549  Modules.push_back(Buffer);
550 }
551 
553  PreservedSymbols.insert(Name);
554 }
555 
557  // FIXME: At the moment, we don't take advantage of this extra information,
558  // we're conservatively considering cross-references as preserved.
559  // CrossReferencedSymbols.insert(Name);
560  PreservedSymbols.insert(Name);
561 }
562 
563 // TargetMachine factory
564 std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const {
565  std::string ErrMsg;
566  const Target *TheTarget =
567  TargetRegistry::lookupTarget(TheTriple.str(), ErrMsg);
568  if (!TheTarget) {
569  report_fatal_error("Can't load target for this Triple: " + ErrMsg);
570  }
571 
572  // Use MAttr as the default set of features.
574  Features.getDefaultSubtargetFeatures(TheTriple);
575  std::string FeatureStr = Features.getString();
576 
577  return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
578  TheTriple.str(), MCpu, FeatureStr, Options, RelocModel,
580 }
581 
582 /**
583  * Produce the combined summary index from all the bitcode files:
584  * "thin-link".
585  */
586 std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
587  std::unique_ptr<ModuleSummaryIndex> CombinedIndex;
588  uint64_t NextModuleId = 0;
589  for (auto &ModuleBuffer : Modules) {
592  ModuleBuffer.getMemBuffer());
593  if (!ObjOrErr) {
594  // FIXME diagnose
596  ObjOrErr.takeError(), errs(),
597  "error: can't create ModuleSummaryIndexObjectFile for buffer: ");
598  return nullptr;
599  }
600  auto Index = (*ObjOrErr)->takeIndex();
601  if (CombinedIndex) {
602  CombinedIndex->mergeFrom(std::move(Index), ++NextModuleId);
603  } else {
604  CombinedIndex = std::move(Index);
605  }
606  }
607  return CombinedIndex;
608 }
609 
610 /**
611  * Perform promotion and renaming of exported internal functions.
612  * Index is updated to reflect linkage changes from weak resolution.
613  */
615  ModuleSummaryIndex &Index) {
616  auto ModuleCount = Index.modulePaths().size();
617  auto ModuleIdentifier = TheModule.getModuleIdentifier();
618 
619  // Collect for each module the list of function it defines (GUID -> Summary).
620  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries;
621  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
622 
623  // Convert the preserved symbols set from string to GUID
624  auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
625  PreservedSymbols, Triple(TheModule.getTargetTriple()));
626 
627  // Compute "dead" symbols, we don't want to import/export these!
628  auto DeadSymbols = computeDeadSymbols(Index, GUIDPreservedSymbols);
629 
630  // Generate import/export list
631  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
632  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
633  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
634  ExportLists, &DeadSymbols);
635 
636  // Resolve LinkOnce/Weak symbols.
638  resolveWeakForLinkerInIndex(Index, ResolvedODR);
639 
641  TheModule, ModuleToDefinedGVSummaries[ModuleIdentifier]);
642 
643  // Promote the exported values in the index, so that they are promoted
644  // in the module.
645  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
646  const auto &ExportList = ExportLists.find(ModuleIdentifier);
647  return (ExportList != ExportLists.end() &&
648  ExportList->second.count(GUID)) ||
649  GUIDPreservedSymbols.count(GUID);
650  };
651  thinLTOInternalizeAndPromoteInIndex(Index, isExported);
652 
653  promoteModule(TheModule, Index);
654 }
655 
656 /**
657  * Perform cross-module importing for the module identified by ModuleIdentifier.
658  */
660  ModuleSummaryIndex &Index) {
661  auto ModuleMap = generateModuleMap(Modules);
662  auto ModuleCount = Index.modulePaths().size();
663 
664  // Collect for each module the list of function it defines (GUID -> Summary).
665  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
666  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
667 
668  // Convert the preserved symbols set from string to GUID
669  auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
670  PreservedSymbols, Triple(TheModule.getTargetTriple()));
671 
672  // Compute "dead" symbols, we don't want to import/export these!
673  auto DeadSymbols = computeDeadSymbols(Index, GUIDPreservedSymbols);
674 
675  // Generate import/export list
676  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
677  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
678  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
679  ExportLists, &DeadSymbols);
680  auto &ImportList = ImportLists[TheModule.getModuleIdentifier()];
681 
682  crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
683 }
684 
685 /**
686  * Compute the list of summaries needed for importing into module.
687  */
689  StringRef ModulePath, ModuleSummaryIndex &Index,
690  std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex) {
691  auto ModuleCount = Index.modulePaths().size();
692 
693  // Collect for each module the list of function it defines (GUID -> Summary).
694  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
695  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
696 
697  // Generate import/export list
698  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
699  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
700  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
701  ExportLists);
702 
703  llvm::gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
704  ImportLists[ModulePath],
705  ModuleToSummariesForIndex);
706 }
707 
708 /**
709  * Emit the list of files needed for importing into module.
710  */
712  StringRef OutputName,
713  ModuleSummaryIndex &Index) {
714  auto ModuleCount = Index.modulePaths().size();
715 
716  // Collect for each module the list of function it defines (GUID -> Summary).
717  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
718  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
719 
720  // Generate import/export list
721  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
722  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
723  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
724  ExportLists);
725 
726  std::error_code EC;
727  if ((EC = EmitImportsFiles(ModulePath, OutputName, ImportLists[ModulePath])))
728  report_fatal_error(Twine("Failed to open ") + OutputName +
729  " to save imports lists\n");
730 }
731 
732 /**
733  * Perform internalization. Index is updated to reflect linkage changes.
734  */
736  ModuleSummaryIndex &Index) {
737  initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
738  auto ModuleCount = Index.modulePaths().size();
739  auto ModuleIdentifier = TheModule.getModuleIdentifier();
740 
741  // Convert the preserved symbols set from string to GUID
742  auto GUIDPreservedSymbols =
743  computeGUIDPreservedSymbols(PreservedSymbols, TMBuilder.TheTriple);
744 
745  // Collect for each module the list of function it defines (GUID -> Summary).
746  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
747  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
748 
749  // Compute "dead" symbols, we don't want to import/export these!
750  auto DeadSymbols = computeDeadSymbols(Index, GUIDPreservedSymbols);
751 
752  // Generate import/export list
753  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
754  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
755  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
756  ExportLists, &DeadSymbols);
757  auto &ExportList = ExportLists[ModuleIdentifier];
758 
759  // Be friendly and don't nuke totally the module when the client didn't
760  // supply anything to preserve.
761  if (ExportList.empty() && GUIDPreservedSymbols.empty())
762  return;
763 
764  // Internalization
765  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
766  const auto &ExportList = ExportLists.find(ModuleIdentifier);
767  return (ExportList != ExportLists.end() &&
768  ExportList->second.count(GUID)) ||
769  GUIDPreservedSymbols.count(GUID);
770  };
771  thinLTOInternalizeAndPromoteInIndex(Index, isExported);
772  thinLTOInternalizeModule(TheModule,
773  ModuleToDefinedGVSummaries[ModuleIdentifier]);
774 }
775 
776 /**
777  * Perform post-importing ThinLTO optimizations.
778  */
780  initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
781 
782  // Optimize now
783  optimizeModule(TheModule, *TMBuilder.create(), OptLevel);
784 }
785 
786 /**
787  * Perform ThinLTO CodeGen.
788  */
789 std::unique_ptr<MemoryBuffer> ThinLTOCodeGenerator::codegen(Module &TheModule) {
790  initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
791  return codegenModule(TheModule, *TMBuilder.create());
792 }
793 
794 /// Write out the generated object file, either from CacheEntryPath or from
795 /// OutputBuffer, preferring hard-link when possible.
796 /// Returns the path to the generated file in SavedObjectsDirectoryPath.
797 static std::string writeGeneratedObject(int count, StringRef CacheEntryPath,
798  StringRef SavedObjectsDirectoryPath,
799  const MemoryBuffer &OutputBuffer) {
800  SmallString<128> OutputPath(SavedObjectsDirectoryPath);
801  llvm::sys::path::append(OutputPath, Twine(count) + ".thinlto.o");
802  OutputPath.c_str(); // Ensure the string is null terminated.
803  if (sys::fs::exists(OutputPath))
804  sys::fs::remove(OutputPath);
805 
806  // We don't return a memory buffer to the linker, just a list of files.
807  if (!CacheEntryPath.empty()) {
808  // Cache is enabled, hard-link the entry (or copy if hard-link fails).
809  auto Err = sys::fs::create_hard_link(CacheEntryPath, OutputPath);
810  if (!Err)
811  return OutputPath.str();
812  // Hard linking failed, try to copy.
813  Err = sys::fs::copy_file(CacheEntryPath, OutputPath);
814  if (!Err)
815  return OutputPath.str();
816  // Copy failed (could be because the CacheEntry was removed from the cache
817  // in the meantime by another process), fall back and try to write down the
818  // buffer to the output.
819  errs() << "error: can't link or copy from cached entry '" << CacheEntryPath
820  << "' to '" << OutputPath << "'\n";
821  }
822  // No cache entry, just write out the buffer.
823  std::error_code Err;
824  raw_fd_ostream OS(OutputPath, Err, sys::fs::F_None);
825  if (Err)
826  report_fatal_error("Can't open output '" + OutputPath + "'\n");
827  OS << OutputBuffer.getBuffer();
828  return OutputPath.str();
829 }
830 
831 // Main entry point for the ThinLTO processing
833  // Prepare the resulting object vector
834  assert(ProducedBinaries.empty() && "The generator should not be reused");
835  if (SavedObjectsDirectoryPath.empty())
836  ProducedBinaries.resize(Modules.size());
837  else {
838  sys::fs::create_directories(SavedObjectsDirectoryPath);
839  bool IsDir;
840  sys::fs::is_directory(SavedObjectsDirectoryPath, IsDir);
841  if (!IsDir)
842  report_fatal_error("Unexistent dir: '" + SavedObjectsDirectoryPath + "'");
843  ProducedBinaryFiles.resize(Modules.size());
844  }
845 
846  if (CodeGenOnly) {
847  // Perform only parallel codegen and return.
848  ThreadPool Pool;
849  int count = 0;
850  for (auto &ModuleBuffer : Modules) {
851  Pool.async([&](int count) {
854 
855  // Parse module now
856  auto TheModule =
857  loadModuleFromBuffer(ModuleBuffer.getMemBuffer(), Context, false,
858  /*IsImporting*/ false);
859 
860  // CodeGen
861  auto OutputBuffer = codegen(*TheModule);
862  if (SavedObjectsDirectoryPath.empty())
863  ProducedBinaries[count] = std::move(OutputBuffer);
864  else
865  ProducedBinaryFiles[count] = writeGeneratedObject(
866  count, "", SavedObjectsDirectoryPath, *OutputBuffer);
867  }, count++);
868  }
869 
870  return;
871  }
872 
873  // Sequential linking phase
874  auto Index = linkCombinedIndex();
875 
876  // Save temps: index.
877  if (!SaveTempsDir.empty()) {
878  auto SaveTempPath = SaveTempsDir + "index.bc";
879  std::error_code EC;
880  raw_fd_ostream OS(SaveTempPath, EC, sys::fs::F_None);
881  if (EC)
882  report_fatal_error(Twine("Failed to open ") + SaveTempPath +
883  " to save optimized bitcode\n");
884  WriteIndexToFile(*Index, OS);
885  }
886 
887 
888  // Prepare the module map.
889  auto ModuleMap = generateModuleMap(Modules);
890  auto ModuleCount = Modules.size();
891 
892  // Collect for each module the list of function it defines (GUID -> Summary).
893  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
894  Index->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
895 
896  // Convert the preserved symbols set from string to GUID, this is needed for
897  // computing the caching hash and the internalization.
898  auto GUIDPreservedSymbols =
899  computeGUIDPreservedSymbols(PreservedSymbols, TMBuilder.TheTriple);
900 
901  // Compute "dead" symbols, we don't want to import/export these!
902  auto DeadSymbols = computeDeadSymbols(*Index, GUIDPreservedSymbols);
903 
904  // Collect the import/export lists for all modules from the call-graph in the
905  // combined index.
906  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
907  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
908  ComputeCrossModuleImport(*Index, ModuleToDefinedGVSummaries, ImportLists,
909  ExportLists, &DeadSymbols);
910 
911  // We use a std::map here to be able to have a defined ordering when
912  // producing a hash for the cache entry.
913  // FIXME: we should be able to compute the caching hash for the entry based
914  // on the index, and nuke this map.
916 
917  // Resolve LinkOnce/Weak symbols, this has to be computed early because it
918  // impacts the caching.
919  resolveWeakForLinkerInIndex(*Index, ResolvedODR);
920 
921  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
922  const auto &ExportList = ExportLists.find(ModuleIdentifier);
923  return (ExportList != ExportLists.end() &&
924  ExportList->second.count(GUID)) ||
925  GUIDPreservedSymbols.count(GUID);
926  };
927 
928  // Use global summary-based analysis to identify symbols that can be
929  // internalized (because they aren't exported or preserved as per callback).
930  // Changes are made in the index, consumed in the ThinLTO backends.
931  thinLTOInternalizeAndPromoteInIndex(*Index, isExported);
932 
933  // Make sure that every module has an entry in the ExportLists and
934  // ResolvedODR maps to enable threaded access to these maps below.
935  for (auto &DefinedGVSummaries : ModuleToDefinedGVSummaries) {
936  ExportLists[DefinedGVSummaries.first()];
937  ResolvedODR[DefinedGVSummaries.first()];
938  }
939 
940  // Compute the ordering we will process the inputs: the rough heuristic here
941  // is to sort them per size so that the largest module get schedule as soon as
942  // possible. This is purely a compile-time optimization.
943  std::vector<int> ModulesOrdering;
944  ModulesOrdering.resize(Modules.size());
945  std::iota(ModulesOrdering.begin(), ModulesOrdering.end(), 0);
946  std::sort(ModulesOrdering.begin(), ModulesOrdering.end(),
947  [&](int LeftIndex, int RightIndex) {
948  auto LSize = Modules[LeftIndex].getBuffer().size();
949  auto RSize = Modules[RightIndex].getBuffer().size();
950  return LSize > RSize;
951  });
952 
953  // Parallel optimizer + codegen
954  {
955  ThreadPool Pool(ThreadCount);
956  for (auto IndexCount : ModulesOrdering) {
957  auto &ModuleBuffer = Modules[IndexCount];
958  Pool.async([&](int count) {
959  auto ModuleIdentifier = ModuleBuffer.getBufferIdentifier();
960  auto &ExportList = ExportLists[ModuleIdentifier];
961 
962  auto &DefinedFunctions = ModuleToDefinedGVSummaries[ModuleIdentifier];
963 
964  // The module may be cached, this helps handling it.
965  ModuleCacheEntry CacheEntry(CacheOptions.Path, *Index, ModuleIdentifier,
966  ImportLists[ModuleIdentifier], ExportList,
967  ResolvedODR[ModuleIdentifier],
968  DefinedFunctions, GUIDPreservedSymbols,
969  OptLevel, TMBuilder);
970  auto CacheEntryPath = CacheEntry.getEntryPath();
971 
972  {
973  auto ErrOrBuffer = CacheEntry.tryLoadingBuffer();
974  DEBUG(dbgs() << "Cache " << (ErrOrBuffer ? "hit" : "miss") << " '"
975  << CacheEntryPath << "' for buffer " << count << " "
976  << ModuleIdentifier << "\n");
977 
978  if (ErrOrBuffer) {
979  // Cache Hit!
980  if (SavedObjectsDirectoryPath.empty())
981  ProducedBinaries[count] = std::move(ErrOrBuffer.get());
982  else
983  ProducedBinaryFiles[count] = writeGeneratedObject(
984  count, CacheEntryPath, SavedObjectsDirectoryPath,
985  *ErrOrBuffer.get());
986  return;
987  }
988  }
989 
992  Context.enableDebugTypeODRUniquing();
993  auto DiagFileOrErr = setupOptimizationRemarks(Context, count);
994  if (!DiagFileOrErr) {
995  errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
996  report_fatal_error("ThinLTO: Can't get an output file for the "
997  "remarks");
998  }
999 
1000  // Parse module now
1001  auto TheModule =
1002  loadModuleFromBuffer(ModuleBuffer.getMemBuffer(), Context, false,
1003  /*IsImporting*/ false);
1004 
1005  // Save temps: original file.
1006  saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");
1007 
1008  auto &ImportList = ImportLists[ModuleIdentifier];
1009  // Run the main process now, and generates a binary
1010  auto OutputBuffer = ProcessThinLTOModule(
1011  *TheModule, *Index, ModuleMap, *TMBuilder.create(), ImportList,
1012  ExportList, GUIDPreservedSymbols,
1013  ModuleToDefinedGVSummaries[ModuleIdentifier], CacheOptions,
1014  DisableCodeGen, SaveTempsDir, OptLevel, count);
1015 
1016  // Commit to the cache (if enabled)
1017  CacheEntry.write(*OutputBuffer);
1018 
1019  if (SavedObjectsDirectoryPath.empty()) {
1020  // We need to generated a memory buffer for the linker.
1021  if (!CacheEntryPath.empty()) {
1022  // Cache is enabled, reload from the cache
1023  // We do this to lower memory pressuree: the buffer is on the heap
1024  // and releasing it frees memory that can be used for the next input
1025  // file. The final binary link will read from the VFS cache
1026  // (hopefully!) or from disk if the memory pressure wasn't too high.
1027  auto ReloadedBufferOrErr = CacheEntry.tryLoadingBuffer();
1028  if (auto EC = ReloadedBufferOrErr.getError()) {
1029  // On error, keeping the preexisting buffer and printing a
1030  // diagnostic is more friendly than just crashing.
1031  errs() << "error: can't reload cached file '" << CacheEntryPath
1032  << "': " << EC.message() << "\n";
1033  } else {
1034  OutputBuffer = std::move(*ReloadedBufferOrErr);
1035  }
1036  }
1037  ProducedBinaries[count] = std::move(OutputBuffer);
1038  return;
1039  }
1040  ProducedBinaryFiles[count] = writeGeneratedObject(
1041  count, CacheEntryPath, SavedObjectsDirectoryPath, *OutputBuffer);
1042  }, IndexCount);
1043  }
1044  }
1045 
1046  CachePruning(CacheOptions.Path)
1047  .setPruningInterval(std::chrono::seconds(CacheOptions.PruningInterval))
1048  .setEntryExpiration(std::chrono::seconds(CacheOptions.Expiration))
1050  .prune();
1051 
1052  // If statistics were requested, print them out now.
1055 }
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
Definition: StringRef.h:634
void print(const char *ProgName, raw_ostream &S, bool ShowColors=true, bool ShowKindLabel=true) const
Definition: SourceMgr.cpp:336
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:882
Represents either an error or a value T.
Definition: ErrorOr.h:68
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
std::vector< std::unique_ptr< GlobalValueSummary > > GlobalValueSummaryList
List of global value summary structures for a particular value held in the GlobalValueMap.
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:575
LLVMContext & Context
PassManagerBuilder - This class is used to set up a standard optimization sequence for languages like...
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
Definition: GlobalValue.h:465
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
const ModuleHash & getModuleHash(const StringRef ModPath) const
Get the module SHA1 hash recorded for the given module path.
void getDefaultSubtargetFeatures(const Triple &Triple)
Adds the default features for the specified target triple.
void setDiagnosticsOutputFile(std::unique_ptr< yaml::Output > F)
Set the diagnostics output file used for optimization diagnostics.
void promote(Module &Module, ModuleSummaryIndex &Index)
Perform promotion and renaming of exported internal functions, and additionally resolve weak and link...
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:121
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
Expected< std::unique_ptr< Module > > getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata=false, bool IsImporting=false)
Read the header of the specified bitcode buffer and prepare for lazy deserialization of function bodi...
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:473
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner)
Log all errors (if any) in E to OS.
This is the interface to build a ModuleSummaryIndex for a module.
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
This file provides a bitcode writing pass.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:202
void populateThinLTOPassManager(legacy::PassManagerBase &PM)
unsigned DataSections
Emit data into separate sections.
std::unique_ptr< TargetMachine > create() const
Analysis providing profile information.
static Expected< std::unique_ptr< ModuleSummaryIndexObjectFile > > create(MemoryBufferRef Object)
Parse module summary index in the given memory buffer.
void enableDebugTypeODRUniquing()
ImmutablePass * createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA)
Create an analysis pass wrapper around a TTI object.
CachePruning & setEntryExpiration(std::chrono::seconds ExpireAfter)
Define the expiration for a file.
Definition: CachePruning.h:41
iterator find(StringRef Key)
Definition: StringMap.h:315
StringRef getBuffer() const
Definition: MemoryBuffer.h:59
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:490
Implementation of the target library information.
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:736
const std::string & str() const
Definition: Triple.h:339
A class that wrap the SHA1 algorithm.
Definition: SHA1.h:29
Error takeError()
Take ownership of the stored error.
static const Target * lookupTarget(const std::string &Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
void addModule(StringRef Identifier, StringRef Data)
Add given module to the code generator.
Base class for error info classes.
Definition: Support/Error.h:46
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:218
Pass * Inliner
Inliner - Specifies the inliner to use.
void setDiscardValueNames(bool Discard)
Set the Context runtime configuration to discard all value name (but GlobalValue).
ModuleSummaryIndex buildModuleSummaryIndex(const Module &M, std::function< BlockFrequencyInfo *(const Function &F)> GetBFICallback, ProfileSummaryInfo *PSI)
Direct function to compute a ModuleSummaryIndex from a given module.
Wrapper around MemoryBufferRef, owning the identifier.
const Triple & getTargetTriple() const
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:448
std::unordered_set< GlobalValue::GUID > ExportSetTy
The set contains an entry for every global value the module exports.
std::string toString(Error E)
Write all error messages (if any) in E to a string.
void add(Pass *P) override
Add a pass to the queue of passes to run.
std::unique_ptr< MemoryBuffer > codegen(Module &Module)
Perform ThinLTO CodeGen.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
void setDiagnosticHotnessRequested(bool Requested)
Set if a code hotness metric should be included in optimization diagnostics.
MemoryBufferRef getMemBuffer() const
Tagged union holding either a T or a Error.
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:341
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:193
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:261
void run()
Process all the modules that were added to the code generator in parallel.
static std::string toHex(StringRef Input)
Convert buffer Input to its hexadecimal representation.
Definition: StringExtras.h:65
#define F(x, y, z)
Definition: MD5.cpp:51
cl::opt< bool > LTOPassRemarksWithHotness("lto-pass-remarks-with-hotness", cl::desc("With PGO, include profile count in optimization remarks"), cl::Hidden)
Pass * createObjCARCContractPass()
unsigned OptLevel
The Optimization Level - Specify the basic optimization level.
const StringMap< std::pair< uint64_t, ModuleHash > > & modulePaths() const
Table of modules, containing module hash and id.
unsigned FunctionSections
Emit functions into separate sections.
static std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:79
A ThreadPool for asynchronous parallel execution on a defined number of threads.
Definition: ThreadPool.h:51
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:270
auto count(R &&Range, const E &Element) -> typename std::iterator_traits< decltype(std::begin(Range))>::difference_type
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:791
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:135
Class to hold module path string table and global value map, and encapsulate methods for operating on...
void update(ArrayRef< uint8_t > Data)
Digest more data.
Definition: SHA1.cpp:213
bool isWeakForLinker() const
Definition: GlobalValue.h:435
PassManager manages ModulePassManagers.
std::error_code copy_file(const Twine &From, const Twine &To)
Copy the contents of From to To.
Definition: Path.cpp:906
std::shared_future< VoidTy > async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
Definition: ThreadPool.h:78
DebuggerKind DebuggerTuning
Which debugger to tune for.
void crossReferenceSymbol(StringRef Name)
Adds to a list of all global symbols that are cross-referenced between ThinLTO files.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
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.
void optimize(Module &Module)
Perform post-importing ThinLTO optimizations.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
CachePruning & setMaxSize(unsigned Percentage)
Define the maximum size for the cache directory, in terms of percentage of the available space on the...
Definition: CachePruning.h:51
TargetLibraryInfoImpl * LibraryInfo
LibraryInfo - Specifies information about the runtime library for the optimizer.
Helper to gather options relevant to the target machine creation.
virtual TargetIRAnalysis getTargetIRAnalysis()
Get a TargetIRAnalysis appropriate for the target.
unsigned size() const
Definition: StringMap.h:114
Expected< std::string > getBitcodeTargetTriple(MemoryBufferRef Buffer)
Read the header of the specified bitcode buffer and extract just the triple information.
void handleAllErrors(Error E, HandlerTs &&...Handlers)
Behaves the same as handleErrors, except that it requires that all errors be handled by the given han...
std::error_code create_hard_link(const Twine &to, const Twine &from)
Create a hard link from from to to, or return an error.
Function and variable summary information to aid decisions and implementation of importing.
void ComputeCrossModuleImport(const ModuleSummaryIndex &Index, const StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries, StringMap< FunctionImporter::ImportMapTy > &ImportLists, StringMap< FunctionImporter::ExportSetTy > &ExportLists, const DenseSet< GlobalValue::GUID > *DeadSymbols=nullptr)
Compute all the imports and exports for every module in the Index.
static void write(bool isBE, void *P, T V)
bool prune()
Peform pruning using the supplied options, returns true if pruning occured, i.e.
std::string getString() const
Features string accessors.
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
bool is_directory(file_status status)
Does status represent a directory?
Definition: Path.cpp:948
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
static std::string writeGeneratedObject(int count, StringRef CacheEntryPath, StringRef SavedObjectsDirectoryPath, const MemoryBuffer &OutputBuffer)
Write out the generated object file, either from CacheEntryPath or from OutputBuffer, preferring hard-link when possible.
std::error_code rename(const Twine &from, const Twine &to)
Rename from to to.
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
Definition: Triple.h:455
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, CodeModel::Model CM=CodeModel::Default, CodeGenOpt::Level OL=CodeGenOpt::Default) const
createTargetMachine - Create a target specific machine implementation for the specified Triple...
virtual bool addPassesToEmitFile(PassManagerBase &, raw_pwrite_stream &, CodeGenFileType, bool=true, AnalysisID=nullptr, AnalysisID=nullptr, AnalysisID=nullptr, AnalysisID=nullptr, MachineFunctionInitializer *=nullptr)
Add passes to the specified pass manager to get the specified file emitted.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
static bool isAvailableExternallyLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:273
bool renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index, DenseSet< const GlobalValue * > *GlobalsToImport=nullptr)
Perform in-place global value handling on the given Module for exported local functions renamed and p...
reference get()
Returns a reference to the stored T value.
std::error_code EmitImportsFiles(StringRef ModulePath, StringRef OutputFilename, const FunctionImporter::ImportMapTy &ModuleImports)
Emit into OutputFilename the files module ModulePath will import from.
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:40
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:223
Target - Wrapper for Target specific information.
SubtargetFeatures - Manages the enabling and disabling of subtarget specific features.
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:267
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
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 ...
void collectDefinedGVSummariesPerModule(StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries) const
Collect for each module the list of Summaries it defines (GUID -> Summary).
std::unique_ptr< ModuleSummaryIndex > linkCombinedIndex()
Produce the combined summary index from all the bitcode files: "thin-link".
unsigned RelaxELFRelocations
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:130
static void gatherImportedSummariesForModule(StringRef ModulePath, ModuleSummaryIndex &Index, std::map< std::string, GVSummaryMapTy > &ModuleToSummariesForIndex)
Compute the list of summaries needed for importing into module.
Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context)
Read the specified bitcode file, returning the module.
cl::opt< bool > LTODiscardValueNames("lto-discard-value-names", cl::desc("Strip names from Value during LTO (other than GlobalValue)."), cl::init(false), cl::Hidden)
ErrorOr< T > expectedToErrorOrAndEmitErrors(LLVMContext &Ctx, Expected< T > Val)
Definition: BitcodeReader.h:37
std::map< GlobalValue::GUID, GlobalValueSummary * > GVSummaryMapTy
Map of global value GUID to its summary, used to identify values defined in a particular module...
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:357
size_type count(const ValueT &V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:81
void WriteBitcodeToFile(const Module *M, raw_ostream &Out, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false)
Write the specified module to the specified raw output stream.
void thinLTOResolveWeakForLinkerInIndex(ModuleSummaryIndex &Index, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, function_ref< void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> recordNewLinkage)
Resolve Weak and LinkOnce values in the Index.
Definition: LTO.cpp:182
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatileSize=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD, SmallVectorImpl< char > &ResultPath)
Create a file in the system temporary directory.
Definition: Path.cpp:794
DenseSet< GlobalValue::GUID > computeDeadSymbols(const ModuleSummaryIndex &Index, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols)
Compute all the symbols that are "dead": i.e these that can't be reached in the graph from any of t...
const char * c_str()
Definition: SmallString.h:270
#define I(x, y, z)
Definition: MD5.cpp:54
void thinLTOInternalizeModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals)
Internalize TheModule based on the information recorded in the summaries during global summary-based ...
void preserveSymbol(StringRef Name)
Adds to a list of all global symbols that must exist in the final generated code. ...
void thinLTOResolveWeakForLinkerModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals)
Resolve WeakForLinker values in TheModule based on the information recorded in the summaries during g...
void crossModuleImport(Module &Module, ModuleSummaryIndex &Index)
Perform cross-module importing for the module identified by ModuleIdentifier.
void PrintStatistics()
Print statistics to the file returned by CreateInfoOutputFile().
Definition: Statistic.cpp:183
Optional< Reloc::Model > RelocModel
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef getBufferIdentifier() const
Definition: MemoryBuffer.h:171
Pass * createFunctionInliningPass()
createFunctionInliningPass - Return a new pass object that uses a heuristic to inline direct function...
void internalize(Module &Module, ModuleSummaryIndex &Index)
Perform internalization.
The function importer is automatically importing function from other modules based on the provided su...
const FeatureBitset Features
CachePruning & setPruningInterval(std::chrono::seconds PruningInterval)
Define the pruning interval.
Definition: CachePruning.h:33
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:23
#define DEBUG(X)
Definition: Debug.h:100
Primary interface to the complete machine description for the target machine.
static void emitImports(StringRef ModulePath, StringRef OutputName, ModuleSummaryIndex &Index)
Compute and emit the imported files for module at ModulePath.
void mergeFrom(std::unique_ptr< ModuleSummaryIndex > Other, uint64_t NextModuleId)
Add the given per-module index into this module index/summary, assigning it the given module ID...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
This pass exposes codegen information to IR-level passes.
bool exists(file_status status)
Does file exist?
Definition: Path.cpp:940
auto find_if(R &&Range, UnaryPredicate P) -> decltype(std::begin(Range))
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:764
bool AreStatisticsEnabled()
Check if statistics are enabled.
Definition: Statistic.cpp:112
iterator end()
Definition: StringMap.h:305
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:216
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:222
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:228
Handle pruning a directory provided a path and some options to control what to prune.
Definition: CachePruning.h:25