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