Add a new BasicBlockPass::doInitialization/Finalization(Function &) pair of

[oota-llvm.git] / include / llvm / AbstractTypeUser.h

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index a36bd49e23bbfd68c70e58d304099a86e0897a3d..659c1b9b6170269794055fc597a5a75bd7621be8 100644 (file)
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -47,11 +47,13 @@ public:
   //
   virtual void refineAbstractType(const DerivedType *OldTy,
                                  const Type *NewTy) = 0;
+  // for debugging...
+  virtual void dump() const = 0;
 };
 
 
 // PATypeHandle - Handle to a Type subclass.  This class is parameterized so
-// that users can have handles to MethodType's that are still specialized, for
+// that users can have handles to FunctionType's that are still specialized, for
 // example.  This class is a simple class used to keep the use list of abstract
 // types up-to-date.
 //
@@ -119,40 +121,39 @@ 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.
 //
-template <class TypeSC>
-class PATypeHolder : public AbstractTypeUser, public PATypeHandle<TypeSC> {
-public:
-  inline PATypeHolder(const TypeSC *ty) : PATypeHandle<TypeSC>(ty, this) {}
+struct PATypeHolder : public AbstractTypeUser, public PATypeHandle<Type> {
+  inline PATypeHolder(const Type *ty) : PATypeHandle<Type>(ty, this) {}
   inline PATypeHolder(const PATypeHolder &T)
-    : AbstractTypeUser(T), PATypeHandle<TypeSC>(T, this) {}
+    : AbstractTypeUser(T), PATypeHandle<Type>(T, this) {}
 
   // refineAbstractType - All we do is update our PATypeHandle member to point
   // to the new type.
   //
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
-    assert(get() == OldTy && "Can't refine to unknown value!");
+    assert(get() == (const Type*)OldTy && "Can't refine to unknown value!");
 
     // Check to see if the type just became concrete.  If so, we have to
     // removeUser to get off its AbstractTypeUser list
     removeUserFromConcrete();
 
-    if (OldTy != NewTy)
-      PATypeHandle<TypeSC>::operator=((const TypeSC*)NewTy);
+    if ((const Type*)OldTy != NewTy)
+      PATypeHandle<Type>::operator=(NewTy);
   }
 
   // operator= - Allow assignment to handle
-  inline const TypeSC *operator=(const TypeSC *ty) {
-    return PATypeHandle<TypeSC>::operator=(ty);
+  inline const Type *operator=(const Type *ty) {
+    return PATypeHandle<Type>::operator=(ty);
   }
 
   // operator= - Allow assignment to handle
-  inline const TypeSC *operator=(const PATypeHandle<TypeSC> &T) {
-    return PATypeHandle<TypeSC>::operator=(T);
+  inline const Type *operator=(const PATypeHandle<Type> &T) {
+    return PATypeHandle<Type>::operator=(T);
   }
-  inline const TypeSC *operator=(const PATypeHolder<TypeSC> &H) {
-    return PATypeHandle<TypeSC>::operator=(H);
+  inline const Type *operator=(const PATypeHolder &H) {
+    return PATypeHandle<Type>::operator=(H);
   }
-};
 
+  void dump() const;
+};
 
 #endif