Changes in directory llvm/lib/VMCore:
Type.cpp updated: 1.134 -> 1.135
---
Log message:
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.
---
Diffs of the changes: (+52 -50)
Type.cpp | 102 ++++++++++++++++++++++++++++++++-------------------------------
1 files changed, 52 insertions(+), 50 deletions(-)
Index: llvm/lib/VMCore/Type.cpp
diff -u llvm/lib/VMCore/Type.cpp:1.134 llvm/lib/VMCore/Type.cpp:1.135
--- llvm/lib/VMCore/Type.cpp:1.134 Sat Nov 12 19:58:06 2005
+++ llvm/lib/VMCore/Type.cpp Sat Nov 12 21:14:09 2005
@@ -43,14 +43,13 @@
static std::map<const Type*, std::string> ConcreteTypeDescriptions;
static std::map<const Type*, std::string> 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 @@
// 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 ValType, class TypeClass>
-class TypeMap {
- std::map<ValType, PATypeHolder> 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<unsigned, PATypeHolder> TypesByHash;
- friend void Type::clearAllTypeMaps();
-
-private:
- void clear(std::vector<Type *> &DerivedTypes) {
- for (typename std::map<ValType, PATypeHolder>::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<ValType, PATypeHolder>::iterator iterator;
- ~TypeMap() { print("ON EXIT"); }
-
- inline TypeClass *get(const ValType &V) {
- iterator I = Map.find(V);
- return I != Map.end() ? cast<TypeClass>((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<unsigned, PATypeHolder>::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 @@
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 ValType, class TypeClass>
+class TypeMap : public TypeMapBase {
+ std::map<ValType, PATypeHolder> Map;
+public:
+ typedef typename std::map<ValType, PATypeHolder>::iterator iterator;
+ ~TypeMap() { print("ON EXIT"); }
+
+ inline TypeClass *get(const ValType &V) {
+ iterator I = Map.find(V);
+ return I != Map.end() ? cast<TypeClass>((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<Type *> &DerivedTypes) {
+ for (typename std::map<ValType, PATypeHolder>::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 @@
// 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 @@
}
Entry = I;
}
-
TypesByHash.erase(Entry);
Ty->refineAbstractTypeTo(NewTy);
return;
@@ -1148,7 +1151,6 @@
return PT;
}
-
//===----------------------------------------------------------------------===//
// Derived Type Refinement Functions
//===----------------------------------------------------------------------===//
@@ -1158,7 +1160,7 @@
// 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.
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
