class Module;
class FunctionInfoIndex;
-/// The function importer is automatically importing function from other modules
-/// based on the provided summary informations.
-class FunctionImporter {
+/// Helper to load on demand a Module from file and cache it for subsequent
+/// queries. It can be used with the FunctionImporter.
+class ModuleLazyLoaderCache {
+ /// The context that will be used for importing.
+ LLVMContext &Context;
/// Cache of lazily loaded module for import.
StringMap<std::unique_ptr<Module>> ModuleMap;
- /// The context that will be used for importing.
- LLVMContext &Context;
+public:
+ /// Create the loader, Module will be initialized in \p Context.
+ ModuleLazyLoaderCache(LLVMContext &Context) : Context(Context) {}
+
+ /// Retrieve a Module from the cache or lazily load it on demand.
+ Module &operator()(StringRef FileName);
+};
+
+/// The function importer is automatically importing function from other modules
+/// based on the provided summary informations.
+class FunctionImporter {
/// The summaries index used to trigger importing.
const FunctionInfoIndex &Index;
DiagnosticHandlerFunction DiagnosticHandler;
/// Retrieve a Module from the cache or lazily load it on demand.
- Module &getOrLoadModule(StringRef FileName);
+ std::function<Module &(StringRef FileName)> getLazyModule;
public:
/// Create a Function Importer.
- FunctionImporter(LLVMContext &Context, const FunctionInfoIndex &Index,
- DiagnosticHandlerFunction DiagnosticHandler)
- : Context(Context), Index(Index), DiagnosticHandler(DiagnosticHandler) {}
+ FunctionImporter(const FunctionInfoIndex &Index,
+ DiagnosticHandlerFunction DiagnosticHandler,
+ std::function<Module &(StringRef FileName)> ModuleLoader)
+ : Index(Index), DiagnosticHandler(DiagnosticHandler),
+ getLazyModule(ModuleLoader) {}
/// Import functions in Module \p M based on the summary informations.
bool importFunctions(Module &M);
}
// Get a Module for \p FileName from the cache, or load it lazily.
-Module &FunctionImporter::getOrLoadModule(StringRef FileName) {
+Module &ModuleLazyLoaderCache::operator()(StringRef FileName) {
auto &Module = ModuleMap[FileName];
if (!Module)
Module = loadFile(FileName, Context);
// The current implementation imports every called functions that exists in the
// summaries index.
bool FunctionImporter::importFunctions(Module &M) {
- assert(&Context == &M.getContext());
bool Changed = false;
<< "\n");
// Get the module for the import (potentially from the cache).
- auto &Module = getOrLoadModule(FileName);
+ auto &Module = getLazyModule(FileName);
+ assert(&Module.getContext() == &M.getContext());
// The function that we will import!
GlobalValue *SGV = Module.getNamedValue(CalledFunctionName);
}
// Perform the import now.
- FunctionImporter Importer(M.getContext(), *Index, diagnosticHandler);
+ ModuleLazyLoaderCache Loader(M.getContext());
+ FunctionImporter Importer(*Index, diagnosticHandler,
+ [&](StringRef Name)
+ -> Module &{ return Loader(Name); });
return Importer.importFunctions(M);
return false;