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