255105f28801ebdc749bc4cc7e4cb9b07182bd46
[oota-llvm.git] / include / llvm / Value.h
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 Def, Method, Module, Type, etc...
5 //
6 // This file also defines the Use<> template for users of value.
7 //
8 // This file also defines the isa<X>(), cast<X>(), and dyn_cast<X>() templates.
9 //
10 //===----------------------------------------------------------------------===//
11
12 #ifndef LLVM_VALUE_H
13 #define LLVM_VALUE_H
14
15 #include <vector>
16 #include "llvm/Annotation.h"
17 #include "llvm/AbstractTypeUser.h"
18
19 class User;
20 class Type;
21 class ConstPoolVal;
22 class MethodArgument;
23 class Instruction;
24 class BasicBlock;
25 class GlobalValue;
26 class Method;
27 class GlobalVariable;
28 class Module;
29 class SymbolTable;
30 template<class ValueSubclass, class ItemParentType, class SymTabType> 
31   class ValueHolder;
32
33 //===----------------------------------------------------------------------===//
34 //                                 Value Class
35 //===----------------------------------------------------------------------===//
36
37 class Value : public Annotable,         // Values are annotable
38               public AbstractTypeUser { // Values use potentially abstract types
39 public:
40   enum ValueTy {
41     TypeVal,                // This is an instance of Type
42     ConstantVal,            // This is an instance of ConstPoolVal
43     MethodArgumentVal,      // This is an instance of MethodArgument
44     InstructionVal,         // This is an instance of Instruction
45     BasicBlockVal,          // This is an instance of BasicBlock
46     MethodVal,              // This is an instance of Method
47     GlobalVariableVal,      // This is an instance of GlobalVariable
48     ModuleVal,              // This is an instance of Module
49   };
50
51 private:
52   vector<User *> Uses;
53   string Name;
54   PATypeHandle<Type> Ty;
55   ValueTy VTy;
56
57   Value(const Value &);              // Do not implement
58 protected:
59   inline void setType(const Type *ty) { Ty = ty; }
60 public:
61   Value(const Type *Ty, ValueTy vty, const string &name = "");
62   virtual ~Value();
63   
64   // Support for debugging 
65   void dump() const;
66   
67   // All values can potentially be typed
68   inline const Type *getType() const { return Ty; }
69   
70   // All values can potentially be named...
71   inline bool          hasName() const { return Name != ""; }
72   inline const string &getName() const { return Name; }
73
74   virtual void setName(const string &name, SymbolTable * = 0) {
75     Name = name;
76   }
77   
78   // Methods for determining the subtype of this Value.  The getValueType()
79   // method returns the type of the value directly.  The cast*() methods are
80   // equivalent to using dynamic_cast<>... if the cast is successful, this is
81   // returned, otherwise you get a null pointer.
82   //
83   // The family of functions Val->cast<type>Asserting() is used in the same
84   // way as the Val->cast<type>() instructions, but they assert the expected
85   // type instead of checking it at runtime.
86   //
87   inline ValueTy getValueType() const { return VTy; }
88   
89   // replaceAllUsesWith - Go through the uses list for this definition and make
90   // each use point to "D" instead of "this".  After this completes, 'this's 
91   // use list should be empty.
92   //
93   void replaceAllUsesWith(Value *D);
94
95   // refineAbstractType - This function is implemented because we use
96   // potentially abstract types, and these types may be resolved to more
97   // concrete types after we are constructed.
98   //
99   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
100   
101   //----------------------------------------------------------------------
102   // Methods for handling the vector of uses of this Value.
103   //
104   typedef vector<User*>::iterator       use_iterator;
105   typedef vector<User*>::const_iterator use_const_iterator;
106
107   inline unsigned           use_size()  const { return Uses.size();  }
108   inline bool               use_empty() const { return Uses.empty(); }
109   inline use_iterator       use_begin()       { return Uses.begin(); }
110   inline use_const_iterator use_begin() const { return Uses.begin(); }
111   inline use_iterator       use_end()         { return Uses.end();   }
112   inline use_const_iterator use_end()   const { return Uses.end();   }
113
114   inline void use_push_back(User *I)   { Uses.push_back(I); }
115   User *use_remove(use_iterator &I);
116
117   inline void addUse(User *I)      { Uses.push_back(I); }
118   void killUse(User *I);
119 };
120
121
122 //===----------------------------------------------------------------------===//
123 //                                 UseTy Class
124 //===----------------------------------------------------------------------===//
125
126 // UseTy and it's friendly typedefs (Use) are here to make keeping the "use" 
127 // list of a definition node up-to-date really easy.
128 //
129 template<class ValueSubclass>
130 class UseTy {
131   ValueSubclass *Val;
132   User *U;
133 public:
134   inline UseTy<ValueSubclass>(ValueSubclass *v, User *user) {
135     Val = v; U = user;
136     if (Val) Val->addUse(U);
137   }
138
139   inline ~UseTy<ValueSubclass>() { if (Val) Val->killUse(U); }
140
141   inline operator ValueSubclass *() const { return Val; }
142
143   inline UseTy<ValueSubclass>(const UseTy<ValueSubclass> &user) {
144     Val = 0;
145     U = user.U;
146     operator=(user.Val);
147   }
148   inline ValueSubclass *operator=(ValueSubclass *V) { 
149     if (Val) Val->killUse(U);
150     Val = V;
151     if (V) V->addUse(U);
152     return V;
153   }
154
155   inline       ValueSubclass *operator->()       { return Val; }
156   inline const ValueSubclass *operator->() const { return Val; }
157
158   inline       ValueSubclass *get()       { return Val; }
159   inline const ValueSubclass *get() const { return Val; }
160
161   inline UseTy<ValueSubclass> &operator=(const UseTy<ValueSubclass> &user) {
162     if (Val) Val->killUse(U);
163     Val = user.Val;
164     Val->addUse(U);
165     return *this;
166   }
167 };
168
169 typedef UseTy<Value> Use;    // Provide Use as a common UseTy type
170
171 // real_type - Provide a macro to get the real type of a value that might be 
172 // a use.  This provides a typedef 'Type' that is the argument type for all
173 // non UseTy types, and is the contained pointer type of the use if it is a
174 // UseTy.
175 //
176 template <class X> class real_type { typedef X Type; };
177 template <class X> class real_type <class UseTy<X> > { typedef X *Type; };
178
179 //===----------------------------------------------------------------------===//
180 //                          Type Checking Templates
181 //===----------------------------------------------------------------------===//
182
183 // isa<X> - Return true if the parameter to the template is an instance of the
184 // template type argument.  Used like this:
185 //
186 //  if (isa<Type>(myVal)) { ... }
187 //
188 template <class X, class Y>
189 inline bool isa(Y Val) { return X::classof(Val); }
190
191
192 // cast<X> - Return the argument parameter cast to the specified type.  This
193 // casting operator asserts that the type is correct, so it does not return null
194 // on failure.  Used Like this:
195 //
196 //  cast<      Instruction>(myVal)->getParent()
197 //  cast<const Instruction>(myVal)->getParent()
198 //
199 template <class X, class Y>
200 inline X *cast(Y Val) {
201   assert(isa<X>(Val) && "Invalid cast argument type!");
202   return (X*)(real_type<Y>::Type)Val;
203 }
204
205
206 // dyn_cast<X> - Return the argument parameter cast to the specified type.  This
207 // casting operator returns null if the argument is of the wrong type, so it can
208 // be used to test for a type as well as cast if successful.  This should be
209 // used in the context of an if statement like this:
210 //
211 //  if (const Instruction *I = dyn_cast<const Instruction>(myVal)) { ... }
212 //
213
214 template <class X, class Y>
215 inline X *dyn_cast(Y Val) {
216   return isa<X>(Val) ? cast<X>(Val) : 0;
217 }
218
219
220 // isa - Provide some specializations of isa so that we have to include the
221 // subtype header files to test to see if the value is a subclass...
222 //
223 template <> inline bool isa<Type, const Value*>(const Value *Val) { 
224   return Val->getValueType() == Value::TypeVal;
225 }
226 template <> inline bool isa<Type, Value*>(Value *Val) { 
227   return Val->getValueType() == Value::TypeVal;
228 }
229 template <> inline bool isa<ConstPoolVal, const Value*>(const Value *Val) { 
230   return Val->getValueType() == Value::ConstantVal; 
231 }
232 template <> inline bool isa<ConstPoolVal, Value*>(Value *Val) { 
233   return Val->getValueType() == Value::ConstantVal; 
234 }
235 template <> inline bool isa<MethodArgument, const Value*>(const Value *Val) { 
236   return Val->getValueType() == Value::MethodArgumentVal;
237 }
238 template <> inline bool isa<MethodArgument, Value*>(Value *Val) { 
239   return Val->getValueType() == Value::MethodArgumentVal;
240 }
241 template <> inline bool isa<Instruction, const Value*>(const Value *Val) { 
242   return Val->getValueType() == Value::InstructionVal;
243 }
244 template <> inline bool isa<Instruction, Value*>(Value *Val) { 
245   return Val->getValueType() == Value::InstructionVal;
246 }
247 template <> inline bool isa<BasicBlock, const Value*>(const Value *Val) { 
248   return Val->getValueType() == Value::BasicBlockVal;
249 }
250 template <> inline bool isa<BasicBlock, Value*>(Value *Val) { 
251   return Val->getValueType() == Value::BasicBlockVal;
252 }
253 template <> inline bool isa<Method, const Value*>(const Value *Val) { 
254   return Val->getValueType() == Value::MethodVal;
255 }
256 template <> inline bool isa<Method, Value*>(Value *Val) { 
257   return Val->getValueType() == Value::MethodVal;
258 }
259 template <> inline bool isa<GlobalVariable, const Value*>(const Value *Val) { 
260   return Val->getValueType() == Value::GlobalVariableVal;
261 }
262 template <> inline bool isa<GlobalVariable, Value*>(Value *Val) { 
263   return Val->getValueType() == Value::GlobalVariableVal;
264 }
265 template <> inline bool isa<GlobalValue, const Value*>(const Value *Val) { 
266   return isa<GlobalVariable>(Val) || isa<Method>(Val);
267 }
268 template <> inline bool isa<GlobalValue, Value*>(Value *Val) { 
269   return isa<GlobalVariable>(Val) || isa<Method>(Val);
270 }
271 template <> inline bool isa<Module, const Value*>(const Value *Val) { 
272   return Val->getValueType() == Value::ModuleVal;
273 }
274 template <> inline bool isa<Module, Value*>(Value *Val) { 
275   return Val->getValueType() == Value::ModuleVal;
276 }
277
278 #endif