X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAbstractTypeUser.h;h=81f5c5c7680d87ef4b6f8b0fe76cc3963923287d;hb=688d58033a077dd05be830cd23f8d416ce1be59d;hp=d21116539419235e99acfec25e859edb79116526;hpb=dbd9b3f75c5b52b2310513ff5e781fd83a49db08;p=oota-llvm.git diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h index d2111653941..81f5c5c7680 100644 --- a/include/llvm/AbstractTypeUser.h +++ b/include/llvm/AbstractTypeUser.h @@ -1,33 +1,25 @@ //===-- 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 LLVM Compiler Infrastructure // -// 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. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // -// 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. +// 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 Whether this file needs it or not, // it must always include for the files which include // llvm/AbstractTypeUser.h @@ -39,12 +31,37 @@ namespace llvm { +class Value; class Type; class DerivedType; +template 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 @@ -52,10 +69,10 @@ public: /// 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. /// @@ -79,7 +96,7 @@ class PATypeHandle { 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(); } @@ -93,17 +110,17 @@ public: 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(Ty); } + inline Type *get() const { return const_cast(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 @@ -117,14 +134,6 @@ public: // 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(); }; @@ -135,7 +144,9 @@ public: /// class PATypeHolder { mutable const Type *Ty; + void destroy(); public: + PATypeHolder() : Ty(0) {} PATypeHolder(const Type *ty) : Ty(ty) { addRef(); } @@ -145,14 +156,14 @@ public: ~PATypeHolder() { dropRef(); } - operator const Type *() const { return get(); } - const Type *get() const; + 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; @@ -160,15 +171,35 @@ public: } 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 { + typedef const Type* SimpleType; + static SimpleType getSimplifiedValue(const PATypeHolder &Val) { + return static_cast(Val.get()); + } +}; +template<> struct simplify_type { + typedef const Type* SimpleType; + static SimpleType getSimplifiedValue(const PATypeHolder &Val) { + return static_cast(Val.get()); + } +}; + } // End llvm namespace #endif