Line data Source code
1 : //===- ConstantFolder.h - Constant folding helper ---------------*- 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 defines the ConstantFolder class, a helper for IRBuilder.
11 : // It provides IRBuilder with a set of methods for creating constants
12 : // with minimal folding. For general constant creation and folding,
13 : // use ConstantExpr and the routines in llvm/Analysis/ConstantFolding.h.
14 : //
15 : //===----------------------------------------------------------------------===//
16 :
17 : #ifndef LLVM_IR_CONSTANTFOLDER_H
18 : #define LLVM_IR_CONSTANTFOLDER_H
19 :
20 : #include "llvm/ADT/ArrayRef.h"
21 : #include "llvm/IR/Constants.h"
22 : #include "llvm/IR/InstrTypes.h"
23 : #include "llvm/IR/Instruction.h"
24 :
25 : namespace llvm {
26 :
27 : /// ConstantFolder - Create constants with minimum, target independent, folding.
28 : class ConstantFolder {
29 : public:
30 : explicit ConstantFolder() = default;
31 :
32 : //===--------------------------------------------------------------------===//
33 : // Binary Operators
34 : //===--------------------------------------------------------------------===//
35 :
36 : Constant *CreateAdd(Constant *LHS, Constant *RHS,
37 : bool HasNUW = false, bool HasNSW = false) const {
38 30425 : return ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW);
39 : }
40 :
41 : Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
42 : return ConstantExpr::getFAdd(LHS, RHS);
43 : }
44 :
45 : Constant *CreateSub(Constant *LHS, Constant *RHS,
46 : bool HasNUW = false, bool HasNSW = false) const {
47 88765 : return ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW);
48 : }
49 :
50 : Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
51 : return ConstantExpr::getFSub(LHS, RHS);
52 : }
53 :
54 : Constant *CreateMul(Constant *LHS, Constant *RHS,
55 : bool HasNUW = false, bool HasNSW = false) const {
56 8759 : return ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW);
57 : }
58 :
59 : Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
60 : return ConstantExpr::getFMul(LHS, RHS);
61 : }
62 :
63 : Constant *CreateUDiv(Constant *LHS, Constant *RHS,
64 : bool isExact = false) const {
65 11716 : return ConstantExpr::getUDiv(LHS, RHS, isExact);
66 : }
67 :
68 : Constant *CreateSDiv(Constant *LHS, Constant *RHS,
69 : bool isExact = false) const {
70 21142 : return ConstantExpr::getSDiv(LHS, RHS, isExact);
71 : }
72 :
73 : Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
74 : return ConstantExpr::getFDiv(LHS, RHS);
75 : }
76 :
77 : Constant *CreateURem(Constant *LHS, Constant *RHS) const {
78 : return ConstantExpr::getURem(LHS, RHS);
79 : }
80 :
81 : Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
82 : return ConstantExpr::getSRem(LHS, RHS);
83 : }
84 :
85 : Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
86 : return ConstantExpr::getFRem(LHS, RHS);
87 : }
88 :
89 : Constant *CreateShl(Constant *LHS, Constant *RHS,
90 : bool HasNUW = false, bool HasNSW = false) const {
91 2016 : return ConstantExpr::getShl(LHS, RHS, HasNUW, HasNSW);
92 : }
93 :
94 : Constant *CreateLShr(Constant *LHS, Constant *RHS,
95 : bool isExact = false) const {
96 139 : return ConstantExpr::getLShr(LHS, RHS, isExact);
97 : }
98 :
99 : Constant *CreateAShr(Constant *LHS, Constant *RHS,
100 : bool isExact = false) const {
101 585 : return ConstantExpr::getAShr(LHS, RHS, isExact);
102 : }
103 :
104 0 : Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
105 1533 : return ConstantExpr::getAnd(LHS, RHS);
106 : }
107 :
108 0 : Constant *CreateOr(Constant *LHS, Constant *RHS) const {
109 2738 : return ConstantExpr::getOr(LHS, RHS);
110 : }
111 :
112 : Constant *CreateXor(Constant *LHS, Constant *RHS) const {
113 : return ConstantExpr::getXor(LHS, RHS);
114 : }
115 :
116 0 : Constant *CreateBinOp(Instruction::BinaryOps Opc,
117 : Constant *LHS, Constant *RHS) const {
118 0 : return ConstantExpr::get(Opc, LHS, RHS);
119 : }
120 :
121 : //===--------------------------------------------------------------------===//
122 : // Unary Operators
123 : //===--------------------------------------------------------------------===//
124 :
125 : Constant *CreateNeg(Constant *C,
126 : bool HasNUW = false, bool HasNSW = false) const {
127 3516 : return ConstantExpr::getNeg(C, HasNUW, HasNSW);
128 : }
129 :
130 0 : Constant *CreateFNeg(Constant *C) const {
131 12 : return ConstantExpr::getFNeg(C);
132 : }
133 :
134 0 : Constant *CreateNot(Constant *C) const {
135 9293 : return ConstantExpr::getNot(C);
136 : }
137 :
138 : //===--------------------------------------------------------------------===//
139 : // Memory Instructions
140 : //===--------------------------------------------------------------------===//
141 :
142 : Constant *CreateGetElementPtr(Type *Ty, Constant *C,
143 : ArrayRef<Constant *> IdxList) const {
144 : return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
145 : }
146 :
147 0 : Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
148 : // This form of the function only exists to avoid ambiguous overload
149 : // warnings about whether to convert Idx to ArrayRef<Constant *> or
150 : // ArrayRef<Value *>.
151 399 : return ConstantExpr::getGetElementPtr(Ty, C, Idx);
152 : }
153 :
154 0 : Constant *CreateGetElementPtr(Type *Ty, Constant *C,
155 : ArrayRef<Value *> IdxList) const {
156 375 : return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
157 : }
158 :
159 : Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
160 : ArrayRef<Constant *> IdxList) const {
161 : return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
162 : }
163 :
164 0 : Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
165 : Constant *Idx) const {
166 : // This form of the function only exists to avoid ambiguous overload
167 : // warnings about whether to convert Idx to ArrayRef<Constant *> or
168 : // ArrayRef<Value *>.
169 0 : return ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx);
170 : }
171 :
172 0 : Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
173 : ArrayRef<Value *> IdxList) const {
174 829255 : return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
175 : }
176 :
177 : //===--------------------------------------------------------------------===//
178 : // Cast/Conversion Operators
179 : //===--------------------------------------------------------------------===//
180 :
181 0 : Constant *CreateCast(Instruction::CastOps Op, Constant *C,
182 : Type *DestTy) const {
183 264325 : return ConstantExpr::getCast(Op, C, DestTy);
184 : }
185 :
186 0 : Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
187 3365 : return ConstantExpr::getPointerCast(C, DestTy);
188 : }
189 :
190 0 : Constant *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
191 : Type *DestTy) const {
192 992 : return ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy);
193 : }
194 :
195 : Constant *CreateIntCast(Constant *C, Type *DestTy,
196 : bool isSigned) const {
197 531180 : return ConstantExpr::getIntegerCast(C, DestTy, isSigned);
198 : }
199 :
200 0 : Constant *CreateFPCast(Constant *C, Type *DestTy) const {
201 0 : return ConstantExpr::getFPCast(C, DestTy);
202 : }
203 :
204 0 : Constant *CreateBitCast(Constant *C, Type *DestTy) const {
205 0 : return CreateCast(Instruction::BitCast, C, DestTy);
206 : }
207 :
208 0 : Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
209 0 : return CreateCast(Instruction::IntToPtr, C, DestTy);
210 : }
211 :
212 0 : Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
213 0 : return CreateCast(Instruction::PtrToInt, C, DestTy);
214 : }
215 :
216 0 : Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
217 143 : return ConstantExpr::getZExtOrBitCast(C, DestTy);
218 : }
219 :
220 0 : Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
221 0 : return ConstantExpr::getSExtOrBitCast(C, DestTy);
222 : }
223 :
224 0 : Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
225 66 : return ConstantExpr::getTruncOrBitCast(C, DestTy);
226 : }
227 :
228 : //===--------------------------------------------------------------------===//
229 : // Compare Instructions
230 : //===--------------------------------------------------------------------===//
231 :
232 0 : Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
233 : Constant *RHS) const {
234 4706 : return ConstantExpr::getCompare(P, LHS, RHS);
235 : }
236 :
237 0 : Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
238 : Constant *RHS) const {
239 37 : return ConstantExpr::getCompare(P, LHS, RHS);
240 : }
241 :
242 : //===--------------------------------------------------------------------===//
243 : // Other Instructions
244 : //===--------------------------------------------------------------------===//
245 :
246 0 : Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
247 95 : return ConstantExpr::getSelect(C, True, False);
248 : }
249 :
250 0 : Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
251 223 : return ConstantExpr::getExtractElement(Vec, Idx);
252 : }
253 :
254 0 : Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
255 : Constant *Idx) const {
256 200313 : return ConstantExpr::getInsertElement(Vec, NewElt, Idx);
257 : }
258 :
259 0 : Constant *CreateShuffleVector(Constant *V1, Constant *V2,
260 : Constant *Mask) const {
261 3137 : return ConstantExpr::getShuffleVector(V1, V2, Mask);
262 : }
263 :
264 0 : Constant *CreateExtractValue(Constant *Agg,
265 : ArrayRef<unsigned> IdxList) const {
266 310 : return ConstantExpr::getExtractValue(Agg, IdxList);
267 : }
268 :
269 0 : Constant *CreateInsertValue(Constant *Agg, Constant *Val,
270 : ArrayRef<unsigned> IdxList) const {
271 46 : return ConstantExpr::getInsertValue(Agg, Val, IdxList);
272 : }
273 : };
274 :
275 : } // end namespace llvm
276 :
277 : #endif // LLVM_IR_CONSTANTFOLDER_H
|
