X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FModule.h;h=7a139cc1e0a92638daf8312e9b74a668c100b3b2;hb=617dd7baa6dfd3a7b5ee72ace37f6b6aeaa6006b;hp=09eba81b4ebeefaf4db4a6bcad252d7a110f2f63;hpb=b7c2c1246f10972d5a8f55499226872608eb10f9;p=oota-llvm.git diff --git a/include/llvm/Module.h b/include/llvm/Module.h index 09eba81b4eb..7a139cc1e0a 100644 --- a/include/llvm/Module.h +++ b/include/llvm/Module.h @@ -7,7 +7,8 @@ // //===----------------------------------------------------------------------===// // -/// @file This file contains the declarations for the Module class. +/// @file +/// Module.h This file contains the declarations for the Module class. // //===----------------------------------------------------------------------===// @@ -24,33 +25,36 @@ namespace llvm { class GlobalValueRefMap; // Used by ConstantVals.cpp class FunctionType; +class LLVMContext; template<> struct ilist_traits : public SymbolTableListTraits { - // createSentinel is used to create a node that marks the end of the list. - static Function *createSentinel(); - static void destroySentinel(Function *F) { delete F; } - static iplist &getList(Module *M); - static inline ValueSymbolTable *getSymTab(Module *M); - static int getListOffset(); + + // createSentinel is used to get hold of the node that marks the end of the + // list... (same trick used here as in ilist_traits) + Function *createSentinel() const { + return static_cast(&Sentinel); + } + static void destroySentinel(Function*) {} + + Function *provideInitialHead() const { return createSentinel(); } + Function *ensureHead(Function*) const { return createSentinel(); } + static void noteHead(Function*, Function*) {} + +private: + mutable ilist_node Sentinel; }; template<> struct ilist_traits : public SymbolTableListTraits { // createSentinel is used to create a node that marks the end of the list. static GlobalVariable *createSentinel(); static void destroySentinel(GlobalVariable *GV) { delete GV; } - static iplist &getList(Module *M); - static inline ValueSymbolTable *getSymTab(Module *M); - static int getListOffset(); }; template<> struct ilist_traits : public SymbolTableListTraits { // createSentinel is used to create a node that marks the end of the list. static GlobalAlias *createSentinel(); static void destroySentinel(GlobalAlias *GA) { delete GA; } - static iplist &getList(Module *M); - static inline ValueSymbolTable *getSymTab(Module *M); - static int getListOffset(); }; /// A Module instance is used to store all the information related to an @@ -106,6 +110,8 @@ public: /// @name Member Variables /// @{ private: + LLVMContext& Context; ///< The LLVMContext from which types and + ///< constants are allocated. GlobalListType GlobalList; ///< The Global Variables in the module FunctionListType FunctionList; ///< The Functions in the module AliasListType AliasList; ///< The Aliases in the module @@ -125,7 +131,7 @@ private: public: /// The Module constructor. Note that there is no default constructor. You /// must provide a name for the module upon construction. - explicit Module(const std::string &ModuleID); + explicit Module(const std::string &ModuleID, LLVMContext& C); /// The module destructor. This will dropAllReferences. ~Module(); @@ -154,6 +160,10 @@ public: /// @returns PointerSize - an enumeration for the size of the target's pointer PointerSize getPointerSize() const; + /// Get the global data context. + /// @returns LLVMContext - a container for LLVM's global information + LLVMContext& getContext() const { return Context; } + /// Get any module-scope inline assembly blocks. /// @returns a string containing the module-scope inline assembly blocks. const std::string &getModuleInlineAsm() const { return GlobalScopeAsm; } @@ -181,6 +191,16 @@ public: GlobalScopeAsm += '\n'; } +/// @} +/// @name Generic Value Accessors +/// @{ + + /// getNamedValue - Return the first global value in the module with + /// the specified name, of arbitrary type. This method returns null + /// if a global with the specified name is not found. + GlobalValue *getNamedValue(const std::string &Name) const; + GlobalValue *getNamedValue(const char *Name) const; + /// @} /// @name Function Accessors /// @{ @@ -188,12 +208,15 @@ public: /// getOrInsertFunction - Look up the specified function in the module symbol /// table. Four possibilities: /// 1. If it does not exist, add a prototype for the function and return it. - /// 2. If it exists, and has internal linkage, the existing function is + /// 2. If it exists, and has a local linkage, the existing function is /// renamed and a new one is inserted. /// 3. Otherwise, if the existing function has the correct prototype, return /// the existing function. /// 4. Finally, the function exists but has the wrong prototype: return the /// function with a constantexpr cast to the right prototype. + Constant *getOrInsertFunction(const std::string &Name, const FunctionType *T, + AttrListPtr AttributeList); + Constant *getOrInsertFunction(const std::string &Name, const FunctionType *T); /// getOrInsertFunction - Look up the specified function in the module symbol @@ -203,9 +226,17 @@ public: /// named function has a different type. This version of the method takes a /// null terminated list of function arguments, which makes it easier for /// clients to use. - Constant *getOrInsertFunction(const std::string &Name, const Type *RetTy,...) + Constant *getOrInsertFunction(const std::string &Name, + AttrListPtr AttributeList, + const Type *RetTy, ...) END_WITH_NULL; + + Constant *getOrInsertFunction(const std::string &Name, const Type *RetTy, ...) END_WITH_NULL; + Constant *getOrInsertTargetIntrinsic(const std::string &Name, + const FunctionType *Ty, + AttrListPtr AttributeList); + /// getFunction - Look up the specified function in the module symbol table. /// If it does not exist, return null. Function *getFunction(const std::string &Name) const; @@ -272,14 +303,23 @@ public: const GlobalListType &getGlobalList() const { return GlobalList; } /// Get the Module's list of global variables. GlobalListType &getGlobalList() { return GlobalList; } + static iplist Module::*getSublistAccess(GlobalVariable*) { + return &Module::GlobalList; + } /// Get the Module's list of functions (constant). const FunctionListType &getFunctionList() const { return FunctionList; } /// Get the Module's list of functions. FunctionListType &getFunctionList() { return FunctionList; } + static iplist Module::*getSublistAccess(Function*) { + return &Module::FunctionList; + } /// Get the Module's list of aliases (constant). const AliasListType &getAliasList() const { return AliasList; } /// Get the Module's list of aliases. AliasListType &getAliasList() { return AliasList; } + static iplist Module::*getSublistAccess(GlobalAlias*) { + return &Module::AliasList; + } /// Get the symbol table of global variable and function identifiers const ValueSymbolTable &getValueSymbolTable() const { return *ValSymTab; } /// Get the Module's symbol table of global variable and function identifiers. @@ -373,19 +413,6 @@ public: /// that has "dropped all references", except operator delete. void dropAllReferences(); /// @} - - static unsigned getFunctionListOffset() { - Module *Obj = 0; - return unsigned(reinterpret_cast(&Obj->FunctionList)); - } - static unsigned getGlobalVariableListOffset() { - Module *Obj = 0; - return unsigned(reinterpret_cast(&Obj->GlobalList)); - } - static unsigned getAliasListOffset() { - Module *Obj = 0; - return unsigned(reinterpret_cast(&Obj->AliasList)); - } }; /// An iostream inserter for modules. @@ -397,37 +424,6 @@ inline raw_ostream &operator<<(raw_ostream &O, const Module &M) { M.print(O, 0); return O; } - - -inline ValueSymbolTable * -ilist_traits::getSymTab(Module *M) { - return M ? &M->getValueSymbolTable() : 0; -} - -inline ValueSymbolTable * -ilist_traits::getSymTab(Module *M) { - return M ? &M->getValueSymbolTable() : 0; -} - -inline ValueSymbolTable * -ilist_traits::getSymTab(Module *M) { - return M ? &M->getValueSymbolTable() : 0; -} - -inline int -ilist_traits::getListOffset() { - return Module::getFunctionListOffset(); -} - -inline int -ilist_traits::getListOffset() { - return Module::getGlobalVariableListOffset(); -} - -inline int -ilist_traits::getListOffset() { - return Module::getAliasListOffset(); -} } // End llvm namespace