From: Chris Lattner Date: Sun, 13 Nov 2005 03:14:09 +0000 (+0000) Subject: Move some methods around. Refactor the parts of TypeMap that do not depend X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=cfe822728fe2ce1d53a07018f160f010fd133aad;p=oota-llvm.git Move some methods around. Refactor the parts of TypeMap that do not depend on its template arguments into a base class so that the code isn't duplicated 5 times. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24343 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index 178af803ad1..236ecfb6e10 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -43,14 +43,13 @@ AbstractTypeUser::~AbstractTypeUser() {} static std::map ConcreteTypeDescriptions; static std::map AbstractTypeDescriptions; -Type::Type( const std::string& name, TypeID id ) - : RefCount(0), ForwardType(0) { - if (!name.empty()) - ConcreteTypeDescriptions[this] = name; - ID = id; - Abstract = false; +Type::Type(const char *Name, TypeID id) + : ID(id), Abstract(false), RefCount(0), ForwardType(0) { + assert(Name && Name[0] && "Should use other ctor if no name!"); + ConcreteTypeDescriptions[this] = Name; } + const Type *Type::getPrimitiveType(TypeID IDNumber) { switch (IDNumber) { case VoidTyID : return VoidTy; @@ -678,66 +677,35 @@ static bool TypeHasCycleThroughItself(const Type *Ty) { // Derived Type Factory Functions //===----------------------------------------------------------------------===// -// TypeMap - Make sure that only one instance of a particular type may be -// created on any given run of the compiler... note that this involves updating -// our map if an abstract type gets refined somehow. -// namespace llvm { -template -class TypeMap { - std::map Map; - +class TypeMapBase { +protected: /// TypesByHash - Keep track of types by their structure hash value. Note /// that we only keep track of types that have cycles through themselves in /// this map. /// std::multimap TypesByHash; - friend void Type::clearAllTypeMaps(); - -private: - 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(); - } public: - typedef typename std::map::iterator iterator; - ~TypeMap() { print("ON EXIT"); } - - inline TypeClass *get(const ValType &V) { - iterator I = Map.find(V); - return I != Map.end() ? cast((Type*)I->second.get()) : 0; - } - - inline void add(const ValType &V, TypeClass *Ty) { - Map.insert(std::make_pair(V, Ty)); - - // If this type has a cycle, remember it. - TypesByHash.insert(std::make_pair(ValType::hashTypeStructure(Ty), Ty)); - print("add"); - } - void RemoveFromTypesByHash(unsigned Hash, const Type *Ty) { std::multimap::iterator I = - TypesByHash.lower_bound(Hash); + TypesByHash.lower_bound(Hash); while (I->second != Ty) { ++I; assert(I != TypesByHash.end() && I->first == Hash); } TypesByHash.erase(I); } - + /// TypeBecameConcrete - When Ty gets a notification that TheType just became /// concrete, drop uses and make Ty non-abstract if we should. - void TypeBecameConcrete(TypeClass *Ty, const DerivedType *TheType) { + void TypeBecameConcrete(DerivedType *Ty, const DerivedType *TheType) { // If the element just became concrete, remove 'ty' from the abstract // type user list for the type. Do this for as many times as Ty uses // OldType. - for (unsigned i = 0, e = Ty->ContainedTys.size(); i != e; ++i) - if (Ty->ContainedTys[i] == TheType) + for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end(); + I != E; ++I) + if (I->get() == TheType) TheType->removeAbstractTypeUser(Ty); // If the type is currently thought to be abstract, rescan all of our @@ -747,8 +715,44 @@ public: if (Ty->isAbstract()) Ty->PromoteAbstractToConcrete(); } +}; +} + + +// TypeMap - Make sure that only one instance of a particular type may be +// created on any given run of the compiler... note that this involves updating +// our map if an abstract type gets refined somehow. +// +namespace llvm { +template +class TypeMap : public TypeMapBase { + std::map Map; +public: + typedef typename std::map::iterator iterator; + ~TypeMap() { print("ON EXIT"); } + + inline TypeClass *get(const ValType &V) { + iterator I = Map.find(V); + return I != Map.end() ? cast((Type*)I->second.get()) : 0; + } + + inline void add(const ValType &V, TypeClass *Ty) { + Map.insert(std::make_pair(V, Ty)); + + // If this type has a cycle, remember it. + TypesByHash.insert(std::make_pair(ValType::hashTypeStructure(Ty), Ty)); + print("add"); + } - /// RefineAbstractType - This method is called after we have merged a type + 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 /// 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, @@ -762,7 +766,7 @@ public: // OldType must have been abstract, making us abstract. assert(Ty->isAbstract() && "Refining a non-abstract type!"); assert(OldType != NewType); - + // Make a temporary type holder for the type so that it doesn't disappear on // us when we erase the entry from the map. PATypeHolder TyHolder = Ty; @@ -826,7 +830,6 @@ public: } Entry = I; } - TypesByHash.erase(Entry); Ty->refineAbstractTypeTo(NewTy); return; @@ -1148,7 +1151,6 @@ PointerType *PointerType::get(const Type *ValueType) { return PT; } - //===----------------------------------------------------------------------===// // Derived Type Refinement Functions //===----------------------------------------------------------------------===// @@ -1158,7 +1160,7 @@ PointerType *PointerType::get(const Type *ValueType) { // the PATypeHandle class. When there are no users of the abstract type, it // is annihilated, because there is no way to get a reference to it ever again. // -void DerivedType::removeAbstractTypeUser(AbstractTypeUser *U) const { +void Type::removeAbstractTypeUser(AbstractTypeUser *U) const { // Search from back to front because we will notify users from back to // front. Also, it is likely that there will be a stack like behavior to // users that register and unregister users.