X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAbstractTypeUser.h;h=d21116539419235e99acfec25e859edb79116526;hb=32bdd4ea65f58e3227176b9a5a43013fb13f06a5;hp=272560ff2880795a419447a1c4846948116e0a6b;hpb=97ca95d1e7a30d4d178b37881b44ba4039182bde;p=oota-llvm.git diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h index 272560ff288..d2111653941 100644 --- a/include/llvm/AbstractTypeUser.h +++ b/include/llvm/AbstractTypeUser.h @@ -1,4 +1,11 @@ -//===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface -----*- C++ -*--=// +//===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// // // The AbstractTypeUser class is an interface to be implemented by classes who // could possible use an abstract type. Abstract types are denoted by the @@ -21,7 +28,17 @@ #ifndef LLVM_ABSTRACT_TYPE_USER_H #define LLVM_ABSTRACT_TYPE_USER_H -#include +// This is the "master" include for Whether this file needs it or not, +// it must always include 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 directly. +// +#include + +namespace llvm { + class Type; class DerivedType; @@ -30,46 +47,39 @@ 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. - // + /// 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; + + /// 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 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 +/// 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(); } @@ -83,11 +93,11 @@ public: 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; @@ -97,16 +107,16 @@ public: } // 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 @@ -114,47 +124,51 @@ public: // this, we MUST remove ourself from the AbstractTypeUser list, even though // the type is apparently concrete. // - inline void removeUserFromConcrete(); + 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. -// -struct PATypeHolder : public AbstractTypeUser, public PATypeHandle { - inline PATypeHolder(const Type *ty) : PATypeHandle(ty, this) {} - inline PATypeHolder(const PATypeHolder &T) - : AbstractTypeUser(T), PATypeHandle(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!"); +/// 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: + PATypeHolder(const Type *ty) : Ty(ty) { + addRef(); + } + PATypeHolder(const PATypeHolder &T) : Ty(T.Ty) { + addRef(); + } - // Check to see if the type just became concrete. If so, we have to - // removeUser to get off its AbstractTypeUser list - removeUserFromConcrete(); + ~PATypeHolder() { dropRef(); } - if ((const Type*)OldTy != NewTy) - PATypeHandle::operator=(NewTy); - } + operator const Type *() const { return get(); } + const Type *get() const; - // operator= - Allow assignment to handle - inline const Type *operator=(const Type *ty) { - return PATypeHandle::operator=(ty); - } + // operator-> - Allow user to dereference handle naturally... + const Type *operator->() const { return get(); } // operator= - Allow assignment to handle - inline const Type *operator=(const PATypeHandle &T) { - return PATypeHandle::operator=(T); + const Type *operator=(const Type *ty) { + if (Ty != ty) { // Don't accidentally drop last ref to Ty. + dropRef(); + Ty = ty; + addRef(); + } + return get(); } - inline const Type *operator=(const PATypeHolder &H) { - return PATypeHandle::operator=(H); + const Type *operator=(const PATypeHolder &H) { + return operator=(H.Ty); } - void dump() const; +private: + void addRef(); + void dropRef(); }; +} // End llvm namespace + #endif