1 //===-- llvm/Value.h - Definition of the Value class -------------*- C++ -*--=//
3 // This file defines the very important Value class. This is subclassed by a
4 // bunch of other important classes, like Def, Method, Module, Type, etc...
6 //===----------------------------------------------------------------------===//
12 #include "llvm/Annotation.h"
13 #include "llvm/AbstractTypeUser.h"
25 template<class ValueSubclass, class ItemParentType, class SymTabType>
28 //===----------------------------------------------------------------------===//
30 //===----------------------------------------------------------------------===//
32 class Value : public Annotable, // Values are annotable
33 public AbstractTypeUser { // Values use potentially abstract types
36 TypeVal, // This is an instance of Type
37 ConstantVal, // This is an instance of ConstPoolVal
38 MethodArgumentVal, // This is an instance of MethodArgument
39 InstructionVal, // This is an instance of Instruction
40 BasicBlockVal, // This is an instance of BasicBlock
41 MethodVal, // This is an instance of Method
42 GlobalVal, // This is an instance of GlobalVariable
43 ModuleVal, // This is an instance of Module
49 PATypeHandle<Type> Ty;
52 Value(const Value &); // Do not implement
54 inline void setType(const Type *ty) { Ty = ty; }
56 Value(const Type *Ty, ValueTy vty, const string &name = "");
59 // Support for debugging
62 // All values can potentially be typed
63 inline const Type* getType() const { return Ty; }
65 // All values can potentially be named...
66 inline bool hasName() const { return Name != ""; }
67 inline const string& getName() const { return Name; }
68 virtual void setName(const string &name, SymbolTable * = 0)
71 // Methods for determining the subtype of this Value. The getValueType()
72 // method returns the type of the value directly. The cast*() methods are
73 // equivalent to using dynamic_cast<>... if the cast is successful, this is
74 // returned, otherwise you get a null pointer, allowing expressions like:
76 // if (Instruction *I = Val->castInstruction()) { ... }
78 // This section also defines a family of isType, isConstant,
79 // isMethodArgument, etc functions...
81 // The family of functions Val->cast<type>Asserting() is used in the same
82 // way as the Val->cast<type>() instructions, but they assert the expected
83 // type instead of checking it at runtime.
85 inline ValueTy getValueType() const { return VTy; }
87 // Use a macro to define the functions, otherwise these definitions are just
88 // really long and ugly.
89 #define CAST_FN(NAME, CLASS) \
90 inline bool is##NAME() const { return VTy == NAME##Val; } \
91 inline const CLASS *cast##NAME() const { /*const version */ \
92 return is##NAME() ? (const CLASS*)this : 0; \
94 inline CLASS *cast##NAME() { /* nonconst version */ \
95 return is##NAME() ? (CLASS*)this : 0; \
97 inline const CLASS *cast##NAME##Asserting() const { /*const version */ \
98 assert(is##NAME() && "Expected Value Type: " #NAME); \
99 return (const CLASS*)this; \
101 inline CLASS *cast##NAME##Asserting() { /* nonconst version */ \
102 assert(is##NAME() && "Expected Value Type: " #NAME); \
103 return (CLASS*)this; \
106 CAST_FN(Constant , ConstPoolVal )
107 CAST_FN(MethodArgument, MethodArgument)
108 CAST_FN(Instruction , Instruction )
109 CAST_FN(BasicBlock , BasicBlock )
110 CAST_FN(Method , Method )
111 CAST_FN(Global , GlobalVariable)
112 CAST_FN(Module , Module )
115 // Type value is special, because there is no nonconst version of functions!
116 inline bool isType() const { return VTy == TypeVal; }
117 inline const Type *castType() const {
118 return (VTy == TypeVal) ? (const Type*)this : 0;
120 inline const Type *castTypeAsserting() const {
121 assert(isType() && "Expected Value Type: Type");
122 return (const Type*)this;
125 // replaceAllUsesWith - Go through the uses list for this definition and make
126 // each use point to "D" instead of "this". After this completes, 'this's
127 // use list should be empty.
129 void replaceAllUsesWith(Value *D);
131 // refineAbstractType - This function is implemented because we use
132 // potentially abstract types, and these types may be resolved to more
133 // concrete types after we are constructed.
135 virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
137 //----------------------------------------------------------------------
138 // Methods for handling the vector of uses of this Value.
140 typedef vector<User*>::iterator use_iterator;
141 typedef vector<User*>::const_iterator use_const_iterator;
143 inline unsigned use_size() const { return Uses.size(); }
144 inline bool use_empty() const { return Uses.empty(); }
145 inline use_iterator use_begin() { return Uses.begin(); }
146 inline use_const_iterator use_begin() const { return Uses.begin(); }
147 inline use_iterator use_end() { return Uses.end(); }
148 inline use_const_iterator use_end() const { return Uses.end(); }
150 inline void use_push_back(User *I) { Uses.push_back(I); }
151 User *use_remove(use_iterator &I);
153 inline void addUse(User *I) { Uses.push_back(I); }
154 void killUse(User *I);
157 // UseTy and it's friendly typedefs (Use) are here to make keeping the "use"
158 // list of a definition node up-to-date really easy.
160 template<class ValueSubclass>
165 inline UseTy<ValueSubclass>(ValueSubclass *v, User *user) {
167 if (Val) Val->addUse(U);
170 inline ~UseTy<ValueSubclass>() { if (Val) Val->killUse(U); }
172 inline operator ValueSubclass *() const { return Val; }
174 inline UseTy<ValueSubclass>(const UseTy<ValueSubclass> &user) {
179 inline ValueSubclass *operator=(ValueSubclass *V) {
180 if (Val) Val->killUse(U);
186 inline ValueSubclass *operator->() { return Val; }
187 inline const ValueSubclass *operator->() const { return Val; }
189 inline UseTy<ValueSubclass> &operator=(const UseTy<ValueSubclass> &user) {
190 if (Val) Val->killUse(U);
197 typedef UseTy<Value> Use;
199 //----------------------------------------------------------------------
200 // Debugging support for class Value and its subclasses.
203 void DebugValue (const Value* V);
204 void DebugValue (const Value& V);
206 ostream& operator<< (ostream &o, const Value& I);