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