X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FLTO%2FLTOModule.h;h=97b5865bd47f81ac6322508542ec840b3ee25d15;hb=HEAD;hp=973466cc0eaadd5d5bbfaf40aedda048db39f60f;hpb=cc48854d5d51a2d7557f1040a61f160ad86c9729;p=oota-llvm.git diff --git a/include/llvm/LTO/LTOModule.h b/include/llvm/LTO/LTOModule.h index 973466cc0ea..97b5865bd47 100644 --- a/include/llvm/LTO/LTOModule.h +++ b/include/llvm/LTO/LTOModule.h @@ -11,15 +11,16 @@ // //===----------------------------------------------------------------------===// -#ifndef LTO_MODULE_H -#define LTO_MODULE_H +#ifndef LLVM_LTO_LTOMODULE_H +#define LLVM_LTO_LTOMODULE_H #include "llvm-c/lto.h" -#include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/StringMap.h" +#include "llvm/ADT/StringSet.h" #include "llvm/IR/Module.h" #include "llvm/MC/MCContext.h" -#include "llvm/Target/Mangler.h" +#include "llvm/MC/MCObjectFileInfo.h" +#include "llvm/Object/IRObjectFile.h" #include "llvm/Target/TargetMachine.h" #include #include @@ -31,166 +32,183 @@ namespace llvm { class MemoryBuffer; class TargetOptions; class Value; -} //===----------------------------------------------------------------------===// -/// LTOModule - C++ class which implements the opaque lto_module_t type. +/// C++ class which implements the opaque lto_module_t type. /// struct LTOModule { private: - typedef llvm::StringMap StringSet; - struct NameAndAttributes { const char *name; uint32_t attributes; bool isFunction; - const llvm::GlobalValue *symbol; + const GlobalValue *symbol; }; - llvm::OwningPtr _module; - llvm::OwningPtr _target; - std::vector _symbols; + std::unique_ptr OwnedContext; + + std::string LinkerOpts; + + std::unique_ptr IRFile; + std::unique_ptr _target; + std::vector _symbols; // _defines and _undefines only needed to disambiguate tentative definitions - StringSet _defines; - llvm::StringMap _undefines; + StringSet<> _defines; + StringMap _undefines; std::vector _asm_undefines; - llvm::MCContext _context; - // Use mangler to add GlobalPrefix to names to match linker names. - llvm::Mangler _mangler; + LTOModule(std::unique_ptr Obj, TargetMachine *TM); + LTOModule(std::unique_ptr Obj, TargetMachine *TM, + std::unique_ptr Context); - LTOModule(llvm::Module *m, llvm::TargetMachine *t); public: - /// isBitcodeFile - Returns 'true' if the file or memory contents is LLVM - /// bitcode. + ~LTOModule(); + + /// Returns 'true' if the file or memory contents is LLVM bitcode. static bool isBitcodeFile(const void *mem, size_t length); static bool isBitcodeFile(const char *path); - /// isBitcodeFileForTarget - Returns 'true' if the file or memory contents - /// is LLVM bitcode for the specified triple. - static bool isBitcodeFileForTarget(const void *mem, - size_t length, - const char *triplePrefix); - static bool isBitcodeFileForTarget(const char *path, - const char *triplePrefix); - - /// makeLTOModule - Create an LTOModule. N.B. These methods take ownership - /// of the buffer. The caller must have initialized the Targets, the - /// TargetMCs, the AsmPrinters, and the AsmParsers by calling: + /// Returns 'true' if the memory buffer is LLVM bitcode for the specified + /// triple. + static bool isBitcodeForTarget(MemoryBuffer *memBuffer, + StringRef triplePrefix); + + /// Returns a string representing the producer identification stored in the + /// bitcode, or "" if the bitcode does not contains any. + /// + static std::string getProducerString(MemoryBuffer *Buffer); + + /// Create a MemoryBuffer from a memory range with an optional name. + static std::unique_ptr + makeBuffer(const void *mem, size_t length, StringRef name = ""); + + /// Create an LTOModule. N.B. These methods take ownership of the buffer. The + /// caller must have initialized the Targets, the TargetMCs, the AsmPrinters, + /// and the AsmParsers by calling: /// /// InitializeAllTargets(); /// InitializeAllTargetMCs(); /// InitializeAllAsmPrinters(); /// InitializeAllAsmParsers(); - static LTOModule *makeLTOModule(const char* path, - std::string &errMsg); - static LTOModule *makeLTOModule(int fd, const char *path, - size_t size, std::string &errMsg); - static LTOModule *makeLTOModule(int fd, const char *path, - size_t map_size, - off_t offset, - std::string& errMsg); - static LTOModule *makeLTOModule(const void *mem, size_t length, - std::string &errMsg); - - /// getTargetTriple - Return the Module's target triple. - const char *getTargetTriple() { - return _module->getTargetTriple().c_str(); + static ErrorOr> + createFromFile(LLVMContext &Context, const char *path, TargetOptions options); + static ErrorOr> + createFromOpenFile(LLVMContext &Context, int fd, const char *path, + size_t size, TargetOptions options); + static ErrorOr> + createFromOpenFileSlice(LLVMContext &Context, int fd, const char *path, + size_t map_size, off_t offset, TargetOptions options); + static ErrorOr> + createFromBuffer(LLVMContext &Context, const void *mem, size_t length, + TargetOptions options, StringRef path = ""); + + static ErrorOr> + createInLocalContext(const void *mem, size_t length, TargetOptions options, + StringRef path); + static ErrorOr> + createInContext(const void *mem, size_t length, TargetOptions options, + StringRef path, LLVMContext *Context); + + const Module &getModule() const { + return const_cast(this)->getModule(); + } + Module &getModule() { + return IRFile->getModule(); + } + + std::unique_ptr takeModule() { return IRFile->takeModule(); } + + /// Return the Module's target triple. + const std::string &getTargetTriple() { + return getModule().getTargetTriple(); } - /// setTargetTriple - Set the Module's target triple. - void setTargetTriple(const char *triple) { - _module->setTargetTriple(triple); + /// Set the Module's target triple. + void setTargetTriple(StringRef Triple) { + getModule().setTargetTriple(Triple); } - /// getSymbolCount - Get the number of symbols + /// Get the number of symbols uint32_t getSymbolCount() { return _symbols.size(); } - /// getSymbolAttributes - Get the attributes for a symbol at the specified - /// index. + /// Get the attributes for a symbol at the specified index. lto_symbol_attributes getSymbolAttributes(uint32_t index) { if (index < _symbols.size()) return lto_symbol_attributes(_symbols[index].attributes); return lto_symbol_attributes(0); } - /// getSymbolName - Get the name of the symbol at the specified index. + /// Get the name of the symbol at the specified index. const char *getSymbolName(uint32_t index) { if (index < _symbols.size()) return _symbols[index].name; - return NULL; + return nullptr; + } + + const GlobalValue *getSymbolGV(uint32_t index) { + if (index < _symbols.size()) + return _symbols[index].symbol; + return nullptr; } - /// getLLVVMModule - Return the Module. - llvm::Module *getLLVVMModule() { return _module.get(); } + const char *getLinkerOpts() { + return LinkerOpts.c_str(); + } - /// getAsmUndefinedRefs - const std::vector &getAsmUndefinedRefs() { return _asm_undefines; } - /// getTargetOptions - Fill the TargetOptions object with the options - /// specified on the command line. - static void getTargetOptions(llvm::TargetOptions &Options); - private: - /// parseSymbols - Parse the symbols from the module and model-level ASM and - /// add them to either the defined or undefined lists. - bool parseSymbols(std::string &errMsg); + /// Parse metadata from the module + // FIXME: it only parses "Linker Options" metadata at the moment + void parseMetadata(); - /// addPotentialUndefinedSymbol - Add a symbol which isn't defined just yet - /// to a list to be resolved later. - void addPotentialUndefinedSymbol(const llvm::GlobalValue *dcl, bool isFunc); + /// Parse the symbols from the module and model-level ASM and add them to + /// either the defined or undefined lists. + void parseSymbols(); - /// addDefinedSymbol - Add a defined symbol to the list. - void addDefinedSymbol(const llvm::GlobalValue *def, bool isFunction); + /// Add a symbol which isn't defined just yet to a list to be resolved later. + void addPotentialUndefinedSymbol(const object::BasicSymbolRef &Sym, + bool isFunc); - /// addDefinedFunctionSymbol - Add a function symbol as defined to the list. - void addDefinedFunctionSymbol(const llvm::Function *f); + /// Add a defined symbol to the list. + void addDefinedSymbol(const char *Name, const GlobalValue *def, + bool isFunction); - /// addDefinedDataSymbol - Add a data symbol as defined to the list. - void addDefinedDataSymbol(const llvm::GlobalValue *v); + /// Add a data symbol as defined to the list. + void addDefinedDataSymbol(const object::BasicSymbolRef &Sym); + void addDefinedDataSymbol(const char*Name, const GlobalValue *v); - /// addAsmGlobalSymbols - Add global symbols from module-level ASM to the - /// defined or undefined lists. - bool addAsmGlobalSymbols(std::string &errMsg); + /// Add a function symbol as defined to the list. + void addDefinedFunctionSymbol(const object::BasicSymbolRef &Sym); + void addDefinedFunctionSymbol(const char *Name, const Function *F); - /// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the - /// defined list. + /// Add a global symbol from module-level ASM to the defined list. void addAsmGlobalSymbol(const char *, lto_symbol_attributes scope); - /// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to - /// the undefined list. + /// Add a global symbol from module-level ASM to the undefined list. void addAsmGlobalSymbolUndef(const char *); - /// addObjCClass - Parse i386/ppc ObjC class data structure. - void addObjCClass(const llvm::GlobalVariable *clgv); - - /// addObjCCategory - Parse i386/ppc ObjC category data structure. - void addObjCCategory(const llvm::GlobalVariable *clgv); - - /// addObjCClassRef - Parse i386/ppc ObjC class list data structure. - void addObjCClassRef(const llvm::GlobalVariable *clgv); + /// Parse i386/ppc ObjC class data structure. + void addObjCClass(const GlobalVariable *clgv); - /// objcClassNameFromExpression - Get string that the data pointer points - /// to. - bool objcClassNameFromExpression(const llvm::Constant* c, std::string &name); + /// Parse i386/ppc ObjC category data structure. + void addObjCCategory(const GlobalVariable *clgv); - /// isTargetMatch - Returns 'true' if the memory buffer is for the specified - /// target triple. - static bool isTargetMatch(llvm::MemoryBuffer *memBuffer, - const char *triplePrefix); + /// Parse i386/ppc ObjC class list data structure. + void addObjCClassRef(const GlobalVariable *clgv); - /// makeLTOModule - Create an LTOModule (private version). N.B. This - /// method takes ownership of the buffer. - static LTOModule *makeLTOModule(llvm::MemoryBuffer *buffer, - std::string &errMsg); + /// Get string that the data pointer points to. + bool objcClassNameFromExpression(const Constant *c, std::string &name); - /// makeBuffer - Create a MemoryBuffer from a memory range. - static llvm::MemoryBuffer *makeBuffer(const void *mem, size_t length); + /// Create an LTOModule (private version). + static ErrorOr> + makeLTOModule(MemoryBufferRef Buffer, TargetOptions options, + LLVMContext *Context); }; - -#endif // LTO_MODULE_H +} +#endif