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 
15 #include "llvm/LTO/ThinLTOCodeGenerator.h"
16 
17 #include "llvm/ADT/Statistic.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/Analysis/TargetLibraryInfo.h"
20 #include "llvm/Analysis/TargetTransformInfo.h"
21 #include "llvm/Bitcode/BitcodeWriterPass.h"
22 #include "llvm/Bitcode/ReaderWriter.h"
23 #include "llvm/ExecutionEngine/ObjectMemoryBuffer.h"
24 #include "llvm/IR/DiagnosticPrinter.h"
25 #include "llvm/IR/LLVMContext.h"
26 #include "llvm/IR/LegacyPassManager.h"
27 #include "llvm/IR/Mangler.h"
28 #include "llvm/IRReader/IRReader.h"
29 #include "llvm/Linker/Linker.h"
30 #include "llvm/MC/SubtargetFeature.h"
31 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
32 #include "llvm/Support/SourceMgr.h"
33 #include "llvm/Support/TargetRegistry.h"
34 #include "llvm/Support/ThreadPool.h"
35 #include "llvm/Target/TargetMachine.h"
36 #include "llvm/Transforms/IPO.h"
37 #include "llvm/Transforms/IPO/FunctionImport.h"
38 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
39 #include "llvm/Transforms/ObjCARC.h"
40 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
41 
42 using namespace llvm;
43 
44 namespace llvm {
45 // Flags -discard-value-names, defined in LTOCodeGenerator.cpp
46 extern cl::opt<bool> LTODiscardValueNames;
47 }
48 
49 namespace {
50 
51 static cl::opt<int> ThreadCount("threads",
52                                 cl::init(std::thread::hardware_concurrency()));
53 
54 static void diagnosticHandler(const DiagnosticInfo &DI) {
55   DiagnosticPrinterRawOStream DP(errs());
56   DI.print(DP);
57   errs() << '\n';
58 }
59 
60 // Simple helper to load a module from bitcode
61 static std::unique_ptr<Module>
62 loadModuleFromBuffer(const MemoryBufferRef &Buffer, LLVMContext &Context,
63                      bool Lazy) {
64   SMDiagnostic Err;
65   ErrorOr<std::unique_ptr<Module>> ModuleOrErr(nullptr);
66   if (Lazy) {
67     ModuleOrErr =
68         getLazyBitcodeModule(MemoryBuffer::getMemBuffer(Buffer, false), Context,
69                              /* ShouldLazyLoadMetadata */ Lazy);
70   } else {
71     ModuleOrErr = parseBitcodeFile(Buffer, Context);
72   }
73   if (std::error_code EC = ModuleOrErr.getError()) {
74     Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error,
75                        EC.message());
76     Err.print("ThinLTO", errs());
77     report_fatal_error("Can't load module, abort.");
78   }
79   return std::move(ModuleOrErr.get());
80 }
81 
82 // Simple helper to save temporary files for debug.
83 static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
84                             unsigned count, StringRef Suffix) {
85   if (TempDir.empty())
86     return;
87   // User asked to save temps, let dump the bitcode file after import.
88   auto SaveTempPath = TempDir + llvm::utostr(count) + Suffix;
89   std::error_code EC;
90   raw_fd_ostream OS(SaveTempPath.str(), EC, sys::fs::F_None);
91   if (EC)
92     report_fatal_error(Twine("Failed to open ") + SaveTempPath +
93                        " to save optimized bitcode\n");
94   WriteBitcodeToFile(&TheModule, OS, true, false);
95 }
96 
97 static StringMap<MemoryBufferRef>
98 generateModuleMap(const std::vector<MemoryBufferRef> &Modules) {
99   StringMap<MemoryBufferRef> ModuleMap;
100   for (auto &ModuleBuffer : Modules) {
101     assert(ModuleMap.find(ModuleBuffer.getBufferIdentifier()) ==
102                ModuleMap.end() &&
103            "Expect unique Buffer Identifier");
104     ModuleMap[ModuleBuffer.getBufferIdentifier()] = ModuleBuffer;
105   }
106   return ModuleMap;
107 }
108 
109 /// Provide a "loader" for the FunctionImporter to access function from other
110 /// modules.
111 class ModuleLoader {
112   /// The context that will be used for importing.
113   LLVMContext &Context;
114 
115   /// Map from Module identifier to MemoryBuffer. Used by clients like the
116   /// FunctionImported to request loading a Module.
117   StringMap<MemoryBufferRef> &ModuleMap;
118 
119 public:
120   ModuleLoader(LLVMContext &Context, StringMap<MemoryBufferRef> &ModuleMap)
121       : Context(Context), ModuleMap(ModuleMap) {}
122 
123   /// Load a module on demand.
124   std::unique_ptr<Module> operator()(StringRef Identifier) {
125     return loadModuleFromBuffer(ModuleMap[Identifier], Context, /*Lazy*/ true);
126   }
127 };
128 
129 static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index) {
130   if (renameModuleForThinLTO(TheModule, Index))
131     report_fatal_error("renameModuleForThinLTO failed");
132 }
133 
134 static void
135 crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
136                       StringMap<MemoryBufferRef> &ModuleMap,
137                       const FunctionImporter::ImportMapTy &ImportList) {
138   ModuleLoader Loader(TheModule.getContext(), ModuleMap);
139   FunctionImporter Importer(Index, Loader);
140   Importer.importFunctions(TheModule, ImportList);
141 }
142 
143 static void optimizeModule(Module &TheModule, TargetMachine &TM) {
144   // Populate the PassManager
145   PassManagerBuilder PMB;
146   PMB.LibraryInfo = new TargetLibraryInfoImpl(TM.getTargetTriple());
147   PMB.Inliner = createFunctionInliningPass();
148   // FIXME: should get it from the bitcode?
149   PMB.OptLevel = 3;
150   PMB.LoopVectorize = true;
151   PMB.SLPVectorize = true;
152   PMB.VerifyInput = true;
153   PMB.VerifyOutput = false;
154 
155   legacy::PassManager PM;
156 
157   // Add the TTI (required to inform the vectorizer about register size for
158   // instance)
159   PM.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
160 
161   // Add optimizations
162   PMB.populateThinLTOPassManager(PM);
163   PM.add(createObjCARCContractPass());
164 
165   PM.run(TheModule);
166 }
167 
168 std::unique_ptr<MemoryBuffer> codegenModule(Module &TheModule,
169                                             TargetMachine &TM) {
170   SmallVector<char, 128> OutputBuffer;
171 
172   // CodeGen
173   {
174     raw_svector_ostream OS(OutputBuffer);
175     legacy::PassManager PM;
176     if (TM.addPassesToEmitFile(PM, OS, TargetMachine::CGFT_ObjectFile,
177                                /* DisableVerify */ true))
178       report_fatal_error("Failed to setup codegen");
179 
180     // Run codegen now. resulting binary is in OutputBuffer.
181     PM.run(TheModule);
182   }
183   return make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
184 }
185 
186 static std::unique_ptr<MemoryBuffer>
187 ProcessThinLTOModule(Module &TheModule, const ModuleSummaryIndex &Index,
188                      StringMap<MemoryBufferRef> &ModuleMap, TargetMachine &TM,
189                      const FunctionImporter::ImportMapTy &ImportList,
190                      ThinLTOCodeGenerator::CachingOptions CacheOptions,
191                      StringRef SaveTempsDir, unsigned count) {
192 
193   // Save temps: after IPO.
194   saveTempBitcode(TheModule, SaveTempsDir, count, ".1.IPO.bc");
195 
196   // "Benchmark"-like optimization: single-source case
197   bool SingleModule = (ModuleMap.size() == 1);
198 
199   if (!SingleModule) {
200     promoteModule(TheModule, Index);
201 
202     // Save temps: after promotion.
203     saveTempBitcode(TheModule, SaveTempsDir, count, ".2.promoted.bc");
204 
205     crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
206 
207     // Save temps: after cross-module import.
208     saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
209   }
210 
211   optimizeModule(TheModule, TM);
212 
213   saveTempBitcode(TheModule, SaveTempsDir, count, ".3.opt.bc");
214 
215   return codegenModule(TheModule, TM);
216 }
217 
218 // Initialize the TargetMachine builder for a given Triple
219 static void initTMBuilder(TargetMachineBuilder &TMBuilder,
220                           const Triple &TheTriple) {
221   // Set a default CPU for Darwin triples (copied from LTOCodeGenerator).
222   // FIXME this looks pretty terrible...
223   if (TMBuilder.MCpu.empty() && TheTriple.isOSDarwin()) {
224     if (TheTriple.getArch() == llvm::Triple::x86_64)
225       TMBuilder.MCpu = "core2";
226     else if (TheTriple.getArch() == llvm::Triple::x86)
227       TMBuilder.MCpu = "yonah";
228     else if (TheTriple.getArch() == llvm::Triple::aarch64)
229       TMBuilder.MCpu = "cyclone";
230   }
231   TMBuilder.TheTriple = std::move(TheTriple);
232 }
233 
234 } // end anonymous namespace
235 
236 void ThinLTOCodeGenerator::addModule(StringRef Identifier, StringRef Data) {
237   MemoryBufferRef Buffer(Data, Identifier);
238   if (Modules.empty()) {
239     // First module added, so initialize the triple and some options
240     LLVMContext Context;
241     Triple TheTriple(getBitcodeTargetTriple(Buffer, Context));
242     initTMBuilder(TMBuilder, Triple(TheTriple));
243   }
244 #ifndef NDEBUG
245   else {
246     LLVMContext Context;
247     assert(TMBuilder.TheTriple.str() ==
248                getBitcodeTargetTriple(Buffer, Context) &&
249            "ThinLTO modules with different triple not supported");
250   }
251 #endif
252   Modules.push_back(Buffer);
253 }
254 
255 void ThinLTOCodeGenerator::preserveSymbol(StringRef Name) {
256   PreservedSymbols.insert(Name);
257 }
258 
259 void ThinLTOCodeGenerator::crossReferenceSymbol(StringRef Name) {
260   CrossReferencedSymbols.insert(Name);
261 }
262 
263 // TargetMachine factory
264 std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const {
265   std::string ErrMsg;
266   const Target *TheTarget =
267       TargetRegistry::lookupTarget(TheTriple.str(), ErrMsg);
268   if (!TheTarget) {
269     report_fatal_error("Can't load target for this Triple: " + ErrMsg);
270   }
271 
272   // Use MAttr as the default set of features.
273   SubtargetFeatures Features(MAttr);
274   Features.getDefaultSubtargetFeatures(TheTriple);
275   std::string FeatureStr = Features.getString();
276   return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
277       TheTriple.str(), MCpu, FeatureStr, Options, RelocModel,
278       CodeModel::Default, CGOptLevel));
279 }
280 
281 /**
282  * Produce the combined summary index from all the bitcode files:
283  * "thin-link".
284  */
285 std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
286   std::unique_ptr<ModuleSummaryIndex> CombinedIndex;
287   uint64_t NextModuleId = 0;
288   for (auto &ModuleBuffer : Modules) {
289     ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr =
290         object::ModuleSummaryIndexObjectFile::create(ModuleBuffer,
291                                                      diagnosticHandler, false);
292     if (std::error_code EC = ObjOrErr.getError()) {
293       // FIXME diagnose
294       errs() << "error: can't create ModuleSummaryIndexObjectFile for buffer: "
295              << EC.message() << "\n";
296       return nullptr;
297     }
298     auto Index = (*ObjOrErr)->takeIndex();
299     if (CombinedIndex) {
300       CombinedIndex->mergeFrom(std::move(Index), ++NextModuleId);
301     } else {
302       CombinedIndex = std::move(Index);
303     }
304   }
305   return CombinedIndex;
306 }
307 
308 /**
309  * Perform promotion and renaming of exported internal functions.
310  */
311 void ThinLTOCodeGenerator::promote(Module &TheModule,
312                                    ModuleSummaryIndex &Index) {
313   promoteModule(TheModule, Index);
314 }
315 
316 /**
317  * Perform cross-module importing for the module identified by ModuleIdentifier.
318  */
319 void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
320                                              ModuleSummaryIndex &Index) {
321   auto ModuleMap = generateModuleMap(Modules);
322 
323   // Generate import/export list
324   auto ModuleCount = Index.modulePaths().size();
325   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
326   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
327   ComputeCrossModuleImport(Index, ImportLists, ExportLists);
328   auto &ImportList = ImportLists[TheModule.getModuleIdentifier()];
329 
330   crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
331 }
332 
333 /**
334  * Perform post-importing ThinLTO optimizations.
335  */
336 void ThinLTOCodeGenerator::optimize(Module &TheModule) {
337   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
338   optimizeModule(TheModule, *TMBuilder.create());
339 }
340 
341 /**
342  * Perform ThinLTO CodeGen.
343  */
344 std::unique_ptr<MemoryBuffer> ThinLTOCodeGenerator::codegen(Module &TheModule) {
345   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
346   return codegenModule(TheModule, *TMBuilder.create());
347 }
348 
349 // Main entry point for the ThinLTO processing
350 void ThinLTOCodeGenerator::run() {
351   // Sequential linking phase
352   auto Index = linkCombinedIndex();
353 
354   // Save temps: index.
355   if (!SaveTempsDir.empty()) {
356     auto SaveTempPath = SaveTempsDir + "index.bc";
357     std::error_code EC;
358     raw_fd_ostream OS(SaveTempPath, EC, sys::fs::F_None);
359     if (EC)
360       report_fatal_error(Twine("Failed to open ") + SaveTempPath +
361                          " to save optimized bitcode\n");
362     WriteIndexToFile(*Index, OS);
363   }
364 
365   // Prepare the resulting object vector
366   assert(ProducedBinaries.empty() && "The generator should not be reused");
367   ProducedBinaries.resize(Modules.size());
368 
369   // Prepare the module map.
370   auto ModuleMap = generateModuleMap(Modules);
371   auto ModuleCount = Modules.size();
372 
373   // Collect the import/export lists for all modules from the call-graph in the
374   // combined index.
375   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
376   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
377   ComputeCrossModuleImport(*Index, ImportLists, ExportLists);
378 
379   // Parallel optimizer + codegen
380   {
381     ThreadPool Pool(ThreadCount);
382     int count = 0;
383     for (auto &ModuleBuffer : Modules) {
384       Pool.async([&](int count) {
385         LLVMContext Context;
386         Context.setDiscardValueNames(LTODiscardValueNames);
387 
388         // Parse module now
389         auto TheModule = loadModuleFromBuffer(ModuleBuffer, Context, false);
390 
391         // Save temps: original file.
392         if (!SaveTempsDir.empty()) {
393           saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");
394         }
395 
396         auto &ImportList = ImportLists[TheModule->getModuleIdentifier()];
397         ProducedBinaries[count] = ProcessThinLTOModule(
398             *TheModule, *Index, ModuleMap, *TMBuilder.create(), ImportList,
399             CacheOptions, SaveTempsDir, count);
400       }, count);
401       count++;
402     }
403   }
404 
405   // If statistics were requested, print them out now.
406   if (llvm::AreStatisticsEnabled())
407     llvm::PrintStatistics();
408 }
409