X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FModule.h;h=7a139cc1e0a92638daf8312e9b74a668c100b3b2;hb=617dd7baa6dfd3a7b5ee72ace37f6b6aeaa6006b;hp=bce671ddb296b378065191badf44ad8214bb10b2;hpb=e20bbc81012e636cb59bbbe3a114895a2f7fa0da;p=oota-llvm.git diff --git a/include/llvm/Module.h b/include/llvm/Module.h index bce671ddb29..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,12 +226,21 @@ 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; + Function *getFunction(const char *Name) const; /// @} /// @name Global Variable Accessors @@ -228,6 +260,15 @@ public: return getGlobalVariable(Name, true); } + /// getOrInsertGlobal - Look up the specified global in the module symbol + /// table. + /// 1. If it does not exist, add a declaration of the global and return it. + /// 2. Else, the global exists but has the wrong type: return the function + /// with a constantexpr cast to the right type. + /// 3. Finally, if the existing global is the correct delclaration, return + /// the existing global. + Constant *getOrInsertGlobal(const std::string &Name, const Type *Ty); + /// @} /// @name Global Alias Accessors /// @{ @@ -262,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. @@ -349,15 +399,11 @@ public: /// @name Utility functions for printing and dumping Module objects /// @{ public: - /// Print the module to an output stream - void print(std::ostream &OS) const { print(OS, 0); } - void print(std::ostream *OS) const { if (OS) print(*OS); } /// Print the module to an output stream with AssemblyAnnotationWriter. + void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const; void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const; - void print(std::ostream *OS, AssemblyAnnotationWriter *AAW) const { - if (OS) print(*OS, AAW); - } - /// Dump the module to std::cerr (for debugging). + + /// Dump the module to stderr (for debugging). void dump() const; /// This function causes all the subinstructions to "let go" of all references /// that they are maintaining. This allows one to 'delete' a whole class at @@ -367,55 +413,16 @@ 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. inline std::ostream &operator<<(std::ostream &O, const Module &M) { - M.print(O); + 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(); +inline raw_ostream &operator<<(raw_ostream &O, const Module &M) { + M.print(O, 0); + return O; } } // End llvm namespace