X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FValue.h;h=67af6edb8f98a6475636038f8125b0c5709372eb;hb=80a75bfae980df96f969f1c05b0c4a80ce975240;hp=262880a0e745647e7720ee3af07854bd7aa9a79f;hpb=5c7e326585f3a543388ba871c3425f7664cd9143;p=oota-llvm.git diff --git a/include/llvm/Value.h b/include/llvm/Value.h index 262880a0e74..67af6edb8f9 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -30,8 +30,12 @@ class BasicBlock; class GlobalValue; class Function; class GlobalVariable; +class GlobalAlias; class InlineAsm; -class SymbolTable; +class ValueSymbolTable; +class TypeSymbolTable; +template class StringMapEntry; +typedef StringMapEntry ValueName; //===----------------------------------------------------------------------===// // Value Class @@ -48,7 +52,7 @@ class SymbolTable; /// using this Value. /// @brief LLVM Value Representation class Value { - unsigned short SubclassID; // Subclass identifier (for isa/dyn_cast) + const unsigned short SubclassID; // Subclass identifier (for isa/dyn_cast) protected: /// 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. @@ -60,13 +64,13 @@ private: friend class ValueSymbolTable; // Allow ValueSymbolTable to directly mod Name. friend class SymbolTable; // Allow SymbolTable to directly poke Name. - std::string Name; + ValueName *Name; void operator=(const Value &); // Do not implement Value(const Value &); // Do not implement public: - Value(const Type *Ty, unsigned scid, const std::string &name = ""); + Value(const Type *Ty, unsigned scid); virtual ~Value(); /// dump - Support for debugging, callable in GDB: V->dump() @@ -83,10 +87,33 @@ public: inline const Type *getType() const { return Ty; } // All values can potentially be named... - inline bool hasName() const { return !Name.empty(); } - inline const std::string &getName() const { return Name; } + 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; + + /// 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(); } + 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. + + + /// takeName - transfer the name from V to this value, setting V's name to + /// empty. It is an error to call V->takeName(V). + void takeName(Value *V); /// replaceAllUsesWith - Go through the uses list for this definition and make /// each use point to "V" instead of "this". After this completes, 'this's @@ -148,16 +175,16 @@ public: ArgumentVal, // This is an instance of Argument BasicBlockVal, // This is an instance of BasicBlock FunctionVal, // This is an instance of Function + GlobalAliasVal, // This is an instance of GlobalAlias GlobalVariableVal, // This is an instance of GlobalVariable UndefValueVal, // This is an instance of UndefValue ConstantExprVal, // This is an instance of ConstantExpr ConstantAggregateZeroVal, // This is an instance of ConstantAggregateNull - ConstantBoolVal, // This is an instance of ConstantBool ConstantIntVal, // This is an instance of ConstantInt ConstantFPVal, // This is an instance of ConstantFP ConstantArrayVal, // This is an instance of ConstantArray ConstantStructVal, // This is an instance of ConstantStruct - ConstantPackedVal, // This is an instance of ConstantPacked + ConstantVectorVal, // This is an instance of ConstantVector ConstantPointerNullVal, // This is an instance of ConstantPointerNull InlineAsmVal, // This is an instance of InlineAsm InstructionVal, // This is an instance of Instruction @@ -167,14 +194,16 @@ public: ConstantLastVal = ConstantPointerNullVal }; - /// getValueType - Return an ID for the concrete type of this object. This is + /// getValueID - Return an ID for the concrete type of this object. This is /// used to implement the classof checks. This should not be used for any /// other purpose, as the values may change as LLVM evolves. Also, note that - /// starting with the InstructionVal value, the value stored is actually the - /// Instruction opcode, so there are more than just these values possible here - /// (and Instruction must be last). - /// - unsigned getValueType() const { + /// for instructions, the Instruction's opcode is added to InstructionVal. So + /// this means three things: + /// # there is no value with code InstructionVal (no opcode==0). + /// # there are more possible values for the value type than in ValueTy enum. + /// # the InstructionVal enumerator must be the highest valued enumerator in + /// the ValueTy enum. + unsigned getValueID() const { return SubclassID; } @@ -186,11 +215,6 @@ public: /// getRawType - This should only be used to implement the vmcore library. /// const Type *getRawType() const { return Ty.getRawType(); } - -private: - /// FIXME: this is a gross hack, needed by another gross hack. Eliminate! - void setValueType(unsigned short VT) { SubclassID = VT; } - friend class Instruction; }; inline std::ostream &operator<<(std::ostream &OS, const Value &V) { @@ -219,29 +243,32 @@ void Use::set(Value *V) { // the subtype header files to test to see if the value is a subclass... // template <> inline bool isa_impl(const Value &Val) { - return Val.getValueType() >= Value::ConstantFirstVal && - Val.getValueType() <= Value::ConstantLastVal; + return Val.getValueID() >= Value::ConstantFirstVal && + Val.getValueID() <= Value::ConstantLastVal; } template <> inline bool isa_impl(const Value &Val) { - return Val.getValueType() == Value::ArgumentVal; + return Val.getValueID() == Value::ArgumentVal; } template <> inline bool isa_impl(const Value &Val) { - return Val.getValueType() == Value::InlineAsmVal; + return Val.getValueID() == Value::InlineAsmVal; } template <> inline bool isa_impl(const Value &Val) { - return Val.getValueType() >= Value::InstructionVal; + return Val.getValueID() >= Value::InstructionVal; } template <> inline bool isa_impl(const Value &Val) { - return Val.getValueType() == Value::BasicBlockVal; + return Val.getValueID() == Value::BasicBlockVal; } template <> inline bool isa_impl(const Value &Val) { - return Val.getValueType() == Value::FunctionVal; + return Val.getValueID() == Value::FunctionVal; } template <> inline bool isa_impl(const Value &Val) { - return Val.getValueType() == Value::GlobalVariableVal; + return Val.getValueID() == Value::GlobalVariableVal; +} +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); + return isa(Val) || isa(Val) || isa(Val); } } // End llvm namespace