// 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;
+ // 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
+// 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.
//
// 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();
};
// 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) {}
+struct PATypeHolder : public AbstractTypeUser, public PATypeHandle<Type> {
+ inline PATypeHolder(const Type *ty) : PATypeHandle<Type>(ty, this) {}
inline PATypeHolder(const PATypeHolder &T)
- : AbstractTypeUser(T), PATypeHandle<TypeSC>(T, this) {}
+ : AbstractTypeUser(T), PATypeHandle<Type>(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);
+ 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<Type>::operator=(NewTy);
}
// operator= - Allow assignment to handle
- inline const TypeSC *operator=(const TypeSC *ty) {
- return PATypeHandle<TypeSC>::operator=(ty);
+ inline const Type *operator=(const Type *ty) {
+ return PATypeHandle<Type>::operator=(ty);
}
// operator= - Allow assignment to handle
- inline const TypeSC *operator=(const PATypeHandle<TypeSC> &T) {
- return PATypeHandle<TypeSC>::operator=(T);
+ inline const Type *operator=(const PATypeHandle<Type> &T) {
+ return PATypeHandle<Type>::operator=(T);
}
- inline const TypeSC *operator=(const PATypeHolder<TypeSC> &H) {
- return PATypeHandle<TypeSC>::operator=(H);
+ inline const Type *operator=(const PATypeHolder &H) {
+ return PATypeHandle<Type>::operator=(H);
}
-};
+ void dump() const;
+};
#endif