From dc4c3f2f5fc6132885d590631b54de0be2c659be Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sat, 14 Jul 2001 06:07:58 +0000 Subject: [PATCH] Made the following changes: * ValueHolder became a 3 argument template. This allows for BasicBlock to use the value holder arg as a typesafe parent pointer. * SymTabValue no longer inherits from Value * Method does not inherit from only SymTabValue. Now it inherits from both STV & Value. * Module does not inherit from only SymTabValue. Now it inherits from both STV & Value. * Updated the SymTabValue.h file to reference SymTabValue instead of STDef in several places * Added isArraySelector & isStructSelector to GetElementPtr instruction git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@177 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/BasicBlock.h | 8 +++---- include/llvm/ConstPoolVals.h | 4 +++- include/llvm/ConstantPool.h | 8 ++++--- include/llvm/Function.h | 8 +++---- include/llvm/Instruction.h | 2 +- include/llvm/Module.h | 5 +++-- include/llvm/SymTabValue.h | 24 ++++++++++++--------- include/llvm/Value.h | 3 ++- include/llvm/ValueHolder.h | 23 ++++++++++++-------- include/llvm/iMemory.h | 3 +++ include/llvm/iOther.h | 2 +- lib/VMCore/ValueHolderImpl.h | 42 ++++++++++++++++++++---------------- 12 files changed, 78 insertions(+), 54 deletions(-) diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h index 402b1fd0875..c0922d62905 100644 --- a/include/llvm/BasicBlock.h +++ b/include/llvm/BasicBlock.h @@ -32,11 +32,11 @@ class TerminatorInst; class BasicBlock : public Value { // Basic blocks are data objects also public: - typedef ValueHolder InstListType; + typedef ValueHolder InstListType; private : InstListType InstList; - friend class ValueHolder; + friend class ValueHolder; void setParent(Method *parent); public: @@ -57,8 +57,8 @@ public: // Specialize setName to take care of symbol table majik virtual void setName(const string &name); - const Method *getParent() const { return (const Method*)InstList.getParent();} - Method *getParent() { return (Method*)InstList.getParent(); } + const Method *getParent() const { return InstList.getParent(); } + Method *getParent() { return InstList.getParent(); } // getTerminator() - If this is a well formed basic block, then this returns // a pointer to the terminator instruction. If it is not, then you get a null diff --git a/include/llvm/ConstPoolVals.h b/include/llvm/ConstPoolVals.h index 47941eb82ee..ff7baf5b404 100644 --- a/include/llvm/ConstPoolVals.h +++ b/include/llvm/ConstPoolVals.h @@ -23,7 +23,7 @@ class StructType; class ConstPoolVal : public User { SymTabValue *Parent; - friend class ValueHolder; + friend class ValueHolder; inline void setParent(SymTabValue *parent) { Parent = parent; } @@ -50,6 +50,8 @@ public: inline const SymTabValue *getParent() const { return Parent; } inline SymTabValue *getParent() { return Parent; } + inline const Value *getParentV() const { return Parent->getSTVParent(); } + inline Value *getParentV() { return Parent->getSTVParent(); } }; diff --git a/include/llvm/ConstantPool.h b/include/llvm/ConstantPool.h index 7c8e255790c..ad4d64ac5b7 100644 --- a/include/llvm/ConstantPool.h +++ b/include/llvm/ConstantPool.h @@ -10,14 +10,14 @@ #include #include "llvm/ValueHolder.h" - -class ConstPoolVal; class SymTabValue; +class ConstPoolVal; class Type; +class Value; class ConstantPool { public: - typedef ValueHolder PlaneType; + typedef ValueHolder PlaneType; private: typedef vector PlanesType; PlanesType Planes; @@ -30,6 +30,8 @@ public: inline SymTabValue *getParent() { return Parent; } inline const SymTabValue *getParent() const { return Parent; } + const Value *getParentV() const; + Value *getParentV() ; void setParent(SymTabValue *STV); diff --git a/include/llvm/Function.h b/include/llvm/Function.h index b7aa855b2c2..349dd61a846 100644 --- a/include/llvm/Function.h +++ b/include/llvm/Function.h @@ -21,10 +21,10 @@ class MethodArgument; class MethodType; class Module; -class Method : public SymTabValue { +class Method : public Value, public SymTabValue { public: - typedef ValueHolder ArgumentListType; - typedef ValueHolder BasicBlocksType; + typedef ValueHolder ArgumentListType; + typedef ValueHolder BasicBlocksType; // BasicBlock iterators... typedef BasicBlocksType::iterator iterator; @@ -40,7 +40,7 @@ private: Module *Parent; // The module that contains this method - friend class ValueHolder; + friend class ValueHolder; void setParent(Module *parent); public: diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h index 25be14fbd21..6b6d31a15c0 100644 --- a/include/llvm/Instruction.h +++ b/include/llvm/Instruction.h @@ -18,7 +18,7 @@ class Instruction : public User { BasicBlock *Parent; unsigned iType; // InstructionType - friend class ValueHolder; + friend class ValueHolder; inline void setParent(BasicBlock *P) { Parent = P; } public: diff --git a/include/llvm/Module.h b/include/llvm/Module.h index d02b3a050ea..740a8879b65 100644 --- a/include/llvm/Module.h +++ b/include/llvm/Module.h @@ -8,12 +8,13 @@ #ifndef LLVM_MODULE_H #define LLVM_MODULE_H +#include "llvm/Value.h" #include "llvm/SymTabValue.h" class Method; -class Module : public SymTabValue { +class Module : public Value, public SymTabValue { public: - typedef ValueHolder MethodListType; + typedef ValueHolder MethodListType; // Method iterators... typedef MethodListType::iterator iterator; diff --git a/include/llvm/SymTabValue.h b/include/llvm/SymTabValue.h index 556d5c7a071..f86218d198b 100644 --- a/include/llvm/SymTabValue.h +++ b/include/llvm/SymTabValue.h @@ -1,31 +1,35 @@ -//===-- llvm/SymTabDef.h - Implement SymbolTable Defs ------------*- C++ -*--=// +//===-- llvm/SymTabValue.h - Implement SymbolTable Values --------*- C++ -*--=// // -// This subclass of Def implements a def that has a symbol table for keeping -// track of children. This is used by the DefHolder template class... +// This subclass of Value implements a def that has a symbol table for keeping +// track of children. This is used by the ValueHolder template class... // //===----------------------------------------------------------------------===// -#ifndef LLVM_SYMTABDEF_H -#define LLVM_SYMTABDEF_H +#ifndef LLVM_SYMTAB_VALUE_H +#define LLVM_SYMTAB_VALUE_H -#include "llvm/Value.h" // Get the definition of Value #include "llvm/ConstantPool.h" class SymbolTable; class ConstPoolVal; +class Value; -class SymTabValue : public Value { +class SymTabValue { public: typedef ConstantPool ConstantPoolType; private: SymbolTable *SymTab, *ParentSymTab; ConstantPool ConstPool; // The constant pool + Value *ValueParent; protected: void setParentSymTab(SymbolTable *ST); public: - SymTabValue(const Type *Ty, ValueTy dty, const string &name = ""); - ~SymTabValue(); // Implemented in Def.cpp + SymTabValue(Value *Parent); + ~SymTabValue(); // Implemented in Value.cpp + + inline Value *getSTVParent() { return ValueParent; } + inline const Value *getSTVParent() const { return ValueParent; } // hasSymbolTable() - Returns true if there is a symbol table allocated to // this object AND if there is at least one name in it! @@ -45,7 +49,7 @@ public: // the method does not already have a symtab, one is created. Use this if // you intend to put something into the symbol table for the method. // - SymbolTable *getSymbolTableSure(); // Implemented in Def.cpp + SymbolTable *getSymbolTableSure(); // Implemented in Value.cpp }; #endif diff --git a/include/llvm/Value.h b/include/llvm/Value.h index 43373321c70..07a61a60188 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -19,7 +19,8 @@ class Instruction; class BasicBlock; class Method; class Module; -template class ValueHolder; +template + class ValueHolder; //===----------------------------------------------------------------------===// // Value Class diff --git a/include/llvm/ValueHolder.h b/include/llvm/ValueHolder.h index 18f6e3f40b9..09aa49d0577 100644 --- a/include/llvm/ValueHolder.h +++ b/include/llvm/ValueHolder.h @@ -13,22 +13,27 @@ #define LLVM_VALUEHOLDER_H #include -class SymTabValue; -// ItemParentType ItemParent - I call setParent() on all of my -// "ValueSubclass" items, and this is the value that I pass in. +// ValueSubClass - The type of objects that I hold +// ItemParentType - I call setParent() on all of my "ValueSubclass" items, and +// this is the value that I pass in. +// SymTabType - This is the class type (which should be derived from +// SymTabValue), whose symtab I insert my ValueSubClass items +// into. Most of the time it is ItemParentType, but +// Instructions have item parents of bb's but symtabtype's of +// a Method // -template +template class ValueHolder { // TODO: Should I use a deque instead of a vector? vector ValueList; ItemParentType *ItemParent; - SymTabValue *Parent; + SymTabType *Parent; ValueHolder(const ValueHolder &V); // DO NOT IMPLEMENT public: - inline ValueHolder(ItemParentType *IP, SymTabValue *parent = 0) { + inline ValueHolder(ItemParentType *IP, SymTabType *parent = 0) { assert(IP && "Item parent may not be null!"); ItemParent = IP; Parent = 0; @@ -41,9 +46,9 @@ public: assert(Parent == 0 && "Should have been unlinked from method!"); } - inline const SymTabValue *getParent() const { return Parent; } - inline SymTabValue *getParent() { return Parent; } - void setParent(SymTabValue *Parent); // Defined in ValueHolderImpl.h + inline const SymTabType *getParent() const { return Parent; } + inline SymTabType *getParent() { return Parent; } + void setParent(SymTabType *Parent); // Defined in ValueHolderImpl.h inline unsigned size() const { return ValueList.size(); } inline bool empty() const { return ValueList.empty(); } diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h index fe045d72667..92d6a6c80d4 100644 --- a/include/llvm/iMemory.h +++ b/include/llvm/iMemory.h @@ -178,6 +178,9 @@ public: const string &Name = ""); virtual Instruction *clone() const { return new GetElementPtrInst(*this); } virtual const char *getOpcodeName() const { return "getelementptr"; } + + inline bool isArraySelector() const { return !isStructSelector(); } + bool isStructSelector() const; }; #endif // LLVM_IMEMORY_H diff --git a/include/llvm/iOther.h b/include/llvm/iOther.h index ce5aa930620..e522e1453d2 100644 --- a/include/llvm/iOther.h +++ b/include/llvm/iOther.h @@ -87,7 +87,7 @@ public: class MethodArgument : public Value { // Defined in the InstrType.cpp file Method *Parent; - friend class ValueHolder; + friend class ValueHolder; inline void setParent(Method *parent) { Parent = parent; } public: diff --git a/lib/VMCore/ValueHolderImpl.h b/lib/VMCore/ValueHolderImpl.h index f19d71f5026..c59f9f2dafa 100644 --- a/lib/VMCore/ValueHolderImpl.h +++ b/lib/VMCore/ValueHolderImpl.h @@ -13,8 +13,9 @@ #include "llvm/SymbolTable.h" #include -template -void ValueHolder::setParent(SymTabValue *P) { +template +void ValueHolder +::setParent(SymTabType *P) { if (Parent) { // Remove all of the items from the old symbol table.. SymbolTable *SymTab = Parent->getSymbolTable(); for (iterator I = begin(); I != end(); ++I) @@ -31,8 +32,9 @@ void ValueHolder::setParent(SymTabValue *P) { } -template -void ValueHolder::remove(ValueSubclass *D) { +template +void ValueHolder +::remove(ValueSubclass *D) { iterator I(find(begin(), end(), D)); assert(I != end() && "Value not in ValueHolder!!"); remove(I); @@ -42,8 +44,9 @@ void ValueHolder::remove(ValueSubclass *D) { // specified by the iterator, and leaves the iterator pointing to the element // that used to follow the element deleted. // -template -ValueSubclass *ValueHolder::remove(iterator &DI) { +template +ValueSubclass *ValueHolder +::remove(iterator &DI) { assert(DI != ValueList.end() && "Trying to remove the end of the def list!!!"); @@ -59,8 +62,9 @@ ValueSubclass *ValueHolder::remove(iterator &DI) { return i; } -template -ValueSubclass *ValueHolder::pop_back() { +template +ValueSubclass *ValueHolder +::pop_back() { assert(!ValueList.empty() && "Can't pop_back an empty valuelist!"); ValueSubclass *i = ValueList.back(); ValueList.pop_back(); @@ -74,8 +78,8 @@ ValueSubclass *ValueHolder::pop_back() { } -template -ValueSubclass *ValueHolder +template +ValueSubclass *ValueHolder ::remove(const iterator &DI) { assert(DI != ValueList.end() && "Trying to remove the end of the def list!!!"); @@ -92,8 +96,9 @@ ValueSubclass *ValueHolder return i; } -template -void ValueHolder::push_front(ValueSubclass *Inst) { +template +void ValueHolder +::push_front(ValueSubclass *Inst) { assert(Inst->getParent() == 0 && "Value already has parent!"); Inst->setParent(ItemParent); @@ -104,8 +109,9 @@ void ValueHolder::push_front(ValueSubclass *Inst) Parent->getSymbolTableSure()->insert(Inst); } -template -void ValueHolder::push_back(ValueSubclass *Inst) { +template +void ValueHolder +::push_back(ValueSubclass *Inst) { assert(Inst->getParent() == 0 && "Value already has parent!"); Inst->setParent(ItemParent); @@ -119,10 +125,10 @@ void ValueHolder::push_back(ValueSubclass *Inst) { // indicated iterator position, and returns an interator to the newly inserted // value. // -template -ValueHolder::iterator -ValueHolder::insert(iterator Pos, - ValueSubclass *Inst){ +template +ValueHolder::iterator +ValueHolder +::insert(iterator Pos, ValueSubclass *Inst) { assert(Inst->getParent() == 0 && "Value already has parent!"); Inst->setParent(ItemParent);