X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAbstractTypeUser.h;h=fe51effc61f0cb79d768447e07d06df5be0f807b;hb=a727d5502c8e23c090da658bf14c5ebc1169a070;hp=d21116539419235e99acfec25e859edb79116526;hpb=dbd9b3f75c5b52b2310513ff5e781fd83a49db08;p=oota-llvm.git

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index d2111653941..fe51effc61f 100644
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -1,33 +1,25 @@
 //===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
-//===----------------------------------------------------------------------===//
-//
-// The AbstractTypeUser class is an interface to be implemented by classes who
-// could possible use an abstract type.  Abstract types are denoted by the
-// isAbstract flag set to true in the Type class.  These are classes that
-// contain an Opaque type in their structure somehow.
 //
-// Classes must implement this interface so that they may be notified when an
-// abstract type is resolved.  Abstract types may be resolved into more concrete
-// types through: linking, parsing, and bytecode reading.  When this happens,
-// all of the users of the type must be updated to reference the new, more
-// concrete type.  They are notified through the AbstractTypeUser interface.
+//===----------------------------------------------------------------------===//
 //
-// In addition to this, AbstractTypeUsers must keep the use list of the
-// potentially abstract type that they reference up-to-date.  To do this in a
-// nice, transparent way, the PATypeHandle class is used to hold "Potentially
-// Abstract Types", and keep the use list of the abstract types up-to-date.
+// This file declares the AbstractTypeUser class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ABSTRACT_TYPE_USER_H
 #define LLVM_ABSTRACT_TYPE_USER_H
 
+#if !defined(LLVM_TYPE_H) && !defined(LLVM_VALUE_H)
+#error Do not include this file directly.  Include Type.h instead.
+#error Some versions of GCC (e.g. 3.4 and 4.1) can not handle the inlined method
+#error PATypeHolder::dropRef() correctly otherwise.
+#endif
+
 // 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
@@ -42,9 +34,26 @@ namespace llvm {
 class Type;
 class DerivedType;
 
+/// The AbstractTypeUser class is an interface to be implemented by classes who
+/// could possibly use an abstract type.  Abstract types are denoted by the
+/// isAbstract flag set to true in the Type class.  These are classes that
+/// contain an Opaque type in their structure somewhere.
+///
+/// Classes must implement this interface so that they may be notified when an
+/// abstract type is resolved.  Abstract types may be resolved into more 
+/// concrete types through: linking, parsing, and bytecode reading.  When this 
+/// happens, all of the users of the type must be updated to reference the new,
+/// more concrete type.  They are notified through the AbstractTypeUser 
+/// interface.
+///
+/// In addition to this, AbstractTypeUsers must keep the use list of the
+/// potentially abstract type that they reference up-to-date.  To do this in a
+/// nice, transparent way, the PATypeHandle class is used to hold "Potentially
+/// Abstract Types", and keep the use list of the abstract types up-to-date.
+/// @brief LLVM Abstract Type User Representation
 class AbstractTypeUser {
 protected:
-  virtual ~AbstractTypeUser() {}                        // Derive from me
+  virtual ~AbstractTypeUser();                        // Derive from me
 public:
 
   /// refineAbstractType - The callback method invoked when an abstract type is
@@ -52,7 +61,7 @@ public:
   /// its internal state to reference NewType instead of OldType.
   ///
   virtual void refineAbstractType(const DerivedType *OldTy,
-				  const Type *NewTy) = 0;
+                                  const Type *NewTy) = 0;
 
   /// The other case which AbstractTypeUsers must be aware of is when a type
   /// makes the transition from being abstract (where it has clients on it's
@@ -79,7 +88,7 @@ class PATypeHandle {
   void removeUser();
 public:
   // ctor - Add use to type if abstract.  Note that Ty must not be null
-  inline PATypeHandle(const Type *ty, AbstractTypeUser *user) 
+  inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
     : Ty(ty), User(user) {
     addUser();
   }
@@ -93,17 +102,17 @@ public:
   inline ~PATypeHandle() { removeUser(); }
 
   // Automatic casting operator so that the handle may be used naturally
-  inline operator const Type *() const { return Ty; }
-  inline const Type *get() const { return Ty; }
+  inline operator Type *() const { return const_cast<Type*>(Ty); }
+  inline Type *get() const { return const_cast<Type*>(Ty); }
 
   // operator= - Allow assignment to handle
-  inline const Type *operator=(const Type *ty) {
+  inline Type *operator=(const Type *ty) {
     if (Ty != ty) {   // Ensure we don't accidentally drop last ref to Ty
       removeUser();
       Ty = ty;
       addUser();
     }
-    return Ty;
+    return get();
   }
 
   // operator= - Allow assignment to handle
@@ -117,14 +126,6 @@ public:
 
   // operator-> - Allow user to dereference handle naturally...
   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
-  // itself, which is now a concrete type.  When a type becomes concrete like
-  // this, we MUST remove ourself from the AbstractTypeUser list, even though
-  // the type is apparently concrete.
-  //
-  void removeUserFromConcrete();
 };
 
 
@@ -145,14 +146,14 @@ public:
 
   ~PATypeHolder() { dropRef(); }
 
-  operator const Type *() const { return get(); }
-  const Type *get() const;
+  operator Type *() const { return get(); }
+  Type *get() const;
 
   // operator-> - Allow user to dereference handle naturally...
-  const Type *operator->() const { return get(); }
+  Type *operator->() const { return get(); }
 
   // operator= - Allow assignment to handle
-  const Type *operator=(const Type *ty) {
+  Type *operator=(const Type *ty) {
     if (Ty != ty) {   // Don't accidentally drop last ref to Ty.
       dropRef();
       Ty = ty;
@@ -160,10 +161,14 @@ public:
     }
     return get();
   }
-  const Type *operator=(const PATypeHolder &H) {
+  Type *operator=(const PATypeHolder &H) {
     return operator=(H.Ty);
   }
 
+  /// getRawType - This should only be used to implement the vmcore library.
+  ///
+  const Type *getRawType() const { return Ty; }
+
 private:
   void addRef();
   void dropRef();