From: Chris Lattner Date: Wed, 18 Jun 2003 19:22:36 +0000 (+0000) Subject: Detemplatize the PATypeHandle class, which was only really instantiated on 'Type'. X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=893f025262574d01de5585d64860673e13d77ee5;p=oota-llvm.git Detemplatize the PATypeHandle class, which was only really instantiated on 'Type'. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6774 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h index 272560ff288..751c5accdc3 100644 --- a/include/llvm/AbstractTypeUser.h +++ b/include/llvm/AbstractTypeUser.h @@ -58,9 +58,8 @@ public: // example. This class is a simple class used to keep the use list of abstract // types up-to-date. // -template class PATypeHandle { - const TypeSubClass *Ty; + const Type *Ty; AbstractTypeUser * const User; // These functions are defined at the bottom of Type.h. See the comment there @@ -69,7 +68,7 @@ class PATypeHandle { inline void removeUser(); public: // ctor - Add use to type if abstract. Note that Ty must not be null - inline PATypeHandle(const TypeSubClass *ty, AbstractTypeUser *user) + inline PATypeHandle(const Type *ty, AbstractTypeUser *user) : Ty(ty), User(user) { addUser(); } @@ -83,11 +82,11 @@ public: inline ~PATypeHandle() { removeUser(); } // Automatic casting operator so that the handle may be used naturally - inline operator const TypeSubClass *() const { return Ty; } - inline const TypeSubClass *get() const { return Ty; } + inline operator const Type *() const { return Ty; } + inline const Type *get() const { return Ty; } // operator= - Allow assignment to handle - inline const TypeSubClass *operator=(const TypeSubClass *ty) { + inline const Type *operator=(const Type *ty) { if (Ty != ty) { // Ensure we don't accidentally drop last ref to Ty removeUser(); Ty = ty; @@ -97,16 +96,16 @@ public: } // operator= - Allow assignment to handle - inline const TypeSubClass *operator=(const PATypeHandle &T) { + inline const Type *operator=(const PATypeHandle &T) { return operator=(T.Ty); } - inline bool operator==(const TypeSubClass *ty) { + inline bool operator==(const Type *ty) { return Ty == ty; } // operator-> - Allow user to dereference handle naturally... - inline const TypeSubClass *operator->() const { return Ty; } + inline const Type *operator->() const { return Ty; } // removeUserFromConcrete - This function should be called when the User is // notified that our type is refined... and the type is being refined to @@ -122,10 +121,10 @@ public: // as both a handle (as above) and an AbstractTypeUser. It uses the callback to // keep its pointer member updated to the current version of the type. // -struct PATypeHolder : public AbstractTypeUser, public PATypeHandle { - inline PATypeHolder(const Type *ty) : PATypeHandle(ty, this) {} +struct PATypeHolder : public AbstractTypeUser, public PATypeHandle { + inline PATypeHolder(const Type *ty) : PATypeHandle(ty, this) {} inline PATypeHolder(const PATypeHolder &T) - : AbstractTypeUser(T), PATypeHandle(T, this) {} + : AbstractTypeUser(T), PATypeHandle(T, this) {} // refineAbstractType - All we do is update our PATypeHandle member to point // to the new type. @@ -138,20 +137,20 @@ struct PATypeHolder : public AbstractTypeUser, public PATypeHandle { removeUserFromConcrete(); if ((const Type*)OldTy != NewTy) - PATypeHandle::operator=(NewTy); + PATypeHandle::operator=(NewTy); } // operator= - Allow assignment to handle inline const Type *operator=(const Type *ty) { - return PATypeHandle::operator=(ty); + return PATypeHandle::operator=(ty); } // operator= - Allow assignment to handle - inline const Type *operator=(const PATypeHandle &T) { - return PATypeHandle::operator=(T); + inline const Type *operator=(const PATypeHandle &T) { + return PATypeHandle::operator=(T); } inline const Type *operator=(const PATypeHolder &H) { - return PATypeHandle::operator=(H); + return PATypeHandle::operator=(H); } void dump() const; diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h index ed1856f770b..bd44bd27200 100644 --- a/include/llvm/DerivedTypes.h +++ b/include/llvm/DerivedTypes.h @@ -86,9 +86,9 @@ public: class FunctionType : public DerivedType { public: - typedef std::vector > ParamTypes; + typedef std::vector ParamTypes; private: - PATypeHandle ResultType; + PATypeHandle ResultType; ParamTypes ParamTys; bool isVarArgs; @@ -181,7 +181,7 @@ public: class StructType : public CompositeType { public: - typedef std::vector > ElementTypes; + typedef std::vector ElementTypes; private: ElementTypes ETypes; // Element types of struct @@ -245,10 +245,10 @@ class SequentialType : public CompositeType { SequentialType(const SequentialType &); // Do not implement! const SequentialType &operator=(const SequentialType &); // Do not implement! protected: - PATypeHandle ElementType; + PATypeHandle ElementType; SequentialType(PrimitiveID TID, const Type *ElType) - : CompositeType(TID), ElementType(PATypeHandle(ElType, this)) { + : CompositeType(TID), ElementType(PATypeHandle(ElType, this)) { } public: @@ -390,18 +390,17 @@ public: // contains an AbstractTypeUser instance, so there is no good way to factor out // the code. Hence this bit of uglyness. // -template void PATypeHandle::addUser() { +inline void PATypeHandle::addUser() { assert(Ty && "Type Handle has a null type!"); if (Ty->isAbstract()) cast(Ty)->addAbstractTypeUser(User); } -template void PATypeHandle::removeUser() { +inline void PATypeHandle::removeUser() { if (Ty->isAbstract()) cast(Ty)->removeAbstractTypeUser(User); } -template -void PATypeHandle::removeUserFromConcrete() { +inline void PATypeHandle::removeUserFromConcrete() { if (!Ty->isAbstract()) cast(Ty)->removeAbstractTypeUser(User); } diff --git a/include/llvm/Value.h b/include/llvm/Value.h index f6bd144676f..aef34347897 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -50,7 +50,7 @@ public: private: std::vector Uses; std::string Name; - PATypeHandle Ty; + PATypeHandle Ty; ValueTy VTy; void operator=(const Value &); // Do not implement diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index 8fd88ac11f0..ca5b48d01fb 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -816,7 +816,7 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference | UpRTypesV '(' ArgTypeListI ')' { // Function derived type? std::vector Params; mapto($3->begin(), $3->end(), std::back_inserter(Params), - std::mem_fun_ref(&PATypeHandle::get)); + std::mem_fun_ref(&PATypeHandle::get)); bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); @@ -831,7 +831,7 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference | '{' TypeListI '}' { // Structure type? std::vector Elements; mapto($2->begin(), $2->end(), std::back_inserter(Elements), - std::mem_fun_ref(&PATypeHandle::get)); + std::mem_fun_ref(&PATypeHandle::get)); $$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements))); delete $2; diff --git a/lib/Bytecode/Reader/ConstantReader.cpp b/lib/Bytecode/Reader/ConstantReader.cpp index 80c6fc34f4a..32874e2f8b9 100644 --- a/lib/Bytecode/Reader/ConstantReader.cpp +++ b/lib/Bytecode/Reader/ConstantReader.cpp @@ -139,7 +139,7 @@ bool BytecodeParser::parseTypeConstants(const unsigned char *&Buf, // Insert a bunch of opaque types to be resolved later... for (unsigned i = 0; i < NumEntries; ++i) - Tab.push_back(PATypeHandle(OpaqueType::get(), this)); + Tab.push_back(PATypeHandle(OpaqueType::get(), this)); // Loop through reading all of the types. Forward types will make use of the // opaque types just inserted. diff --git a/lib/Bytecode/Reader/ReaderInternals.h b/lib/Bytecode/Reader/ReaderInternals.h index a8ee6fc8b94..e09e5e585b9 100644 --- a/lib/Bytecode/Reader/ReaderInternals.h +++ b/lib/Bytecode/Reader/ReaderInternals.h @@ -104,7 +104,7 @@ private: // All of this data is transient across calls to ParseBytecode // TypesLoaded - This vector mirrors the Values[TypeTyID] plane. It is used // to deal with forward references to types. // - typedef std::vector > TypeValuesListTy; + typedef std::vector TypeValuesListTy; TypeValuesListTy ModuleTypeValues; TypeValuesListTy FunctionTypeValues; diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index 686527315fb..28ed4f366e5 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -216,11 +216,11 @@ Type *Type::LabelTy = &TheLabelTy; FunctionType::FunctionType(const Type *Result, const std::vector &Params, bool IsVarArgs) : DerivedType(FunctionTyID), - ResultType(PATypeHandle(Result, this)), + ResultType(PATypeHandle(Result, this)), isVarArgs(IsVarArgs) { ParamTys.reserve(Params.size()); for (unsigned i = 0; i < Params.size(); ++i) - ParamTys.push_back(PATypeHandle(Params[i], this)); + ParamTys.push_back(PATypeHandle(Params[i], this)); setDerivedTypeProperties(); } @@ -230,7 +230,7 @@ StructType::StructType(const std::vector &Types) ETypes.reserve(Types.size()); for (unsigned i = 0; i < Types.size(); ++i) { assert(Types[i] != Type::VoidTy && "Void type in method prototype!!"); - ETypes.push_back(PATypeHandle(Types[i], this)); + ETypes.push_back(PATypeHandle(Types[i], this)); } setDerivedTypeProperties(); } @@ -427,20 +427,20 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2) { // template class TypeMap : public AbstractTypeUser { - typedef std::map > MapTy; + typedef std::map MapTy; MapTy Map; public: ~TypeMap() { print("ON EXIT"); } inline TypeClass *get(const ValType &V) { - typename std::map >::iterator I + 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(std::make_pair(V, PATypeHandle(T, this))); + Map.insert(std::make_pair(V, PATypeHandle(T, this))); print("add"); } @@ -521,7 +521,7 @@ protected: TypeMap &Table = MyTable; // Copy MyTable reference ValType Tmp(*(ValType*)this); // Copy this. - PATypeHandle OldType(Table.get(*(ValType*)this), this); + PATypeHandle OldType(Table.get(*(ValType*)this), this); Table.remove(*(ValType*)this); // Destroy's this! // Refine temporary to new state... @@ -546,8 +546,8 @@ protected: // FunctionValType - Define a class to hold the key that goes into the TypeMap // class FunctionValType : public ValTypeBase { - PATypeHandle RetTy; - std::vector > ArgTypes; + PATypeHandle RetTy; + std::vector ArgTypes; bool isVarArg; public: FunctionValType(const Type *ret, const std::vector &args, @@ -555,7 +555,7 @@ public: : ValTypeBase(Tab), RetTy(ret, this), isVarArg(IVA) { for (unsigned i = 0; i < args.size(); ++i) - ArgTypes.push_back(PATypeHandle(args[i], this)); + ArgTypes.push_back(PATypeHandle(args[i], this)); } // We *MUST* have an explicit copy ctor so that the TypeHandles think that @@ -566,7 +566,7 @@ public: isVarArg(MVT.isVarArg) { ArgTypes.reserve(MVT.ArgTypes.size()); for (unsigned i = 0; i < MVT.ArgTypes.size(); ++i) - ArgTypes.push_back(PATypeHandle(MVT.ArgTypes[i], this)); + ArgTypes.push_back(PATypeHandle(MVT.ArgTypes[i], this)); } // Subclass should override this... to update self as usual @@ -615,7 +615,7 @@ FunctionType *FunctionType::get(const Type *ReturnType, // Array Type Factory... // class ArrayValType : public ValTypeBase { - PATypeHandle ValTy; + PATypeHandle ValTy; unsigned Size; public: ArrayValType(const Type *val, int sz, TypeMap &Tab) @@ -671,14 +671,14 @@ 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 { - std::vector > ElTypes; + std::vector ElTypes; public: StructValType(const std::vector &args, TypeMap &Tab) : ValTypeBase(Tab) { ElTypes.reserve(args.size()); for (unsigned i = 0, e = args.size(); i != e; ++i) - ElTypes.push_back(PATypeHandle(args[i], this)); + ElTypes.push_back(PATypeHandle(args[i], this)); } // We *MUST* have an explicit copy ctor so that the TypeHandles think that @@ -688,7 +688,7 @@ public: : ValTypeBase(SVT){ ElTypes.reserve(SVT.ElTypes.size()); for (unsigned i = 0, e = SVT.ElTypes.size(); i != e; ++i) - ElTypes.push_back(PATypeHandle(SVT.ElTypes[i], this)); + ElTypes.push_back(PATypeHandle(SVT.ElTypes[i], this)); } // Subclass should override this... to update self as usual @@ -731,7 +731,7 @@ StructType *StructType::get(const std::vector &ETypes) { // PointerValType - Define a class to hold the key that goes into the TypeMap // class PointerValType : public ValTypeBase { - PATypeHandle ValTy; + PATypeHandle ValTy; public: PointerValType(const Type *val, TypeMap &Tab) : ValTypeBase(Tab), ValTy(val, this) {}