Refactor some code, moving methods and data around. This gets rid of some

virtual methods.

llvm-svn: 24342

llvm/include/llvm/DerivedTypes.h

@@ -32,17 +32,10 @@ class PointerValType;
 class PackedValType;
 
 class DerivedType : public Type, public AbstractTypeUser {
-  // AbstractTypeUsers - Implement a list of the users that need to be notified
-  // if I am a type, and I get resolved into a more concrete type.
-  //
-  mutable std::vector<AbstractTypeUser *> AbstractTypeUsers;
   friend class Type;
 
 protected:
-  DerivedType(TypeID id) : Type("", id) {}
+  DerivedType(TypeID id) : Type(id) {}
-  ~DerivedType() {
-    assert(AbstractTypeUsers.empty());
-  }
 
   /// notifyUsesThatTypeBecameConcrete - Notify AbstractTypeUsers of this type
   /// that the current type has transitioned from being abstract to being
@@ -56,12 +49,6 @@ protected:
   ///
   void dropAllTypeUses();
 
-  void RefCountIsZero() const {
-    if (AbstractTypeUsers.empty())
-      delete this;
-  }
-
-
 public:
 
   //===--------------------------------------------------------------------===//
@@ -69,22 +56,6 @@ public:
   // are managed by (add|remove)AbstractTypeUser. See comments in
   // AbstractTypeUser.h for more information.
 
-  /// addAbstractTypeUser - Notify an abstract type that there is a new user of
-  /// it.  This function is called primarily by the PATypeHandle class.
-  ///
-  void addAbstractTypeUser(AbstractTypeUser *U) const {
-    assert(isAbstract() && "addAbstractTypeUser: Current type not abstract!");
-    AbstractTypeUsers.push_back(U);
-  }
-
-  /// removeAbstractTypeUser - Notify an abstract type that a user of the class
-  /// no longer has a handle to the type.  This function is called primarily by
-  /// 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 removeAbstractTypeUser(AbstractTypeUser *U) const;
-
   /// refineAbstractTypeTo - This function is used to when it is discovered that
   /// the 'this' abstract type is actually equivalent to the NewType specified.
   /// This causes all users of 'this' to switch to reference the more concrete

llvm/include/llvm/Type.h

@@ -49,6 +49,7 @@ class OpaqueType;
 class PointerType;
 class StructType;
 class PackedType;
+class TypeMapBase;
 
 class Type {
 public:
@@ -94,17 +95,16 @@ private:
 
   const Type *getForwardedTypeInternal() const;
 protected:
-  Type(const std::string& Name, TypeID id);
+  Type(const char *Name, TypeID id);
-  virtual ~Type() {}
+  Type(TypeID id) : ID(id), Abstract(false), RefCount(0), ForwardType(0) {}
+  virtual ~Type() {
+    assert(AbstractTypeUsers.empty());
+  }
 
   /// Types can become nonabstract later, if they are refined.
   ///
   inline void setAbstract(bool Val) { Abstract = Val; }
 
-  // PromoteAbstractToConcrete - This is an internal method used to calculate
-  // change "Abstract" from true to false when types are refined.
-  void PromoteAbstractToConcrete();
-
   unsigned getRefCount() const { return RefCount; }
 
   /// ForwardType - This field is used to implement the union find scheme for
@@ -121,6 +121,10 @@ protected:
   /// not contain any elements (most are derived).
   std::vector<PATypeHandle> ContainedTys;
 
+  /// AbstractTypeUsers - Implement a list of the users that need to be notified
+  /// if I am a type, and I get resolved into a more concrete type.
+  ///
+  mutable std::vector<AbstractTypeUser *> AbstractTypeUsers;
 public:
   void print(std::ostream &O) const;
 
@@ -295,15 +299,6 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Type *T) { return true; }
 
-  // Virtual methods used by callbacks below.  These should only be implemented
-  // in the DerivedType class.
-  virtual void addAbstractTypeUser(AbstractTypeUser *U) const {
-    abort(); // Only on derived types!
-  }
-  virtual void removeAbstractTypeUser(AbstractTypeUser *U) const {
-    abort(); // Only on derived types!
-  }
-
   void addRef() const {
     assert(isAbstract() && "Cannot add a reference to a non-abstract type!");
     ++RefCount;
@@ -315,9 +310,25 @@ public:
 
     // If this is the last PATypeHolder using this object, and there are no
     // PATypeHandles using it, the type is dead, delete it now.
-    if (--RefCount == 0)
+    if (--RefCount == 0 && AbstractTypeUsers.empty())
-      RefCountIsZero();
+      delete this;
   }
+  
+  /// addAbstractTypeUser - Notify an abstract type that there is a new user of
+  /// it.  This function is called primarily by the PATypeHandle class.
+  ///
+  void addAbstractTypeUser(AbstractTypeUser *U) const {
+    assert(isAbstract() && "addAbstractTypeUser: Current type not abstract!");
+    AbstractTypeUsers.push_back(U);
+  }
+  
+  /// removeAbstractTypeUser - Notify an abstract type that a user of the class
+  /// no longer has a handle to the type.  This function is called primarily by
+  /// 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 removeAbstractTypeUser(AbstractTypeUser *U) const;
 
   /// clearAllTypeMaps - This method frees all internal memory used by the
   /// type subsystem, which can be used in environments where this memory is
@@ -330,10 +341,11 @@ private:
   /// their size is relatively uncommon, move this operation out of line.
   bool isSizedDerivedType() const;
 
-  virtual void RefCountIsZero() const {
+protected:
-    abort(); // only on derived types!
+  // PromoteAbstractToConcrete - This is an internal method used to calculate
-  }
+  // change "Abstract" from true to false when types are refined.
-
+  void PromoteAbstractToConcrete();
+  friend class TypeMapBase;
 };
 
 //===----------------------------------------------------------------------===//