| //===-- llvm/ModuleProvider.h - Interface for module providers --*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file was developed by the LLVM research group and is distributed under |
| // the University of Illinois Open Source License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file provides an abstract interface for loading a module from some |
| // place. This interface allows incremental or random access loading of |
| // functions from the file. This is useful for applications like JIT compilers |
| // or interprocedural optimizers that do not need the entire program in memory |
| // at the same time. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef MODULEPROVIDER_H |
| #define MODULEPROVIDER_H |
| |
| #include <string> |
| |
| namespace llvm { |
| |
| class Function; |
| class Module; |
| |
| class ModuleProvider { |
| protected: |
| Module *TheModule; |
| ModuleProvider(); |
| |
| public: |
| virtual ~ModuleProvider(); |
| |
| /// getModule - returns the module this provider is encapsulating. |
| /// |
| Module* getModule() { return TheModule; } |
| |
| /// materializeFunction - make sure the given function is fully read. If the |
| /// module is corrupt, this returns true and fills in the optional string |
| /// with information about the problem. If successful, this returns false. |
| /// |
| virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0) = 0; |
| |
| /// materializeModule - make sure the entire Module has been completely read. |
| /// On error, return null and fill in the error string if specified. |
| /// |
| virtual Module* materializeModule(std::string *ErrInfo = 0) = 0; |
| |
| /// releaseModule - no longer delete the Module* when provider is destroyed. |
| /// On error, return null and fill in the error string if specified. |
| /// |
| virtual Module* releaseModule(std::string *ErrInfo = 0) { |
| // Since we're losing control of this Module, we must hand it back complete |
| if (!materializeModule(ErrInfo)) |
| return 0; |
| Module *tempM = TheModule; |
| TheModule = 0; |
| return tempM; |
| } |
| }; |
| |
| |
| /// ExistingModuleProvider - Allow conversion from a fully materialized Module |
| /// into a ModuleProvider, allowing code that expects a ModuleProvider to work |
| /// if we just have a Module. Note that the ModuleProvider takes ownership of |
| /// the Module specified. |
| struct ExistingModuleProvider : public ModuleProvider { |
| ExistingModuleProvider(Module *M) { |
| TheModule = M; |
| } |
| bool materializeFunction(Function *F, std::string *ErrInfo = 0) { |
| return false; |
| } |
| Module* materializeModule(std::string *ErrInfo = 0) { return TheModule; } |
| }; |
| |
| } // End llvm namespace |
| |
| #endif |