Value.h revision b163f1c3e551cb3e5abd9bead0eae7a753502540
1//===-- llvm/Value.h - Definition of the Value class -------------*- C++ -*--=// 2// 3// This file defines the very important Value class. This is subclassed by a 4// bunch of other important classes, like Instruction, Function, Type, etc... 5// 6// This file also defines the Use<> template for users of value. 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef LLVM_VALUE_H 11#define LLVM_VALUE_H 12 13#include <vector> 14#include "llvm/Annotation.h" 15#include "llvm/AbstractTypeUser.h" 16#include "Support/Casting.h" 17#include <iostream> 18 19class User; 20class Type; 21class Constant; 22class Argument; 23class Instruction; 24class BasicBlock; 25class GlobalValue; 26class Function; 27class GlobalVariable; 28class SymbolTable; 29 30//===----------------------------------------------------------------------===// 31// Value Class 32//===----------------------------------------------------------------------===// 33 34/// Value - The base class of all values computed by a program that may be used 35/// as operands to other values. 36/// 37class Value : public Annotable, // Values are annotable 38 public AbstractTypeUser { // Values use potentially abstract types 39public: 40 enum ValueTy { 41 TypeVal, // This is an instance of Type 42 ConstantVal, // This is an instance of Constant 43 ArgumentVal, // This is an instance of Argument 44 InstructionVal, // This is an instance of Instruction 45 BasicBlockVal, // This is an instance of BasicBlock 46 FunctionVal, // This is an instance of Function 47 GlobalVariableVal, // This is an instance of GlobalVariable 48 }; 49 50private: 51 std::vector<User *> Uses; 52 std::string Name; 53 PATypeHandle<Type> Ty; 54 ValueTy VTy; 55 56 void operator=(const Value &); // Do not implement 57 Value(const Value &); // Do not implement 58public: 59 Value(const Type *Ty, ValueTy vty, const std::string &name = ""); 60 virtual ~Value(); 61 62 /// dump - Support for debugging, callable in GDB: V->dump() 63 // 64 void dump() const; 65 66 /// print - Implement operator<< on Value... 67 /// 68 virtual void print(std::ostream &O) const = 0; 69 70 /// All values are typed, get the type of this value. 71 /// 72 inline const Type *getType() const { return Ty; } 73 74 // All values can potentially be named... 75 inline bool hasName() const { return Name != ""; } 76 inline const std::string &getName() const { return Name; } 77 78 virtual void setName(const std::string &name, SymbolTable * = 0) { 79 Name = name; 80 } 81 82 /// getValueType - Return the immediate subclass of this Value. 83 /// 84 inline ValueTy getValueType() const { return VTy; } 85 86 /// replaceAllUsesWith - Go through the uses list for this definition and make 87 /// each use point to "V" instead of "this". After this completes, 'this's 88 /// use list is guaranteed to be empty. 89 /// 90 void replaceAllUsesWith(Value *V); 91 92 /// refineAbstractType - This function is implemented because we use 93 /// potentially abstract types, and these types may be resolved to more 94 /// concrete types after we are constructed. 95 /// 96 virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy); 97 98 //---------------------------------------------------------------------- 99 // Methods for handling the vector of uses of this Value. 100 // 101 typedef std::vector<User*>::iterator use_iterator; 102 typedef std::vector<User*>::const_iterator use_const_iterator; 103 104 inline unsigned use_size() const { return Uses.size(); } 105 inline bool use_empty() const { return Uses.empty(); } 106 inline use_iterator use_begin() { return Uses.begin(); } 107 inline use_const_iterator use_begin() const { return Uses.begin(); } 108 inline use_iterator use_end() { return Uses.end(); } 109 inline use_const_iterator use_end() const { return Uses.end(); } 110 inline User *use_back() { return Uses.back(); } 111 inline const User *use_back() const { return Uses.back(); } 112 113 inline void use_push_back(User *I) { Uses.push_back(I); } 114 User *use_remove(use_iterator &I); 115 116 inline void addUse(User *I) { Uses.push_back(I); } 117 void killUse(User *I); 118}; 119 120inline std::ostream &operator<<(std::ostream &OS, const Value *V) { 121 if (V == 0) 122 OS << "<null> value!\n"; 123 else 124 V->print(OS); 125 return OS; 126} 127 128inline std::ostream &operator<<(std::ostream &OS, const Value &V) { 129 V.print(OS); 130 return OS; 131} 132 133 134//===----------------------------------------------------------------------===// 135// UseTy Class 136//===----------------------------------------------------------------------===// 137 138// UseTy and it's friendly typedefs (Use) are here to make keeping the "use" 139// list of a definition node up-to-date really easy. 140// 141template<class ValueSubclass> 142class UseTy { 143 ValueSubclass *Val; 144 User *U; 145public: 146 inline UseTy<ValueSubclass>(ValueSubclass *v, User *user) { 147 Val = v; U = user; 148 if (Val) Val->addUse(U); 149 } 150 151 inline ~UseTy<ValueSubclass>() { if (Val) Val->killUse(U); } 152 153 inline operator ValueSubclass *() const { return Val; } 154 155 inline UseTy<ValueSubclass>(const UseTy<ValueSubclass> &user) { 156 Val = 0; 157 U = user.U; 158 operator=(user.Val); 159 } 160 inline ValueSubclass *operator=(ValueSubclass *V) { 161 if (Val) Val->killUse(U); 162 Val = V; 163 if (V) V->addUse(U); 164 return V; 165 } 166 167 inline ValueSubclass *operator->() { return Val; } 168 inline const ValueSubclass *operator->() const { return Val; } 169 170 inline ValueSubclass *get() { return Val; } 171 inline const ValueSubclass *get() const { return Val; } 172 173 inline UseTy<ValueSubclass> &operator=(const UseTy<ValueSubclass> &user) { 174 if (Val) Val->killUse(U); 175 Val = user.Val; 176 Val->addUse(U); 177 return *this; 178 } 179}; 180 181typedef UseTy<Value> Use; // Provide Use as a common UseTy type 182 183template<typename From> struct simplify_type<UseTy<From> > { 184 typedef typename simplify_type<From*>::SimpleType SimpleType; 185 186 static SimpleType getSimplifiedValue(const UseTy<From> &Val) { 187 return (SimpleType)Val.get(); 188 } 189}; 190template<typename From> struct simplify_type<const UseTy<From> > { 191 typedef typename simplify_type<From*>::SimpleType SimpleType; 192 193 static SimpleType getSimplifiedValue(const UseTy<From> &Val) { 194 return (SimpleType)Val.get(); 195 } 196}; 197 198// isa - Provide some specializations of isa so that we don't have to include 199// the subtype header files to test to see if the value is a subclass... 200// 201template <> inline bool isa_impl<Type, Value>(const Value &Val) { 202 return Val.getValueType() == Value::TypeVal; 203} 204template <> inline bool isa_impl<Constant, Value>(const Value &Val) { 205 return Val.getValueType() == Value::ConstantVal; 206} 207template <> inline bool isa_impl<Argument, Value>(const Value &Val) { 208 return Val.getValueType() == Value::ArgumentVal; 209} 210template <> inline bool isa_impl<Instruction, Value>(const Value &Val) { 211 return Val.getValueType() == Value::InstructionVal; 212} 213template <> inline bool isa_impl<BasicBlock, Value>(const Value &Val) { 214 return Val.getValueType() == Value::BasicBlockVal; 215} 216template <> inline bool isa_impl<Function, Value>(const Value &Val) { 217 return Val.getValueType() == Value::FunctionVal; 218} 219template <> inline bool isa_impl<GlobalVariable, Value>(const Value &Val) { 220 return Val.getValueType() == Value::GlobalVariableVal; 221} 222template <> inline bool isa_impl<GlobalValue, Value>(const Value &Val) { 223 return isa<GlobalVariable>(Val) || isa<Function>(Val); 224} 225 226#endif 227