X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FValue.h;h=b1db1ce3e1ee8831c1923c410f481a88ccac0a73;hb=b6d667403fed489ef92174b3f19d4b87db5c39f7;hp=b86d1374ebc9bf11d78e4d7e1bba56c45b2d8409;hpb=a3f343f4cd453b33214ba892bfeb58706fcf8cea;p=oota-llvm.git diff --git a/include/llvm/Value.h b/include/llvm/Value.h index b86d1374ebc..b1db1ce3e1e 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -16,6 +16,8 @@ #include "llvm/AbstractTypeUser.h" #include "llvm/Use.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/Twine.h" #include "llvm/Support/Casting.h" #include #include @@ -34,9 +36,13 @@ class InlineAsm; class ValueSymbolTable; class TypeSymbolTable; template class StringMapEntry; +template +class AssertingVH; typedef StringMapEntry ValueName; class raw_ostream; -struct AssemblyAnnotationWriter; +class AssemblyAnnotationWriter; +class ValueHandleBase; +class LLVMContext; //===----------------------------------------------------------------------===// // Value Class @@ -50,11 +56,21 @@ struct AssemblyAnnotationWriter; /// automatically updates the module's symbol table. /// /// Every value has a "use list" that keeps track of which other Values are -/// using this Value. +/// using this Value. A Value can also have an arbitrary number of ValueHandle +/// objects that watch it and listen to RAUW and Destroy events see +/// llvm/Support/ValueHandle.h for details. +/// /// @brief LLVM Value Representation class Value { - const unsigned short SubclassID; // Subclass identifier (for isa/dyn_cast) + const unsigned char SubclassID; // Subclass identifier (for isa/dyn_cast) + unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this? protected: + /// SubclassOptionalData - This member is similar to SubclassData, however it + /// is for holding information which may be used to aid optimization, but + /// which may be cleared to zero without affecting conservative + /// interpretation. + unsigned char SubclassOptionalData : 7; + /// SubclassData - This member is defined by this class, but is not used for /// anything. Subclasses can use it to hold whatever state they find useful. /// This field is initialized to zero by the ctor. @@ -65,6 +81,7 @@ private: friend class ValueSymbolTable; // Allow ValueSymbolTable to directly mod Name. friend class SymbolTable; // Allow SymbolTable to directly poke Name. + friend class ValueHandleBase; ValueName *Name; void operator=(const Value &); // Do not implement @@ -87,35 +104,34 @@ public: /// inline const Type *getType() const { return VTy; } + /// All values hold a context through their type. + LLVMContext &getContext() const; + // All values can potentially be named... inline bool hasName() const { return Name != 0; } ValueName *getValueName() const { return Name; } - - /// getNameStart - Return a pointer to a null terminated string for this name. - /// Note that names can have null characters within the string as well as at - /// their end. This always returns a non-null pointer. - const char *getNameStart() const; - /// getNameEnd - Return a pointer to the end of the name. - const char *getNameEnd() const { return getNameStart() + getNameLen(); } - - /// isName - Return true if this value has the name specified by the provided - /// nul terminated string. - bool isName(const char *N) const; - /// getNameLen - Return the length of the string, correctly handling nul - /// characters embedded into them. - unsigned getNameLen() const; - - /// getName()/getNameStr() - Return the name of the specified value, - /// *constructing a string* to hold it. Because these are guaranteed to - /// construct a string, they are very expensive and should be avoided. - std::string getName() const { return getNameStr(); } + /// getName() - Return a constant reference to the value's name. This is cheap + /// and guaranteed to return the same reference as long as the value is not + /// modified. + /// + /// This is currently guaranteed to return a StringRef for which data() points + /// to a valid null terminated string. The use of StringRef.data() is + /// deprecated here, however, and clients should not rely on it. If such + /// behavior is needed, clients should use expensive getNameStr(), or switch + /// to an interface that does not depend on null termination. + StringRef getName() const; + + /// getNameStr() - Return the name of the specified value, *constructing a + /// string* to hold it. This is guaranteed to construct a string and is very + /// expensive, clients should use getName() unless necessary. std::string getNameStr() const; - - void setName(const std::string &name); - void setName(const char *Name, unsigned NameLen); - void setName(const char *Name); // Takes a null-terminated string. + /// setName() - Change the name of the value, choosing a new unique name if + /// the provided name is taken. + /// + /// \arg Name - The new name; or "" if the value's name should be removed. + void setName(const Twine &Name); /// takeName - transfer the name from V to this value, setting V's name to @@ -132,8 +148,14 @@ public: // Only use when in type resolution situations! void uncheckedReplaceAllUsesWith(Value *V); + /// clearOptionalData - Clear any optional optimization data from this Value. + /// Transformation passes must call this method whenever changing the IR + /// in a way that would affect the values produced by this Value, unless + /// it takes special care to ensure correctness in some other way. + void clearOptionalData() { SubclassOptionalData = 0; } + //---------------------------------------------------------------------- - // Methods for handling the vector of uses of this Value. + // Methods for handling the chain of uses of this Value. // typedef value_use_iterator use_iterator; typedef value_use_iterator use_const_iterator; @@ -144,7 +166,7 @@ public: use_iterator use_end() { return use_iterator(0); } use_const_iterator use_end() const { return use_const_iterator(0); } User *use_back() { return *use_begin(); } - const User *use_back() const { return *use_begin(); } + const User *use_back() const { return *use_begin(); } /// hasOneUse - Return true if there is exactly one user of this value. This /// is specialized because it is a common request and does not require @@ -165,7 +187,7 @@ public: /// bool hasNUsesOrMore(unsigned N) const; - bool isUsedInBasicBlock(BasicBlock *BB) const; + bool isUsedInBasicBlock(const BasicBlock *BB) const; /// getNumUses - This method computes the number of uses of this Value. This /// is a linear time operation. Use hasOneUse, hasNUses, or hasMoreThanNUses @@ -195,6 +217,9 @@ public: ConstantStructVal, // This is an instance of ConstantStruct ConstantVectorVal, // This is an instance of ConstantVector ConstantPointerNullVal, // This is an instance of ConstantPointerNull + MDNodeVal, // This is an instance of MDNode + MDStringVal, // This is an instance of MDString + NamedMDNodeVal, // This is an instance of NamedMDNode InlineAsmVal, // This is an instance of InlineAsm PseudoSourceValueVal, // This is an instance of PseudoSourceValue InstructionVal, // This is an instance of Instruction @@ -228,11 +253,31 @@ public: /// stripPointerCasts - This method strips off any unneeded pointer /// casts from the specified value, returning the original uncasted value. - /// Note that the returned value is guaranteed to have pointer type. + /// Note that the returned value has pointer type if the specified value does. Value *stripPointerCasts(); const Value *stripPointerCasts() const { return const_cast(this)->stripPointerCasts(); } + + /// getUnderlyingObject - This method strips off any GEP address adjustments + /// and pointer casts from the specified value, returning the original object + /// being addressed. Note that the returned value has pointer type if the + /// specified value does. + Value *getUnderlyingObject(); + const Value *getUnderlyingObject() const { + return const_cast(this)->getUnderlyingObject(); + } + + /// DoPHITranslation - If this value is a PHI node with CurBB as its parent, + /// return the value in the PHI node corresponding to PredBB. If not, return + /// ourself. This is useful if you want to know the value something has in a + /// predecessor block. + Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB); + + const Value *DoPHITranslation(const BasicBlock *CurBB, + const BasicBlock *PredBB) const{ + return const_cast(this)->DoPHITranslation(CurBB, PredBB); + } }; inline std::ostream &operator<<(std::ostream &OS, const Value &V) { @@ -244,11 +289,6 @@ inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) { return OS; } -void Use::init(Value *V, User *) { - Val = V; - if (V) V->addUse(*this); -} - void Use::set(Value *V) { if (Val) removeFromList(); Val = V; @@ -285,8 +325,22 @@ template <> inline bool isa_impl(const Value &Val) { return Val.getValueID() == Value::GlobalAliasVal; } template <> inline bool isa_impl(const Value &Val) { - return isa(Val) || isa(Val) || isa(Val); + return isa(Val) || isa(Val) || + isa(Val); } + + +// Value* is only 4-byte aligned. +template<> +class PointerLikeTypeTraits { + typedef Value* PT; +public: + static inline void *getAsVoidPointer(PT P) { return P; } + static inline PT getFromVoidPointer(void *P) { + return static_cast(P); + } + enum { NumLowBitsAvailable = 2 }; +}; } // End llvm namespace