[llvm] r254583 - Refactor FunctionImporter::importFunctions with a helper function to process the Worklist (NFC)
Mehdi Amini via llvm-commits
llvm-commits at lists.llvm.org
Wed Dec 2 18:37:33 PST 2015
Author: mehdi_amini
Date: Wed Dec 2 20:37:33 2015
New Revision: 254583
URL: http://llvm.org/viewvc/llvm-project?rev=254583&view=rev
Log:
Refactor FunctionImporter::importFunctions with a helper function to process the Worklist (NFC)
This precludes some more functional changes to perform bulk imports.
From: Mehdi Amini <mehdi.amini at apple.com>
Modified:
llvm/trunk/lib/Transforms/IPO/FunctionImport.cpp
Modified: llvm/trunk/lib/Transforms/IPO/FunctionImport.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/FunctionImport.cpp?rev=254583&r1=254582&r2=254583&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/IPO/FunctionImport.cpp (original)
+++ llvm/trunk/lib/Transforms/IPO/FunctionImport.cpp Wed Dec 2 20:37:33 2015
@@ -66,7 +66,6 @@ static void findExternalCalls(const Func
for (auto &BB : F) {
for (auto &I : BB) {
if (isa<CallInst>(I)) {
- DEBUG(dbgs() << "Found a call: '" << I << "'\n");
auto CalledFunction = cast<CallInst>(I).getCalledFunction();
// Insert any new external calls that have not already been
// added to set/worklist.
@@ -81,28 +80,14 @@ static void findExternalCalls(const Func
}
}
-// Automatically import functions in Module \p M based on the summaries index.
-//
-// The current implementation imports every called functions that exists in the
-// summaries index.
-bool FunctionImporter::importFunctions(Module &M) {
-
- bool Changed = false;
-
- /// First step is collecting the called external functions.
- StringSet<> CalledFunctions;
- SmallVector<StringRef, 64> Worklist;
- for (auto &F : M) {
- if (F.isDeclaration() || F.hasFnAttribute(Attribute::OptimizeNone))
- continue;
- findExternalCalls(F, CalledFunctions, Worklist);
- }
-
- /// Second step: for every call to an external function, try to import it.
-
- // Linker that will be used for importing function
- Linker L(M, DiagnosticHandler);
+// Helper function: given a worklist and an index, will process all the worklist
+// and import them based on the summary information
+static unsigned ProcessImportWorklist(Module &DestModule, SmallVector<StringRef, 64> &Worklist,
+ StringSet<> &CalledFunctions,
+ Linker &TheLinker, const FunctionInfoIndex &Index,
+ std::function<Module &(StringRef FileName)> &LazyModuleLoader) {
+ unsigned ImportCount = 0;
while (!Worklist.empty()) {
auto CalledFunctionName = Worklist.pop_back_val();
DEBUG(dbgs() << "Process import for " << CalledFunctionName << "\n");
@@ -141,14 +126,14 @@ bool FunctionImporter::importFunctions(M
<< "\n");
// Get the module for the import (potentially from the cache).
- auto &Module = getLazyModule(FileName);
- assert(&Module.getContext() == &M.getContext());
+ auto &Module = LazyModuleLoader(FileName);
+ assert(&Module.getContext() == &DestModule.getContext());
// The function that we will import!
GlobalValue *SGV = Module.getNamedValue(CalledFunctionName);
StringRef ImportFunctionName = CalledFunctionName;
if (!SGV) {
- // Might be local in source Module, promoted/renamed in dest Module M.
+ // Might be local in source Module, promoted/renamed in DestModule.
std::pair<StringRef, StringRef> Split =
CalledFunctionName.split(".llvm.");
SGV = Module.getNamedValue(Split.first);
@@ -184,21 +169,52 @@ bool FunctionImporter::importFunctions(M
// Link in the specified function.
DenseSet<const GlobalValue *> FunctionsToImport;
FunctionsToImport.insert(F);
- if (L.linkInModule(Module, Linker::Flags::None, &Index,
+ if (TheLinker.linkInModule(Module, Linker::Flags::None, &Index,
&FunctionsToImport))
report_fatal_error("Function Import: link error");
// Process the newly imported function and add callees to the worklist.
- GlobalValue *NewGV = M.getNamedValue(ImportFunctionName);
+ GlobalValue *NewGV = DestModule.getNamedValue(ImportFunctionName);
assert(NewGV);
Function *NewF = dyn_cast<Function>(NewGV);
assert(NewF);
findExternalCalls(*NewF, CalledFunctions, Worklist);
+ ++ImportCount;
+ }
+ return ImportCount;
+}
+
+// Automatically import functions in Module \p DestModule based on the summaries
+// index.
+//
+// The current implementation imports every called functions that exists in the
+// summaries index.
+bool FunctionImporter::importFunctions(Module &DestModule) {
+ DEBUG(errs() << "Starting import for Module " << DestModule.getModuleIdentifier()
+ << "\n");
+ unsigned ImportedCount = 0;
- Changed = true;
+ /// First step is collecting the called external functions.
+ StringSet<> CalledFunctions;
+ SmallVector<StringRef, 64> Worklist;
+ for (auto &F : DestModule) {
+ if (F.isDeclaration() || F.hasFnAttribute(Attribute::OptimizeNone))
+ continue;
+ findExternalCalls(F, CalledFunctions, Worklist);
}
+ if (Worklist.empty())
+ return false;
+
+ /// Second step: for every call to an external function, try to import it.
+
+ // Linker that will be used for importing function
+ Linker TheLinker(DestModule, DiagnosticHandler);
+
+ ImportedCount += ProcessImportWorklist(DestModule, Worklist, CalledFunctions, TheLinker, Index, getLazyModule );
- return Changed;
+ DEBUG(errs() << "Imported " << ImportedCount << " functions for Module "
+ << DestModule.getModuleIdentifier() << "\n");
+ return ImportedCount;
}
/// Summary file to use for function importing when using -function-import from
More information about the llvm-commits
mailing list