1 //===- FunctionImport.cpp - ThinLTO Summary-based Function Import ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements Function import based on summaries.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Transforms/IPO/FunctionImport.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/Statistic.h"
18 #include "llvm/ADT/StringSet.h"
19 #include "llvm/ADT/Triple.h"
20 #include "llvm/IR/AutoUpgrade.h"
21 #include "llvm/IR/DiagnosticPrinter.h"
22 #include "llvm/IR/IntrinsicInst.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/IR/Verifier.h"
25 #include "llvm/IRReader/IRReader.h"
26 #include "llvm/Linker/Linker.h"
27 #include "llvm/Object/IRObjectFile.h"
28 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
29 #include "llvm/Support/CommandLine.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/SourceMgr.h"
32 #include "llvm/Transforms/IPO/Internalize.h"
33 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
35 #define DEBUG_TYPE "function-import"
39 STATISTIC(NumImported, "Number of functions imported");
41 /// Limit on instruction count of imported functions.
42 static cl::opt<unsigned> ImportInstrLimit(
43 "import-instr-limit", cl::init(100), cl::Hidden, cl::value_desc("N"),
44 cl::desc("Only import functions with less than N instructions"));
47 ImportInstrFactor("import-instr-evolution-factor", cl::init(0.7),
48 cl::Hidden, cl::value_desc("x"),
49 cl::desc("As we import functions, multiply the "
50 "`import-instr-limit` threshold by this factor "
51 "before processing newly imported functions"));
53 static cl::opt<float> ImportHotInstrFactor(
54 "import-hot-evolution-factor", cl::init(1.0), cl::Hidden,
56 cl::desc("As we import functions called from hot callsite, multiply the "
57 "`import-instr-limit` threshold by this factor "
58 "before processing newly imported functions"));
60 static cl::opt<float> ImportHotMultiplier(
61 "import-hot-multiplier", cl::init(3.0), cl::Hidden, cl::value_desc("x"),
62 cl::desc("Multiply the `import-instr-limit` threshold for hot callsites"));
64 // FIXME: This multiplier was not really tuned up.
65 static cl::opt<float> ImportColdMultiplier(
66 "import-cold-multiplier", cl::init(0), cl::Hidden, cl::value_desc("N"),
67 cl::desc("Multiply the `import-instr-limit` threshold for cold callsites"));
69 static cl::opt<bool> PrintImports("print-imports", cl::init(false), cl::Hidden,
70 cl::desc("Print imported functions"));
72 // Temporary allows the function import pass to disable always linking
73 // referenced discardable symbols.
75 DontForceImportReferencedDiscardableSymbols("disable-force-link-odr",
76 cl::init(false), cl::Hidden);
78 static cl::opt<bool> EnableImportMetadata(
79 "enable-import-metadata", cl::init(
81 true /*Enabled with asserts.*/
86 cl::Hidden, cl::desc("Enable import metadata like 'thinlto_src_module'"));
88 // Load lazily a module from \p FileName in \p Context.
89 static std::unique_ptr<Module> loadFile(const std::string &FileName,
90 LLVMContext &Context) {
92 DEBUG(dbgs() << "Loading '" << FileName << "'\n");
93 // Metadata isn't loaded until functions are imported, to minimize
94 // the memory overhead.
95 std::unique_ptr<Module> Result =
96 getLazyIRFileModule(FileName, Err, Context,
97 /* ShouldLazyLoadMetadata = */ true);
99 Err.print("function-import", errs());
100 report_fatal_error("Abort");
108 // Return true if the Summary describes a GlobalValue that can be externally
109 // referenced, i.e. it does not need renaming (linkage is not local) or renaming
110 // is possible (does not have a section for instance).
111 static bool canBeExternallyReferenced(const GlobalValueSummary &Summary) {
112 if (!Summary.needsRenaming())
115 if (Summary.noRename())
116 // Can't externally reference a global that needs renaming if has a section
117 // or is referenced from inline assembly, for example.
123 // Return true if \p GUID describes a GlobalValue that can be externally
124 // referenced, i.e. it does not need renaming (linkage is not local) or
125 // renaming is possible (does not have a section for instance).
126 static bool canBeExternallyReferenced(const ModuleSummaryIndex &Index,
127 GlobalValue::GUID GUID) {
128 auto Summaries = Index.findGlobalValueSummaryList(GUID);
129 if (Summaries == Index.end())
131 if (Summaries->second.size() != 1)
132 // If there are multiple globals with this GUID, then we know it is
133 // not a local symbol, and it is necessarily externally referenced.
136 // We don't need to check for the module path, because if it can't be
137 // externally referenced and we call it, it is necessarilly in the same
139 return canBeExternallyReferenced(**Summaries->second.begin());
142 // Return true if the global described by \p Summary can be imported in another
144 static bool eligibleForImport(const ModuleSummaryIndex &Index,
145 const GlobalValueSummary &Summary) {
146 if (!canBeExternallyReferenced(Summary))
147 // Can't import a global that needs renaming if has a section for instance.
148 // FIXME: we may be able to import it by copying it without promotion.
151 // Don't import functions that are not viable to inline.
152 if (Summary.isNotViableToInline())
155 // Check references (and potential calls) in the same module. If the current
156 // value references a global that can't be externally referenced it is not
157 // eligible for import. First check the flag set when we have possible
158 // opaque references (e.g. inline asm calls), then check the call and
160 if (Summary.hasInlineAsmMaybeReferencingInternal())
162 bool AllRefsCanBeExternallyReferenced =
163 llvm::all_of(Summary.refs(), [&](const ValueInfo &VI) {
164 return canBeExternallyReferenced(Index, VI.getGUID());
166 if (!AllRefsCanBeExternallyReferenced)
169 if (auto *FuncSummary = dyn_cast<FunctionSummary>(&Summary)) {
170 bool AllCallsCanBeExternallyReferenced = llvm::all_of(
171 FuncSummary->calls(), [&](const FunctionSummary::EdgeTy &Edge) {
172 return canBeExternallyReferenced(Index, Edge.first.getGUID());
174 if (!AllCallsCanBeExternallyReferenced)
180 /// Given a list of possible callee implementation for a call site, select one
181 /// that fits the \p Threshold.
183 /// FIXME: select "best" instead of first that fits. But what is "best"?
184 /// - The smallest: more likely to be inlined.
185 /// - The one with the least outgoing edges (already well optimized).
186 /// - One from a module already being imported from in order to reduce the
187 /// number of source modules parsed/linked.
188 /// - One that has PGO data attached.
189 /// - [insert you fancy metric here]
190 static const GlobalValueSummary *
191 selectCallee(const ModuleSummaryIndex &Index,
192 const GlobalValueSummaryList &CalleeSummaryList,
193 unsigned Threshold) {
194 auto It = llvm::find_if(
196 [&](const std::unique_ptr<GlobalValueSummary> &SummaryPtr) {
197 auto *GVSummary = SummaryPtr.get();
198 if (GlobalValue::isInterposableLinkage(GVSummary->linkage()))
199 // There is no point in importing these, we can't inline them
201 if (auto *AS = dyn_cast<AliasSummary>(GVSummary)) {
202 GVSummary = &AS->getAliasee();
203 // Alias can't point to "available_externally". However when we import
204 // linkOnceODR the linkage does not change. So we import the alias
205 // and aliasee only in this case.
206 // FIXME: we should import alias as available_externally *function*,
207 // the destination module does need to know it is an alias.
208 if (!GlobalValue::isLinkOnceODRLinkage(GVSummary->linkage()))
212 auto *Summary = cast<FunctionSummary>(GVSummary);
214 if (Summary->instCount() > Threshold)
217 if (!eligibleForImport(Index, *Summary))
222 if (It == CalleeSummaryList.end())
225 return cast<GlobalValueSummary>(It->get());
228 /// Return the summary for the function \p GUID that fits the \p Threshold, or
229 /// null if there's no match.
230 static const GlobalValueSummary *selectCallee(GlobalValue::GUID GUID,
232 const ModuleSummaryIndex &Index) {
233 auto CalleeSummaryList = Index.findGlobalValueSummaryList(GUID);
234 if (CalleeSummaryList == Index.end())
235 return nullptr; // This function does not have a summary
236 return selectCallee(Index, CalleeSummaryList->second, Threshold);
239 using EdgeInfo = std::tuple<const FunctionSummary *, unsigned /* Threshold */,
242 /// Compute the list of functions to import for a given caller. Mark these
243 /// imported functions and the symbols they reference in their source module as
244 /// exported from their source module.
245 static void computeImportForFunction(
246 const FunctionSummary &Summary, const ModuleSummaryIndex &Index,
247 const unsigned Threshold, const GVSummaryMapTy &DefinedGVSummaries,
248 SmallVectorImpl<EdgeInfo> &Worklist,
249 FunctionImporter::ImportMapTy &ImportList,
250 StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr) {
251 for (auto &Edge : Summary.calls()) {
252 auto GUID = Edge.first.getGUID();
253 DEBUG(dbgs() << " edge -> " << GUID << " Threshold:" << Threshold << "\n");
255 if (DefinedGVSummaries.count(GUID)) {
256 DEBUG(dbgs() << "ignored! Target already in destination module.\n");
260 auto GetBonusMultiplier = [](CalleeInfo::HotnessType Hotness) -> float {
261 if (Hotness == CalleeInfo::HotnessType::Hot)
262 return ImportHotMultiplier;
263 if (Hotness == CalleeInfo::HotnessType::Cold)
264 return ImportColdMultiplier;
268 const auto NewThreshold =
269 Threshold * GetBonusMultiplier(Edge.second.Hotness);
271 auto *CalleeSummary = selectCallee(GUID, NewThreshold, Index);
272 if (!CalleeSummary) {
273 DEBUG(dbgs() << "ignored! No qualifying callee with summary found.\n");
276 // "Resolve" the summary, traversing alias,
277 const FunctionSummary *ResolvedCalleeSummary;
278 if (isa<AliasSummary>(CalleeSummary)) {
279 ResolvedCalleeSummary = cast<FunctionSummary>(
280 &cast<AliasSummary>(CalleeSummary)->getAliasee());
282 GlobalValue::isLinkOnceODRLinkage(ResolvedCalleeSummary->linkage()) &&
283 "Unexpected alias to a non-linkonceODR in import list");
285 ResolvedCalleeSummary = cast<FunctionSummary>(CalleeSummary);
287 assert(ResolvedCalleeSummary->instCount() <= NewThreshold &&
288 "selectCallee() didn't honor the threshold");
290 auto GetAdjustedThreshold = [](unsigned Threshold, bool IsHotCallsite) {
291 // Adjust the threshold for next level of imported functions.
292 // The threshold is different for hot callsites because we can then
293 // inline chains of hot calls.
295 return Threshold * ImportHotInstrFactor;
296 return Threshold * ImportInstrFactor;
299 bool IsHotCallsite = Edge.second.Hotness == CalleeInfo::HotnessType::Hot;
300 const auto AdjThreshold = GetAdjustedThreshold(Threshold, IsHotCallsite);
302 auto ExportModulePath = ResolvedCalleeSummary->modulePath();
303 auto &ProcessedThreshold = ImportList[ExportModulePath][GUID];
304 /// Since the traversal of the call graph is DFS, we can revisit a function
305 /// a second time with a higher threshold. In this case, it is added back to
306 /// the worklist with the new threshold.
307 if (ProcessedThreshold && ProcessedThreshold >= AdjThreshold) {
308 DEBUG(dbgs() << "ignored! Target was already seen with Threshold "
309 << ProcessedThreshold << "\n");
312 bool PreviouslyImported = ProcessedThreshold != 0;
313 // Mark this function as imported in this module, with the current Threshold
314 ProcessedThreshold = AdjThreshold;
316 // Make exports in the source module.
318 auto &ExportList = (*ExportLists)[ExportModulePath];
319 ExportList.insert(GUID);
320 if (!PreviouslyImported) {
321 // This is the first time this function was exported from its source
322 // module, so mark all functions and globals it references as exported
323 // to the outside if they are defined in the same source module.
324 // For efficiency, we unconditionally add all the referenced GUIDs
325 // to the ExportList for this module, and will prune out any not
326 // defined in the module later in a single pass.
327 for (auto &Edge : ResolvedCalleeSummary->calls()) {
328 auto CalleeGUID = Edge.first.getGUID();
329 ExportList.insert(CalleeGUID);
331 for (auto &Ref : ResolvedCalleeSummary->refs()) {
332 auto GUID = Ref.getGUID();
333 ExportList.insert(GUID);
338 // Insert the newly imported function to the worklist.
339 Worklist.emplace_back(ResolvedCalleeSummary, AdjThreshold, GUID);
343 /// Given the list of globals defined in a module, compute the list of imports
344 /// as well as the list of "exports", i.e. the list of symbols referenced from
345 /// another module (that may require promotion).
346 static void ComputeImportForModule(
347 const GVSummaryMapTy &DefinedGVSummaries, const ModuleSummaryIndex &Index,
348 FunctionImporter::ImportMapTy &ImportList,
349 StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr) {
350 // Worklist contains the list of function imported in this module, for which
351 // we will analyse the callees and may import further down the callgraph.
352 SmallVector<EdgeInfo, 128> Worklist;
354 // Populate the worklist with the import for the functions in the current
356 for (auto &GVSummary : DefinedGVSummaries) {
357 auto *Summary = GVSummary.second;
358 if (auto *AS = dyn_cast<AliasSummary>(Summary))
359 Summary = &AS->getAliasee();
360 auto *FuncSummary = dyn_cast<FunctionSummary>(Summary);
362 // Skip import for global variables
364 DEBUG(dbgs() << "Initalize import for " << GVSummary.first << "\n");
365 computeImportForFunction(*FuncSummary, Index, ImportInstrLimit,
366 DefinedGVSummaries, Worklist, ImportList,
370 // Process the newly imported functions and add callees to the worklist.
371 while (!Worklist.empty()) {
372 auto FuncInfo = Worklist.pop_back_val();
373 auto *Summary = std::get<0>(FuncInfo);
374 auto Threshold = std::get<1>(FuncInfo);
375 auto GUID = std::get<2>(FuncInfo);
377 // Check if we later added this summary with a higher threshold.
378 // If so, skip this entry.
379 auto ExportModulePath = Summary->modulePath();
380 auto &LatestProcessedThreshold = ImportList[ExportModulePath][GUID];
381 if (LatestProcessedThreshold > Threshold)
384 computeImportForFunction(*Summary, Index, Threshold, DefinedGVSummaries,
385 Worklist, ImportList, ExportLists);
389 } // anonymous namespace
391 /// Compute all the import and export for every module using the Index.
392 void llvm::ComputeCrossModuleImport(
393 const ModuleSummaryIndex &Index,
394 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
395 StringMap<FunctionImporter::ImportMapTy> &ImportLists,
396 StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
397 // For each module that has function defined, compute the import/export lists.
398 for (auto &DefinedGVSummaries : ModuleToDefinedGVSummaries) {
399 auto &ImportList = ImportLists[DefinedGVSummaries.first()];
400 DEBUG(dbgs() << "Computing import for Module '"
401 << DefinedGVSummaries.first() << "'\n");
402 ComputeImportForModule(DefinedGVSummaries.second, Index, ImportList,
406 // When computing imports we added all GUIDs referenced by anything
407 // imported from the module to its ExportList. Now we prune each ExportList
408 // of any not defined in that module. This is more efficient than checking
409 // while computing imports because some of the summary lists may be long
410 // due to linkonce (comdat) copies.
411 for (auto &ELI : ExportLists) {
412 const auto &DefinedGVSummaries =
413 ModuleToDefinedGVSummaries.lookup(ELI.first());
414 for (auto EI = ELI.second.begin(); EI != ELI.second.end();) {
415 if (!DefinedGVSummaries.count(*EI))
416 EI = ELI.second.erase(EI);
423 DEBUG(dbgs() << "Import/Export lists for " << ImportLists.size()
425 for (auto &ModuleImports : ImportLists) {
426 auto ModName = ModuleImports.first();
427 auto &Exports = ExportLists[ModName];
428 DEBUG(dbgs() << "* Module " << ModName << " exports " << Exports.size()
429 << " functions. Imports from " << ModuleImports.second.size()
431 for (auto &Src : ModuleImports.second) {
432 auto SrcModName = Src.first();
433 DEBUG(dbgs() << " - " << Src.second.size() << " functions imported from "
434 << SrcModName << "\n");
440 /// Compute all the imports for the given module in the Index.
441 void llvm::ComputeCrossModuleImportForModule(
442 StringRef ModulePath, const ModuleSummaryIndex &Index,
443 FunctionImporter::ImportMapTy &ImportList) {
445 // Collect the list of functions this module defines.
447 GVSummaryMapTy FunctionSummaryMap;
448 Index.collectDefinedFunctionsForModule(ModulePath, FunctionSummaryMap);
450 // Compute the import list for this module.
451 DEBUG(dbgs() << "Computing import for Module '" << ModulePath << "'\n");
452 ComputeImportForModule(FunctionSummaryMap, Index, ImportList);
455 DEBUG(dbgs() << "* Module " << ModulePath << " imports from "
456 << ImportList.size() << " modules.\n");
457 for (auto &Src : ImportList) {
458 auto SrcModName = Src.first();
459 DEBUG(dbgs() << " - " << Src.second.size() << " functions imported from "
460 << SrcModName << "\n");
465 /// Compute the set of summaries needed for a ThinLTO backend compilation of
467 void llvm::gatherImportedSummariesForModule(
468 StringRef ModulePath,
469 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
470 const FunctionImporter::ImportMapTy &ImportList,
471 std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex) {
472 // Include all summaries from the importing module.
473 ModuleToSummariesForIndex[ModulePath] =
474 ModuleToDefinedGVSummaries.lookup(ModulePath);
475 // Include summaries for imports.
476 for (auto &ILI : ImportList) {
477 auto &SummariesForIndex = ModuleToSummariesForIndex[ILI.first()];
478 const auto &DefinedGVSummaries =
479 ModuleToDefinedGVSummaries.lookup(ILI.first());
480 for (auto &GI : ILI.second) {
481 const auto &DS = DefinedGVSummaries.find(GI.first);
482 assert(DS != DefinedGVSummaries.end() &&
483 "Expected a defined summary for imported global value");
484 SummariesForIndex[GI.first] = DS->second;
489 /// Emit the files \p ModulePath will import from into \p OutputFilename.
491 llvm::EmitImportsFiles(StringRef ModulePath, StringRef OutputFilename,
492 const FunctionImporter::ImportMapTy &ModuleImports) {
494 raw_fd_ostream ImportsOS(OutputFilename, EC, sys::fs::OpenFlags::F_None);
497 for (auto &ILI : ModuleImports)
498 ImportsOS << ILI.first() << "\n";
499 return std::error_code();
502 /// Fixup WeakForLinker linkages in \p TheModule based on summary analysis.
503 void llvm::thinLTOResolveWeakForLinkerModule(
504 Module &TheModule, const GVSummaryMapTy &DefinedGlobals) {
505 auto updateLinkage = [&](GlobalValue &GV) {
506 if (!GlobalValue::isWeakForLinker(GV.getLinkage()))
508 // See if the global summary analysis computed a new resolved linkage.
509 const auto &GS = DefinedGlobals.find(GV.getGUID());
510 if (GS == DefinedGlobals.end())
512 auto NewLinkage = GS->second->linkage();
513 if (NewLinkage == GV.getLinkage())
515 DEBUG(dbgs() << "ODR fixing up linkage for `" << GV.getName() << "` from "
516 << GV.getLinkage() << " to " << NewLinkage << "\n");
517 GV.setLinkage(NewLinkage);
518 // Remove functions converted to available_externally from comdats,
519 // as this is a declaration for the linker, and will be dropped eventually.
520 // It is illegal for comdats to contain declarations.
521 auto *GO = dyn_cast_or_null<GlobalObject>(&GV);
522 if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) {
523 assert(GO->hasAvailableExternallyLinkage() &&
524 "Expected comdat on definition (possibly available external)");
525 GO->setComdat(nullptr);
529 // Process functions and global now
530 for (auto &GV : TheModule)
532 for (auto &GV : TheModule.globals())
534 for (auto &GV : TheModule.aliases())
538 /// Run internalization on \p TheModule based on symmary analysis.
539 void llvm::thinLTOInternalizeModule(Module &TheModule,
540 const GVSummaryMapTy &DefinedGlobals) {
541 // Parse inline ASM and collect the list of symbols that are not defined in
542 // the current module.
543 StringSet<> AsmUndefinedRefs;
544 ModuleSymbolTable::CollectAsmSymbols(
545 Triple(TheModule.getTargetTriple()), TheModule.getModuleInlineAsm(),
546 [&AsmUndefinedRefs](StringRef Name, object::BasicSymbolRef::Flags Flags) {
547 if (Flags & object::BasicSymbolRef::SF_Undefined)
548 AsmUndefinedRefs.insert(Name);
551 // Declare a callback for the internalize pass that will ask for every
552 // candidate GlobalValue if it can be internalized or not.
553 auto MustPreserveGV = [&](const GlobalValue &GV) -> bool {
554 // Can't be internalized if referenced in inline asm.
555 if (AsmUndefinedRefs.count(GV.getName()))
558 // Lookup the linkage recorded in the summaries during global analysis.
559 const auto &GS = DefinedGlobals.find(GV.getGUID());
560 GlobalValue::LinkageTypes Linkage;
561 if (GS == DefinedGlobals.end()) {
562 // Must have been promoted (possibly conservatively). Find original
563 // name so that we can access the correct summary and see if it can
564 // be internalized again.
565 // FIXME: Eventually we should control promotion instead of promoting
566 // and internalizing again.
568 ModuleSummaryIndex::getOriginalNameBeforePromote(GV.getName());
569 std::string OrigId = GlobalValue::getGlobalIdentifier(
570 OrigName, GlobalValue::InternalLinkage,
571 TheModule.getSourceFileName());
572 const auto &GS = DefinedGlobals.find(GlobalValue::getGUID(OrigId));
573 if (GS == DefinedGlobals.end()) {
574 // Also check the original non-promoted non-globalized name. In some
575 // cases a preempted weak value is linked in as a local copy because
576 // it is referenced by an alias (IRLinker::linkGlobalValueProto).
577 // In that case, since it was originally not a local value, it was
578 // recorded in the index using the original name.
579 // FIXME: This may not be needed once PR27866 is fixed.
580 const auto &GS = DefinedGlobals.find(GlobalValue::getGUID(OrigName));
581 assert(GS != DefinedGlobals.end());
582 Linkage = GS->second->linkage();
584 Linkage = GS->second->linkage();
587 Linkage = GS->second->linkage();
588 return !GlobalValue::isLocalLinkage(Linkage);
591 // FIXME: See if we can just internalize directly here via linkage changes
592 // based on the index, rather than invoking internalizeModule.
593 llvm::internalizeModule(TheModule, MustPreserveGV);
596 // Automatically import functions in Module \p DestModule based on the summaries
599 Expected<bool> FunctionImporter::importFunctions(
600 Module &DestModule, const FunctionImporter::ImportMapTy &ImportList,
601 bool ForceImportReferencedDiscardableSymbols) {
602 DEBUG(dbgs() << "Starting import for Module "
603 << DestModule.getModuleIdentifier() << "\n");
604 unsigned ImportedCount = 0;
606 // Linker that will be used for importing function
607 Linker TheLinker(DestModule);
608 // Do the actual import of functions now, one Module at a time
609 std::set<StringRef> ModuleNameOrderedList;
610 for (auto &FunctionsToImportPerModule : ImportList) {
611 ModuleNameOrderedList.insert(FunctionsToImportPerModule.first());
613 for (auto &Name : ModuleNameOrderedList) {
614 // Get the module for the import
615 const auto &FunctionsToImportPerModule = ImportList.find(Name);
616 assert(FunctionsToImportPerModule != ImportList.end());
617 Expected<std::unique_ptr<Module>> SrcModuleOrErr = ModuleLoader(Name);
619 return SrcModuleOrErr.takeError();
620 std::unique_ptr<Module> SrcModule = std::move(*SrcModuleOrErr);
621 assert(&DestModule.getContext() == &SrcModule->getContext() &&
624 // If modules were created with lazy metadata loading, materialize it
625 // now, before linking it (otherwise this will be a noop).
626 if (Error Err = SrcModule->materializeMetadata())
627 return std::move(Err);
628 UpgradeDebugInfo(*SrcModule);
630 auto &ImportGUIDs = FunctionsToImportPerModule->second;
631 // Find the globals to import
632 DenseSet<const GlobalValue *> GlobalsToImport;
633 for (Function &F : *SrcModule) {
636 auto GUID = F.getGUID();
637 auto Import = ImportGUIDs.count(GUID);
638 DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing function " << GUID
639 << " " << F.getName() << " from "
640 << SrcModule->getSourceFileName() << "\n");
642 if (Error Err = F.materialize())
643 return std::move(Err);
644 if (EnableImportMetadata) {
645 // Add 'thinlto_src_module' metadata for statistics and debugging.
647 "thinlto_src_module",
649 DestModule.getContext(),
650 {llvm::MDString::get(DestModule.getContext(),
651 SrcModule->getSourceFileName())}));
653 GlobalsToImport.insert(&F);
656 for (GlobalVariable &GV : SrcModule->globals()) {
659 auto GUID = GV.getGUID();
660 auto Import = ImportGUIDs.count(GUID);
661 DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing global " << GUID
662 << " " << GV.getName() << " from "
663 << SrcModule->getSourceFileName() << "\n");
665 if (Error Err = GV.materialize())
666 return std::move(Err);
667 GlobalsToImport.insert(&GV);
670 for (GlobalAlias &GA : SrcModule->aliases()) {
673 auto GUID = GA.getGUID();
674 auto Import = ImportGUIDs.count(GUID);
675 DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing alias " << GUID
676 << " " << GA.getName() << " from "
677 << SrcModule->getSourceFileName() << "\n");
679 // Alias can't point to "available_externally". However when we import
680 // linkOnceODR the linkage does not change. So we import the alias
681 // and aliasee only in this case. This has been handled by
682 // computeImportForFunction()
683 GlobalObject *GO = GA.getBaseObject();
684 assert(GO->hasLinkOnceODRLinkage() &&
685 "Unexpected alias to a non-linkonceODR in import list");
687 if (!GlobalsToImport.count(GO))
688 DEBUG(dbgs() << " alias triggers importing aliasee " << GO->getGUID()
689 << " " << GO->getName() << " from "
690 << SrcModule->getSourceFileName() << "\n");
692 if (Error Err = GO->materialize())
693 return std::move(Err);
694 GlobalsToImport.insert(GO);
695 if (Error Err = GA.materialize())
696 return std::move(Err);
697 GlobalsToImport.insert(&GA);
701 // Link in the specified functions.
702 if (renameModuleForThinLTO(*SrcModule, Index, &GlobalsToImport))
706 for (const auto *GV : GlobalsToImport)
707 dbgs() << DestModule.getSourceFileName() << ": Import " << GV->getName()
708 << " from " << SrcModule->getSourceFileName() << "\n";
711 // Instruct the linker that the client will take care of linkonce resolution
712 unsigned Flags = Linker::Flags::None;
713 if (!ForceImportReferencedDiscardableSymbols)
714 Flags |= Linker::Flags::DontForceLinkLinkonceODR;
716 if (TheLinker.linkInModule(std::move(SrcModule), Flags, &GlobalsToImport))
717 report_fatal_error("Function Import: link error");
719 ImportedCount += GlobalsToImport.size();
722 NumImported += ImportedCount;
724 DEBUG(dbgs() << "Imported " << ImportedCount << " functions for Module "
725 << DestModule.getModuleIdentifier() << "\n");
726 return ImportedCount;
729 /// Summary file to use for function importing when using -function-import from
730 /// the command line.
731 static cl::opt<std::string>
732 SummaryFile("summary-file",
733 cl::desc("The summary file to use for function importing."));
735 static bool doImportingForModule(Module &M) {
736 if (SummaryFile.empty())
737 report_fatal_error("error: -function-import requires -summary-file\n");
738 Expected<std::unique_ptr<ModuleSummaryIndex>> IndexPtrOrErr =
739 getModuleSummaryIndexForFile(SummaryFile);
740 if (!IndexPtrOrErr) {
741 logAllUnhandledErrors(IndexPtrOrErr.takeError(), errs(),
742 "Error loading file '" + SummaryFile + "': ");
745 std::unique_ptr<ModuleSummaryIndex> Index = std::move(*IndexPtrOrErr);
747 // First step is collecting the import list.
748 FunctionImporter::ImportMapTy ImportList;
749 ComputeCrossModuleImportForModule(M.getModuleIdentifier(), *Index,
752 // Conservatively mark all internal values as promoted. This interface is
753 // only used when doing importing via the function importing pass. The pass
754 // is only enabled when testing importing via the 'opt' tool, which does
755 // not do the ThinLink that would normally determine what values to promote.
756 for (auto &I : *Index) {
757 for (auto &S : I.second) {
758 if (GlobalValue::isLocalLinkage(S->linkage()))
759 S->setLinkage(GlobalValue::ExternalLinkage);
763 // Next we need to promote to global scope and rename any local values that
764 // are potentially exported to other modules.
765 if (renameModuleForThinLTO(M, *Index, nullptr)) {
766 errs() << "Error renaming module\n";
770 // Perform the import now.
771 auto ModuleLoader = [&M](StringRef Identifier) {
772 return loadFile(Identifier, M.getContext());
774 FunctionImporter Importer(*Index, ModuleLoader);
775 Expected<bool> Result = Importer.importFunctions(
776 M, ImportList, !DontForceImportReferencedDiscardableSymbols);
778 // FIXME: Probably need to propagate Errors through the pass manager.
780 logAllUnhandledErrors(Result.takeError(), errs(),
781 "Error importing module: ");
789 /// Pass that performs cross-module function import provided a summary file.
790 class FunctionImportLegacyPass : public ModulePass {
792 /// Pass identification, replacement for typeid
795 /// Specify pass name for debug output
796 StringRef getPassName() const override { return "Function Importing"; }
798 explicit FunctionImportLegacyPass() : ModulePass(ID) {}
800 bool runOnModule(Module &M) override {
804 return doImportingForModule(M);
807 } // anonymous namespace
809 PreservedAnalyses FunctionImportPass::run(Module &M,
810 ModuleAnalysisManager &AM) {
811 if (!doImportingForModule(M))
812 return PreservedAnalyses::all();
814 return PreservedAnalyses::none();
817 char FunctionImportLegacyPass::ID = 0;
818 INITIALIZE_PASS(FunctionImportLegacyPass, "function-import",
819 "Summary Based Function Import", false, false)
822 Pass *createFunctionImportPass() {
823 return new FunctionImportLegacyPass();