-//===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface -----*- C++ -*--=//
+//===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===//
//
-// The AbstractTypeUser class is an interface to be implemented by classes who
-// could possible use an abstract type. Abstract types are denoted by the
-// isAbstract flag set to true in the Type class. These are classes that
-// contain an Opaque type in their structure somehow.
+// The LLVM Compiler Infrastructure
//
-// Classes must implement this interface so that they may be notified when an
-// abstract type is resolved. Abstract types may be resolved into more concrete
-// types through: linking, parsing, and bytecode reading. When this happens,
-// all of the users of the type must be updated to reference the new, more
-// concrete type. They are notified through the AbstractTypeUser interface.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
-// In addition to this, AbstractTypeUsers must keep the use list of the
-// potentially abstract type that they reference up-to-date. To do this in a
-// nice, transparent way, the PATypeHandle class is used to hold "Potentially
-// Abstract Types", and keep the use list of the abstract types up-to-date.
+//===----------------------------------------------------------------------===//
+//
+// This file declares the AbstractTypeUser class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ABSTRACT_TYPE_USER_H
#define LLVM_ABSTRACT_TYPE_USER_H
+#if !defined(LLVM_TYPE_H) && !defined(LLVM_VALUE_H)
+#error Do not include this file directly. Include Type.h instead.
+#error Some versions of GCC (e.g. 3.4 and 4.1) can not handle the inlined method
+#error PATypeHolder::dropRef() correctly otherwise.
+#endif
+
+// This is the "master" include for <cassert> Whether this file needs it or not,
+// it must always include <cassert> for the files which include
+// llvm/AbstractTypeUser.h
+//
+// In this way, most every LLVM source file will have access to the assert()
+// macro without having to #include <cassert> directly.
+//
+#include <cassert>
+
+namespace llvm {
+
class Type;
class DerivedType;
-
+template<typename T> struct simplify_type;
+
+/// The AbstractTypeUser class is an interface to be implemented by classes who
+/// could possibly use an abstract type. Abstract types are denoted by the
+/// isAbstract flag set to true in the Type class. These are classes that
+/// contain an Opaque type in their structure somewhere.
+///
+/// Classes must implement this interface so that they may be notified when an
+/// abstract type is resolved. Abstract types may be resolved into more
+/// concrete types through: linking, parsing, and bitcode reading. When this
+/// happens, all of the users of the type must be updated to reference the new,
+/// more concrete type. They are notified through the AbstractTypeUser
+/// interface.
+///
+/// In addition to this, AbstractTypeUsers must keep the use list of the
+/// potentially abstract type that they reference up-to-date. To do this in a
+/// nice, transparent way, the PATypeHandle class is used to hold "Potentially
+/// Abstract Types", and keep the use list of the abstract types up-to-date.
+/// @brief LLVM Abstract Type User Representation
class AbstractTypeUser {
protected:
- virtual ~AbstractTypeUser() {} // Derive from me
+ 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.
- //
+ /// 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;
+ 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 MethodType'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.
-//
-template <class TypeSubClass>
+/// PATypeHandle - Handle to a Type subclass. This class is used to keep the
+/// use list of abstract types up-to-date.
+///
class PATypeHandle {
- const TypeSubClass *Ty;
+ const Type *Ty;
AbstractTypeUser * const User;
// These functions are defined at the bottom of Type.h. See the comment there
// for justification.
- inline void addUser();
- inline void removeUser();
+ void addUser();
+ void removeUser();
public:
// ctor - Add use to type if abstract. Note that Ty must not be null
- inline PATypeHandle(const TypeSubClass *ty, AbstractTypeUser *user)
+ inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
: Ty(ty), User(user) {
addUser();
}
inline ~PATypeHandle() { removeUser(); }
// Automatic casting operator so that the handle may be used naturally
- inline operator const TypeSubClass *() const { return Ty; }
- inline const TypeSubClass *get() const { return Ty; }
+ inline operator Type *() const { return const_cast<Type*>(Ty); }
+ inline Type *get() const { return const_cast<Type*>(Ty); }
// operator= - Allow assignment to handle
- inline const TypeSubClass *operator=(const TypeSubClass *ty) {
+ inline Type *operator=(const Type *ty) {
if (Ty != ty) { // Ensure we don't accidentally drop last ref to Ty
removeUser();
Ty = ty;
addUser();
}
- return Ty;
+ return get();
}
// operator= - Allow assignment to handle
- inline const TypeSubClass *operator=(const PATypeHandle &T) {
+ inline const Type *operator=(const PATypeHandle &T) {
return operator=(T.Ty);
}
- inline bool operator==(const TypeSubClass *ty) {
+ inline bool operator==(const Type *ty) {
return Ty == ty;
}
// operator-> - Allow user to dereference handle naturally...
- inline const TypeSubClass *operator->() const { return Ty; }
+ inline const Type *operator->() const { return Ty; }
};
-// 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.
-//
-template <class TypeSC>
-class PATypeHolder : public AbstractTypeUser, public PATypeHandle<TypeSC> {
+/// 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:
- inline PATypeHolder(const TypeSC *ty) : PATypeHandle<TypeSC>(ty, this) {}
- inline PATypeHolder(const PATypeHolder &T)
- : AbstractTypeUser(T), PATypeHandle<TypeSC>(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() == OldTy && "Can't refine to unknown value!");
- PATypeHandle<TypeSC>::operator=((const TypeSC*)NewTy);
+ PATypeHolder(const Type *ty) : Ty(ty) {
+ addRef();
}
-
- // operator= - Allow assignment to handle
- inline const TypeSC *operator=(const TypeSC *ty) {
- return PATypeHandle<TypeSC>::operator=(ty);
+ PATypeHolder(const PATypeHolder &T) : Ty(T.Ty) {
+ addRef();
}
+ ~PATypeHolder() { dropRef(); }
+
+ operator Type *() const { return get(); }
+ Type *get() const;
+
+ // operator-> - Allow user to dereference handle naturally...
+ Type *operator->() const { return get(); }
+
// operator= - Allow assignment to handle
- inline const TypeSC *operator=(const PATypeHandle<TypeSC> &T) {
- return PATypeHandle<TypeSC>::operator=(T);
+ Type *operator=(const Type *ty) {
+ if (Ty != ty) { // Don't accidentally drop last ref to Ty.
+ dropRef();
+ Ty = ty;
+ addRef();
+ }
+ return get();
}
- inline const TypeSC *operator=(const PATypeHolder<TypeSC> &H) {
- return PATypeHandle<TypeSC>::operator=(H);
+ Type *operator=(const PATypeHolder &H) {
+ return operator=(H.Ty);
}
+
+ /// getRawType - This should only be used to implement the vmcore library.
+ ///
+ const Type *getRawType() const { return Ty; }
+
+private:
+ void addRef();
+ void dropRef();
};
+// simplify_type - Allow clients to treat uses just like values when using
+// casting operators.
+template<> struct simplify_type<PATypeHolder> {
+ typedef const Type* SimpleType;
+ static SimpleType getSimplifiedValue(const PATypeHolder &Val) {
+ return static_cast<SimpleType>(Val.get());
+ }
+};
+template<> struct simplify_type<const PATypeHolder> {
+ typedef const Type* SimpleType;
+ static SimpleType getSimplifiedValue(const PATypeHolder &Val) {
+ return static_cast<SimpleType>(Val.get());
+ }
+};
+
+} // End llvm namespace
#endif