include/llvm/AbstractTypeUser.h

   1 //===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===//
   2 //
   3 // The AbstractTypeUser class is an interface to be implemented by classes who
   4 // could possible use an abstract type.  Abstract types are denoted by the
   5 // isAbstract flag set to true in the Type class.  These are classes that
   6 // contain an Opaque type in their structure somehow.
   7 //
   8 // Classes must implement this interface so that they may be notified when an
   9 // abstract type is resolved.  Abstract types may be resolved into more concrete
  10 // types through: linking, parsing, and bytecode reading.  When this happens,
  11 // all of the users of the type must be updated to reference the new, more
  12 // concrete type.  They are notified through the AbstractTypeUser interface.
  13 //
  14 // In addition to this, AbstractTypeUsers must keep the use list of the
  15 // potentially abstract type that they reference up-to-date.  To do this in a
  16 // nice, transparent way, the PATypeHandle class is used to hold "Potentially
  17 // Abstract Types", and keep the use list of the abstract types up-to-date.
  18 //
  19 //===----------------------------------------------------------------------===//
  20
  21 #ifndef LLVM_ABSTRACT_TYPE_USER_H
  22 #define LLVM_ABSTRACT_TYPE_USER_H
  23
  24 // This is the "master" include for <cassert> Whether this file needs it or not,
  25 // it must always include <cassert> for the files which include
  26 // llvm/AbstractTypeUser.h
  27 //
  28 // In this way, most every LLVM source file will have access to the assert()
  29 // macro without having to #include <cassert> directly.
  30 //
  31 #include <cassert>
  32
  33 class Type;
  34 class DerivedType;
  35
  36 class AbstractTypeUser {
  37 protected:
  38   virtual ~AbstractTypeUser() {}                        // Derive from me
  39 public:
  40
  41   // refineAbstractType - The callback method invoked when an abstract type
  42   // has been found to be more concrete.  A class must override this method to
  43   // update its internal state to reference NewType instead of OldType.  Soon
  44   // after this method is invoked, OldType shall be deleted, so referencing it
  45   // is quite unwise.
  46   //
  47   // Another case that is important to consider is when a type is refined, but
  48   // stays in the same place in memory.  In this case OldTy will equal NewTy.
  49   // This callback just notifies ATU's that the underlying structure of the type
  50   // has changed... but any previously used properties are still valid.
  51   //
  52   // Note that it is possible to refine a type with parameters OldTy==NewTy, and
  53   // OldTy is no longer abstract.  In this case, abstract type users should
  54   // release their hold on a type, because it went from being abstract to
  55   // concrete.
  56   //
  57   virtual void refineAbstractType(const DerivedType *OldTy,
  58                                   const Type *NewTy) = 0;
  59   // for debugging...
  60   virtual void dump() const = 0;
  61 };
  62
  63
  64 // PATypeHandle - Handle to a Type subclass.  This class is used to keep the use
  65 // list of abstract types up-to-date.
  66 //
  67 class PATypeHandle {
  68   const Type *Ty;
  69   AbstractTypeUser * const User;
  70
  71   // These functions are defined at the bottom of Type.h.  See the comment there
  72   // for justification.
  73   void addUser();
  74   void removeUser();
  75 public:
  76   // ctor - Add use to type if abstract.  Note that Ty must not be null
  77   inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
  78     : Ty(ty), User(user) {
  79     addUser();
  80   }
  81
  82   // ctor - Add use to type if abstract.
  83   inline PATypeHandle(const PATypeHandle &T) : Ty(T.Ty), User(T.User) {
  84     addUser();
  85   }
  86
  87   // dtor - Remove reference to type...
  88   inline ~PATypeHandle() { removeUser(); }
  89
  90   // Automatic casting operator so that the handle may be used naturally
  91   inline operator const Type *() const { return Ty; }
  92   inline const Type *get() const { return Ty; }
  93
  94   // operator= - Allow assignment to handle
  95   inline const Type *operator=(const Type *ty) {
  96     if (Ty != ty) {   // Ensure we don't accidentally drop last ref to Ty
  97       removeUser();
  98       Ty = ty;
  99       addUser();
 100     }
 101     return Ty;
 102   }
 103
 104   // operator= - Allow assignment to handle
 105   inline const Type *operator=(const PATypeHandle &T) {
 106     return operator=(T.Ty);
 107   }
 108
 109   inline bool operator==(const Type *ty) {
 110     return Ty == ty;
 111   }
 112
 113   // operator-> - Allow user to dereference handle naturally...
 114   inline const Type *operator->() const { return Ty; }
 115
 116   // removeUserFromConcrete - This function should be called when the User is
 117   // notified that our type is refined... and the type is being refined to
 118   // itself, which is now a concrete type.  When a type becomes concrete like
 119   // this, we MUST remove ourself from the AbstractTypeUser list, even though
 120   // the type is apparently concrete.
 121   //
 122   void removeUserFromConcrete();
 123 };
 124
 125
 126 // PATypeHolder - Holder class for a potentially abstract type.  This functions
 127 // as both a handle (as above) and an AbstractTypeUser.  It uses the callback to
 128 // keep its pointer member updated to the current version of the type.
 129 //
 130 struct PATypeHolder : public AbstractTypeUser, public PATypeHandle {
 131   inline PATypeHolder(const Type *ty) : PATypeHandle(ty, this) {}
 132   inline PATypeHolder(const PATypeHolder &T)
 133     : AbstractTypeUser(T), PATypeHandle(T, this) {}
 134
 135   // refineAbstractType - All we do is update our PATypeHandle member to point
 136   // to the new type.
 137   //
 138   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
 139     assert(get() == (const Type*)OldTy && "Can't refine to unknown value!");
 140
 141     // Check to see if the type just became concrete.  If so, we have to
 142     // removeUser to get off its AbstractTypeUser list
 143     removeUserFromConcrete();
 144
 145     if ((const Type*)OldTy != NewTy)
 146       PATypeHandle::operator=(NewTy);
 147   }
 148
 149   // operator= - Allow assignment to handle
 150   inline const Type *operator=(const Type *ty) {
 151     return PATypeHandle::operator=(ty);
 152   }
 153
 154   // operator= - Allow assignment to handle
 155   inline const Type *operator=(const PATypeHandle &T) {
 156     return PATypeHandle::operator=(T);
 157   }
 158   inline const Type *operator=(const PATypeHolder &H) {
 159     return PATypeHandle::operator=(H);
 160   }
 161
 162   void dump() const;
 163 };
 164
 165 #endif