X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FType.cpp;h=4990700370f3c873b49d853f78b447778a674145;hb=627079d42a1340360f8699cd87865e20799cff21;hp=1af616f866373c32ada4387c0545409572ae9b8a;hpb=af93dbcc95accfc9583aa59d19515adc5acacde7;p=oota-llvm.git diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index 1af616f8663..4990700370f 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -6,9 +6,11 @@ #include "llvm/DerivedTypes.h" #include "llvm/SymbolTable.h" +#include "llvm/Constants.h" #include "Support/StringExtras.h" #include "Support/STLExtras.h" #include +#include using std::vector; using std::string; @@ -85,8 +87,8 @@ const Type *Type::getPrimitiveType(PrimitiveID IDNumber) { // bool Type::isLosslesslyConvertableTo(const Type *Ty) const { if (this == Ty) return true; - if ((!isPrimitiveType() && !isPointerType()) || - (!Ty->isPointerType() && !Ty->isPrimitiveType())) return false; + if ((!isPrimitiveType() && !isa(this)) || + (!isa(Ty) && !Ty->isPrimitiveType())) return false; if (getPrimitiveID() == Ty->getPrimitiveID()) return true; // Handles identity cast, and cast of differing pointer types @@ -102,13 +104,24 @@ bool Type::isLosslesslyConvertableTo(const Type *Ty) const { case Type::ULongTyID: case Type::LongTyID: case Type::PointerTyID: - return Ty == Type::ULongTy || Ty == Type::LongTy || - Ty->getPrimitiveID() == Type::PointerTyID; + return Ty == Type::ULongTy || Ty == Type::LongTy || isa(Ty); default: return false; // Other types have no identity values } } +// getPrimitiveSize - Return the basic size of this type if it is a primative +// type. These are fixed by LLVM and are not target dependant. This will +// return zero if the type does not have a size or is not a primitive type. +// +unsigned Type::getPrimitiveSize() const { + switch (getPrimitiveID()) { +#define HANDLE_PRIM_TYPE(TY,SIZE) case TY##TyID: return SIZE; +#include "llvm/Type.def" + default: return 0; + } +} + bool StructType::indexValid(const Value *V) const { if (!isa(V)) return false; @@ -138,36 +151,28 @@ const Type *StructType::getTypeAtIndex(const Value *V) const { // These classes are used to implement specialized behavior for each different // type. // -class SignedIntType : public Type { - int Size; -public: - SignedIntType(const string &Name, PrimitiveID id, int size) : Type(Name, id) { - Size = size; - } +struct SignedIntType : public Type { + SignedIntType(const string &Name, PrimitiveID id) : Type(Name, id) {} // isSigned - Return whether a numeric type is signed. virtual bool isSigned() const { return 1; } - // isIntegral - Equivalent to isSigned() || isUnsigned, but with only a single + // isInteger - Equivalent to isSigned() || isUnsigned, but with only a single // virtual function invocation. // - virtual bool isIntegral() const { return 1; } + virtual bool isInteger() const { return 1; } }; -class UnsignedIntType : public Type { - uint64_t Size; -public: - UnsignedIntType(const string &N, PrimitiveID id, int size) : Type(N, id) { - Size = size; - } +struct UnsignedIntType : public Type { + UnsignedIntType(const string &N, PrimitiveID id) : Type(N, id) {} // isUnsigned - Return whether a numeric type is signed. virtual bool isUnsigned() const { return 1; } - // isIntegral - Equivalent to isSigned() || isUnsigned, but with only a single + // isInteger - Equivalent to isSigned() || isUnsigned, but with only a single // virtual function invocation. // - virtual bool isIntegral() const { return 1; } + virtual bool isInteger() const { return 1; } }; static struct TypeType : public Type { @@ -181,14 +186,14 @@ static struct TypeType : public Type { Type *Type::VoidTy = new Type("void" , VoidTyID), *Type::BoolTy = new Type("bool" , BoolTyID), - *Type::SByteTy = new SignedIntType("sbyte" , SByteTyID, 1), - *Type::UByteTy = new UnsignedIntType("ubyte" , UByteTyID, 1), - *Type::ShortTy = new SignedIntType("short" , ShortTyID, 2), - *Type::UShortTy = new UnsignedIntType("ushort", UShortTyID, 2), - *Type::IntTy = new SignedIntType("int" , IntTyID, 4), - *Type::UIntTy = new UnsignedIntType("uint" , UIntTyID, 4), - *Type::LongTy = new SignedIntType("long" , LongTyID, 8), - *Type::ULongTy = new UnsignedIntType("ulong" , ULongTyID, 8), + *Type::SByteTy = new SignedIntType("sbyte" , SByteTyID), + *Type::UByteTy = new UnsignedIntType("ubyte" , UByteTyID), + *Type::ShortTy = new SignedIntType("short" , ShortTyID), + *Type::UShortTy = new UnsignedIntType("ushort", UShortTyID), + *Type::IntTy = new SignedIntType("int" , IntTyID), + *Type::UIntTy = new UnsignedIntType("uint" , UIntTyID), + *Type::LongTy = new SignedIntType("long" , LongTyID), + *Type::ULongTy = new UnsignedIntType("ulong" , ULongTyID), *Type::FloatTy = new Type("float" , FloatTyID), *Type::DoubleTy = new Type("double", DoubleTyID), *Type::TypeTy = &TheTypeType, @@ -415,11 +420,10 @@ class TypeMap : public AbstractTypeUser { typedef map > MapTy; MapTy Map; public: - ~TypeMap() { print("ON EXIT"); } inline TypeClass *get(const ValType &V) { - map >::iterator I = Map.find(V); + typename map >::iterator I = Map.find(V); // TODO: FIXME: When Types are not CONST. return (I != Map.end()) ? (TypeClass*)I->second.get() : 0; } @@ -433,7 +437,7 @@ public: // structurally equivalent to the specified type. // inline const TypeClass *containsEquivalent(const TypeClass *Ty) { - for (MapTy::iterator I = Map.begin(), E = Map.end(); I != E; ++I) + for (typename MapTy::iterator I = Map.begin(), E = Map.end(); I != E; ++I) if (I->second.get() != Ty && TypesEqual(Ty, I->second.get())) return (TypeClass*)I->second.get(); // FIXME TODO when types not const return 0; @@ -445,33 +449,22 @@ public: // corrected. // virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) { - assert(OldTy == NewTy || OldTy->isAbstract()); - if (OldTy == NewTy) { - if (!OldTy->isAbstract()) { - // Check to see if the type just became concrete. - // If so, remove self from user list. - for (MapTy::iterator I = Map.begin(), E = Map.end(); I != E; ++I) - if (I->second == OldTy) - I->second.removeUserFromConcrete(); - } - return; - } #ifdef DEBUG_MERGE_TYPES cerr << "Removing Old type from Tab: " << (void*)OldTy << ", " << OldTy->getDescription() << " replacement == " << (void*)NewTy << ", " << NewTy->getDescription() << endl; #endif - for (MapTy::iterator I = Map.begin(), E = Map.end(); I != E; ++I) + for (typename MapTy::iterator I = Map.begin(), E = Map.end(); I != E; ++I) if (I->second == OldTy) { - Map.erase(I); - print("refineAbstractType after"); - return; + // Check to see if the type just became concrete. If so, remove self + // from user list. + I->second.removeUserFromConcrete(); + I->second = cast(NewTy); } - assert(0 && "Abstract type not found in table!"); } void remove(const ValType &OldVal) { - MapTy::iterator I = Map.find(OldVal); + typename MapTy::iterator I = Map.find(OldVal); assert(I != Map.end() && "TypeMap::remove, element not found!"); Map.erase(I); } @@ -511,22 +504,21 @@ protected: virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) { assert(OldTy == NewTy || OldTy->isAbstract()); - if (OldTy == NewTy) { - if (!OldTy->isAbstract()) - typeBecameConcrete(OldTy); - // MUST fall through here to update map, even if the type pointers stay - // the same! - } + + if (!OldTy->isAbstract()) + typeBecameConcrete(OldTy); + TypeMap &Table = MyTable; // Copy MyTable reference ValType Tmp(*(ValType*)this); // Copy this. PATypeHandle OldType(Table.get(*(ValType*)this), this); Table.remove(*(ValType*)this); // Destroy's this! -#if 0 + // Refine temporary to new state... - Tmp.doRefinement(OldTy, NewTy); + if (OldTy != NewTy) + Tmp.doRefinement(OldTy, NewTy); + // FIXME: when types are not const! Table.add((ValType&)Tmp, (TypeClass*)OldType.get()); -#endif } void dump() const { @@ -569,7 +561,7 @@ public: // Subclass should override this... to update self as usual virtual void doRefinement(const DerivedType *OldType, const Type *NewType) { if (RetTy == OldType) RetTy = NewType; - for (unsigned i = 0; i < ArgTypes.size(); ++i) + for (unsigned i = 0, e = ArgTypes.size(); i != e; ++i) if (ArgTypes[i] == OldType) ArgTypes[i] = NewType; } @@ -627,7 +619,8 @@ public: // Subclass should override this... to update self as usual virtual void doRefinement(const DerivedType *OldType, const Type *NewType) { - if (ValTy == OldType) ValTy = NewType; + assert(ValTy == OldType); + ValTy = NewType; } virtual void typeBecameConcrete(const DerivedType *Ty) { @@ -694,8 +687,9 @@ public: } virtual void typeBecameConcrete(const DerivedType *Ty) { - for (unsigned i = 0; i < ElTypes.size(); ++i) - if (ElTypes[i] == Ty) ElTypes[i].removeUserFromConcrete(); + for (unsigned i = 0, e = ElTypes.size(); i != e; ++i) + if (ElTypes[i] == Ty) + ElTypes[i].removeUserFromConcrete(); } inline bool operator<(const StructValType &STV) const { @@ -739,7 +733,8 @@ public: // Subclass should override this... to update self as usual virtual void doRefinement(const DerivedType *OldType, const Type *NewType) { - if (ValTy == OldType) ValTy = NewType; + assert(ValTy == OldType); + ValTy = NewType; } virtual void typeBecameConcrete(const DerivedType *Ty) { @@ -771,6 +766,12 @@ PointerType *PointerType::get(const Type *ValueType) { return PT; } +void debug_type_tables() { + FunctionTypes.dump(); + ArrayTypes.dump(); + StructTypes.dump(); + PointerTypes.dump(); +} //===----------------------------------------------------------------------===// @@ -782,9 +783,6 @@ PointerType *PointerType::get(const Type *ValueType) { // void DerivedType::addAbstractTypeUser(AbstractTypeUser *U) const { assert(isAbstract() && "addAbstractTypeUser: Current type not abstract!"); - if (U == (AbstractTypeUser*)0x2568a8) { - cerr << "Found bad guy!\n"; - } #if DEBUG_MERGE_TYPES cerr << " addAbstractTypeUser[" << (void*)this << ", " << getDescription() @@ -921,18 +919,38 @@ void DerivedType::typeIsRefined() { #ifdef DEBUG_MERGE_TYPES cerr << "typeIsREFINED type: " << (void*)this <<" "< Refined; + while (1) { + unsigned i; + for (i = AbstractTypeUsers.size(); i != 0; --i) + if (find(Refined.begin(), Refined.end(), AbstractTypeUsers[i-1]) == + Refined.end()) + break; // Found an unrefined user? + + if (i == 0) break; // Noone to refine left, break out of here! + + AbstractTypeUser *ATU = AbstractTypeUsers[--i]; + Refined.push_back(ATU); // Keep track of which users we have refined! + #ifdef DEBUG_MERGE_TYPES cerr << " typeIsREFINED user " << i << "[" << ATU << "] of abstract type [" << (void*)this << " " << getDescription() << "]\n"; #endif - unsigned OldSize = AbstractTypeUsers.size(); ATU->refineAbstractType(this, this); - - // If the user didn't remove itself from the list, continue... - if (AbstractTypeUsers.size() == OldSize && AbstractTypeUsers[i] == ATU) - ++i; } --isRefining; @@ -968,20 +986,16 @@ void FunctionType::refineAbstractType(const DerivedType *OldType, << NewType->getDescription() << "])\n"; #endif // Find the type element we are refining... - PATypeHandle *MatchTy = 0; - if (ResultType == OldType) - MatchTy = &ResultType; - else { - unsigned i; - for (i = 0; ParamTys[i] != OldType; ++i) - assert(i != ParamTys.size()); - MatchTy = &ParamTys[i]; + if (ResultType == OldType) { + ResultType.removeUserFromConcrete(); + ResultType = NewType; } + for (unsigned i = 0, e = ParamTys.size(); i != e; ++i) + if (ParamTys[i] == OldType) { + ParamTys[i].removeUserFromConcrete(); + ParamTys[i] = NewType; + } - if (!OldType->isAbstract()) - MatchTy->removeUserFromConcrete(); - - *MatchTy = NewType; const FunctionType *MT = FunctionTypes.containsEquivalent(this); if (MT && MT != this) { refineAbstractTypeTo(MT); // Different type altogether... @@ -1004,12 +1018,10 @@ void ArrayType::refineAbstractType(const DerivedType *OldType, << NewType->getDescription() << "])\n"; #endif - if (!OldType->isAbstract()) { - assert(getElementType() == OldType); - ElementType.removeUserFromConcrete(); - } - + assert(getElementType() == OldType); + ElementType.removeUserFromConcrete(); ElementType = NewType; + const ArrayType *AT = ArrayTypes.containsEquivalent(this); if (AT && AT != this) { refineAbstractTypeTo(AT); // Different type altogether... @@ -1031,15 +1043,13 @@ void StructType::refineAbstractType(const DerivedType *OldType, << OldType->getDescription() << "], " << (void*)NewType << " [" << NewType->getDescription() << "])\n"; #endif - unsigned i; - for (i = 0; ETypes[i] != OldType; ++i) - assert(i != ETypes.size() && "OldType not found in this structure!"); - - if (!OldType->isAbstract()) - ETypes[i].removeUserFromConcrete(); + for (unsigned i = 0, e = ETypes.size(); i != e; ++i) + if (ETypes[i] == OldType) { + ETypes[i].removeUserFromConcrete(); - // Update old type to new type in the array... - ETypes[i] = NewType; + // Update old type to new type in the array... + ETypes[i] = NewType; + } const StructType *ST = StructTypes.containsEquivalent(this); if (ST && ST != this) { @@ -1062,14 +1072,11 @@ void PointerType::refineAbstractType(const DerivedType *OldType, << NewType->getDescription() << "])\n"; #endif - if (!OldType->isAbstract()) { - assert(ElementType == OldType); - ElementType.removeUserFromConcrete(); - } - + assert(ElementType == OldType); + ElementType.removeUserFromConcrete(); ElementType = NewType; - const PointerType *PT = PointerTypes.containsEquivalent(this); + const PointerType *PT = PointerTypes.containsEquivalent(this); if (PT && PT != this) { refineAbstractTypeTo(PT); // Different type altogether... } else {