//===-- 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
//
#include <cassert>
+namespace llvm {
+
+class Value;
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
+
+ /// setType - It's normally not possible to change a Value's type in place,
+ /// but an AbstractTypeUser subclass that knows what its doing can be
+ /// permitted to do so with care.
+ void setType(Value *V, const Type *NewTy);
+
public:
/// refineAbstractType - The callback method invoked when an abstract type is
/// 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
+ /// makes the transition from being abstract (where it has clients on its
/// AbstractTypeUsers list) to concrete (where it does not). This method
/// notifies ATU's when this occurs for a type.
///
void removeUser();
public:
// ctor - Add use to type if abstract. Note that Ty must not be null
- inline PATypeHandle(const Type *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 Type *() const { return Ty; }
- inline const Type *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 Type *operator=(const Type *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
// operator-> - Allow user to dereference handle naturally...
inline const Type *operator->() const { return Ty; }
-
- // removeUserFromConcrete - This function should be called when the User is
- // notified that our type is refined... and the type is being refined to
- // itself, which is now a concrete type. When a type becomes concrete like
- // this, we MUST remove ourself from the AbstractTypeUser list, even though
- // the type is apparently concrete.
- //
- void removeUserFromConcrete();
};
///
class PATypeHolder {
mutable const Type *Ty;
+ void destroy();
public:
+ PATypeHolder() : Ty(0) {}
PATypeHolder(const Type *ty) : Ty(ty) {
addRef();
}
addRef();
}
- operator const Type *() const { return get(); }
- const Type *get() const;
+ ~PATypeHolder() { dropRef(); }
+
+ operator Type *() const { return get(); }
+ Type *get() const;
// operator-> - Allow user to dereference handle naturally...
- const Type *operator->() const { return get(); }
+ Type *operator->() const { return get(); }
// operator= - Allow assignment to handle
- const Type *operator=(const Type *ty) {
+ Type *operator=(const Type *ty) {
if (Ty != ty) { // Don't accidentally drop last ref to Ty.
dropRef();
Ty = ty;
}
return get();
}
- const Type *operator=(const PATypeHolder &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();
+ friend class TypeMapBase;
+};
+
+// 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
projects / oota-llvm.git / blobdiff