b9e5f1c6593a2cef25334e3a32d33110ffcb7524
[oota-llvm.git] / 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
65 /// use 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 uses
127 /// efficient union-find techniques to handle dynamic type resolution.  Unless
128 /// you need to do custom processing when types are resolved, you should always
129 /// use PATypeHolders in preference to PATypeHandles.
130 ///
131 class PATypeHolder {
132   mutable const Type *Ty;
133 public:
134   PATypeHolder(const Type *ty) : Ty(ty) {
135     addRef();
136   }
137   PATypeHolder(const PATypeHolder &T) : Ty(T.Ty) {
138     addRef();
139   }
140
141   operator const Type *() const { return get(); }
142   const Type *get() const;
143
144   // operator-> - Allow user to dereference handle naturally...
145   const Type *operator->() const { return get(); }
146
147   // operator= - Allow assignment to handle
148   const Type *operator=(const Type *ty) {
149     if (Ty != ty) {   // Don't accidentally drop last ref to Ty.
150       dropRef();
151       Ty = ty;
152       addRef();
153     }
154     return get();
155   }
156   const Type *operator=(const PATypeHolder &H) {
157     return operator=(H.Ty);
158   }
159
160 private:
161   void addRef();
162   void dropRef();
163 };
164
165 #endif