1 //===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file declares the AbstractTypeUser class.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_ABSTRACT_TYPE_USER_H
15 #define LLVM_ABSTRACT_TYPE_USER_H
17 #if !defined(LLVM_TYPE_H) && !defined(LLVM_VALUE_H)
18 #error Do not include this file directly. Include Type.h instead.
19 #error Some versions of GCC (e.g. 3.4 and 4.1) can not handle the inlined method
20 #error PATypeHolder::dropRef() correctly otherwise.
23 // This is the "master" include for <cassert> Whether this file needs it or not,
24 // it must always include <cassert> for the files which include
25 // llvm/AbstractTypeUser.h
27 // In this way, most every LLVM source file will have access to the assert()
28 // macro without having to #include <cassert> directly.
37 template<typename T> struct simplify_type;
39 /// The AbstractTypeUser class is an interface to be implemented by classes who
40 /// could possibly use an abstract type. Abstract types are denoted by the
41 /// isAbstract flag set to true in the Type class. These are classes that
42 /// contain an Opaque type in their structure somewhere.
44 /// Classes must implement this interface so that they may be notified when an
45 /// abstract type is resolved. Abstract types may be resolved into more
46 /// concrete types through: linking, parsing, and bitcode reading. When this
47 /// happens, all of the users of the type must be updated to reference the new,
48 /// more concrete type. They are notified through the AbstractTypeUser
51 /// In addition to this, AbstractTypeUsers must keep the use list of the
52 /// potentially abstract type that they reference up-to-date. To do this in a
53 /// nice, transparent way, the PATypeHandle class is used to hold "Potentially
54 /// Abstract Types", and keep the use list of the abstract types up-to-date.
55 /// @brief LLVM Abstract Type User Representation
56 class AbstractTypeUser {
58 virtual ~AbstractTypeUser(); // Derive from me
60 /// setType - It's normally not possible to change a Value's type in place,
61 /// but an AbstractTypeUser subclass that knows what its doing can be
62 /// permitted to do so with care.
63 void setType(Value *V, const Type *NewTy);
67 /// refineAbstractType - The callback method invoked when an abstract type is
68 /// resolved to another type. An object must override this method to update
69 /// its internal state to reference NewType instead of OldType.
71 virtual void refineAbstractType(const DerivedType *OldTy,
72 const Type *NewTy) = 0;
74 /// The other case which AbstractTypeUsers must be aware of is when a type
75 /// makes the transition from being abstract (where it has clients on its
76 /// AbstractTypeUsers list) to concrete (where it does not). This method
77 /// notifies ATU's when this occurs for a type.
79 virtual void typeBecameConcrete(const DerivedType *AbsTy) = 0;
82 virtual void dump() const = 0;
86 /// PATypeHandle - Handle to a Type subclass. This class is used to keep the
87 /// use list of abstract types up-to-date.
91 AbstractTypeUser * const User;
93 // These functions are defined at the bottom of Type.h. See the comment there
98 // ctor - Add use to type if abstract. Note that Ty must not be null
99 inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
100 : Ty(ty), User(user) {
104 // ctor - Add use to type if abstract.
105 inline PATypeHandle(const PATypeHandle &T) : Ty(T.Ty), User(T.User) {
109 // dtor - Remove reference to type...
110 inline ~PATypeHandle() { removeUser(); }
112 // Automatic casting operator so that the handle may be used naturally
113 inline operator Type *() const { return const_cast<Type*>(Ty); }
114 inline Type *get() const { return const_cast<Type*>(Ty); }
116 // operator= - Allow assignment to handle
117 inline Type *operator=(const Type *ty) {
118 if (Ty != ty) { // Ensure we don't accidentally drop last ref to Ty
126 // operator= - Allow assignment to handle
127 inline const Type *operator=(const PATypeHandle &T) {
128 return operator=(T.Ty);
131 inline bool operator==(const Type *ty) {
135 // operator-> - Allow user to dereference handle naturally...
136 inline const Type *operator->() const { return Ty; }
140 /// PATypeHolder - Holder class for a potentially abstract type. This uses
141 /// efficient union-find techniques to handle dynamic type resolution. Unless
142 /// you need to do custom processing when types are resolved, you should always
143 /// use PATypeHolders in preference to PATypeHandles.
146 mutable const Type *Ty;
149 PATypeHolder(const Type *ty) : Ty(ty) {
152 PATypeHolder(const PATypeHolder &T) : Ty(T.Ty) {
156 ~PATypeHolder() { if (Ty) dropRef(); }
158 operator Type *() const { return get(); }
161 // operator-> - Allow user to dereference handle naturally...
162 Type *operator->() const { return get(); }
164 // operator= - Allow assignment to handle
165 Type *operator=(const Type *ty) {
166 if (Ty != ty) { // Don't accidentally drop last ref to Ty.
173 Type *operator=(const PATypeHolder &H) {
174 return operator=(H.Ty);
177 /// getRawType - This should only be used to implement the vmcore library.
179 const Type *getRawType() const { return Ty; }
184 friend class TypeMapBase;
187 // simplify_type - Allow clients to treat uses just like values when using
188 // casting operators.
189 template<> struct simplify_type<PATypeHolder> {
190 typedef const Type* SimpleType;
191 static SimpleType getSimplifiedValue(const PATypeHolder &Val) {
192 return static_cast<SimpleType>(Val.get());
195 template<> struct simplify_type<const PATypeHolder> {
196 typedef const Type* SimpleType;
197 static SimpleType getSimplifiedValue(const PATypeHolder &Val) {
198 return static_cast<SimpleType>(Val.get());
202 } // End llvm namespace