[llvm-commits] CVS: llvm/include/llvm/DerivedTypes.h Type.h
Reid Spencer
reid at x10sys.com
Thu Apr 5 19:02:42 PDT 2007
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
More information about the llvm-commits
mailing list