X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FValue.h;h=628e32cedbd2539686e55915435cc121e4fb49e6;hb=1bc33a5227d6d4b9e1da6fbde1c8369921e3fba5;hp=573ca174dee689d0282d7fb585eac3f6574b7da4;hpb=18961504fc2b299578dba817900a0696cf3ccc4d;p=oota-llvm.git diff --git a/include/llvm/Value.h b/include/llvm/Value.h index 573ca174dee..628e32cedbd 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -1,4 +1,4 @@ -//===-- llvm/Value.h - Definition of the Value class -------------*- C++ -*--=// +//===-- llvm/Value.h - Definition of the Value class ------------*- C++ -*-===// // // This file defines the very important Value class. This is subclassed by a // bunch of other important classes, like Instruction, Function, Type, etc... @@ -10,10 +10,11 @@ #ifndef LLVM_VALUE_H #define LLVM_VALUE_H -#include -#include "llvm/Annotation.h" #include "llvm/AbstractTypeUser.h" +#include "Support/Annotation.h" #include "Support/Casting.h" +#include +#include class User; class Type; @@ -30,9 +31,10 @@ class SymbolTable; // Value Class //===----------------------------------------------------------------------===// -class Value : public Annotable, // Values are annotable - public AbstractTypeUser { // Values use potentially abstract types -public: +/// Value - The base class of all values computed by a program that may be used +/// as operands to other values. +/// +struct Value : public Annotable { // Values are annotable enum ValueTy { TypeVal, // This is an instance of Type ConstantVal, // This is an instance of Constant @@ -46,23 +48,25 @@ public: private: std::vector Uses; std::string Name; - PATypeHandle Ty; + PATypeHolder Ty; ValueTy VTy; + void operator=(const Value &); // Do not implement Value(const Value &); // Do not implement -protected: - inline void setType(const Type *ty) { Ty = ty; } public: Value(const Type *Ty, ValueTy vty, const std::string &name = ""); virtual ~Value(); - // Support for debugging - void dump() const; + /// dump - Support for debugging, callable in GDB: V->dump() + // + virtual void dump() const; - // Implement operator<< on Value... + /// print - Implement operator<< on Value... + /// virtual void print(std::ostream &O) const = 0; - // All values can potentially be typed + /// All values are typed, get the type of this value. + /// inline const Type *getType() const { return Ty; } // All values can potentially be named... @@ -73,29 +77,20 @@ public: Name = name; } - // Methods for determining the subtype of this Value. The getValueType() - // method returns the type of the value directly. The cast*() methods are - // equivalent to using dynamic_cast<>... if the cast is successful, this is - // returned, otherwise you get a null pointer. - // - // The family of functions Val->castAsserting() is used in the same - // way as the Val->cast() instructions, but they assert the expected - // type instead of checking it at runtime. - // + /// getValueType - Return the immediate subclass of this Value. + /// inline ValueTy getValueType() const { return VTy; } - // replaceAllUsesWith - Go through the uses list for this definition and make - // each use point to "D" instead of "this". After this completes, 'this's - // use list should be empty. - // - void replaceAllUsesWith(Value *D); + /// replaceAllUsesWith - Go through the uses list for this definition and make + /// each use point to "V" instead of "this". After this completes, 'this's + /// use list is guaranteed to be empty. + /// + void replaceAllUsesWith(Value *V); + + // uncheckedReplaceAllUsesWith - Just like replaceAllUsesWith but dangerous. + // Only use when in type resolution situations! + void uncheckedReplaceAllUsesWith(Value *V); - // refineAbstractType - This function is implemented because we use - // potentially abstract types, and these types may be resolved to more - // concrete types after we are constructed. - // - virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy); - //---------------------------------------------------------------------- // Methods for handling the vector of uses of this Value. // @@ -111,9 +106,8 @@ public: inline User *use_back() { return Uses.back(); } inline const User *use_back() const { return Uses.back(); } - inline void use_push_back(User *I) { Uses.push_back(I); } - User *use_remove(use_iterator &I); - + /// addUse/killUse - These two methods should only be used by the Use class + /// below. inline void addUse(User *I) { Uses.push_back(I); } void killUse(User *I); }; @@ -133,45 +127,42 @@ inline std::ostream &operator<<(std::ostream &OS, const Value &V) { //===----------------------------------------------------------------------===// -// UseTy Class +// Use Class //===----------------------------------------------------------------------===// -// UseTy and it's friendly typedefs (Use) are here to make keeping the "use" -// list of a definition node up-to-date really easy. +// Use is here to make keeping the "use" list of a Value up-to-date really easy. // -template -class UseTy { - ValueSubclass *Val; +class Use { + Value *Val; User *U; public: - inline UseTy(ValueSubclass *v, User *user) { + inline Use(Value *v, User *user) { Val = v; U = user; if (Val) Val->addUse(U); } - inline ~UseTy() { if (Val) Val->killUse(U); } - - inline operator ValueSubclass *() const { return Val; } - - inline UseTy(const UseTy &user) { + inline Use(const Use &user) { Val = 0; U = user.U; operator=(user.Val); } - inline ValueSubclass *operator=(ValueSubclass *V) { + inline ~Use() { if (Val) Val->killUse(U); } + inline operator Value*() const { return Val; } + + inline Value *operator=(Value *V) { if (Val) Val->killUse(U); Val = V; if (V) V->addUse(U); return V; } - inline ValueSubclass *operator->() { return Val; } - inline const ValueSubclass *operator->() const { return Val; } + inline Value *operator->() { return Val; } + inline const Value *operator->() const { return Val; } - inline ValueSubclass *get() { return Val; } - inline const ValueSubclass *get() const { return Val; } + inline Value *get() { return Val; } + inline const Value *get() const { return Val; } - inline UseTy &operator=(const UseTy &user) { + inline const Use &operator=(const Use &user) { if (Val) Val->killUse(U); Val = user.Val; Val->addUse(U); @@ -179,19 +170,17 @@ public: } }; -typedef UseTy Use; // Provide Use as a common UseTy type - -template struct simplify_type > { - typedef typename simplify_type::SimpleType SimpleType; +template<> struct simplify_type { + typedef Value* SimpleType; - static SimpleType getSimplifiedValue(const UseTy &Val) { + static SimpleType getSimplifiedValue(const Use &Val) { return (SimpleType)Val.get(); } }; -template struct simplify_type > { - typedef typename simplify_type::SimpleType SimpleType; +template<> struct simplify_type { + typedef Value* SimpleType; - static SimpleType getSimplifiedValue(const UseTy &Val) { + static SimpleType getSimplifiedValue(const Use &Val) { return (SimpleType)Val.get(); } };