Changes in directory llvm/include/llvm:
Function.h updated: 1.81 -> 1.82 GlobalValue.h updated: 1.38 -> 1.39 GlobalVariable.h updated: 1.44 -> 1.45 Module.h updated: 1.88 -> 1.89 Value.h updated: 1.100 -> 1.101 ValueSymbolTable.h updated: 1.12 -> 1.13 --- Log message: Implement aliases. This fixes PR1017: http://llvm.org/PR1017 and it's dependent bugs. CFE part will follow. --- Diffs of the changes: (+94 -16) Function.h | 4 +- GlobalValue.h | 13 +++++++- GlobalVariable.h | 4 +- Module.h | 81 ++++++++++++++++++++++++++++++++++++++++++++++------- Value.h | 7 +++- ValueSymbolTable.h | 1 6 files changed, 94 insertions(+), 16 deletions(-) Index: llvm/include/llvm/Function.h diff -u llvm/include/llvm/Function.h:1.81 llvm/include/llvm/Function.h:1.82 --- llvm/include/llvm/Function.h:1.81 Sun Apr 22 12:28:03 2007 +++ llvm/include/llvm/Function.h Wed Apr 25 09:27:10 2007 @@ -141,12 +141,12 @@ /// removeFromParent - This method unlinks 'this' from the containing module, /// but does not delete it. /// - void removeFromParent(); + virtual void removeFromParent(); /// eraseFromParent - This method unlinks 'this' from the containing module /// and deletes it. /// - void eraseFromParent(); + virtual void eraseFromParent(); /// Get the underlying elements of the Function... the basic block list is Index: llvm/include/llvm/GlobalValue.h diff -u llvm/include/llvm/GlobalValue.h:1.38 llvm/include/llvm/GlobalValue.h:1.39 --- llvm/include/llvm/GlobalValue.h:1.38 Sun Apr 22 10:11:24 2007 +++ llvm/include/llvm/GlobalValue.h Wed Apr 25 09:27:10 2007 @@ -121,6 +121,16 @@ /// value is outside of the current translation unit... virtual bool isDeclaration() const = 0; + /// removeFromParent - This method unlinks 'this' from the containing module, + /// but does not delete it. + /// + virtual void removeFromParent() = 0; + + /// eraseFromParent - This method unlinks 'this' from the containing module + /// and deletes it. + /// + virtual void eraseFromParent() = 0; + /// getParent - Get the module that this global value is contained inside /// of... inline Module *getParent() { return Parent; } @@ -136,7 +146,8 @@ static inline bool classof(const GlobalValue *) { return true; } static inline bool classof(const Value *V) { return V->getValueID() == Value::FunctionVal || - V->getValueID() == Value::GlobalVariableVal; + V->getValueID() == Value::GlobalVariableVal || + V->getValueID() == Value::GlobalAliasVal; } }; Index: llvm/include/llvm/GlobalVariable.h diff -u llvm/include/llvm/GlobalVariable.h:1.44 llvm/include/llvm/GlobalVariable.h:1.45 --- llvm/include/llvm/GlobalVariable.h:1.44 Tue Apr 17 13:30:41 2007 +++ llvm/include/llvm/GlobalVariable.h Wed Apr 25 09:27:10 2007 @@ -107,12 +107,12 @@ /// removeFromParent - This method unlinks 'this' from the containing module, /// but does not delete it. /// - void removeFromParent(); + virtual void removeFromParent(); /// eraseFromParent - This method unlinks 'this' from the containing module /// and deletes it. /// - void eraseFromParent(); + virtual void eraseFromParent(); /// Override Constant's implementation of this method so we can /// replace constant initializers. Index: llvm/include/llvm/Module.h diff -u llvm/include/llvm/Module.h:1.88 llvm/include/llvm/Module.h:1.89 --- llvm/include/llvm/Module.h:1.88 Tue Apr 17 00:33:04 2007 +++ llvm/include/llvm/Module.h Wed Apr 25 09:27:10 2007 @@ -16,12 +16,12 @@ #include "llvm/Function.h" #include "llvm/GlobalVariable.h" +#include "llvm/GlobalAlias.h" #include "llvm/Support/DataTypes.h" #include <vector> namespace llvm { -class GlobalVariable; class GlobalValueRefMap; // Used by ConstantVals.cpp class FunctionType; @@ -43,6 +43,15 @@ static inline ValueSymbolTable *getSymTab(Module *M); static int getListOffset(); }; +template<> struct ilist_traits<GlobalAlias> + : public SymbolTableListTraits<GlobalAlias, Module> { + // 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<GlobalAlias> &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 /// LLVM module. Modules are the top level container of all other LLVM @@ -63,6 +72,8 @@ typedef iplist<GlobalVariable> GlobalListType; /// The type for the list of functions. typedef iplist<Function> FunctionListType; + /// The type for the list of aliases. + typedef iplist<GlobalAlias> AliasListType; /// The type for the list of dependent libraries. typedef std::vector<std::string> LibraryListType; @@ -77,6 +88,11 @@ /// The Function constant iterator typedef FunctionListType::const_iterator const_iterator; + /// The Global Alias iterators. + typedef AliasListType::iterator alias_iterator; + /// The Global Alias constant iterator + typedef AliasListType::const_iterator const_alias_iterator; + /// The Library list iterator. typedef LibraryListType::const_iterator lib_iterator; @@ -92,6 +108,7 @@ private: GlobalListType GlobalList; ///< The Global Variables in the module FunctionListType FunctionList; ///< The Functions in the module + AliasListType AliasList; ///< The Aliases in the module LibraryListType LibraryList; ///< The Libraries needed by the module std::string GlobalScopeAsm; ///< Inline Asm at global scope. ValueSymbolTable *ValSymTab; ///< Symbol table for values @@ -175,10 +192,10 @@ /// getOrInsertFunction - Look up the specified function in the module symbol /// table. If it does not exist, add a prototype for the function and return /// it. This function guarantees to return a constant of pointer to the - /// specified function type or a ConstantExpr BitCast of that type if the - /// 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. + /// specified function type or a ConstantExpr BitCast of that type if the + /// 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,...) END_WITH_NULL; @@ -205,6 +222,15 @@ GlobalVariable *getNamedGlobal(const std::string &Name) const { return getGlobalVariable(Name, true); } + +/// @} +/// @name Global Variable Accessors +/// @{ +public: + /// getNamedGlobal - Return the first global alias in the module with the + /// specified name, of arbitrary type. This method returns null if a global + /// with the specified name is not found. + GlobalAlias *getNamedAlias(const std::string &Name) const; /// @} /// @name Type Accessors @@ -235,14 +261,18 @@ const FunctionListType &getFunctionList() const { return FunctionList; } /// Get the Module's list of functions. FunctionListType &getFunctionList() { return 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; } /// 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. ValueSymbolTable &getValueSymbolTable() { return *ValSymTab; } /// Get the symbol table of types - const TypeSymbolTable &getTypeSymbolTable() const { return *TypeSymTab; } + const TypeSymbolTable &getTypeSymbolTable() const { return *TypeSymTab; } /// Get the Module's symbol table of types - TypeSymbolTable &getTypeSymbolTable() { return *TypeSymTab; } + TypeSymbolTable &getTypeSymbolTable() { return *TypeSymTab; } /// @} /// @name Global Variable Iteration @@ -272,7 +302,7 @@ /// Get a constant iterator to the last function. const_iterator end () const { return FunctionList.end(); } /// Determine how many functions are in the Module's list of functions. - size_t size() const { return FunctionList.size(); } + size_t size() const { return FunctionList.size(); } /// Determine if the list of functions is empty. bool empty() const { return FunctionList.empty(); } @@ -283,9 +313,9 @@ /// @brief Get a constant iterator to beginning of dependent library list. inline lib_iterator lib_begin() const { return LibraryList.begin(); } /// @brief Get a constant iterator to end of dependent library list. - inline lib_iterator lib_end() const { return LibraryList.end(); } + inline lib_iterator lib_end() const { return LibraryList.end(); } /// @brief Returns the number of items in the list of libraries. - inline size_t lib_size() const { return LibraryList.size(); } + inline size_t lib_size() const { return LibraryList.size(); } /// @brief Add a library to the list of dependent libraries void addLibrary(const std::string& Lib); /// @brief Remove a library from the list of dependent libraries @@ -294,6 +324,23 @@ inline const LibraryListType& getLibraries() const { return LibraryList; } /// @} +/// @name Alias Iteration +/// @{ +public: + /// Get an iterator to the first alias. + alias_iterator alias_begin() { return AliasList.begin(); } + /// Get a constant iterator to the first alias. + const_alias_iterator alias_begin() const { return AliasList.begin(); } + /// Get an iterator to the last alias. + alias_iterator alias_end () { return AliasList.end(); } + /// Get a constant iterator to the last alias. + const_alias_iterator alias_end () const { return AliasList.end(); } + /// Determine how many functions are in the Module's list of aliases. + size_t alias_size () const { return AliasList.size(); } + /// Determine if the list of aliases is empty. + bool alias_empty() const { return AliasList.empty(); } + +/// @} /// @name Utility functions for printing and dumping Module objects /// @{ public: @@ -324,6 +371,10 @@ Module *Obj = 0; return unsigned(reinterpret_cast<uintptr_t>(&Obj->GlobalList)); } + static unsigned getAliasListOffset() { + Module *Obj = 0; + return unsigned(reinterpret_cast<uintptr_t>(&Obj->AliasList)); + } }; /// An iostream inserter for modules. @@ -342,6 +393,11 @@ return M ? &M->getValueSymbolTable() : 0; } +inline ValueSymbolTable * +ilist_traits<GlobalAlias>::getSymTab(Module *M) { + return M ? &M->getValueSymbolTable() : 0; +} + inline int ilist_traits<Function>::getListOffset() { return Module::getFunctionListOffset(); @@ -352,6 +408,11 @@ return Module::getGlobalVariableListOffset(); } +inline int +ilist_traits<GlobalAlias>::getListOffset() { + return Module::getAliasListOffset(); +} + } // End llvm namespace #endif Index: llvm/include/llvm/Value.h diff -u llvm/include/llvm/Value.h:1.100 llvm/include/llvm/Value.h:1.101 --- llvm/include/llvm/Value.h:1.100 Fri Apr 13 13:12:09 2007 +++ llvm/include/llvm/Value.h Wed Apr 25 09:27:10 2007 @@ -30,6 +30,7 @@ class GlobalValue; class Function; class GlobalVariable; +class GlobalAlias; class InlineAsm; class ValueSymbolTable; class TypeSymbolTable; @@ -160,6 +161,7 @@ ArgumentVal, // This is an instance of Argument BasicBlockVal, // This is an instance of BasicBlock FunctionVal, // This is an instance of Function + GlobalAliasVal, // This is an instance of GlobalAlias GlobalVariableVal, // This is an instance of GlobalVariable UndefValueVal, // This is an instance of UndefValue ConstantExprVal, // This is an instance of ConstantExpr @@ -248,8 +250,11 @@ template <> inline bool isa_impl<GlobalVariable, Value>(const Value &Val) { return Val.getValueID() == Value::GlobalVariableVal; } +template <> inline bool isa_impl<GlobalAlias, Value>(const Value &Val) { + return Val.getValueID() == Value::GlobalAliasVal; +} template <> inline bool isa_impl<GlobalValue, Value>(const Value &Val) { - return isa<GlobalVariable>(Val) || isa<Function>(Val); + return isa<GlobalVariable>(Val) || isa<Function>(Val) || isa<GlobalAlias>(Val); } } // End llvm namespace Index: llvm/include/llvm/ValueSymbolTable.h diff -u llvm/include/llvm/ValueSymbolTable.h:1.12 llvm/include/llvm/ValueSymbolTable.h:1.13 --- llvm/include/llvm/ValueSymbolTable.h:1.12 Mon Apr 16 22:26:42 2007 +++ llvm/include/llvm/ValueSymbolTable.h Wed Apr 25 09:27:10 2007 @@ -35,6 +35,7 @@ friend class SymbolTableListTraits<Instruction, BasicBlock>; friend class SymbolTableListTraits<Function, Module>; friend class SymbolTableListTraits<GlobalVariable, Module>; + friend class SymbolTableListTraits<GlobalAlias, Module>; /// @name Types /// @{ public: _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
