Change the way unused regs. are marked and found to consider regType

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

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index c995b61cad6a60491b8a641b1dfbcff80a8b0103..7c6f429dc607a66d74853b564c24b4e09a4665db 100644 (file)
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -21,6 +21,15 @@
 #ifndef LLVM_ABSTRACT_TYPE_USER_H
 #define LLVM_ABSTRACT_TYPE_USER_H
 
+// This is the "master" include for <cassert> Whether this file needs it or not,
+// it must always include <cassert> for the files which include
+// llvm/AbstractTypeUser.h
+//
+// In this way, most every LLVM source file will have access to the assert()
+// macro without having to #include <cassert> directly.
+//
+#include <cassert>
+
 class Type;
 class DerivedType;
 
@@ -53,22 +62,21 @@ public:
 
 
 // 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.
 //
-template <class TypeSubClass>
 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
   // for justification.
-  inline void addUser();
-  inline void removeUser();
+  void addUser();
+  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();
   }
@@ -82,11 +90,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;
@@ -96,16 +104,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
@@ -113,7 +121,7 @@ public:
   // this, we MUST remove ourself from the AbstractTypeUser list, even though
   // the type is apparently concrete.
   //
-  inline void removeUserFromConcrete();
+  void removeUserFromConcrete();
 };
 
 
@@ -121,10 +129,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<Type> {
-  inline PATypeHolder(const Type *ty) : PATypeHandle<Type>(ty, this) {}
+struct PATypeHolder : public AbstractTypeUser, public PATypeHandle {
+  inline PATypeHolder(const Type *ty) : PATypeHandle(ty, this) {}
   inline PATypeHolder(const PATypeHolder &T)
-    : AbstractTypeUser(T), PATypeHandle<Type>(T, this) {}
+    : AbstractTypeUser(T), PATypeHandle(T, this) {}
 
   // refineAbstractType - All we do is update our PATypeHandle member to point
   // to the new type.
@@ -137,20 +145,20 @@ struct PATypeHolder : public AbstractTypeUser, public PATypeHandle<Type> {
     removeUserFromConcrete();
 
     if ((const Type*)OldTy != NewTy)
-      PATypeHandle<Type>::operator=(NewTy);
+      PATypeHandle::operator=(NewTy);
   }
 
   // operator= - Allow assignment to handle
   inline const Type *operator=(const Type *ty) {
-    return PATypeHandle<Type>::operator=(ty);
+    return PATypeHandle::operator=(ty);
   }
 
   // operator= - Allow assignment to handle
-  inline const Type *operator=(const PATypeHandle<Type> &T) {
-    return PATypeHandle<Type>::operator=(T);
+  inline const Type *operator=(const PATypeHandle &T) {
+    return PATypeHandle::operator=(T);
   }
   inline const Type *operator=(const PATypeHolder &H) {
-    return PATypeHandle<Type>::operator=(H);
+    return PATypeHandle::operator=(H);
   }
 
   void dump() const;