Hi Anton, You forgot to check in GlobalAlias.h.
Evan On Apr 25, 2007, at 7:28 AM, Anton Korobeynikov wrote: > > > 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 _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
