X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FType.cpp;h=6b884445ee8e787eec9205b3f191e1d83c7f7280;hb=5fe6e33ef81fc33d74f2569e85fb2128ef2e2024;hp=00c6d48dceb1eac4410bad3588dd38517ee31eb7;hpb=b5f378e11b7bdcf4a81c98ec535cc487ab9a92f9;p=oota-llvm.git diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index 00c6d48dceb..6b884445ee8 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -11,9 +11,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/AbstractTypeUser.h" #include "llvm/DerivedTypes.h" -#include "llvm/SymbolTable.h" #include "llvm/Constants.h" #include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/StringExtras.h" @@ -63,31 +61,91 @@ 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) { - case VoidTyID : return VoidTy; - case FloatTyID : return FloatTy; - case DoubleTyID: return DoubleTy; - case LabelTyID : return LabelTy; + case VoidTyID : return VoidTy; + case FloatTyID : return FloatTy; + case DoubleTyID : return DoubleTy; + case X86_FP80TyID : return X86_FP80Ty; + case FP128TyID : return FP128Ty; + case PPC_FP128TyID : return PPC_FP128Ty; + case LabelTyID : return LabelTy; default: return 0; } } +const Type *Type::getVAArgsPromotedType() const { + if (ID == IntegerTyID && getSubclassData() < 32) + return Type::Int32Ty; + else if (ID == FloatTyID) + return Type::DoubleTy; + else + return this; +} + +/// isIntOrIntVector - Return true if this is an integer type or a vector of +/// integer types. +/// +bool Type::isIntOrIntVector() const { + if (isInteger()) + return true; + if (ID != Type::VectorTyID) return false; + + return cast(this)->getElementType()->isInteger(); +} + /// isFPOrFPVector - Return true if this is a FP type or a vector of FP types. /// bool Type::isFPOrFPVector() const { - if (ID == Type::FloatTyID || ID == Type::DoubleTyID) return true; - if (ID != Type::PackedTyID) return false; + if (ID == Type::FloatTyID || ID == Type::DoubleTyID || + ID == Type::FP128TyID || ID == Type::X86_FP80TyID || + ID == Type::PPC_FP128TyID) + return true; + 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 @@ -102,10 +160,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 @@ -120,8 +178,11 @@ unsigned Type::getPrimitiveSizeInBits() const { switch (getTypeID()) { case Type::FloatTyID: return 32; case Type::DoubleTyID: return 64; + case Type::X86_FP80TyID: return 80; + case Type::FP128TyID: return 128; + case Type::PPC_FP128TyID: return 128; case Type::IntegerTyID: return cast(this)->getBitWidth(); - case Type::PackedTyID: return cast(this)->getBitWidth(); + case Type::VectorTyID: return cast(this)->getBitWidth(); default: return 0; } } @@ -130,10 +191,13 @@ unsigned Type::getPrimitiveSizeInBits() const { /// iff all of the members of the type are sized as well. Since asking for /// their size is relatively uncommon, move this operation out of line. bool Type::isSizedDerivedType() const { + if (isa(this)) + return true; + 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)) @@ -197,7 +261,23 @@ 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::X86_FP80TyID: + return (*ConcreteTypeDescriptions)[Ty] = "x86_fp80"; + case Type::FP128TyID: return (*ConcreteTypeDescriptions)[Ty] = "fp128"; + case Type::PPC_FP128TyID: + return (*ConcreteTypeDescriptions)[Ty] = "ppc_fp128"; + case Type::LabelTyID: return (*ConcreteTypeDescriptions)[Ty] = "label"; + } + } } // Check to see if the Type is already on the stack... @@ -226,13 +306,10 @@ static std::string getTypeDescription(const Type *Ty, if (!Result.empty()) Result += " "; Result += getTypeDescription(FTy->getReturnType(), TypeStack) + " ("; - unsigned Idx = 1; for (FunctionType::param_iterator I = FTy->param_begin(), - E = FTy->param_end(); I != E; ++I) { + E = FTy->param_end(); I != E; ++I) { if (I != FTy->param_begin()) Result += ", "; - Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx)); - Idx++; Result += getTypeDescription(*I, TypeStack); } if (FTy->isVarArg()) { @@ -240,12 +317,8 @@ static std::string getTypeDescription(const Type *Ty, Result += "..."; } Result += ")"; - if (FTy->getParamAttrs(0)) { - Result += " " + FunctionType::getParamAttrsText(FTy->getParamAttrs(0)); - } break; } - case Type::PackedStructTyID: case Type::StructTyID: { const StructType *STy = cast(Ty); if (STy->isPacked()) @@ -265,7 +338,10 @@ static std::string getTypeDescription(const Type *Ty, } case Type::PointerTyID: { const PointerType *PTy = cast(Ty); - Result = getTypeDescription(PTy->getElementType(), TypeStack) + " *"; + Result = getTypeDescription(PTy->getElementType(), TypeStack); + if (unsigned AddressSpace = PTy->getAddressSpace()) + Result += " addrspace(" + utostr(AddressSpace) + ")"; + Result += " *"; break; } case Type::ArrayTyID: { @@ -276,8 +352,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 "; @@ -319,7 +395,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; } @@ -336,34 +412,24 @@ 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 Type *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::X86_FP80Ty = new Type(Type::X86_FP80TyID); +const Type *Type::FP128Ty = new Type(Type::FP128TyID); +const Type *Type::PPC_FP128Ty = new Type(Type::PPC_FP128TyID); +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); //===----------------------------------------------------------------------===// @@ -372,42 +438,37 @@ DeclareIntegerType(Int64, 64); FunctionType::FunctionType(const Type *Result, const std::vector &Params, - bool IsVarArgs, const ParamAttrsList &Attrs) + bool IsVarArgs) : DerivedType(FunctionTyID), isVarArgs(IsVarArgs) { + ContainedTys = reinterpret_cast(this+1); + NumContainedTys = Params.size() + 1; // + 1 for result type assert((Result->isFirstClassType() || Result == Type::VoidTy || - isa(Result)) && + Result->getTypeID() == Type::StructTyID || + 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(); } @@ -423,17 +484,21 @@ 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"); } -PointerType::PointerType(const Type *E) : SequentialType(PointerTyID, E) { +PointerType::PointerType(const Type *E, unsigned AddrSpace) + : SequentialType(PointerTyID, E) { + AddressSpace = AddrSpace; // Calculate whether or not this type is abstract setAbstract(E->isAbstract()); } @@ -449,17 +514,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; } } @@ -575,8 +640,9 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2, const IntegerType *ITy2 = cast(Ty2); return ITy->getBitWidth() == ITy2->getBitWidth(); } else if (const PointerType *PTy = dyn_cast(Ty)) { - return TypesEqual(PTy->getElementType(), - cast(Ty2)->getElementType(), EqTypes); + const PointerType *PTy2 = cast(Ty2); + return PTy->getAddressSpace() == PTy2->getAddressSpace() && + TypesEqual(PTy->getElementType(), PTy2->getElementType(), EqTypes); } else if (const StructType *STy = dyn_cast(Ty)) { const StructType *STy2 = cast(Ty2); if (STy->getNumElements() != STy2->getNumElements()) return false; @@ -589,21 +655,17 @@ 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; for (unsigned i = 0, e = FTy2->getNumParams(); i != e; ++i) { - if (FTy->getParamAttrs(i+1) != FTy->getParamAttrs(i+1)) - return false; if (!TypesEqual(FTy->getParamType(i), FTy2->getParamType(i), EqTypes)) return false; } @@ -695,12 +757,15 @@ 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(); break; + case Type::PointerTyID: + HashVal ^= cast(SubTy)->getAddressSpace(); + break; } } return HashVal ? HashVal : 1; // Do not return zero unless opaque subty. @@ -783,15 +848,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, @@ -820,7 +877,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); @@ -980,35 +1037,26 @@ 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; bool isVarArg; public: FunctionValType(const Type *ret, const std::vector &args, - bool IVA, const FunctionType::ParamAttrsList &attrs) - : RetTy(ret), 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]); - } + bool isVA) : RetTy(ret), ArgTypes(args), isVarArg(isVA) {} static FunctionValType get(const FunctionType *FT); static unsigned hashTypeStructure(const FunctionType *FT) { - return FT->getNumParams()*64+FT->getNumAttrs()*2+FT->isVarArg(); - } - - // Subclass should override this... to update self as usual - void doRefinement(const DerivedType *OldType, const Type *NewType) { - if (RetTy == OldType) RetTy = NewType; - for (unsigned i = 0, e = ArgTypes.size(); i != e; ++i) - if (ArgTypes[i] == OldType) ArgTypes[i] = NewType; + unsigned Result = FT->getNumParams()*2 + FT->isVarArg(); + return Result; } inline bool operator<(const FunctionValType &MTV) const { @@ -1017,7 +1065,8 @@ 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; + return false; } }; } @@ -1028,63 +1077,32 @@ 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); + return FunctionValType(FT->getReturnType(), ParamTypes, FT->isVarArg()); } // FunctionType::get - The factory function for the FunctionType class... 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; + bool isVarArg) { + FunctionValType VT(ReturnType, Params, isVarArg); + 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); + 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]; -} - -std::string FunctionType::getParamAttrsText(ParameterAttributes Attr) { - std::string Result; - if (Attr & ZExtAttribute) - Result += "zext "; - if (Attr & SExtAttribute) - Result += "sext "; - if (Attr & NoReturnAttribute) - Result += "noreturn "; - return Result; + return FT; } //===----------------------------------------------------------------------===// @@ -1105,12 +1123,6 @@ public: return (unsigned)AT->getNumElements(); } - // Subclass should override this... to update self as usual - void doRefinement(const DerivedType *OldType, const Type *NewType) { - assert(ValTy == OldType); - ValTy = NewType; - } - inline bool operator<(const ArrayValType &MTV) const { if (Size < MTV.Size) return true; return Size == MTV.Size && ValTy < MTV.ValTy; @@ -1138,48 +1150,41 @@ 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(); } - // Subclass should override this... to update self as usual - void doRefinement(const DerivedType *OldType, const Type *NewType) { - assert(ValTy == OldType); - ValTy = NewType; - } - - 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!"); - assert(isPowerOf2_32(NumElements) && "Vector length should be a power of 2!"); +VectorType *VectorType::get(const Type *ElementType, unsigned NumElements) { + assert(ElementType && "Can't get vector of null types!"); - 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"; @@ -1214,12 +1219,6 @@ public: return ST->getNumElements(); } - // Subclass should override this... to update self as usual - void doRefinement(const DerivedType *OldType, const Type *NewType) { - for (unsigned i = 0; i < ElTypes.size(); ++i) - if (ElTypes[i] == OldType) ElTypes[i] = NewType; - } - inline bool operator<(const StructValType &STV) const { if (ElTypes < STV.ElTypes) return true; else if (ElTypes > STV.ElTypes) return false; @@ -1237,7 +1236,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"; @@ -1256,43 +1258,39 @@ StructType *StructType::get(const std::vector &ETypes, namespace llvm { class PointerValType { const Type *ValTy; + unsigned AddressSpace; public: - PointerValType(const Type *val) : ValTy(val) {} + PointerValType(const Type *val, unsigned as) : ValTy(val), AddressSpace(as) {} static PointerValType get(const PointerType *PT) { - return PointerValType(PT->getElementType()); + return PointerValType(PT->getElementType(), PT->getAddressSpace()); } static unsigned hashTypeStructure(const PointerType *PT) { return getSubElementHash(PT); } - // Subclass should override this... to update self as usual - void doRefinement(const DerivedType *OldType, const Type *NewType) { - assert(ValTy == OldType); - ValTy = NewType; - } - bool operator<(const PointerValType &MTV) const { - return ValTy < MTV.ValTy; + if (AddressSpace < MTV.AddressSpace) return true; + return AddressSpace == MTV.AddressSpace && ValTy < MTV.ValTy; } }; } static ManagedStatic > PointerTypes; -PointerType *PointerType::get(const Type *ValueType) { +PointerType *PointerType::get(const Type *ValueType, unsigned AddressSpace) { assert(ValueType && "Can't get a pointer to type!"); assert(ValueType != Type::VoidTy && "Pointer to void is not valid, use sbyte* instead!"); assert(ValueType != Type::LabelTy && "Pointer to label is not valid!"); - PointerValType PVT(ValueType); + PointerValType PVT(ValueType, AddressSpace); PointerType *PT = PointerTypes->get(PVT); if (PT) return PT; // Value not found. Derive a new type! - PointerTypes->add(PVT, PT = new PointerType(ValueType)); + PointerTypes->add(PVT, PT = new PointerType(ValueType, AddressSpace)); #ifdef DEBUG_MERGE_TYPES DOUT << "Derived new type: " << *PT << "\n"; @@ -1333,11 +1331,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 @@ -1456,13 +1453,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