diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index 237449302c8..aa3b676bf4a 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -9,16 +9,8 @@ #include "llvm/Constants.h" #include "Support/StringExtras.h" #include "Support/STLExtras.h" -#include #include -using std::vector; -using std::string; -using std::map; -using std::swap; -using std::make_pair; -using std::cerr; - // DEBUG_MERGE_TYPES - Enable this #define to see how and when derived types are // created and later destroyed, all in an effort to make sure that there is only // a single cannonical version of a type. @@ -26,20 +18,19 @@ using std::cerr; //#define DEBUG_MERGE_TYPES 1 - //===----------------------------------------------------------------------===// // Type Class Implementation //===----------------------------------------------------------------------===// static unsigned CurUID = 0; -static vector UIDMappings; +static std::vector UIDMappings; void PATypeHolder::dump() const { - cerr << "PATypeHolder(" << (void*)this << ")\n"; + std::cerr << "PATypeHolder(" << (void*)this << ")\n"; } -Type::Type(const string &name, PrimitiveID id) +Type::Type(const std::string &name, PrimitiveID id) : Value(Type::TypeTy, Value::TypeVal) { setDescription(name); ID = id; @@ -48,7 +39,7 @@ Type::Type(const string &name, PrimitiveID id) UIDMappings.push_back(this); } -void Type::setName(const string &Name, SymbolTable *ST) { +void Type::setName(const std::string &Name, SymbolTable *ST) { assert(ST && "Type::setName - Must provide symbol table argument!"); if (Name.size()) ST->insert(Name, this); @@ -152,7 +143,7 @@ const Type *StructType::getTypeAtIndex(const Value *V) const { // type. // struct SignedIntType : public Type { - SignedIntType(const string &Name, PrimitiveID id) : Type(Name, id) {} + SignedIntType(const std::string &Name, PrimitiveID id) : Type(Name, id) {} // isSigned - Return whether a numeric type is signed. virtual bool isSigned() const { return 1; } @@ -164,7 +155,7 @@ struct SignedIntType : public Type { }; struct UnsignedIntType : public Type { - UnsignedIntType(const string &N, PrimitiveID id) : Type(N, id) {} + UnsignedIntType(const std::string &N, PrimitiveID id) : Type(N, id) {} // isUnsigned - Return whether a numeric type is signed. virtual bool isUnsigned() const { return 1; } @@ -205,7 +196,7 @@ Type *Type::VoidTy = new Type("void" , VoidTyID), //===----------------------------------------------------------------------===// FunctionType::FunctionType(const Type *Result, - const vector &Params, + const std::vector &Params, bool IsVarArgs) : DerivedType(FunctionTyID), ResultType(PATypeHandle(Result, this)), isVarArgs(IsVarArgs) { @@ -216,7 +207,7 @@ FunctionType::FunctionType(const Type *Result, setDerivedTypeProperties(); } -StructType::StructType(const vector &Types) +StructType::StructType(const std::vector &Types) : CompositeType(StructTyID) { ETypes.reserve(Types.size()); for (unsigned i = 0; i < Types.size(); ++i) { @@ -240,7 +231,7 @@ OpaqueType::OpaqueType() : DerivedType(OpaqueTyID) { setAbstract(true); setDescription("opaque"+utostr(getUniqueID())); #ifdef DEBUG_MERGE_TYPES - cerr << "Derived new type: " << getDescription() << endl; + std::cerr << "Derived new type: " << getDescription() << "\n"; #endif } @@ -257,8 +248,9 @@ OpaqueType::OpaqueType() : DerivedType(OpaqueTyID) { // some whacko opaque types, but in most cases, it will do some simple stuff // when it hits non-abstract types that aren't recursive. // -static string getTypeProps(const Type *Ty, vector &TypeStack, - bool &isAbstract, bool &isRecursive) { +static std::string getTypeProps(const Type *Ty, + std::vector &TypeStack, + bool &isAbstract, bool &isRecursive) { if (!Ty->isAbstract() && !Ty->isRecursive() && // Base case for the recursion Ty->getDescription().size()) { return Ty->getDescription(); // Primitive = leaf type @@ -278,7 +270,7 @@ static string getTypeProps(const Type *Ty, vector &TypeStack, isRecursive = true; // We know we are recursive return "\\" + utostr(CurSize-Slot); // Here's the upreference } else { // Recursive case: abstract derived type... - string Result; + std::string Result; TypeStack.push_back(Ty); // Add us to the stack.. switch (Ty->getPrimitiveID()) { @@ -345,7 +337,7 @@ static string getTypeProps(const Type *Ty, vector &TypeStack, // getTypeProps function does all the dirty work. // void DerivedType::setDerivedTypeProperties() { - vector TypeStack; + std::vector TypeStack; bool isAbstract = false, isRecursive = false; setDescription(getTypeProps(this, TypeStack, isAbstract, isRecursive)); @@ -365,20 +357,20 @@ void DerivedType::setDerivedTypeProperties() { // that assumes that two graphs are the same until proven otherwise. // static bool TypesEqual(const Type *Ty, const Type *Ty2, - map &EqTypes) { + std::map &EqTypes) { if (Ty == Ty2) return true; if (Ty->getPrimitiveID() != Ty2->getPrimitiveID()) return false; if (Ty->isPrimitiveType()) return true; if (isa(Ty)) return false; // Two nonequal opaque types are never equal - map::iterator It = EqTypes.find(Ty); + std::map::iterator It = EqTypes.find(Ty); if (It != EqTypes.end()) return It->second == Ty2; // Looping back on a type, check for equality // Otherwise, add the mapping to the table to make sure we don't get // recursion on the types... - EqTypes.insert(make_pair(Ty, Ty2)); + EqTypes.insert(std::make_pair(Ty, Ty2)); // Iterate over the types and make sure the the contents are equivalent... Type::subtype_iterator I = Ty ->subtype_begin(), IE = Ty ->subtype_end(); @@ -401,7 +393,7 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2, } static bool TypesEqual(const Type *Ty, const Type *Ty2) { - map EqTypes; + std::map EqTypes; return TypesEqual(Ty, Ty2, EqTypes); } @@ -417,19 +409,20 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2) { // template class TypeMap : public AbstractTypeUser { - typedef map > MapTy; + typedef std::map > MapTy; MapTy Map; public: ~TypeMap() { print("ON EXIT"); } inline TypeClass *get(const ValType &V) { - typename map >::iterator I = Map.find(V); + typename std::map >::iterator I + = Map.find(V); // TODO: FIXME: When Types are not CONST. return (I != Map.end()) ? (TypeClass*)I->second.get() : 0; } inline void add(const ValType &V, TypeClass *T) { - Map.insert(make_pair(V, PATypeHandle(T, this))); + Map.insert(std::make_pair(V, PATypeHandle(T, this))); print("add"); } @@ -450,9 +443,9 @@ public: // virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) { #ifdef DEBUG_MERGE_TYPES - cerr << "Removing Old type from Tab: " << (void*)OldTy << ", " - << OldTy->getDescription() << " replacement == " << (void*)NewTy - << ", " << NewTy->getDescription() << endl; + std::cerr << "Removing Old type from Tab: " << (void*)OldTy << ", " + << OldTy->getDescription() << " replacement == " << (void*)NewTy + << ", " << NewTy->getDescription() << "\n"; #endif for (typename MapTy::iterator I = Map.begin(), E = Map.end(); I != E; ++I) if (I->second == OldTy) { @@ -471,11 +464,11 @@ public: void print(const char *Arg) const { #ifdef DEBUG_MERGE_TYPES - cerr << "TypeMap<>::" << Arg << " table contents:\n"; + std::cerr << "TypeMap<>::" << Arg << " table contents:\n"; unsigned i = 0; for (MapTy::const_iterator I = Map.begin(), E = Map.end(); I != E; ++I) - cerr << " " << (++i) << ". " << I->second << " " - << I->second->getDescription() << endl; + std::cerr << " " << (++i) << ". " << I->second << " " + << I->second->getDescription() << "\n"; #endif } @@ -522,7 +515,7 @@ protected: } void dump() const { - cerr << "ValTypeBase instance!\n"; + std::cerr << "ValTypeBase instance!\n"; } }; @@ -536,10 +529,10 @@ protected: // class FunctionValType : public ValTypeBase { PATypeHandle RetTy; - vector > ArgTypes; + std::vector > ArgTypes; bool isVarArg; public: - FunctionValType(const Type *ret, const vector &args, + FunctionValType(const Type *ret, const std::vector &args, bool IVA, TypeMap &Tab) : ValTypeBase(Tab), RetTy(ret, this), isVarArg(IVA) { @@ -586,7 +579,7 @@ static TypeMap FunctionTypes; // FunctionType::get - The factory function for the FunctionType class... FunctionType *FunctionType::get(const Type *ReturnType, - const vector &Params, + const std::vector &Params, bool isVarArg) { FunctionValType VT(ReturnType, Params, isVarArg, FunctionTypes); FunctionType *MT = FunctionTypes.get(VT); @@ -595,7 +588,7 @@ FunctionType *FunctionType::get(const Type *ReturnType, FunctionTypes.add(VT, MT = new FunctionType(ReturnType, Params, isVarArg)); #ifdef DEBUG_MERGE_TYPES - cerr << "Derived new type: " << MT << endl; + std::cerr << "Derived new type: " << MT << "\n"; #endif return MT; } @@ -648,7 +641,7 @@ ArrayType *ArrayType::get(const Type *ElementType, unsigned NumElements) { ArrayTypes.add(AVT, AT = new ArrayType(ElementType, NumElements)); #ifdef DEBUG_MERGE_TYPES - cerr << "Derived new type: " << AT->getDescription() << endl; + std::cerr << "Derived new type: " << AT->getDescription() << "\n"; #endif return AT; } @@ -660,9 +653,9 @@ ArrayType *ArrayType::get(const Type *ElementType, unsigned NumElements) { // StructValType - Define a class to hold the key that goes into the TypeMap // class StructValType : public ValTypeBase { - vector > ElTypes; + std::vector > ElTypes; public: - StructValType(const vector &args, + StructValType(const std::vector &args, TypeMap &Tab) : ValTypeBase(Tab) { ElTypes.reserve(args.size()); @@ -699,7 +692,7 @@ public: static TypeMap StructTypes; -StructType *StructType::get(const vector &ETypes) { +StructType *StructType::get(const std::vector &ETypes) { StructValType STV(ETypes, StructTypes); StructType *ST = StructTypes.get(STV); if (ST) return ST; @@ -708,7 +701,7 @@ StructType *StructType::get(const vector &ETypes) { StructTypes.add(STV, ST = new StructType(ETypes)); #ifdef DEBUG_MERGE_TYPES - cerr << "Derived new type: " << ST->getDescription() << endl; + std::cerr << "Derived new type: " << ST->getDescription() << "\n"; #endif return ST; } @@ -761,7 +754,7 @@ PointerType *PointerType::get(const Type *ValueType) { PointerTypes.add(PVT, PT = new PointerType(ValueType)); #ifdef DEBUG_MERGE_TYPES - cerr << "Derived new type: " << PT->getDescription() << endl; + std::cerr << "Derived new type: " << PT->getDescription() << "\n"; #endif return PT; } @@ -785,8 +778,9 @@ void DerivedType::addAbstractTypeUser(AbstractTypeUser *U) const { assert(isAbstract() && "addAbstractTypeUser: Current type not abstract!"); #if DEBUG_MERGE_TYPES - cerr << " addAbstractTypeUser[" << (void*)this << ", " << getDescription() - << "][" << AbstractTypeUsers.size() << "] User = " << U << endl; + std::cerr << " addAbstractTypeUser[" << (void*)this << ", " + << getDescription() << "][" << AbstractTypeUsers.size() + << "] User = " << U << "\n"; #endif AbstractTypeUsers.push_back(U); } @@ -812,14 +806,14 @@ void DerivedType::removeAbstractTypeUser(AbstractTypeUser *U) const { AbstractTypeUsers.erase(AbstractTypeUsers.begin()+i); #ifdef DEBUG_MERGE_TYPES - cerr << " remAbstractTypeUser[" << (void*)this << ", " - << getDescription() << "][" << i << "] User = " << U << endl; + std::cerr << " remAbstractTypeUser[" << (void*)this << ", " + << getDescription() << "][" << i << "] User = " << U << "\n"; #endif if (AbstractTypeUsers.empty() && isAbstract()) { #ifdef DEBUG_MERGE_TYPES - cerr << "DELETEing unused abstract type: <" << getDescription() - << ">[" << (void*)this << "]" << endl; + std::cerr << "DELETEing unused abstract type: <" << getDescription() + << ">[" << (void*)this << "]" << "\n"; #endif delete this; // No users of this abstract type! } @@ -836,9 +830,9 @@ void DerivedType::refineAbstractTypeTo(const Type *NewType) { assert(this != NewType && "Can't refine to myself!"); #ifdef DEBUG_MERGE_TYPES - cerr << "REFINING abstract type [" << (void*)this << " " << getDescription() - << "] to [" << (void*)NewType << " " << NewType->getDescription() - << "]!\n"; + std::cerr << "REFINING abstract type [" << (void*)this << " " + << getDescription() << "] to [" << (void*)NewType << " " + << NewType->getDescription() << "]!\n"; #endif @@ -870,14 +864,14 @@ void DerivedType::refineAbstractTypeTo(const Type *NewType) { if (User == this) { // Move self use to the start of the list. Increment NSU. - swap(AbstractTypeUsers.back(), AbstractTypeUsers[NumSelfUses++]); + std::swap(AbstractTypeUsers.back(), AbstractTypeUsers[NumSelfUses++]); } else { unsigned OldSize = AbstractTypeUsers.size(); #ifdef DEBUG_MERGE_TYPES - cerr << " REFINING user " << OldSize-1 << "[" << (void*)User - << "] of abstract type [" - << (void*)this << " " << getDescription() << "] to [" - << (void*)NewTy.get() << " " << NewTy->getDescription() << "]!\n"; + std::cerr << " REFINING user " << OldSize-1 << "[" << (void*)User + << "] of abstract type [" << (void*)this << " " + << getDescription() << "] to [" << (void*)NewTy.get() << " " + << NewTy->getDescription() << "]!\n"; #endif User->refineAbstractType(this, NewTy); @@ -885,11 +879,11 @@ void DerivedType::refineAbstractTypeTo(const Type *NewType) { if (AbstractTypeUsers.size() == OldSize) { User->refineAbstractType(this, NewTy); if (AbstractTypeUsers.back() != User) - cerr << "User changed!\n"; - cerr << "Top of user list is:\n"; + std::cerr << "User changed!\n"; + std::cerr << "Top of user list is:\n"; AbstractTypeUsers.back()->dump(); - cerr <<"\nOld User=\n"; + std::cerr <<"\nOld User=\n"; User->dump(); } #endif @@ -917,7 +911,8 @@ void DerivedType::typeIsRefined() { ++isRefining; #ifdef DEBUG_MERGE_TYPES - cerr << "typeIsREFINED type: " << (void*)this <<" "< Refined; + std::vector Refined; while (1) { unsigned i; for (i = AbstractTypeUsers.size(); i != 0; --i) @@ -947,8 +942,9 @@ void DerivedType::typeIsRefined() { 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"; + std::cerr << " typeIsREFINED user " << i << "[" << ATU + << "] of abstract type [" << (void*)this << " " + << getDescription() << "]\n"; #endif ATU->refineAbstractType(this, this); } @@ -960,9 +956,9 @@ void DerivedType::typeIsRefined() { for (unsigned i = 0; i < AbstractTypeUsers.size(); ++i) { if (AbstractTypeUsers[i] != this) { // Debugging hook - cerr << "FOUND FAILURE\nUser: "; + std::cerr << "FOUND FAILURE\nUser: "; AbstractTypeUsers[i]->dump(); - cerr << "\nCatch:\n"; + std::cerr << "\nCatch:\n"; AbstractTypeUsers[i]->refineAbstractType(this, this); assert(0 && "Type became concrete," " but it still has abstract type users hanging around!"); @@ -981,9 +977,9 @@ void DerivedType::typeIsRefined() { void FunctionType::refineAbstractType(const DerivedType *OldType, const Type *NewType) { #ifdef DEBUG_MERGE_TYPES - cerr << "FunctionTy::refineAbstractTy(" << (void*)OldType << "[" - << OldType->getDescription() << "], " << (void*)NewType << " [" - << NewType->getDescription() << "])\n"; + std::cerr << "FunctionTy::refineAbstractTy(" << (void*)OldType << "[" + << OldType->getDescription() << "], " << (void*)NewType << " [" + << NewType->getDescription() << "])\n"; #endif // Find the type element we are refining... if (ResultType == OldType) { @@ -1013,9 +1009,9 @@ void FunctionType::refineAbstractType(const DerivedType *OldType, void ArrayType::refineAbstractType(const DerivedType *OldType, const Type *NewType) { #ifdef DEBUG_MERGE_TYPES - cerr << "ArrayTy::refineAbstractTy(" << (void*)OldType << "[" - << OldType->getDescription() << "], " << (void*)NewType << " [" - << NewType->getDescription() << "])\n"; + std::cerr << "ArrayTy::refineAbstractTy(" << (void*)OldType << "[" + << OldType->getDescription() << "], " << (void*)NewType << " [" + << NewType->getDescription() << "])\n"; #endif assert(getElementType() == OldType); @@ -1039,9 +1035,9 @@ void ArrayType::refineAbstractType(const DerivedType *OldType, void StructType::refineAbstractType(const DerivedType *OldType, const Type *NewType) { #ifdef DEBUG_MERGE_TYPES - cerr << "StructTy::refineAbstractTy(" << (void*)OldType << "[" - << OldType->getDescription() << "], " << (void*)NewType << " [" - << NewType->getDescription() << "])\n"; + std::cerr << "StructTy::refineAbstractTy(" << (void*)OldType << "[" + << OldType->getDescription() << "], " << (void*)NewType << " [" + << NewType->getDescription() << "])\n"; #endif for (int i = ETypes.size()-1; i >= 0; --i) if (ETypes[i] == OldType) { @@ -1067,9 +1063,9 @@ void StructType::refineAbstractType(const DerivedType *OldType, void PointerType::refineAbstractType(const DerivedType *OldType, const Type *NewType) { #ifdef DEBUG_MERGE_TYPES - cerr << "PointerTy::refineAbstractTy(" << (void*)OldType << "[" - << OldType->getDescription() << "], " << (void*)NewType << " [" - << NewType->getDescription() << "])\n"; + std::cerr << "PointerTy::refineAbstractTy(" << (void*)OldType << "[" + << OldType->getDescription() << "], " << (void*)NewType << " [" + << NewType->getDescription() << "])\n"; #endif assert(ElementType == OldType);