#ifndef LLVM_ABSTRACT_TYPE_USER_H
#define LLVM_ABSTRACT_TYPE_USER_H
+// 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>
+
class Type;
class DerivedType;
// PATypeHandle - Handle to a Type subclass. This class is parameterized so
-// that users can have handles to MethodType's that are still specialized, for
+// that users can have handles to FunctionType'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>
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 const Type *() const { return Ty; }
+ inline const Type *get() const { return Ty; }
// operator= - Allow assignment to handle
- inline const TypeSubClass *operator=(const TypeSubClass *ty) {
+ inline const Type *operator=(const Type *ty) {
if (Ty != ty) { // Ensure we don't accidentally drop last ref to Ty
removeUser();
Ty = ty;
}
// 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; }
// removeUserFromConcrete - This function should be called when the User is
// notified that our type is refined... and the type is being refined to
// this, we MUST remove ourself from the AbstractTypeUser list, even though
// the type is apparently concrete.
//
- inline void removeUserFromConcrete();
+ void removeUserFromConcrete();
};
// 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.
//
-struct PATypeHolder : public AbstractTypeUser, public PATypeHandle<Type> {
- inline PATypeHolder(const Type *ty) : PATypeHandle<Type>(ty, this) {}
+struct PATypeHolder : public AbstractTypeUser, public PATypeHandle {
+ inline PATypeHolder(const Type *ty) : PATypeHandle(ty, this) {}
inline PATypeHolder(const PATypeHolder &T)
- : AbstractTypeUser(T), PATypeHandle<Type>(T, this) {}
+ : AbstractTypeUser(T), PATypeHandle(T, this) {}
// refineAbstractType - All we do is update our PATypeHandle member to point
// to the new type.
removeUserFromConcrete();
if ((const Type*)OldTy != NewTy)
- PATypeHandle<Type>::operator=(NewTy);
+ PATypeHandle::operator=(NewTy);
}
// operator= - Allow assignment to handle
inline const Type *operator=(const Type *ty) {
- return PATypeHandle<Type>::operator=(ty);
+ return PATypeHandle::operator=(ty);
}
// operator= - Allow assignment to handle
- inline const Type *operator=(const PATypeHandle<Type> &T) {
- return PATypeHandle<Type>::operator=(T);
+ inline const Type *operator=(const PATypeHandle &T) {
+ return PATypeHandle::operator=(T);
}
inline const Type *operator=(const PATypeHolder &H) {
- return PATypeHandle<Type>::operator=(H);
+ return PATypeHandle::operator=(H);
}
void dump() const;