1 //===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===//
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.
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.
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.
19 //===----------------------------------------------------------------------===//
21 #ifndef LLVM_ABSTRACT_TYPE_USER_H
22 #define LLVM_ABSTRACT_TYPE_USER_H
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
28 // In this way, most every LLVM source file will have access to the assert()
29 // macro without having to #include <cassert> directly.
36 class AbstractTypeUser {
38 virtual ~AbstractTypeUser() {} // Derive from me
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
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.
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
57 virtual void refineAbstractType(const DerivedType *OldTy,
58 const Type *NewTy) = 0;
60 virtual void dump() const = 0;
64 /// PATypeHandle - Handle to a Type subclass. This class is used to keep the
65 /// use list of abstract types up-to-date.
69 AbstractTypeUser * const User;
71 // These functions are defined at the bottom of Type.h. See the comment there
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) {
82 // ctor - Add use to type if abstract.
83 inline PATypeHandle(const PATypeHandle &T) : Ty(T.Ty), User(T.User) {
87 // dtor - Remove reference to type...
88 inline ~PATypeHandle() { removeUser(); }
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; }
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
104 // operator= - Allow assignment to handle
105 inline const Type *operator=(const PATypeHandle &T) {
106 return operator=(T.Ty);
109 inline bool operator==(const Type *ty) {
113 // operator-> - Allow user to dereference handle naturally...
114 inline const Type *operator->() const { return Ty; }
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.
122 void removeUserFromConcrete();
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.
132 mutable const Type *Ty;
134 PATypeHolder(const Type *ty) : Ty(ty) {
137 PATypeHolder(const PATypeHolder &T) : Ty(T.Ty) {
141 operator const Type *() const { return get(); }
142 const Type *get() const;
144 // operator-> - Allow user to dereference handle naturally...
145 const Type *operator->() const { return get(); }
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.
156 const Type *operator=(const PATypeHolder &H) {
157 return operator=(H.Ty);