Changes in directory llvm/include/llvm:
DerivedTypes.h updated: 1.89 -> 1.90 Type.h updated: 1.105 -> 1.106 --- Log message: For PR1209: http://llvm.org/PR1209 : Implement Type class's ContainedTys without using a std::vector. --- Diffs of the changes: (+50 -30) DerivedTypes.h | 27 +++++++++++++++------------ Type.h | 53 +++++++++++++++++++++++++++++++++++------------------ 2 files changed, 50 insertions(+), 30 deletions(-) Index: llvm/include/llvm/DerivedTypes.h diff -u llvm/include/llvm/DerivedTypes.h:1.89 llvm/include/llvm/DerivedTypes.h:1.90 --- llvm/include/llvm/DerivedTypes.h:1.89 Fri Mar 23 13:44:11 2007 +++ llvm/include/llvm/DerivedTypes.h Thu Apr 5 21:02:19 2007 @@ -163,6 +163,7 @@ bool IsVarArgs, const ParamAttrsList &Attrs); public: + virtual ~FunctionType() { delete ParamAttrs; } /// FunctionType::get - This static method is the primary way of constructing /// a FunctionType. /// @@ -179,9 +180,9 @@ inline bool isVarArg() const { return isVarArgs; } inline const Type *getReturnType() const { return ContainedTys[0]; } - typedef std::vector<PATypeHandle>::const_iterator param_iterator; - param_iterator param_begin() const { return ContainedTys.begin()+1; } - param_iterator param_end() const { return ContainedTys.end(); } + typedef Type::subtype_iterator param_iterator; + param_iterator param_begin() const { return ContainedTys + 1; } + param_iterator param_end() const { return &ContainedTys[NumContainedTys]; } // Parameter type accessors... const Type *getParamType(unsigned i) const { return ContainedTys[i+1]; } @@ -189,7 +190,7 @@ /// getNumParams - Return the number of fixed parameters this function type /// requires. This does not consider varargs. /// - unsigned getNumParams() const { return unsigned(ContainedTys.size()-1); } + unsigned getNumParams() const { return NumContainedTys - 1; } bool isStructReturn() const { return (getNumParams() && paramHasAttr(1, StructRetAttribute)); @@ -265,14 +266,14 @@ bool isPacked=false); // Iterator access to the elements - typedef std::vector<PATypeHandle>::const_iterator element_iterator; - element_iterator element_begin() const { return ContainedTys.begin(); } - element_iterator element_end() const { return ContainedTys.end(); } + typedef Type::subtype_iterator element_iterator; + element_iterator element_begin() const { return ContainedTys; } + element_iterator element_end() const { return &ContainedTys[NumContainedTys];} // Random access to the elements - unsigned getNumElements() const { return unsigned(ContainedTys.size()); } + unsigned getNumElements() const { return NumContainedTys; } const Type *getElementType(unsigned N) const { - assert(N < ContainedTys.size() && "Element number out of range!"); + assert(N < NumContainedTys && "Element number out of range!"); return ContainedTys[N]; } @@ -305,12 +306,14 @@ /// components out in memory identically. /// class SequentialType : public CompositeType { + PATypeHandle ContainedType; ///< Storage for the single contained type SequentialType(const SequentialType &); // Do not implement! const SequentialType &operator=(const SequentialType &); // Do not implement! protected: - SequentialType(TypeID TID, const Type *ElType) : CompositeType(TID) { - ContainedTys.reserve(1); - ContainedTys.push_back(PATypeHandle(ElType, this)); + SequentialType(TypeID TID, const Type *ElType) + : CompositeType(TID), ContainedType(ElType, this) { + ContainedTys = &ContainedType; + NumContainedTys = 1; } public: Index: llvm/include/llvm/Type.h diff -u llvm/include/llvm/Type.h:1.105 llvm/include/llvm/Type.h:1.106 --- llvm/include/llvm/Type.h:1.105 Fri Mar 23 13:44:11 2007 +++ llvm/include/llvm/Type.h Thu Apr 5 21:02:19 2007 @@ -101,12 +101,18 @@ mutable unsigned RefCount; const Type *getForwardedTypeInternal() const; + + // Some Type instances are allocated as arrays, some aren't. So we provide + // this method to get the right kind of destruction for the type of Type. + void destroy() const; // const is a lie, this does "delete this"! + protected: Type(const char *Name, TypeID id); explicit Type(TypeID id) : ID(id), Abstract(false), SubclassData(0), - RefCount(0), ForwardType(0) {} + RefCount(0), ForwardType(0), NumContainedTys(0), + ContainedTys(0) {} virtual ~Type() { - assert(AbstractTypeUsers.empty()); + assert(AbstractTypeUsers.empty() && "Abstract types remain"); } /// Types can become nonabstract later, if they are refined. @@ -123,19 +129,31 @@ /// to the more refined type. Only abstract types can be forwarded. mutable const Type *ForwardType; - /// ContainedTys - The list of types contained by this one. For example, this - /// includes the arguments of a function type, the elements of the structure, - /// the pointee of a pointer, etc. Note that keeping this vector in the Type - /// class wastes some space for types that do not contain anything (such as - /// primitive types). However, keeping it here allows the subtype_* members - /// to be implemented MUCH more efficiently, and dynamically very few types do - /// not contain any elements (most are derived). - std::vector<PATypeHandle> ContainedTys; /// AbstractTypeUsers - Implement a list of the users that need to be notified /// if I am a type, and I get resolved into a more concrete type. /// mutable std::vector<AbstractTypeUser *> AbstractTypeUsers; + + /// NumContainedTys - Keeps track of how many PATypeHandle instances there + /// are at the end of this type instance for the list of contained types. It + /// is the subclasses responsibility to set this up. Set to 0 if there are no + /// contained types in this type. + unsigned NumContainedTys; + + /// ContainedTys - A pointer to the array of Types (PATypeHandle) contained + /// by this Type. For example, this includes the arguments of a function + /// type, the elements of a structure, the pointee of a pointer, the element + /// type of an array, etc. This pointer may be 0 for types that don't + /// contain other types (Integer, Double, Float). In general, the subclass + /// should arrange for space for the PATypeHandles to be included in the + /// allocation of the type object and set this pointer to the address of the + /// first element. This allows the Type class to manipulate the ContainedTys + /// without understanding the subclass's placement for this array. keeping + /// it here also allows the subtype_* members to be implemented MUCH more + /// efficiently, and dynamically very few types do not contain any elements. + PATypeHandle *ContainedTys; + public: void print(std::ostream &O) const; void print(std::ostream *O) const { if (O) print(*O); } @@ -235,23 +253,22 @@ //===--------------------------------------------------------------------===// // Type Iteration support // - typedef std::vector<PATypeHandle>::const_iterator subtype_iterator; - subtype_iterator subtype_begin() const { return ContainedTys.begin(); } - subtype_iterator subtype_end() const { return ContainedTys.end(); } + typedef PATypeHandle *subtype_iterator; + subtype_iterator subtype_begin() const { return ContainedTys; } + subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];} /// getContainedType - This method is used to implement the type iterator /// (defined a the end of the file). For derived types, this returns the /// types 'contained' in the derived type. /// const Type *getContainedType(unsigned i) const { - assert(i < ContainedTys.size() && "Index out of range!"); - return ContainedTys[i]; + assert(i < NumContainedTys && "Index out of range!"); + return ContainedTys[i].get(); } /// getNumContainedTypes - Return the number of types in the derived type. /// - typedef std::vector<PATypeHandle>::size_type size_type; - size_type getNumContainedTypes() const { return ContainedTys.size(); } + unsigned getNumContainedTypes() const { return NumContainedTys; } //===--------------------------------------------------------------------===// // Static members exported by the Type class itself. Useful for getting @@ -282,7 +299,7 @@ // If this is the last PATypeHolder using this object, and there are no // PATypeHandles using it, the type is dead, delete it now. if (--RefCount == 0 && AbstractTypeUsers.empty()) - delete this; + this->destroy(); } /// addAbstractTypeUser - Notify an abstract type that there is a new user of _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
