mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-20 11:29:24 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1328 91177308-0d34-0410-b5e6-96231b3b80d8
159 lines
5.9 KiB
C++
159 lines
5.9 KiB
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.
|
|
//
|
|
// 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.
|
|
//
|
|
// 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.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ABSTRACT_TYPE_USER_H
|
|
#define LLVM_ABSTRACT_TYPE_USER_H
|
|
|
|
class Type;
|
|
class DerivedType;
|
|
|
|
class AbstractTypeUser {
|
|
protected:
|
|
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.
|
|
//
|
|
// Another case that is important to consider is when a type is refined, but
|
|
// stays in the same place in memory. In this case OldTy will equal NewTy.
|
|
// This callback just notifies ATU's that the underlying structure of the type
|
|
// has changed... but any previously used properties are still valid.
|
|
//
|
|
// Note that it is possible to refine a type with parameters OldTy==NewTy, and
|
|
// OldTy is no longer abstract. In this case, abstract type users should
|
|
// release their hold on a type, because it went from being abstract to
|
|
// concrete.
|
|
//
|
|
virtual void refineAbstractType(const DerivedType *OldTy,
|
|
const Type *NewTy) = 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>
|
|
class PATypeHandle {
|
|
const TypeSubClass *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();
|
|
public:
|
|
// ctor - Add use to type if abstract. Note that Ty must not be null
|
|
inline PATypeHandle(const TypeSubClass *ty, AbstractTypeUser *user)
|
|
: Ty(ty), User(user) {
|
|
addUser();
|
|
}
|
|
|
|
// ctor - Add use to type if abstract.
|
|
inline PATypeHandle(const PATypeHandle &T) : Ty(T.Ty), User(T.User) {
|
|
addUser();
|
|
}
|
|
|
|
// dtor - Remove reference to type...
|
|
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; }
|
|
|
|
// operator= - Allow assignment to handle
|
|
inline const TypeSubClass *operator=(const TypeSubClass *ty) {
|
|
if (Ty != ty) { // Ensure we don't accidentally drop last ref to Ty
|
|
removeUser();
|
|
Ty = ty;
|
|
addUser();
|
|
}
|
|
return Ty;
|
|
}
|
|
|
|
// operator= - Allow assignment to handle
|
|
inline const TypeSubClass *operator=(const PATypeHandle &T) {
|
|
return operator=(T.Ty);
|
|
}
|
|
|
|
inline bool operator==(const TypeSubClass *ty) {
|
|
return Ty == ty;
|
|
}
|
|
|
|
// operator-> - Allow user to dereference handle naturally...
|
|
inline const TypeSubClass *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.
|
|
//
|
|
inline void removeUserFromConcrete();
|
|
};
|
|
|
|
|
|
// 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> {
|
|
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() == (const Type*)OldTy && "Can't refine to unknown value!");
|
|
|
|
// Check to see if the type just became concrete. If so, we have to
|
|
// removeUser to get off its AbstractTypeUser list
|
|
removeUserFromConcrete();
|
|
|
|
if ((const Type*)OldTy != NewTy)
|
|
PATypeHandle<TypeSC>::operator=((const TypeSC*)NewTy);
|
|
}
|
|
|
|
// operator= - Allow assignment to handle
|
|
inline const TypeSC *operator=(const TypeSC *ty) {
|
|
return PATypeHandle<TypeSC>::operator=(ty);
|
|
}
|
|
|
|
// operator= - Allow assignment to handle
|
|
inline const TypeSC *operator=(const PATypeHandle<TypeSC> &T) {
|
|
return PATypeHandle<TypeSC>::operator=(T);
|
|
}
|
|
inline const TypeSC *operator=(const PATypeHolder<TypeSC> &H) {
|
|
return PATypeHandle<TypeSC>::operator=(H);
|
|
}
|
|
};
|
|
|
|
|
|
#endif
|