X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAbstractTypeUser.h;h=d21116539419235e99acfec25e859edb79116526;hb=440f87eea20f11ea86822816fae965956795d6d3;hp=7c6f429dc607a66d74853b564c24b4e09a4665db;hpb=0192e36cc7d632ec8f9f3e4a8fd2fa6a7403264c;p=oota-llvm.git

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index 7c6f429dc60..d2111653941 100644
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -1,4 +1,11 @@
-//===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface -----*- C++ -*--=//
+//===-- 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
@@ -30,6 +37,8 @@
 //
 #include <cassert>
 
+namespace llvm {
+
 class Type;
 class DerivedType;
 
@@ -38,34 +47,28 @@ protected:
   virtual ~AbstractTypeUser() {}                        // Derive from me
 public:
 
-  // refineAbstractType - The callback method invoked when an abstract type
-  // has been found to be more concrete.  A class must override this method to
-  // update its internal state to reference NewType instead of OldType.  Soon
-  // after this method is invoked, OldType shall be deleted, so referencing it
-  // is quite unwise.
-  //
-  // Another case that is important to consider is when a type is refined, but
-  // stays in the same place in memory.  In this case OldTy will equal NewTy.
-  // This callback just notifies ATU's that the underlying structure of the type
-  // has changed... but any previously used properties are still valid.
-  //
-  // Note that it is possible to refine a type with parameters OldTy==NewTy, and
-  // OldTy is no longer abstract.  In this case, abstract type users should
-  // release their hold on a type, because it went from being abstract to
-  // concrete.
-  //
+  /// refineAbstractType - The callback method invoked when an abstract type is
+  /// resolved to another type.  An object must override this method to update
+  /// its internal state to reference NewType instead of OldType.
+  ///
   virtual void refineAbstractType(const DerivedType *OldTy,
 				  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
+  /// AbstractTypeUsers list) to concrete (where it does not).  This method
+  /// notifies ATU's when this occurs for a type.
+  ///
+  virtual void typeBecameConcrete(const DerivedType *AbsTy) = 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 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.
-//
+/// PATypeHandle - Handle to a Type subclass.  This class is used to keep the
+/// use list of abstract types up-to-date.
+///
 class PATypeHandle {
   const Type *Ty;
   AbstractTypeUser * const User;
@@ -125,43 +128,47 @@ public:
 };
 
 
-// PATypeHolder - Holder class for a potentially abstract type.  This functions
-// 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 {
-  inline PATypeHolder(const Type *ty) : PATypeHandle(ty, this) {}
-  inline PATypeHolder(const PATypeHolder &T)
-    : AbstractTypeUser(T), PATypeHandle(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() == (const Type*)OldTy && "Can't refine to unknown value!");
+/// PATypeHolder - Holder class for a potentially abstract type.  This uses
+/// efficient union-find techniques to handle dynamic type resolution.  Unless
+/// you need to do custom processing when types are resolved, you should always
+/// use PATypeHolders in preference to PATypeHandles.
+///
+class PATypeHolder {
+  mutable const Type *Ty;
+public:
+  PATypeHolder(const Type *ty) : Ty(ty) {
+    addRef();
+  }
+  PATypeHolder(const PATypeHolder &T) : Ty(T.Ty) {
+    addRef();
+  }
 
-    // Check to see if the type just became concrete.  If so, we have to
-    // removeUser to get off its AbstractTypeUser list
-    removeUserFromConcrete();
+  ~PATypeHolder() { dropRef(); }
 
-    if ((const Type*)OldTy != NewTy)
-      PATypeHandle::operator=(NewTy);
-  }
+  operator const Type *() const { return get(); }
+  const Type *get() const;
 
-  // operator= - Allow assignment to handle
-  inline const Type *operator=(const Type *ty) {
-    return PATypeHandle::operator=(ty);
-  }
+  // operator-> - Allow user to dereference handle naturally...
+  const Type *operator->() const { return get(); }
 
   // operator= - Allow assignment to handle
-  inline const Type *operator=(const PATypeHandle &T) {
-    return PATypeHandle::operator=(T);
+  const Type *operator=(const Type *ty) {
+    if (Ty != ty) {   // Don't accidentally drop last ref to Ty.
+      dropRef();
+      Ty = ty;
+      addRef();
+    }
+    return get();
   }
-  inline const Type *operator=(const PATypeHolder &H) {
-    return PATypeHandle::operator=(H);
+  const Type *operator=(const PATypeHolder &H) {
+    return operator=(H.Ty);
   }
 
-  void dump() const;
+private:
+  void addRef();
+  void dropRef();
 };
 
+} // End llvm namespace
+
 #endif