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