/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/IR/Constant.h
Line | Count | Source |
1 | | //===-- llvm/Constant.h - Constant class definition -------------*- C++ -*-===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // This file contains the declaration of the Constant class. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #ifndef LLVM_IR_CONSTANT_H |
15 | | #define LLVM_IR_CONSTANT_H |
16 | | |
17 | | #include "llvm/IR/User.h" |
18 | | #include "llvm/IR/Value.h" |
19 | | #include "llvm/Support/Casting.h" |
20 | | |
21 | | namespace llvm { |
22 | | |
23 | | class APInt; |
24 | | |
25 | | /// This is an important base class in LLVM. It provides the common facilities |
26 | | /// of all constant values in an LLVM program. A constant is a value that is |
27 | | /// immutable at runtime. Functions are constants because their address is |
28 | | /// immutable. Same with global variables. |
29 | | /// |
30 | | /// All constants share the capabilities provided in this class. All constants |
31 | | /// can have a null value. They can have an operand list. Constants can be |
32 | | /// simple (integer and floating point values), complex (arrays and structures), |
33 | | /// or expression based (computations yielding a constant value composed of |
34 | | /// only certain operators and other constant values). |
35 | | /// |
36 | | /// Note that Constants are immutable (once created they never change) |
37 | | /// and are fully shared by structural equivalence. This means that two |
38 | | /// structurally equivalent constants will always have the same address. |
39 | | /// Constants are created on demand as needed and never deleted: thus clients |
40 | | /// don't have to worry about the lifetime of the objects. |
41 | | /// @brief LLVM Constant Representation |
42 | | class Constant : public User { |
43 | | protected: |
44 | | Constant(Type *ty, ValueTy vty, Use *Ops, unsigned NumOps) |
45 | 10.6M | : User(ty, vty, Ops, NumOps) {} |
46 | | |
47 | | public: |
48 | | void operator=(const Constant &) = delete; |
49 | | Constant(const Constant &) = delete; |
50 | | |
51 | | /// Return true if this is the value that would be returned by getNullValue. |
52 | | bool isNullValue() const; |
53 | | |
54 | | /// Returns true if the value is one. |
55 | | bool isOneValue() const; |
56 | | |
57 | | /// Return true if this is the value that would be returned by |
58 | | /// getAllOnesValue. |
59 | | bool isAllOnesValue() const; |
60 | | |
61 | | /// Return true if the value is what would be returned by |
62 | | /// getZeroValueForNegation. |
63 | | bool isNegativeZeroValue() const; |
64 | | |
65 | | /// Return true if the value is negative zero or null value. |
66 | | bool isZeroValue() const; |
67 | | |
68 | | /// Return true if the value is not the smallest signed value. |
69 | | bool isNotMinSignedValue() const; |
70 | | |
71 | | /// Return true if the value is the smallest signed value. |
72 | | bool isMinSignedValue() const; |
73 | | |
74 | | /// Return true if evaluation of this constant could trap. This is true for |
75 | | /// things like constant expressions that could divide by zero. |
76 | | bool canTrap() const; |
77 | | |
78 | | /// Return true if the value can vary between threads. |
79 | | bool isThreadDependent() const; |
80 | | |
81 | | /// Return true if the value is dependent on a dllimport variable. |
82 | | bool isDLLImportDependent() const; |
83 | | |
84 | | /// Return true if the constant has users other than constant expressions and |
85 | | /// other dangling things. |
86 | | bool isConstantUsed() const; |
87 | | |
88 | | /// This method classifies the entry according to whether or not it may |
89 | | /// generate a relocation entry. This must be conservative, so if it might |
90 | | /// codegen to a relocatable entry, it should say so. |
91 | | /// |
92 | | /// FIXME: This really should not be in IR. |
93 | | bool needsRelocation() const; |
94 | | |
95 | | /// For aggregates (struct/array/vector) return the constant that corresponds |
96 | | /// to the specified element if possible, or null if not. This can return null |
97 | | /// if the element index is a ConstantExpr, or if 'this' is a constant expr. |
98 | | Constant *getAggregateElement(unsigned Elt) const; |
99 | | Constant *getAggregateElement(Constant *Elt) const; |
100 | | |
101 | | /// If this is a splat vector constant, meaning that all of the elements have |
102 | | /// the same value, return that value. Otherwise return 0. |
103 | | Constant *getSplatValue() const; |
104 | | |
105 | | /// If C is a constant integer then return its value, otherwise C must be a |
106 | | /// vector of constant integers, all equal, and the common value is returned. |
107 | | const APInt &getUniqueInteger() const; |
108 | | |
109 | | /// Called if some element of this constant is no longer valid. |
110 | | /// At this point only other constants may be on the use_list for this |
111 | | /// constant. Any constants on our Use list must also be destroy'd. The |
112 | | /// implementation must be sure to remove the constant from the list of |
113 | | /// available cached constants. Implementations should implement |
114 | | /// destroyConstantImpl to remove constants from any pools/maps they are |
115 | | /// contained it. |
116 | | void destroyConstant(); |
117 | | |
118 | | //// Methods for support type inquiry through isa, cast, and dyn_cast: |
119 | 40.8M | static bool classof(const Value *V) { |
120 | 40.8M | return V->getValueID() >= ConstantFirstVal && |
121 | 40.8M | V->getValueID() <= ConstantLastVal; |
122 | 40.8M | } |
123 | | |
124 | | /// This method is a special form of User::replaceUsesOfWith |
125 | | /// (which does not work on constants) that does work |
126 | | /// on constants. Basically this method goes through the trouble of building |
127 | | /// a new constant that is equivalent to the current one, with all uses of |
128 | | /// From replaced with uses of To. After this construction is completed, all |
129 | | /// of the users of 'this' are replaced to use the new constant, and then |
130 | | /// 'this' is deleted. In general, you should not call this method, instead, |
131 | | /// use Value::replaceAllUsesWith, which automatically dispatches to this |
132 | | /// method as needed. |
133 | | /// |
134 | | void handleOperandChange(Value *, Value *); |
135 | | |
136 | | static Constant *getNullValue(Type* Ty); |
137 | | |
138 | | /// @returns the value for an integer or vector of integer constant of the |
139 | | /// given type that has all its bits set to true. |
140 | | /// @brief Get the all ones value |
141 | | static Constant *getAllOnesValue(Type* Ty); |
142 | | |
143 | | /// Return the value for an integer or pointer constant, or a vector thereof, |
144 | | /// with the given scalar value. |
145 | | static Constant *getIntegerValue(Type *Ty, const APInt &V); |
146 | | |
147 | | /// If there are any dead constant users dangling off of this constant, remove |
148 | | /// them. This method is useful for clients that want to check to see if a |
149 | | /// global is unused, but don't want to deal with potentially dead constants |
150 | | /// hanging off of the globals. |
151 | | void removeDeadConstantUsers() const; |
152 | | |
153 | 21.4M | const Constant *stripPointerCasts() const { |
154 | 21.4M | return cast<Constant>(Value::stripPointerCasts()); |
155 | 21.4M | } |
156 | | |
157 | 21.4M | Constant *stripPointerCasts() { |
158 | 21.4M | return const_cast<Constant*>( |
159 | 21.4M | static_cast<const Constant *>(this)->stripPointerCasts()); |
160 | 21.4M | } |
161 | | }; |
162 | | |
163 | | } // end namespace llvm |
164 | | |
165 | | #endif // LLVM_IR_CONSTANT_H |