xref: /freebsd-src/contrib/llvm-project/llvm/lib/LTO/ThinLTOCodeGenerator.cpp (revision 81ad626541db97eb356e2c1d4a20eb2a26a766ab) 
1 //===-ThinLTOCodeGenerator.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 the Thin Link Time Optimization library. This library is
10 // intended to be used by linker to optimize code at link time.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/LTO/legacy/ThinLTOCodeGenerator.h"
15 #include "llvm/Support/CommandLine.h"
16 
17 #include "llvm/ADT/ScopeExit.h"
18 #include "llvm/ADT/Statistic.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/Analysis/AliasAnalysis.h"
21 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
22 #include "llvm/Analysis/ProfileSummaryInfo.h"
23 #include "llvm/Analysis/TargetLibraryInfo.h"
24 #include "llvm/Bitcode/BitcodeReader.h"
25 #include "llvm/Bitcode/BitcodeWriter.h"
26 #include "llvm/Bitcode/BitcodeWriterPass.h"
27 #include "llvm/Config/llvm-config.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/DiagnosticPrinter.h"
30 #include "llvm/IR/LegacyPassManager.h"
31 #include "llvm/IR/LLVMContext.h"
32 #include "llvm/IR/LLVMRemarkStreamer.h"
33 #include "llvm/IR/Mangler.h"
34 #include "llvm/IR/PassTimingInfo.h"
35 #include "llvm/IR/Verifier.h"
36 #include "llvm/IRReader/IRReader.h"
37 #include "llvm/LTO/LTO.h"
38 #include "llvm/LTO/SummaryBasedOptimizations.h"
39 #include "llvm/MC/SubtargetFeature.h"
40 #include "llvm/MC/TargetRegistry.h"
41 #include "llvm/Object/IRObjectFile.h"
42 #include "llvm/Passes/PassBuilder.h"
43 #include "llvm/Passes/StandardInstrumentations.h"
44 #include "llvm/Remarks/HotnessThresholdParser.h"
45 #include "llvm/Support/CachePruning.h"
46 #include "llvm/Support/Debug.h"
47 #include "llvm/Support/Error.h"
48 #include "llvm/Support/FileUtilities.h"
49 #include "llvm/Support/Path.h"
50 #include "llvm/Support/SHA1.h"
51 #include "llvm/Support/SmallVectorMemoryBuffer.h"
52 #include "llvm/Support/ThreadPool.h"
53 #include "llvm/Support/Threading.h"
54 #include "llvm/Support/ToolOutputFile.h"
55 #include "llvm/Target/TargetMachine.h"
56 #include "llvm/Transforms/IPO/FunctionAttrs.h"
57 #include "llvm/Transforms/IPO/FunctionImport.h"
58 #include "llvm/Transforms/IPO/Internalize.h"
59 #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
60 #include "llvm/Transforms/ObjCARC.h"
61 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
62 
63 #include <numeric>
64 
65 #if !defined(_MSC_VER) && !defined(__MINGW32__)
66 #include <unistd.h>
67 #else
68 #include <io.h>
69 #endif
70 
71 using namespace llvm;
72 
73 #define DEBUG_TYPE "thinlto"
74 
75 namespace llvm {
76 // Flags -discard-value-names, defined in LTOCodeGenerator.cpp
77 extern cl::opt<bool> LTODiscardValueNames;
78 extern cl::opt<std::string> RemarksFilename;
79 extern cl::opt<std::string> RemarksPasses;
80 extern cl::opt<bool> RemarksWithHotness;
81 extern cl::opt<Optional<uint64_t>, false, remarks::HotnessThresholdParser>
82     RemarksHotnessThreshold;
83 extern cl::opt<std::string> RemarksFormat;
84 }
85 
86 namespace {
87 
88 // Default to using all available threads in the system, but using only one
89 // thred per core, as indicated by the usage of
90 // heavyweight_hardware_concurrency() below.
91 static cl::opt<int> ThreadCount("threads", cl::init(0));
92 
93 // Simple helper to save temporary files for debug.
94 static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
95                             unsigned count, StringRef Suffix) {
96   if (TempDir.empty())
97     return;
98   // User asked to save temps, let dump the bitcode file after import.
99   std::string SaveTempPath = (TempDir + llvm::Twine(count) + Suffix).str();
100   std::error_code EC;
101   raw_fd_ostream OS(SaveTempPath, EC, sys::fs::OF_None);
102   if (EC)
103     report_fatal_error(Twine("Failed to open ") + SaveTempPath +
104                        " to save optimized bitcode\n");
105   WriteBitcodeToFile(TheModule, OS, /* ShouldPreserveUseListOrder */ true);
106 }
107 
108 static const GlobalValueSummary *
109 getFirstDefinitionForLinker(const GlobalValueSummaryList &GVSummaryList) {
110   // If there is any strong definition anywhere, get it.
111   auto StrongDefForLinker = llvm::find_if(
112       GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
113         auto Linkage = Summary->linkage();
114         return !GlobalValue::isAvailableExternallyLinkage(Linkage) &&
115                !GlobalValue::isWeakForLinker(Linkage);
116       });
117   if (StrongDefForLinker != GVSummaryList.end())
118     return StrongDefForLinker->get();
119   // Get the first *linker visible* definition for this global in the summary
120   // list.
121   auto FirstDefForLinker = llvm::find_if(
122       GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
123         auto Linkage = Summary->linkage();
124         return !GlobalValue::isAvailableExternallyLinkage(Linkage);
125       });
126   // Extern templates can be emitted as available_externally.
127   if (FirstDefForLinker == GVSummaryList.end())
128     return nullptr;
129   return FirstDefForLinker->get();
130 }
131 
132 // Populate map of GUID to the prevailing copy for any multiply defined
133 // symbols. Currently assume first copy is prevailing, or any strong
134 // definition. Can be refined with Linker information in the future.
135 static void computePrevailingCopies(
136     const ModuleSummaryIndex &Index,
137     DenseMap<GlobalValue::GUID, const GlobalValueSummary *> &PrevailingCopy) {
138   auto HasMultipleCopies = [&](const GlobalValueSummaryList &GVSummaryList) {
139     return GVSummaryList.size() > 1;
140   };
141 
142   for (auto &I : Index) {
143     if (HasMultipleCopies(I.second.SummaryList))
144       PrevailingCopy[I.first] =
145           getFirstDefinitionForLinker(I.second.SummaryList);
146   }
147 }
148 
149 static StringMap<lto::InputFile *>
150 generateModuleMap(std::vector<std::unique_ptr<lto::InputFile>> &Modules) {
151   StringMap<lto::InputFile *> ModuleMap;
152   for (auto &M : Modules) {
153     assert(ModuleMap.find(M->getName()) == ModuleMap.end() &&
154            "Expect unique Buffer Identifier");
155     ModuleMap[M->getName()] = M.get();
156   }
157   return ModuleMap;
158 }
159 
160 static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index,
161                           bool ClearDSOLocalOnDeclarations) {
162   if (renameModuleForThinLTO(TheModule, Index, ClearDSOLocalOnDeclarations))
163     report_fatal_error("renameModuleForThinLTO failed");
164 }
165 
166 namespace {
167 class ThinLTODiagnosticInfo : public DiagnosticInfo {
168   const Twine &Msg;
169 public:
170   ThinLTODiagnosticInfo(const Twine &DiagMsg,
171                         DiagnosticSeverity Severity = DS_Error)
172       : DiagnosticInfo(DK_Linker, Severity), Msg(DiagMsg) {}
173   void print(DiagnosticPrinter &DP) const override { DP << Msg; }
174 };
175 }
176 
177 /// Verify the module and strip broken debug info.
178 static void verifyLoadedModule(Module &TheModule) {
179   bool BrokenDebugInfo = false;
180   if (verifyModule(TheModule, &dbgs(), &BrokenDebugInfo))
181     report_fatal_error("Broken module found, compilation aborted!");
182   if (BrokenDebugInfo) {
183     TheModule.getContext().diagnose(ThinLTODiagnosticInfo(
184         "Invalid debug info found, debug info will be stripped", DS_Warning));
185     StripDebugInfo(TheModule);
186   }
187 }
188 
189 static std::unique_ptr<Module> loadModuleFromInput(lto::InputFile *Input,
190                                                    LLVMContext &Context,
191                                                    bool Lazy,
192                                                    bool IsImporting) {
193   auto &Mod = Input->getSingleBitcodeModule();
194   SMDiagnostic Err;
195   Expected<std::unique_ptr<Module>> ModuleOrErr =
196       Lazy ? Mod.getLazyModule(Context,
197                                /* ShouldLazyLoadMetadata */ true, IsImporting)
198            : Mod.parseModule(Context);
199   if (!ModuleOrErr) {
200     handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
201       SMDiagnostic Err = SMDiagnostic(Mod.getModuleIdentifier(),
202                                       SourceMgr::DK_Error, EIB.message());
203       Err.print("ThinLTO", errs());
204     });
205     report_fatal_error("Can't load module, abort.");
206   }
207   if (!Lazy)
208     verifyLoadedModule(*ModuleOrErr.get());
209   return std::move(*ModuleOrErr);
210 }
211 
212 static void
213 crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
214                       StringMap<lto::InputFile *> &ModuleMap,
215                       const FunctionImporter::ImportMapTy &ImportList,
216                       bool ClearDSOLocalOnDeclarations) {
217   auto Loader = [&](StringRef Identifier) {
218     auto &Input = ModuleMap[Identifier];
219     return loadModuleFromInput(Input, TheModule.getContext(),
220                                /*Lazy=*/true, /*IsImporting*/ true);
221   };
222 
223   FunctionImporter Importer(Index, Loader, ClearDSOLocalOnDeclarations);
224   Expected<bool> Result = Importer.importFunctions(TheModule, ImportList);
225   if (!Result) {
226     handleAllErrors(Result.takeError(), [&](ErrorInfoBase &EIB) {
227       SMDiagnostic Err = SMDiagnostic(TheModule.getModuleIdentifier(),
228                                       SourceMgr::DK_Error, EIB.message());
229       Err.print("ThinLTO", errs());
230     });
231     report_fatal_error("importFunctions failed");
232   }
233   // Verify again after cross-importing.
234   verifyLoadedModule(TheModule);
235 }
236 
237 static void optimizeModule(Module &TheModule, TargetMachine &TM,
238                            unsigned OptLevel, bool Freestanding,
239                            bool DebugPassManager, ModuleSummaryIndex *Index) {
240   Optional<PGOOptions> PGOOpt;
241   LoopAnalysisManager LAM;
242   FunctionAnalysisManager FAM;
243   CGSCCAnalysisManager CGAM;
244   ModuleAnalysisManager MAM;
245 
246   PassInstrumentationCallbacks PIC;
247   StandardInstrumentations SI(DebugPassManager);
248   SI.registerCallbacks(PIC, &FAM);
249   PipelineTuningOptions PTO;
250   PTO.LoopVectorization = true;
251   PTO.SLPVectorization = true;
252   PassBuilder PB(&TM, PTO, PGOOpt, &PIC);
253 
254   std::unique_ptr<TargetLibraryInfoImpl> TLII(
255       new TargetLibraryInfoImpl(Triple(TM.getTargetTriple())));
256   if (Freestanding)
257     TLII->disableAllFunctions();
258   FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
259 
260   // Register all the basic analyses with the managers.
261   PB.registerModuleAnalyses(MAM);
262   PB.registerCGSCCAnalyses(CGAM);
263   PB.registerFunctionAnalyses(FAM);
264   PB.registerLoopAnalyses(LAM);
265   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
266 
267   ModulePassManager MPM;
268 
269   OptimizationLevel OL;
270 
271   switch (OptLevel) {
272   default:
273     llvm_unreachable("Invalid optimization level");
274   case 0:
275     OL = OptimizationLevel::O0;
276     break;
277   case 1:
278     OL = OptimizationLevel::O1;
279     break;
280   case 2:
281     OL = OptimizationLevel::O2;
282     break;
283   case 3:
284     OL = OptimizationLevel::O3;
285     break;
286   }
287 
288   MPM.addPass(PB.buildThinLTODefaultPipeline(OL, Index));
289 
290   MPM.run(TheModule, MAM);
291 }
292 
293 static void
294 addUsedSymbolToPreservedGUID(const lto::InputFile &File,
295                              DenseSet<GlobalValue::GUID> &PreservedGUID) {
296   for (const auto &Sym : File.symbols()) {
297     if (Sym.isUsed())
298       PreservedGUID.insert(GlobalValue::getGUID(Sym.getIRName()));
299   }
300 }
301 
302 // Convert the PreservedSymbols map from "Name" based to "GUID" based.
303 static void computeGUIDPreservedSymbols(const lto::InputFile &File,
304                                         const StringSet<> &PreservedSymbols,
305                                         const Triple &TheTriple,
306                                         DenseSet<GlobalValue::GUID> &GUIDs) {
307   // Iterate the symbols in the input file and if the input has preserved symbol
308   // compute the GUID for the symbol.
309   for (const auto &Sym : File.symbols()) {
310     if (PreservedSymbols.count(Sym.getName()) && !Sym.getIRName().empty())
311       GUIDs.insert(GlobalValue::getGUID(GlobalValue::getGlobalIdentifier(
312           Sym.getIRName(), GlobalValue::ExternalLinkage, "")));
313   }
314 }
315 
316 static DenseSet<GlobalValue::GUID>
317 computeGUIDPreservedSymbols(const lto::InputFile &File,
318                             const StringSet<> &PreservedSymbols,
319                             const Triple &TheTriple) {
320   DenseSet<GlobalValue::GUID> GUIDPreservedSymbols(PreservedSymbols.size());
321   computeGUIDPreservedSymbols(File, PreservedSymbols, TheTriple,
322                               GUIDPreservedSymbols);
323   return GUIDPreservedSymbols;
324 }
325 
326 std::unique_ptr<MemoryBuffer> codegenModule(Module &TheModule,
327                                             TargetMachine &TM) {
328   SmallVector<char, 128> OutputBuffer;
329 
330   // CodeGen
331   {
332     raw_svector_ostream OS(OutputBuffer);
333     legacy::PassManager PM;
334 
335     // If the bitcode files contain ARC code and were compiled with optimization,
336     // the ObjCARCContractPass must be run, so do it unconditionally here.
337     PM.add(createObjCARCContractPass());
338 
339     // Setup the codegen now.
340     if (TM.addPassesToEmitFile(PM, OS, nullptr, CGFT_ObjectFile,
341                                /* DisableVerify */ true))
342       report_fatal_error("Failed to setup codegen");
343 
344     // Run codegen now. resulting binary is in OutputBuffer.
345     PM.run(TheModule);
346   }
347   return std::make_unique<SmallVectorMemoryBuffer>(
348       std::move(OutputBuffer), /*RequiresNullTerminator=*/false);
349 }
350 
351 /// Manage caching for a single Module.
352 class ModuleCacheEntry {
353   SmallString<128> EntryPath;
354 
355 public:
356   // Create a cache entry. This compute a unique hash for the Module considering
357   // the current list of export/import, and offer an interface to query to
358   // access the content in the cache.
359   ModuleCacheEntry(
360       StringRef CachePath, const ModuleSummaryIndex &Index, StringRef ModuleID,
361       const FunctionImporter::ImportMapTy &ImportList,
362       const FunctionImporter::ExportSetTy &ExportList,
363       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
364       const GVSummaryMapTy &DefinedGVSummaries, unsigned OptLevel,
365       bool Freestanding, const TargetMachineBuilder &TMBuilder) {
366     if (CachePath.empty())
367       return;
368 
369     if (!Index.modulePaths().count(ModuleID))
370       // The module does not have an entry, it can't have a hash at all
371       return;
372 
373     if (all_of(Index.getModuleHash(ModuleID),
374                [](uint32_t V) { return V == 0; }))
375       // No hash entry, no caching!
376       return;
377 
378     llvm::lto::Config Conf;
379     Conf.OptLevel = OptLevel;
380     Conf.Options = TMBuilder.Options;
381     Conf.CPU = TMBuilder.MCpu;
382     Conf.MAttrs.push_back(TMBuilder.MAttr);
383     Conf.RelocModel = TMBuilder.RelocModel;
384     Conf.CGOptLevel = TMBuilder.CGOptLevel;
385     Conf.Freestanding = Freestanding;
386     SmallString<40> Key;
387     computeLTOCacheKey(Key, Conf, Index, ModuleID, ImportList, ExportList,
388                        ResolvedODR, DefinedGVSummaries);
389 
390     // This choice of file name allows the cache to be pruned (see pruneCache()
391     // in include/llvm/Support/CachePruning.h).
392     sys::path::append(EntryPath, CachePath, "llvmcache-" + Key);
393   }
394 
395   // Access the path to this entry in the cache.
396   StringRef getEntryPath() { return EntryPath; }
397 
398   // Try loading the buffer for this cache entry.
399   ErrorOr<std::unique_ptr<MemoryBuffer>> tryLoadingBuffer() {
400     if (EntryPath.empty())
401       return std::error_code();
402     SmallString<64> ResultPath;
403     Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
404         Twine(EntryPath), sys::fs::OF_UpdateAtime, &ResultPath);
405     if (!FDOrErr)
406       return errorToErrorCode(FDOrErr.takeError());
407     ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getOpenFile(
408         *FDOrErr, EntryPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
409     sys::fs::closeFile(*FDOrErr);
410     return MBOrErr;
411   }
412 
413   // Cache the Produced object file
414   void write(const MemoryBuffer &OutputBuffer) {
415     if (EntryPath.empty())
416       return;
417 
418     // Write to a temporary to avoid race condition
419     SmallString<128> TempFilename;
420     SmallString<128> CachePath(EntryPath);
421     llvm::sys::path::remove_filename(CachePath);
422     sys::path::append(TempFilename, CachePath, "Thin-%%%%%%.tmp.o");
423 
424     if (auto Err = handleErrors(
425             llvm::writeFileAtomically(TempFilename, EntryPath,
426                                       OutputBuffer.getBuffer()),
427             [](const llvm::AtomicFileWriteError &E) {
428               std::string ErrorMsgBuffer;
429               llvm::raw_string_ostream S(ErrorMsgBuffer);
430               E.log(S);
431 
432               if (E.Error ==
433                   llvm::atomic_write_error::failed_to_create_uniq_file) {
434                 errs() << "Error: " << ErrorMsgBuffer << "\n";
435                 report_fatal_error("ThinLTO: Can't get a temporary file");
436               }
437             })) {
438       // FIXME
439       consumeError(std::move(Err));
440     }
441   }
442 };
443 
444 static std::unique_ptr<MemoryBuffer>
445 ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
446                      StringMap<lto::InputFile *> &ModuleMap, TargetMachine &TM,
447                      const FunctionImporter::ImportMapTy &ImportList,
448                      const FunctionImporter::ExportSetTy &ExportList,
449                      const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
450                      const GVSummaryMapTy &DefinedGlobals,
451                      const ThinLTOCodeGenerator::CachingOptions &CacheOptions,
452                      bool DisableCodeGen, StringRef SaveTempsDir,
453                      bool Freestanding, unsigned OptLevel, unsigned count,
454                      bool DebugPassManager) {
455 
456   // "Benchmark"-like optimization: single-source case
457   bool SingleModule = (ModuleMap.size() == 1);
458 
459   // When linking an ELF shared object, dso_local should be dropped. We
460   // conservatively do this for -fpic.
461   bool ClearDSOLocalOnDeclarations =
462       TM.getTargetTriple().isOSBinFormatELF() &&
463       TM.getRelocationModel() != Reloc::Static &&
464       TheModule.getPIELevel() == PIELevel::Default;
465 
466   if (!SingleModule) {
467     promoteModule(TheModule, Index, ClearDSOLocalOnDeclarations);
468 
469     // Apply summary-based prevailing-symbol resolution decisions.
470     thinLTOFinalizeInModule(TheModule, DefinedGlobals, /*PropagateAttrs=*/true);
471 
472     // Save temps: after promotion.
473     saveTempBitcode(TheModule, SaveTempsDir, count, ".1.promoted.bc");
474   }
475 
476   // Be friendly and don't nuke totally the module when the client didn't
477   // supply anything to preserve.
478   if (!ExportList.empty() || !GUIDPreservedSymbols.empty()) {
479     // Apply summary-based internalization decisions.
480     thinLTOInternalizeModule(TheModule, DefinedGlobals);
481   }
482 
483   // Save internalized bitcode
484   saveTempBitcode(TheModule, SaveTempsDir, count, ".2.internalized.bc");
485 
486   if (!SingleModule) {
487     crossImportIntoModule(TheModule, Index, ModuleMap, ImportList,
488                           ClearDSOLocalOnDeclarations);
489 
490     // Save temps: after cross-module import.
491     saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
492   }
493 
494   optimizeModule(TheModule, TM, OptLevel, Freestanding, DebugPassManager,
495                  &Index);
496 
497   saveTempBitcode(TheModule, SaveTempsDir, count, ".4.opt.bc");
498 
499   if (DisableCodeGen) {
500     // Configured to stop before CodeGen, serialize the bitcode and return.
501     SmallVector<char, 128> OutputBuffer;
502     {
503       raw_svector_ostream OS(OutputBuffer);
504       ProfileSummaryInfo PSI(TheModule);
505       auto Index = buildModuleSummaryIndex(TheModule, nullptr, &PSI);
506       WriteBitcodeToFile(TheModule, OS, true, &Index);
507     }
508     return std::make_unique<SmallVectorMemoryBuffer>(
509         std::move(OutputBuffer), /*RequiresNullTerminator=*/false);
510   }
511 
512   return codegenModule(TheModule, TM);
513 }
514 
515 /// Resolve prevailing symbols. Record resolutions in the \p ResolvedODR map
516 /// for caching, and in the \p Index for application during the ThinLTO
517 /// backends. This is needed for correctness for exported symbols (ensure
518 /// at least one copy kept) and a compile-time optimization (to drop duplicate
519 /// copies when possible).
520 static void resolvePrevailingInIndex(
521     ModuleSummaryIndex &Index,
522     StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>>
523         &ResolvedODR,
524     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
525     const DenseMap<GlobalValue::GUID, const GlobalValueSummary *>
526         &PrevailingCopy) {
527 
528   auto isPrevailing = [&](GlobalValue::GUID GUID, const GlobalValueSummary *S) {
529     const auto &Prevailing = PrevailingCopy.find(GUID);
530     // Not in map means that there was only one copy, which must be prevailing.
531     if (Prevailing == PrevailingCopy.end())
532       return true;
533     return Prevailing->second == S;
534   };
535 
536   auto recordNewLinkage = [&](StringRef ModuleIdentifier,
537                               GlobalValue::GUID GUID,
538                               GlobalValue::LinkageTypes NewLinkage) {
539     ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
540   };
541 
542   // TODO Conf.VisibilityScheme can be lto::Config::ELF for ELF.
543   lto::Config Conf;
544   thinLTOResolvePrevailingInIndex(Conf, Index, isPrevailing, recordNewLinkage,
545                                   GUIDPreservedSymbols);
546 }
547 
548 // Initialize the TargetMachine builder for a given Triple
549 static void initTMBuilder(TargetMachineBuilder &TMBuilder,
550                           const Triple &TheTriple) {
551   // Set a default CPU for Darwin triples (copied from LTOCodeGenerator).
552   // FIXME this looks pretty terrible...
553   if (TMBuilder.MCpu.empty() && TheTriple.isOSDarwin()) {
554     if (TheTriple.getArch() == llvm::Triple::x86_64)
555       TMBuilder.MCpu = "core2";
556     else if (TheTriple.getArch() == llvm::Triple::x86)
557       TMBuilder.MCpu = "yonah";
558     else if (TheTriple.getArch() == llvm::Triple::aarch64 ||
559              TheTriple.getArch() == llvm::Triple::aarch64_32)
560       TMBuilder.MCpu = "cyclone";
561   }
562   TMBuilder.TheTriple = std::move(TheTriple);
563 }
564 
565 } // end anonymous namespace
566 
567 void ThinLTOCodeGenerator::addModule(StringRef Identifier, StringRef Data) {
568   MemoryBufferRef Buffer(Data, Identifier);
569 
570   auto InputOrError = lto::InputFile::create(Buffer);
571   if (!InputOrError)
572     report_fatal_error(Twine("ThinLTO cannot create input file: ") +
573                        toString(InputOrError.takeError()));
574 
575   auto TripleStr = (*InputOrError)->getTargetTriple();
576   Triple TheTriple(TripleStr);
577 
578   if (Modules.empty())
579     initTMBuilder(TMBuilder, Triple(TheTriple));
580   else if (TMBuilder.TheTriple != TheTriple) {
581     if (!TMBuilder.TheTriple.isCompatibleWith(TheTriple))
582       report_fatal_error("ThinLTO modules with incompatible triples not "
583                          "supported");
584     initTMBuilder(TMBuilder, Triple(TMBuilder.TheTriple.merge(TheTriple)));
585   }
586 
587   Modules.emplace_back(std::move(*InputOrError));
588 }
589 
590 void ThinLTOCodeGenerator::preserveSymbol(StringRef Name) {
591   PreservedSymbols.insert(Name);
592 }
593 
594 void ThinLTOCodeGenerator::crossReferenceSymbol(StringRef Name) {
595   // FIXME: At the moment, we don't take advantage of this extra information,
596   // we're conservatively considering cross-references as preserved.
597   //  CrossReferencedSymbols.insert(Name);
598   PreservedSymbols.insert(Name);
599 }
600 
601 // TargetMachine factory
602 std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const {
603   std::string ErrMsg;
604   const Target *TheTarget =
605       TargetRegistry::lookupTarget(TheTriple.str(), ErrMsg);
606   if (!TheTarget) {
607     report_fatal_error(Twine("Can't load target for this Triple: ") + ErrMsg);
608   }
609 
610   // Use MAttr as the default set of features.
611   SubtargetFeatures Features(MAttr);
612   Features.getDefaultSubtargetFeatures(TheTriple);
613   std::string FeatureStr = Features.getString();
614 
615   std::unique_ptr<TargetMachine> TM(
616       TheTarget->createTargetMachine(TheTriple.str(), MCpu, FeatureStr, Options,
617                                      RelocModel, None, CGOptLevel));
618   assert(TM && "Cannot create target machine");
619 
620   return TM;
621 }
622 
623 /**
624  * Produce the combined summary index from all the bitcode files:
625  * "thin-link".
626  */
627 std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
628   std::unique_ptr<ModuleSummaryIndex> CombinedIndex =
629       std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
630   uint64_t NextModuleId = 0;
631   for (auto &Mod : Modules) {
632     auto &M = Mod->getSingleBitcodeModule();
633     if (Error Err =
634             M.readSummary(*CombinedIndex, Mod->getName(), NextModuleId++)) {
635       // FIXME diagnose
636       logAllUnhandledErrors(
637           std::move(Err), errs(),
638           "error: can't create module summary index for buffer: ");
639       return nullptr;
640     }
641   }
642   return CombinedIndex;
643 }
644 
645 namespace {
646 struct IsExported {
647   const StringMap<FunctionImporter::ExportSetTy> &ExportLists;
648   const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols;
649 
650   IsExported(const StringMap<FunctionImporter::ExportSetTy> &ExportLists,
651              const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols)
652       : ExportLists(ExportLists), GUIDPreservedSymbols(GUIDPreservedSymbols) {}
653 
654   bool operator()(StringRef ModuleIdentifier, ValueInfo VI) const {
655     const auto &ExportList = ExportLists.find(ModuleIdentifier);
656     return (ExportList != ExportLists.end() && ExportList->second.count(VI)) ||
657            GUIDPreservedSymbols.count(VI.getGUID());
658   }
659 };
660 
661 struct IsPrevailing {
662   const DenseMap<GlobalValue::GUID, const GlobalValueSummary *> &PrevailingCopy;
663   IsPrevailing(const DenseMap<GlobalValue::GUID, const GlobalValueSummary *>
664                    &PrevailingCopy)
665       : PrevailingCopy(PrevailingCopy) {}
666 
667   bool operator()(GlobalValue::GUID GUID, const GlobalValueSummary *S) const {
668     const auto &Prevailing = PrevailingCopy.find(GUID);
669     // Not in map means that there was only one copy, which must be prevailing.
670     if (Prevailing == PrevailingCopy.end())
671       return true;
672     return Prevailing->second == S;
673   };
674 };
675 } // namespace
676 
677 static void computeDeadSymbolsInIndex(
678     ModuleSummaryIndex &Index,
679     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
680   // We have no symbols resolution available. And can't do any better now in the
681   // case where the prevailing symbol is in a native object. It can be refined
682   // with linker information in the future.
683   auto isPrevailing = [&](GlobalValue::GUID G) {
684     return PrevailingType::Unknown;
685   };
686   computeDeadSymbolsWithConstProp(Index, GUIDPreservedSymbols, isPrevailing,
687                                   /* ImportEnabled = */ true);
688 }
689 
690 /**
691  * Perform promotion and renaming of exported internal functions.
692  * Index is updated to reflect linkage changes from weak resolution.
693  */
694 void ThinLTOCodeGenerator::promote(Module &TheModule, ModuleSummaryIndex &Index,
695                                    const lto::InputFile &File) {
696   auto ModuleCount = Index.modulePaths().size();
697   auto ModuleIdentifier = TheModule.getModuleIdentifier();
698 
699   // Collect for each module the list of function it defines (GUID -> Summary).
700   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries;
701   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
702 
703   // Convert the preserved symbols set from string to GUID
704   auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
705       File, PreservedSymbols, Triple(TheModule.getTargetTriple()));
706 
707   // Add used symbol to the preserved symbols.
708   addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
709 
710   // Compute "dead" symbols, we don't want to import/export these!
711   computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
712 
713   // Generate import/export list
714   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
715   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
716   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
717                            ExportLists);
718 
719   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
720   computePrevailingCopies(Index, PrevailingCopy);
721 
722   // Resolve prevailing symbols
723   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
724   resolvePrevailingInIndex(Index, ResolvedODR, GUIDPreservedSymbols,
725                            PrevailingCopy);
726 
727   thinLTOFinalizeInModule(TheModule,
728                           ModuleToDefinedGVSummaries[ModuleIdentifier],
729                           /*PropagateAttrs=*/false);
730 
731   // Promote the exported values in the index, so that they are promoted
732   // in the module.
733   thinLTOInternalizeAndPromoteInIndex(
734       Index, IsExported(ExportLists, GUIDPreservedSymbols),
735       IsPrevailing(PrevailingCopy));
736 
737   // FIXME Set ClearDSOLocalOnDeclarations.
738   promoteModule(TheModule, Index, /*ClearDSOLocalOnDeclarations=*/false);
739 }
740 
741 /**
742  * Perform cross-module importing for the module identified by ModuleIdentifier.
743  */
744 void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
745                                              ModuleSummaryIndex &Index,
746                                              const lto::InputFile &File) {
747   auto ModuleMap = generateModuleMap(Modules);
748   auto ModuleCount = Index.modulePaths().size();
749 
750   // Collect for each module the list of function it defines (GUID -> Summary).
751   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
752   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
753 
754   // Convert the preserved symbols set from string to GUID
755   auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
756       File, PreservedSymbols, Triple(TheModule.getTargetTriple()));
757 
758   addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
759 
760   // Compute "dead" symbols, we don't want to import/export these!
761   computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
762 
763   // Generate import/export list
764   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
765   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
766   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
767                            ExportLists);
768   auto &ImportList = ImportLists[TheModule.getModuleIdentifier()];
769 
770   // FIXME Set ClearDSOLocalOnDeclarations.
771   crossImportIntoModule(TheModule, Index, ModuleMap, ImportList,
772                         /*ClearDSOLocalOnDeclarations=*/false);
773 }
774 
775 /**
776  * Compute the list of summaries needed for importing into module.
777  */
778 void ThinLTOCodeGenerator::gatherImportedSummariesForModule(
779     Module &TheModule, ModuleSummaryIndex &Index,
780     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex,
781     const lto::InputFile &File) {
782   auto ModuleCount = Index.modulePaths().size();
783   auto ModuleIdentifier = TheModule.getModuleIdentifier();
784 
785   // Collect for each module the list of function it defines (GUID -> Summary).
786   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
787   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
788 
789   // Convert the preserved symbols set from string to GUID
790   auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
791       File, PreservedSymbols, Triple(TheModule.getTargetTriple()));
792 
793   addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
794 
795   // Compute "dead" symbols, we don't want to import/export these!
796   computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
797 
798   // Generate import/export list
799   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
800   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
801   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
802                            ExportLists);
803 
804   llvm::gatherImportedSummariesForModule(
805       ModuleIdentifier, ModuleToDefinedGVSummaries,
806       ImportLists[ModuleIdentifier], ModuleToSummariesForIndex);
807 }
808 
809 /**
810  * Emit the list of files needed for importing into module.
811  */
812 void ThinLTOCodeGenerator::emitImports(Module &TheModule, StringRef OutputName,
813                                        ModuleSummaryIndex &Index,
814                                        const lto::InputFile &File) {
815   auto ModuleCount = Index.modulePaths().size();
816   auto ModuleIdentifier = TheModule.getModuleIdentifier();
817 
818   // Collect for each module the list of function it defines (GUID -> Summary).
819   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
820   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
821 
822   // Convert the preserved symbols set from string to GUID
823   auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
824       File, PreservedSymbols, Triple(TheModule.getTargetTriple()));
825 
826   addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
827 
828   // Compute "dead" symbols, we don't want to import/export these!
829   computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
830 
831   // Generate import/export list
832   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
833   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
834   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
835                            ExportLists);
836 
837   std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
838   llvm::gatherImportedSummariesForModule(
839       ModuleIdentifier, ModuleToDefinedGVSummaries,
840       ImportLists[ModuleIdentifier], ModuleToSummariesForIndex);
841 
842   std::error_code EC;
843   if ((EC = EmitImportsFiles(ModuleIdentifier, OutputName,
844                              ModuleToSummariesForIndex)))
845     report_fatal_error(Twine("Failed to open ") + OutputName +
846                        " to save imports lists\n");
847 }
848 
849 /**
850  * Perform internalization. Runs promote and internalization together.
851  * Index is updated to reflect linkage changes.
852  */
853 void ThinLTOCodeGenerator::internalize(Module &TheModule,
854                                        ModuleSummaryIndex &Index,
855                                        const lto::InputFile &File) {
856   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
857   auto ModuleCount = Index.modulePaths().size();
858   auto ModuleIdentifier = TheModule.getModuleIdentifier();
859 
860   // Convert the preserved symbols set from string to GUID
861   auto GUIDPreservedSymbols =
862       computeGUIDPreservedSymbols(File, PreservedSymbols, TMBuilder.TheTriple);
863 
864   addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
865 
866   // Collect for each module the list of function it defines (GUID -> Summary).
867   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
868   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
869 
870   // Compute "dead" symbols, we don't want to import/export these!
871   computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
872 
873   // Generate import/export list
874   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
875   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
876   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
877                            ExportLists);
878   auto &ExportList = ExportLists[ModuleIdentifier];
879 
880   // Be friendly and don't nuke totally the module when the client didn't
881   // supply anything to preserve.
882   if (ExportList.empty() && GUIDPreservedSymbols.empty())
883     return;
884 
885   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
886   computePrevailingCopies(Index, PrevailingCopy);
887 
888   // Resolve prevailing symbols
889   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
890   resolvePrevailingInIndex(Index, ResolvedODR, GUIDPreservedSymbols,
891                            PrevailingCopy);
892 
893   // Promote the exported values in the index, so that they are promoted
894   // in the module.
895   thinLTOInternalizeAndPromoteInIndex(
896       Index, IsExported(ExportLists, GUIDPreservedSymbols),
897       IsPrevailing(PrevailingCopy));
898 
899   // FIXME Set ClearDSOLocalOnDeclarations.
900   promoteModule(TheModule, Index, /*ClearDSOLocalOnDeclarations=*/false);
901 
902   // Internalization
903   thinLTOFinalizeInModule(TheModule,
904                           ModuleToDefinedGVSummaries[ModuleIdentifier],
905                           /*PropagateAttrs=*/false);
906 
907   thinLTOInternalizeModule(TheModule,
908                            ModuleToDefinedGVSummaries[ModuleIdentifier]);
909 }
910 
911 /**
912  * Perform post-importing ThinLTO optimizations.
913  */
914 void ThinLTOCodeGenerator::optimize(Module &TheModule) {
915   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
916 
917   // Optimize now
918   optimizeModule(TheModule, *TMBuilder.create(), OptLevel, Freestanding,
919                  DebugPassManager, nullptr);
920 }
921 
922 /// Write out the generated object file, either from CacheEntryPath or from
923 /// OutputBuffer, preferring hard-link when possible.
924 /// Returns the path to the generated file in SavedObjectsDirectoryPath.
925 std::string
926 ThinLTOCodeGenerator::writeGeneratedObject(int count, StringRef CacheEntryPath,
927                                            const MemoryBuffer &OutputBuffer) {
928   auto ArchName = TMBuilder.TheTriple.getArchName();
929   SmallString<128> OutputPath(SavedObjectsDirectoryPath);
930   llvm::sys::path::append(OutputPath,
931                           Twine(count) + "." + ArchName + ".thinlto.o");
932   OutputPath.c_str(); // Ensure the string is null terminated.
933   if (sys::fs::exists(OutputPath))
934     sys::fs::remove(OutputPath);
935 
936   // We don't return a memory buffer to the linker, just a list of files.
937   if (!CacheEntryPath.empty()) {
938     // Cache is enabled, hard-link the entry (or copy if hard-link fails).
939     auto Err = sys::fs::create_hard_link(CacheEntryPath, OutputPath);
940     if (!Err)
941       return std::string(OutputPath.str());
942     // Hard linking failed, try to copy.
943     Err = sys::fs::copy_file(CacheEntryPath, OutputPath);
944     if (!Err)
945       return std::string(OutputPath.str());
946     // Copy failed (could be because the CacheEntry was removed from the cache
947     // in the meantime by another process), fall back and try to write down the
948     // buffer to the output.
949     errs() << "remark: can't link or copy from cached entry '" << CacheEntryPath
950            << "' to '" << OutputPath << "'\n";
951   }
952   // No cache entry, just write out the buffer.
953   std::error_code Err;
954   raw_fd_ostream OS(OutputPath, Err, sys::fs::OF_None);
955   if (Err)
956     report_fatal_error(Twine("Can't open output '") + OutputPath + "'\n");
957   OS << OutputBuffer.getBuffer();
958   return std::string(OutputPath.str());
959 }
960 
961 // Main entry point for the ThinLTO processing
962 void ThinLTOCodeGenerator::run() {
963   timeTraceProfilerBegin("ThinLink", StringRef(""));
964   auto TimeTraceScopeExit = llvm::make_scope_exit([]() {
965     if (llvm::timeTraceProfilerEnabled())
966       llvm::timeTraceProfilerEnd();
967   });
968   // Prepare the resulting object vector
969   assert(ProducedBinaries.empty() && "The generator should not be reused");
970   if (SavedObjectsDirectoryPath.empty())
971     ProducedBinaries.resize(Modules.size());
972   else {
973     sys::fs::create_directories(SavedObjectsDirectoryPath);
974     bool IsDir;
975     sys::fs::is_directory(SavedObjectsDirectoryPath, IsDir);
976     if (!IsDir)
977       report_fatal_error(Twine("Unexistent dir: '") + SavedObjectsDirectoryPath + "'");
978     ProducedBinaryFiles.resize(Modules.size());
979   }
980 
981   if (CodeGenOnly) {
982     // Perform only parallel codegen and return.
983     ThreadPool Pool;
984     int count = 0;
985     for (auto &Mod : Modules) {
986       Pool.async([&](int count) {
987         LLVMContext Context;
988         Context.setDiscardValueNames(LTODiscardValueNames);
989 
990         // Parse module now
991         auto TheModule = loadModuleFromInput(Mod.get(), Context, false,
992                                              /*IsImporting*/ false);
993 
994         // CodeGen
995         auto OutputBuffer = codegenModule(*TheModule, *TMBuilder.create());
996         if (SavedObjectsDirectoryPath.empty())
997           ProducedBinaries[count] = std::move(OutputBuffer);
998         else
999           ProducedBinaryFiles[count] =
1000               writeGeneratedObject(count, "", *OutputBuffer);
1001       }, count++);
1002     }
1003 
1004     return;
1005   }
1006 
1007   // Sequential linking phase
1008   auto Index = linkCombinedIndex();
1009 
1010   // Save temps: index.
1011   if (!SaveTempsDir.empty()) {
1012     auto SaveTempPath = SaveTempsDir + "index.bc";
1013     std::error_code EC;
1014     raw_fd_ostream OS(SaveTempPath, EC, sys::fs::OF_None);
1015     if (EC)
1016       report_fatal_error(Twine("Failed to open ") + SaveTempPath +
1017                          " to save optimized bitcode\n");
1018     writeIndexToFile(*Index, OS);
1019   }
1020 
1021 
1022   // Prepare the module map.
1023   auto ModuleMap = generateModuleMap(Modules);
1024   auto ModuleCount = Modules.size();
1025 
1026   // Collect for each module the list of function it defines (GUID -> Summary).
1027   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
1028   Index->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1029 
1030   // Convert the preserved symbols set from string to GUID, this is needed for
1031   // computing the caching hash and the internalization.
1032   DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
1033   for (const auto &M : Modules)
1034     computeGUIDPreservedSymbols(*M, PreservedSymbols, TMBuilder.TheTriple,
1035                                 GUIDPreservedSymbols);
1036 
1037   // Add used symbol from inputs to the preserved symbols.
1038   for (const auto &M : Modules)
1039     addUsedSymbolToPreservedGUID(*M, GUIDPreservedSymbols);
1040 
1041   // Compute "dead" symbols, we don't want to import/export these!
1042   computeDeadSymbolsInIndex(*Index, GUIDPreservedSymbols);
1043 
1044   // Synthesize entry counts for functions in the combined index.
1045   computeSyntheticCounts(*Index);
1046 
1047   // Currently there is no support for enabling whole program visibility via a
1048   // linker option in the old LTO API, but this call allows it to be specified
1049   // via the internal option. Must be done before WPD below.
1050   updateVCallVisibilityInIndex(*Index,
1051                                /* WholeProgramVisibilityEnabledInLTO */ false,
1052                                // FIXME: This needs linker information via a
1053                                // TBD new interface.
1054                                /* DynamicExportSymbols */ {});
1055 
1056   // Perform index-based WPD. This will return immediately if there are
1057   // no index entries in the typeIdMetadata map (e.g. if we are instead
1058   // performing IR-based WPD in hybrid regular/thin LTO mode).
1059   std::map<ValueInfo, std::vector<VTableSlotSummary>> LocalWPDTargetsMap;
1060   std::set<GlobalValue::GUID> ExportedGUIDs;
1061   runWholeProgramDevirtOnIndex(*Index, ExportedGUIDs, LocalWPDTargetsMap);
1062   for (auto GUID : ExportedGUIDs)
1063     GUIDPreservedSymbols.insert(GUID);
1064 
1065   // Collect the import/export lists for all modules from the call-graph in the
1066   // combined index.
1067   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
1068   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
1069   ComputeCrossModuleImport(*Index, ModuleToDefinedGVSummaries, ImportLists,
1070                            ExportLists);
1071 
1072   // We use a std::map here to be able to have a defined ordering when
1073   // producing a hash for the cache entry.
1074   // FIXME: we should be able to compute the caching hash for the entry based
1075   // on the index, and nuke this map.
1076   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
1077 
1078   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
1079   computePrevailingCopies(*Index, PrevailingCopy);
1080 
1081   // Resolve prevailing symbols, this has to be computed early because it
1082   // impacts the caching.
1083   resolvePrevailingInIndex(*Index, ResolvedODR, GUIDPreservedSymbols,
1084                            PrevailingCopy);
1085 
1086   // Use global summary-based analysis to identify symbols that can be
1087   // internalized (because they aren't exported or preserved as per callback).
1088   // Changes are made in the index, consumed in the ThinLTO backends.
1089   updateIndexWPDForExports(*Index,
1090                            IsExported(ExportLists, GUIDPreservedSymbols),
1091                            LocalWPDTargetsMap);
1092   thinLTOInternalizeAndPromoteInIndex(
1093       *Index, IsExported(ExportLists, GUIDPreservedSymbols),
1094       IsPrevailing(PrevailingCopy));
1095 
1096   thinLTOPropagateFunctionAttrs(*Index, IsPrevailing(PrevailingCopy));
1097 
1098   // Make sure that every module has an entry in the ExportLists, ImportList,
1099   // GVSummary and ResolvedODR maps to enable threaded access to these maps
1100   // below.
1101   for (auto &Module : Modules) {
1102     auto ModuleIdentifier = Module->getName();
1103     ExportLists[ModuleIdentifier];
1104     ImportLists[ModuleIdentifier];
1105     ResolvedODR[ModuleIdentifier];
1106     ModuleToDefinedGVSummaries[ModuleIdentifier];
1107   }
1108 
1109   std::vector<BitcodeModule *> ModulesVec;
1110   ModulesVec.reserve(Modules.size());
1111   for (auto &Mod : Modules)
1112     ModulesVec.push_back(&Mod->getSingleBitcodeModule());
1113   std::vector<int> ModulesOrdering = lto::generateModulesOrdering(ModulesVec);
1114 
1115   if (llvm::timeTraceProfilerEnabled())
1116     llvm::timeTraceProfilerEnd();
1117 
1118   TimeTraceScopeExit.release();
1119 
1120   // Parallel optimizer + codegen
1121   {
1122     ThreadPool Pool(heavyweight_hardware_concurrency(ThreadCount));
1123     for (auto IndexCount : ModulesOrdering) {
1124       auto &Mod = Modules[IndexCount];
1125       Pool.async([&](int count) {
1126         auto ModuleIdentifier = Mod->getName();
1127         auto &ExportList = ExportLists[ModuleIdentifier];
1128 
1129         auto &DefinedGVSummaries = ModuleToDefinedGVSummaries[ModuleIdentifier];
1130 
1131         // The module may be cached, this helps handling it.
1132         ModuleCacheEntry CacheEntry(CacheOptions.Path, *Index, ModuleIdentifier,
1133                                     ImportLists[ModuleIdentifier], ExportList,
1134                                     ResolvedODR[ModuleIdentifier],
1135                                     DefinedGVSummaries, OptLevel, Freestanding,
1136                                     TMBuilder);
1137         auto CacheEntryPath = CacheEntry.getEntryPath();
1138 
1139         {
1140           auto ErrOrBuffer = CacheEntry.tryLoadingBuffer();
1141           LLVM_DEBUG(dbgs() << "Cache " << (ErrOrBuffer ? "hit" : "miss")
1142                             << " '" << CacheEntryPath << "' for buffer "
1143                             << count << " " << ModuleIdentifier << "\n");
1144 
1145           if (ErrOrBuffer) {
1146             // Cache Hit!
1147             if (SavedObjectsDirectoryPath.empty())
1148               ProducedBinaries[count] = std::move(ErrOrBuffer.get());
1149             else
1150               ProducedBinaryFiles[count] = writeGeneratedObject(
1151                   count, CacheEntryPath, *ErrOrBuffer.get());
1152             return;
1153           }
1154         }
1155 
1156         LLVMContext Context;
1157         Context.setDiscardValueNames(LTODiscardValueNames);
1158         Context.enableDebugTypeODRUniquing();
1159         auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
1160             Context, RemarksFilename, RemarksPasses, RemarksFormat,
1161             RemarksWithHotness, RemarksHotnessThreshold, count);
1162         if (!DiagFileOrErr) {
1163           errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
1164           report_fatal_error("ThinLTO: Can't get an output file for the "
1165                              "remarks");
1166         }
1167 
1168         // Parse module now
1169         auto TheModule = loadModuleFromInput(Mod.get(), Context, false,
1170                                              /*IsImporting*/ false);
1171 
1172         // Save temps: original file.
1173         saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");
1174 
1175         auto &ImportList = ImportLists[ModuleIdentifier];
1176         // Run the main process now, and generates a binary
1177         auto OutputBuffer = ProcessThinLTOModule(
1178             *TheModule, *Index, ModuleMap, *TMBuilder.create(), ImportList,
1179             ExportList, GUIDPreservedSymbols,
1180             ModuleToDefinedGVSummaries[ModuleIdentifier], CacheOptions,
1181             DisableCodeGen, SaveTempsDir, Freestanding, OptLevel, count,
1182             DebugPassManager);
1183 
1184         // Commit to the cache (if enabled)
1185         CacheEntry.write(*OutputBuffer);
1186 
1187         if (SavedObjectsDirectoryPath.empty()) {
1188           // We need to generated a memory buffer for the linker.
1189           if (!CacheEntryPath.empty()) {
1190             // When cache is enabled, reload from the cache if possible.
1191             // Releasing the buffer from the heap and reloading it from the
1192             // cache file with mmap helps us to lower memory pressure.
1193             // The freed memory can be used for the next input file.
1194             // The final binary link will read from the VFS cache (hopefully!)
1195             // or from disk (if the memory pressure was too high).
1196             auto ReloadedBufferOrErr = CacheEntry.tryLoadingBuffer();
1197             if (auto EC = ReloadedBufferOrErr.getError()) {
1198               // On error, keep the preexisting buffer and print a diagnostic.
1199               errs() << "remark: can't reload cached file '" << CacheEntryPath
1200                      << "': " << EC.message() << "\n";
1201             } else {
1202               OutputBuffer = std::move(*ReloadedBufferOrErr);
1203             }
1204           }
1205           ProducedBinaries[count] = std::move(OutputBuffer);
1206           return;
1207         }
1208         ProducedBinaryFiles[count] = writeGeneratedObject(
1209             count, CacheEntryPath, *OutputBuffer);
1210       }, IndexCount);
1211     }
1212   }
1213 
1214   pruneCache(CacheOptions.Path, CacheOptions.Policy);
1215 
1216   // If statistics were requested, print them out now.
1217   if (llvm::AreStatisticsEnabled())
1218     llvm::PrintStatistics();
1219   reportAndResetTimings();
1220 }
1221