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 inline const Type *getType() const { return Ty; }
61 // All values can potentially be named...
62 inline bool hasName() const { return Name != ""; }
63 inline const string &getName() const { return Name; }
64 virtual void setName(const string &name, SymbolTable * = 0) { Name = name; }
66 // Methods for determining the subtype of this Value. The getValueType()
67 // method returns the type of the value directly. The cast*() methods are
68 // equilivent to using dynamic_cast<>... if the cast is successful, this is
69 // returned, otherwise you get a null pointer, allowing expressions like this:
71 // if (Instruction *I = Val->castInstruction()) { ... }
73 // This section also defines a family of isType, isConstant, isMethodArgument,
76 // The family of functions Val->cast<type>Asserting() is used in the same
77 // way as the Val->cast<type>() instructions, but they assert the expected
78 // type instead of checking it at runtime.
80 inline ValueTy getValueType() const { return VTy; }
82 // Use a macro to define the functions, otherwise these definitions are just
83 // really long and ugly.
84 #define CAST_FN(NAME, CLASS) \
85 inline bool is##NAME() const { return VTy == NAME##Val; } \
86 inline const CLASS *cast##NAME() const { /*const version */ \
87 return is##NAME() ? (const CLASS*)this : 0; \
89 inline CLASS *cast##NAME() { /* nonconst version */ \
90 return is##NAME() ? (CLASS*)this : 0; \
92 inline const CLASS *cast##NAME##Asserting() const { /*const version */ \
93 assert(is##NAME() && "Expected Value Type: " #NAME); \
94 return (const CLASS*)this; \
96 inline CLASS *cast##NAME##Asserting() { /* nonconst version */ \
97 assert(is##NAME() && "Expected Value Type: " #NAME); \
98 return (CLASS*)this; \
101 CAST_FN(Constant , ConstPoolVal )
102 CAST_FN(MethodArgument, MethodArgument)
103 CAST_FN(Instruction , Instruction )
104 CAST_FN(BasicBlock , BasicBlock )
105 CAST_FN(Method , Method )
106 CAST_FN(Global , GlobalVariable)
107 CAST_FN(Module , Module )
110 // Type value is special, because there is no nonconst version of functions!
111 inline bool isType() const { return VTy == TypeVal; }
112 inline const Type *castType() const {
113 return (VTy == TypeVal) ? (const Type*)this : 0;
115 inline const Type *castTypeAsserting() const {
116 assert(isType() && "Expected Value Type: Type");
117 return (const Type*)this;
120 // replaceAllUsesWith - Go through the uses list for this definition and make
121 // each use point to "D" instead of "this". After this completes, 'this's
122 // use list should be empty.
124 void replaceAllUsesWith(Value *D);
126 // refineAbstractType - This function is implemented because we use
127 // potentially abstract types, and these types may be resolved to more
128 // concrete types after we are constructed.
130 virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
132 //----------------------------------------------------------------------
133 // Methods for handling the vector of uses of this Value.
135 typedef vector<User*>::iterator use_iterator;
136 typedef vector<User*>::const_iterator use_const_iterator;
138 inline unsigned use_size() const { return Uses.size(); }
139 inline bool use_empty() const { return Uses.empty(); }
140 inline use_iterator use_begin() { return Uses.begin(); }
141 inline use_const_iterator use_begin() const { return Uses.begin(); }
142 inline use_iterator use_end() { return Uses.end(); }
143 inline use_const_iterator use_end() const { return Uses.end(); }
145 inline void use_push_back(User *I) { Uses.push_back(I); }
146 User *use_remove(use_iterator &I);
148 inline void addUse(User *I) { Uses.push_back(I); }
149 void killUse(User *I);
152 // UseTy and it's friendly typedefs (Use) are here to make keeping the "use"
153 // list of a definition node up-to-date really easy.
155 template<class ValueSubclass>
160 inline UseTy<ValueSubclass>(ValueSubclass *v, User *user) {
162 if (Val) Val->addUse(U);
165 inline ~UseTy<ValueSubclass>() { if (Val) Val->killUse(U); }
167 inline operator ValueSubclass *() const { return Val; }
169 inline UseTy<ValueSubclass>(const UseTy<ValueSubclass> &user) {
174 inline ValueSubclass *operator=(ValueSubclass *V) {
175 if (Val) Val->killUse(U);
181 inline ValueSubclass *operator->() { return Val; }
182 inline const ValueSubclass *operator->() const { return Val; }
184 inline UseTy<ValueSubclass> &operator=(const UseTy<ValueSubclass> &user) {
185 if (Val) Val->killUse(U);
192 typedef UseTy<Value> Use;