X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FType.cpp;h=9b34dd840c8d7471aa5d860a618b009747dee5aa;hb=58e0ef1e90c3f6dbae213612b44e56f7d6d65ea7;hp=a6e57971bd5a463bc095e060e8ddfb86ac3dfec0;hpb=ef9b9a793949469cdaa4ab6d0173136229dcab7b;p=oota-llvm.git diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index a6e57971bd5..9b34dd840c8 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -11,8 +11,8 @@ // //===----------------------------------------------------------------------===// -#include "llvm/AbstractTypeUser.h" #include "llvm/DerivedTypes.h" +#include "llvm/ParameterAttributes.h" #include "llvm/Constants.h" #include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/StringExtras.h" @@ -62,12 +62,46 @@ static ManagedStatic > AbstractTypeDescriptions; -Type::Type(const char *Name, TypeID id) - : ID(id), Abstract(false), SubclassData(0), RefCount(0), ForwardType(0) { - assert(Name && Name[0] && "Should use other ctor if no name!"); - (*ConcreteTypeDescriptions)[this] = Name; -} +/// Because of the way Type subclasses are allocated, this function is necessary +/// to use the correct kind of "delete" operator to deallocate the Type object. +/// Some type objects (FunctionTy, StructTy) allocate additional space after +/// the space for their derived type to hold the contained types array of +/// PATypeHandles. Using this allocation scheme means all the PATypeHandles are +/// allocated with the type object, decreasing allocations and eliminating the +/// need for a std::vector to be used in the Type class itself. +/// @brief Type destruction function +void Type::destroy() const { + + // Structures and Functions allocate their contained types past the end of + // the type object itself. These need to be destroyed differently than the + // other types. + if (isa(this) || isa(this)) { + // First, make sure we destruct any PATypeHandles allocated by these + // subclasses. They must be manually destructed. + for (unsigned i = 0; i < NumContainedTys; ++i) + ContainedTys[i].PATypeHandle::~PATypeHandle(); + + // Now call the destructor for the subclass directly because we're going + // to delete this as an array of char. + if (isa(this)) + ((FunctionType*)this)->FunctionType::~FunctionType(); + else + ((StructType*)this)->StructType::~StructType(); + + // Finally, remove the memory as an array deallocation of the chars it was + // constructed from. + delete [] reinterpret_cast(this); + + return; + } + // For all the other type subclasses, there is either no contained types or + // just one (all Sequentials). For Sequentials, the PATypeHandle is not + // allocated past the type object, its included directly in the SequentialType + // class. This means we can safely just do "normal" delete of this object and + // all the destructors that need to run will be run. + delete this; +} const Type *Type::getPrimitiveType(TypeID IDNumber) { switch (IDNumber) { @@ -93,9 +127,9 @@ const Type *Type::getVAArgsPromotedType() const { /// bool Type::isFPOrFPVector() const { if (ID == Type::FloatTyID || ID == Type::DoubleTyID) return true; - if (ID != Type::PackedTyID) return false; + if (ID != Type::VectorTyID) return false; - return cast(this)->getElementType()->isFloatingPoint(); + return cast(this)->getElementType()->isFloatingPoint(); } // canLosslesllyBitCastTo - Return true if this type can be converted to @@ -110,10 +144,10 @@ bool Type::canLosslesslyBitCastTo(const Type *Ty) const { if (!this->isFirstClassType() || !Ty->isFirstClassType()) return false; - // Packed -> Packed conversions are always lossless if the two packed types + // Vector -> Vector conversions are always lossless if the two vector types // have the same size, otherwise not. - if (const PackedType *thisPTy = dyn_cast(this)) - if (const PackedType *thatPTy = dyn_cast(Ty)) + if (const VectorType *thisPTy = dyn_cast(this)) + if (const VectorType *thatPTy = dyn_cast(Ty)) return thisPTy->getBitWidth() == thatPTy->getBitWidth(); // At this point we have only various mismatches of the first class types @@ -129,7 +163,7 @@ unsigned Type::getPrimitiveSizeInBits() const { case Type::FloatTyID: return 32; case Type::DoubleTyID: return 64; case Type::IntegerTyID: return cast(this)->getBitWidth(); - case Type::PackedTyID: return cast(this)->getBitWidth(); + case Type::VectorTyID: return cast(this)->getBitWidth(); default: return 0; } } @@ -144,7 +178,7 @@ bool Type::isSizedDerivedType() const { if (const ArrayType *ATy = dyn_cast(this)) return ATy->getElementType()->isSized(); - if (const PackedType *PTy = dyn_cast(this)) + if (const VectorType *PTy = dyn_cast(this)) return PTy->getElementType()->isSized(); if (!isa(this)) @@ -208,7 +242,18 @@ static std::string getTypeDescription(const Type *Ty, if (!Ty->isAbstract()) { // Base case for the recursion std::map::iterator I = ConcreteTypeDescriptions->find(Ty); - if (I != ConcreteTypeDescriptions->end()) return I->second; + if (I != ConcreteTypeDescriptions->end()) + return I->second; + + if (Ty->isPrimitiveType()) { + switch (Ty->getTypeID()) { + default: assert(0 && "Unknown prim type!"); + case Type::VoidTyID: return (*ConcreteTypeDescriptions)[Ty] = "void"; + case Type::FloatTyID: return (*ConcreteTypeDescriptions)[Ty] = "float"; + case Type::DoubleTyID: return (*ConcreteTypeDescriptions)[Ty] = "double"; + case Type::LabelTyID: return (*ConcreteTypeDescriptions)[Ty] = "label"; + } + } } // Check to see if the Type is already on the stack... @@ -238,11 +283,13 @@ static std::string getTypeDescription(const Type *Ty, Result += " "; Result += getTypeDescription(FTy->getReturnType(), TypeStack) + " ("; unsigned Idx = 1; + const ParamAttrsList *Attrs = FTy->getParamAttrs(); for (FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end(); I != E; ++I) { if (I != FTy->param_begin()) Result += ", "; - Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx)); + if (Attrs && Attrs->getParamAttrs(Idx) != ParamAttr::None) + Result += Attrs->getParamAttrsTextByIndex(Idx); Idx++; Result += getTypeDescription(*I, TypeStack); } @@ -251,12 +298,11 @@ static std::string getTypeDescription(const Type *Ty, Result += "..."; } Result += ")"; - if (FTy->getParamAttrs(0)) { - Result += " " + FunctionType::getParamAttrsText(FTy->getParamAttrs(0)); + if (Attrs && Attrs->getParamAttrs(0) != ParamAttr::None) { + Result += " " + Attrs->getParamAttrsTextByIndex(0); } break; } - case Type::PackedStructTyID: case Type::StructTyID: { const StructType *STy = cast(Ty); if (STy->isPacked()) @@ -287,8 +333,8 @@ static std::string getTypeDescription(const Type *Ty, Result += getTypeDescription(ATy->getElementType(), TypeStack) + "]"; break; } - case Type::PackedTyID: { - const PackedType *PTy = cast(Ty); + case Type::VectorTyID: { + const VectorType *PTy = cast(Ty); unsigned NumElements = PTy->getNumElements(); Result = "<"; Result += utostr(NumElements) + " x "; @@ -330,7 +376,7 @@ bool StructType::indexValid(const Value *V) const { // Structure indexes require 32-bit integer constants. if (V->getType() == Type::Int32Ty) if (const ConstantInt *CU = dyn_cast(V)) - return CU->getZExtValue() < ContainedTys.size(); + return CU->getZExtValue() < NumContainedTys; return false; } @@ -347,34 +393,21 @@ const Type *StructType::getTypeAtIndex(const Value *V) const { // Primitive 'Type' data //===----------------------------------------------------------------------===// -#define DeclarePrimType(TY, Str) \ - namespace { \ - struct VISIBILITY_HIDDEN TY##Type : public Type { \ - TY##Type() : Type(Str, Type::TY##TyID) {} \ - }; \ - } \ - static ManagedStatic The##TY##Ty; \ - const Type *Type::TY##Ty = &*The##TY##Ty - -#define DeclareIntegerType(TY, BitWidth) \ - namespace { \ - struct VISIBILITY_HIDDEN TY##Type : public IntegerType { \ - TY##Type() : IntegerType(BitWidth) {} \ - }; \ - } \ - static ManagedStatic The##TY##Ty; \ - const IntegerType *Type::TY##Ty = &*The##TY##Ty - -DeclarePrimType(Void, "void"); -DeclarePrimType(Float, "float"); -DeclarePrimType(Double, "double"); -DeclarePrimType(Label, "label"); -DeclareIntegerType(Int1, 1); -DeclareIntegerType(Int8, 8); -DeclareIntegerType(Int16, 16); -DeclareIntegerType(Int32, 32); -DeclareIntegerType(Int64, 64); -#undef DeclarePrimType +const Type *Type::VoidTy = new Type(Type::VoidTyID); +const Type *Type::FloatTy = new Type(Type::FloatTyID); +const Type *Type::DoubleTy = new Type(Type::DoubleTyID); +const Type *Type::LabelTy = new Type(Type::LabelTyID); + +namespace { + struct BuiltinIntegerType : public IntegerType { + BuiltinIntegerType(unsigned W) : IntegerType(W) {} + }; +} +const IntegerType *Type::Int1Ty = new BuiltinIntegerType(1); +const IntegerType *Type::Int8Ty = new BuiltinIntegerType(8); +const IntegerType *Type::Int16Ty = new BuiltinIntegerType(16); +const IntegerType *Type::Int32Ty = new BuiltinIntegerType(32); +const IntegerType *Type::Int64Ty = new BuiltinIntegerType(64); //===----------------------------------------------------------------------===// @@ -383,42 +416,36 @@ DeclareIntegerType(Int64, 64); FunctionType::FunctionType(const Type *Result, const std::vector &Params, - bool IsVarArgs, const ParamAttrsList &Attrs) - : DerivedType(FunctionTyID), isVarArgs(IsVarArgs) { + bool IsVarArgs, const ParamAttrsList *Attrs) + : DerivedType(FunctionTyID), isVarArgs(IsVarArgs), ParamAttrs(Attrs) { + ContainedTys = reinterpret_cast(this+1); + NumContainedTys = Params.size() + 1; // + 1 for result type assert((Result->isFirstClassType() || Result == Type::VoidTy || isa(Result)) && "LLVM functions cannot return aggregates"); bool isAbstract = Result->isAbstract(); - ContainedTys.reserve(Params.size()+1); - ContainedTys.push_back(PATypeHandle(Result, this)); + new (&ContainedTys[0]) PATypeHandle(Result, this); for (unsigned i = 0; i != Params.size(); ++i) { assert((Params[i]->isFirstClassType() || isa(Params[i])) && "Function arguments must be value types!"); - - ContainedTys.push_back(PATypeHandle(Params[i], this)); + new (&ContainedTys[i+1]) PATypeHandle(Params[i],this); isAbstract |= Params[i]->isAbstract(); } - // Set the ParameterAttributes - if (!Attrs.empty()) - ParamAttrs = new ParamAttrsList(Attrs); - else - ParamAttrs = 0; - // Calculate whether or not this type is abstract setAbstract(isAbstract); - } StructType::StructType(const std::vector &Types, bool isPacked) : CompositeType(StructTyID) { + ContainedTys = reinterpret_cast(this + 1); + NumContainedTys = Types.size(); setSubclassData(isPacked); - ContainedTys.reserve(Types.size()); bool isAbstract = false; for (unsigned i = 0; i < Types.size(); ++i) { assert(Types[i] != Type::VoidTy && "Void type for structure field!!"); - ContainedTys.push_back(PATypeHandle(Types[i], this)); + new (&ContainedTys[i]) PATypeHandle(Types[i], this); isAbstract |= Types[i]->isAbstract(); } @@ -434,13 +461,15 @@ ArrayType::ArrayType(const Type *ElType, uint64_t NumEl) setAbstract(ElType->isAbstract()); } -PackedType::PackedType(const Type *ElType, unsigned NumEl) - : SequentialType(PackedTyID, ElType) { +VectorType::VectorType(const Type *ElType, unsigned NumEl) + : SequentialType(VectorTyID, ElType) { NumElements = NumEl; + setAbstract(ElType->isAbstract()); + assert(NumEl > 0 && "NumEl of a VectorType must be greater than 0"); + assert((ElType->isInteger() || ElType->isFloatingPoint() || + isa(ElType)) && + "Elements of a VectorType must be a primitive type"); - assert(NumEl > 0 && "NumEl of a PackedType must be greater than 0"); - assert((ElType->isInteger() || ElType->isFloatingPoint()) && - "Elements of a PackedType must be a primitive type"); } @@ -460,17 +489,17 @@ OpaqueType::OpaqueType() : DerivedType(OpaqueTyID) { // another (more concrete) type, we must eliminate all references to other // types, to avoid some circular reference problems. void DerivedType::dropAllTypeUses() { - if (!ContainedTys.empty()) { + if (NumContainedTys != 0) { // The type must stay abstract. To do this, we insert a pointer to a type // that will never get resolved, thus will always be abstract. static Type *AlwaysOpaqueTy = OpaqueType::get(); static PATypeHolder Holder(AlwaysOpaqueTy); ContainedTys[0] = AlwaysOpaqueTy; - // Change the rest of the types to be intty's. It doesn't matter what we + // Change the rest of the types to be Int32Ty's. It doesn't matter what we // pick so long as it doesn't point back to this type. We choose something // concrete to avoid overhead for adding to AbstracTypeUser lists and stuff. - for (unsigned i = 1, e = ContainedTys.size(); i != e; ++i) + for (unsigned i = 1, e = NumContainedTys; i != e; ++i) ContainedTys[i] = Type::Int32Ty; } } @@ -600,20 +629,25 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2, const ArrayType *ATy2 = cast(Ty2); return ATy->getNumElements() == ATy2->getNumElements() && TypesEqual(ATy->getElementType(), ATy2->getElementType(), EqTypes); - } else if (const PackedType *PTy = dyn_cast(Ty)) { - const PackedType *PTy2 = cast(Ty2); + } else if (const VectorType *PTy = dyn_cast(Ty)) { + const VectorType *PTy2 = cast(Ty2); return PTy->getNumElements() == PTy2->getNumElements() && TypesEqual(PTy->getElementType(), PTy2->getElementType(), EqTypes); } else if (const FunctionType *FTy = dyn_cast(Ty)) { const FunctionType *FTy2 = cast(Ty2); if (FTy->isVarArg() != FTy2->isVarArg() || FTy->getNumParams() != FTy2->getNumParams() || - FTy->getNumAttrs() != FTy2->getNumAttrs() || - FTy->getParamAttrs(0) != FTy2->getParamAttrs(0) || !TypesEqual(FTy->getReturnType(), FTy2->getReturnType(), EqTypes)) return false; + const ParamAttrsList *Attrs1 = FTy->getParamAttrs(); + const ParamAttrsList *Attrs2 = FTy2->getParamAttrs(); + if ((!Attrs1 && Attrs2) || (!Attrs2 && Attrs1) || + (Attrs1 && Attrs2 && (Attrs1->size() != Attrs2->size() || + (Attrs1->getParamAttrs(0) != Attrs2->getParamAttrs(0))))) + return false; + for (unsigned i = 0, e = FTy2->getNumParams(); i != e; ++i) { - if (FTy->getParamAttrs(i+1) != FTy->getParamAttrs(i+1)) + if (Attrs1 && Attrs1->getParamAttrs(i+1) != Attrs2->getParamAttrs(i+1)) return false; if (!TypesEqual(FTy->getParamType(i), FTy2->getParamType(i), EqTypes)) return false; @@ -706,8 +740,8 @@ static unsigned getSubElementHash(const Type *Ty) { case Type::ArrayTyID: HashVal ^= cast(SubTy)->getNumElements(); break; - case Type::PackedTyID: - HashVal ^= cast(SubTy)->getNumElements(); + case Type::VectorTyID: + HashVal ^= cast(SubTy)->getNumElements(); break; case Type::StructTyID: HashVal ^= cast(SubTy)->getNumElements(); @@ -794,15 +828,7 @@ public: print("add"); } - void clear(std::vector &DerivedTypes) { - for (typename std::map::iterator I = Map.begin(), - E = Map.end(); I != E; ++I) - DerivedTypes.push_back(I->second.get()); - TypesByHash.clear(); - Map.clear(); - } - - /// RefineAbstractType - This method is called after we have merged a type + /// RefineAbstractType - This method is called after we have merged a type /// with another one. We must now either merge the type away with /// some other type or reinstall it in the map with it's new configuration. void RefineAbstractType(TypeClass *Ty, const DerivedType *OldType, @@ -831,7 +857,7 @@ public: unsigned OldTypeHash = ValType::hashTypeStructure(Ty); // Find the type element we are refining... and change it now! - for (unsigned i = 0, e = Ty->ContainedTys.size(); i != e; ++i) + for (unsigned i = 0, e = Ty->getNumContainedTypes(); i != e; ++i) if (Ty->ContainedTys[i] == OldType) Ty->ContainedTys[i] = NewType; unsigned NewTypeHash = ValType::hashTypeStructure(Ty); @@ -991,28 +1017,33 @@ bool IntegerType::isPowerOf2ByteWidth() const { return (BitWidth > 7) && isPowerOf2_32(BitWidth); } +APInt IntegerType::getMask() const { + return APInt::getAllOnesValue(getBitWidth()); +} + // FunctionValType - Define a class to hold the key that goes into the TypeMap // namespace llvm { class FunctionValType { const Type *RetTy; std::vector ArgTypes; - std::vector ParamAttrs; + const ParamAttrsList *ParamAttrs; bool isVarArg; public: FunctionValType(const Type *ret, const std::vector &args, - bool IVA, const FunctionType::ParamAttrsList &attrs) - : RetTy(ret), isVarArg(IVA) { + bool IVA, const ParamAttrsList *attrs) + : RetTy(ret), ParamAttrs(attrs), isVarArg(IVA) { for (unsigned i = 0; i < args.size(); ++i) ArgTypes.push_back(args[i]); - for (unsigned i = 0; i < attrs.size(); ++i) - ParamAttrs.push_back(attrs[i]); } static FunctionValType get(const FunctionType *FT); static unsigned hashTypeStructure(const FunctionType *FT) { - return FT->getNumParams()*64+FT->getNumAttrs()*2+FT->isVarArg(); + unsigned Result = FT->getNumParams()*64 + FT->isVarArg(); + if (FT->getParamAttrs()) + Result += FT->getParamAttrs()->size()*2; + return Result; } inline bool operator<(const FunctionValType &MTV) const { @@ -1021,7 +1052,15 @@ public: if (isVarArg < MTV.isVarArg) return true; if (isVarArg > MTV.isVarArg) return false; if (ArgTypes < MTV.ArgTypes) return true; - return ArgTypes == MTV.ArgTypes && ParamAttrs < MTV.ParamAttrs; + if (ArgTypes > MTV.ArgTypes) return false; + if (ParamAttrs) + if (MTV.ParamAttrs) + return *ParamAttrs < *MTV.ParamAttrs; + else + return false; + else if (MTV.ParamAttrs) + return true; + return false; } }; } @@ -1032,14 +1071,11 @@ static ManagedStatic > FunctionTypes; FunctionValType FunctionValType::get(const FunctionType *FT) { // Build up a FunctionValType std::vector ParamTypes; - std::vector ParamAttrs; ParamTypes.reserve(FT->getNumParams()); for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) ParamTypes.push_back(FT->getParamType(i)); - for (unsigned i = 0, e = FT->getNumAttrs(); i != e; ++i) - ParamAttrs.push_back(FT->getParamAttrs(i)); return FunctionValType(FT->getReturnType(), ParamTypes, FT->isVarArg(), - ParamAttrs); + FT->getParamAttrs()); } @@ -1047,52 +1083,29 @@ FunctionValType FunctionValType::get(const FunctionType *FT) { FunctionType *FunctionType::get(const Type *ReturnType, const std::vector &Params, bool isVarArg, - const std::vector &Attrs) { - bool noAttrs = true; - for (unsigned i = 0, e = Attrs.size(); i < e; ++i) - if (Attrs[i] != FunctionType::NoAttributeSet) { - noAttrs = false; - break; - } - const std::vector NullAttrs; - const std::vector *TheAttrs = &Attrs; - if (noAttrs) - TheAttrs = &NullAttrs; - FunctionValType VT(ReturnType, Params, isVarArg, *TheAttrs); - FunctionType *MT = FunctionTypes->get(VT); - if (MT) return MT; + const ParamAttrsList *Attrs) { + + FunctionValType VT(ReturnType, Params, isVarArg, Attrs); + FunctionType *FT = FunctionTypes->get(VT); + if (FT) { + return FT; + } - MT = new FunctionType(ReturnType, Params, isVarArg, *TheAttrs); - FunctionTypes->add(VT, MT); + FT = (FunctionType*) new char[sizeof(FunctionType) + + sizeof(PATypeHandle)*(Params.size()+1)]; + new (FT) FunctionType(ReturnType, Params, isVarArg, Attrs); + FunctionTypes->add(VT, FT); #ifdef DEBUG_MERGE_TYPES - DOUT << "Derived new type: " << MT << "\n"; + DOUT << "Derived new type: " << FT << "\n"; #endif - return MT; -} - -FunctionType::ParameterAttributes -FunctionType::getParamAttrs(unsigned Idx) const { - if (!ParamAttrs) - return NoAttributeSet; - if (Idx >= ParamAttrs->size()) - return NoAttributeSet; - return (*ParamAttrs)[Idx]; + return FT; } -std::string FunctionType::getParamAttrsText(ParameterAttributes Attr) { - std::string Result; - if (Attr & ZExtAttribute) - Result += "zext "; - if (Attr & SExtAttribute) - Result += "sext "; - if (Attr & NoReturnAttribute) - Result += "noreturn "; - if (Attr & InRegAttribute) - Result += "inreg "; - if (Attr & StructRetAttribute) - Result += "sret "; - return Result; +bool FunctionType::isStructReturn() const { + if (ParamAttrs) + return ParamAttrs->paramHasAttr(1, ParamAttr::StructRet); + return false; } //===----------------------------------------------------------------------===// @@ -1140,42 +1153,42 @@ ArrayType *ArrayType::get(const Type *ElementType, uint64_t NumElements) { //===----------------------------------------------------------------------===// -// Packed Type Factory... +// Vector Type Factory... // namespace llvm { -class PackedValType { +class VectorValType { const Type *ValTy; unsigned Size; public: - PackedValType(const Type *val, int sz) : ValTy(val), Size(sz) {} + VectorValType(const Type *val, int sz) : ValTy(val), Size(sz) {} - static PackedValType get(const PackedType *PT) { - return PackedValType(PT->getElementType(), PT->getNumElements()); + static VectorValType get(const VectorType *PT) { + return VectorValType(PT->getElementType(), PT->getNumElements()); } - static unsigned hashTypeStructure(const PackedType *PT) { + static unsigned hashTypeStructure(const VectorType *PT) { return PT->getNumElements(); } - inline bool operator<(const PackedValType &MTV) const { + inline bool operator<(const VectorValType &MTV) const { if (Size < MTV.Size) return true; return Size == MTV.Size && ValTy < MTV.ValTy; } }; } -static ManagedStatic > PackedTypes; +static ManagedStatic > VectorTypes; -PackedType *PackedType::get(const Type *ElementType, unsigned NumElements) { - assert(ElementType && "Can't get packed of null types!"); +VectorType *VectorType::get(const Type *ElementType, unsigned NumElements) { + assert(ElementType && "Can't get vector of null types!"); assert(isPowerOf2_32(NumElements) && "Vector length should be a power of 2!"); - PackedValType PVT(ElementType, NumElements); - PackedType *PT = PackedTypes->get(PVT); + VectorValType PVT(ElementType, NumElements); + VectorType *PT = VectorTypes->get(PVT); if (PT) return PT; // Found a match, return it! // Value not found. Derive a new type! - PackedTypes->add(PVT, PT = new PackedType(ElementType, NumElements)); + VectorTypes->add(PVT, PT = new VectorType(ElementType, NumElements)); #ifdef DEBUG_MERGE_TYPES DOUT << "Derived new type: " << *PT << "\n"; @@ -1227,7 +1240,10 @@ StructType *StructType::get(const std::vector &ETypes, if (ST) return ST; // Value not found. Derive a new type! - StructTypes->add(STV, ST = new StructType(ETypes, isPacked)); + ST = (StructType*) new char[sizeof(StructType) + + sizeof(PATypeHandle) * ETypes.size()]; + new (ST) StructType(ETypes, isPacked); + StructTypes->add(STV, ST); #ifdef DEBUG_MERGE_TYPES DOUT << "Derived new type: " << *ST << "\n"; @@ -1317,11 +1333,10 @@ void Type::removeAbstractTypeUser(AbstractTypeUser *U) const { DOUT << "DELETEing unused abstract type: <" << *this << ">[" << (void*)this << "]" << "\n"; #endif - delete this; // No users of this abstract type! + this->destroy(); } } - // refineAbstractTypeTo - This function is used when it is discovered that // the 'this' abstract type is actually equivalent to the NewType specified. // This causes all users of 'this' to switch to reference the more concrete type @@ -1440,13 +1455,13 @@ void ArrayType::typeBecameConcrete(const DerivedType *AbsTy) { // concrete - this could potentially change us from an abstract type to a // concrete type. // -void PackedType::refineAbstractType(const DerivedType *OldType, +void VectorType::refineAbstractType(const DerivedType *OldType, const Type *NewType) { - PackedTypes->RefineAbstractType(this, OldType, NewType); + VectorTypes->RefineAbstractType(this, OldType, NewType); } -void PackedType::typeBecameConcrete(const DerivedType *AbsTy) { - PackedTypes->TypeBecameConcrete(this, AbsTy); +void VectorType::typeBecameConcrete(const DerivedType *AbsTy) { + VectorTypes->TypeBecameConcrete(this, AbsTy); } // refineAbstractType - Called when a contained type is found to be more