1 //===- NoFolder.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 NoFolder class, a helper for IRBuilder.  It provides
11 // IRBuilder with a set of methods for creating unfolded constants.  This is
12 // useful for learners trying to understand how LLVM IR works, and who don't
13 // want details to be hidden by the constant folder.  For general constant
14 // creation and folding, use ConstantExpr and the routines in
15 // llvm/Analysis/ConstantFolding.h.
16 //
17 // Note: since it is not actually possible to create unfolded constants, this
18 // class returns instructions rather than constants.
19 //
20 //===----------------------------------------------------------------------===//
21 
22 #ifndef LLVM_IR_NOFOLDER_H
23 #define LLVM_IR_NOFOLDER_H
24 
25 #include "llvm/ADT/ArrayRef.h"
26 #include "llvm/IR/Constants.h"
27 #include "llvm/IR/Instructions.h"
28 
29 namespace llvm {
30 
31 /// NoFolder - Create "constants" (actually, instructions) with no folding.
32 class NoFolder {
33 public:
NoFolder()34   explicit NoFolder() {}
35 
36   //===--------------------------------------------------------------------===//
37   // Binary Operators
38   //===--------------------------------------------------------------------===//
39 
40   Instruction *CreateAdd(Constant *LHS, Constant *RHS,
41                          bool HasNUW = false, bool HasNSW = false) const {
42     BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS);
43     if (HasNUW) BO->setHasNoUnsignedWrap();
44     if (HasNSW) BO->setHasNoSignedWrap();
45     return BO;
46   }
CreateNSWAdd(Constant * LHS,Constant * RHS)47   Instruction *CreateNSWAdd(Constant *LHS, Constant *RHS) const {
48     return BinaryOperator::CreateNSWAdd(LHS, RHS);
49   }
CreateNUWAdd(Constant * LHS,Constant * RHS)50   Instruction *CreateNUWAdd(Constant *LHS, Constant *RHS) const {
51     return BinaryOperator::CreateNUWAdd(LHS, RHS);
52   }
CreateFAdd(Constant * LHS,Constant * RHS)53   Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const {
54     return BinaryOperator::CreateFAdd(LHS, RHS);
55   }
56   Instruction *CreateSub(Constant *LHS, Constant *RHS,
57                          bool HasNUW = false, bool HasNSW = false) const {
58     BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS);
59     if (HasNUW) BO->setHasNoUnsignedWrap();
60     if (HasNSW) BO->setHasNoSignedWrap();
61     return BO;
62   }
CreateNSWSub(Constant * LHS,Constant * RHS)63   Instruction *CreateNSWSub(Constant *LHS, Constant *RHS) const {
64     return BinaryOperator::CreateNSWSub(LHS, RHS);
65   }
CreateNUWSub(Constant * LHS,Constant * RHS)66   Instruction *CreateNUWSub(Constant *LHS, Constant *RHS) const {
67     return BinaryOperator::CreateNUWSub(LHS, RHS);
68   }
CreateFSub(Constant * LHS,Constant * RHS)69   Instruction *CreateFSub(Constant *LHS, Constant *RHS) const {
70     return BinaryOperator::CreateFSub(LHS, RHS);
71   }
72   Instruction *CreateMul(Constant *LHS, Constant *RHS,
73                          bool HasNUW = false, bool HasNSW = false) const {
74     BinaryOperator *BO = BinaryOperator::CreateMul(LHS, RHS);
75     if (HasNUW) BO->setHasNoUnsignedWrap();
76     if (HasNSW) BO->setHasNoSignedWrap();
77     return BO;
78   }
CreateNSWMul(Constant * LHS,Constant * RHS)79   Instruction *CreateNSWMul(Constant *LHS, Constant *RHS) const {
80     return BinaryOperator::CreateNSWMul(LHS, RHS);
81   }
CreateNUWMul(Constant * LHS,Constant * RHS)82   Instruction *CreateNUWMul(Constant *LHS, Constant *RHS) const {
83     return BinaryOperator::CreateNUWMul(LHS, RHS);
84   }
CreateFMul(Constant * LHS,Constant * RHS)85   Instruction *CreateFMul(Constant *LHS, Constant *RHS) const {
86     return BinaryOperator::CreateFMul(LHS, RHS);
87   }
88   Instruction *CreateUDiv(Constant *LHS, Constant *RHS,
89                           bool isExact = false) const {
90     if (!isExact)
91       return BinaryOperator::CreateUDiv(LHS, RHS);
92     return BinaryOperator::CreateExactUDiv(LHS, RHS);
93   }
CreateExactUDiv(Constant * LHS,Constant * RHS)94   Instruction *CreateExactUDiv(Constant *LHS, Constant *RHS) const {
95     return BinaryOperator::CreateExactUDiv(LHS, RHS);
96   }
97   Instruction *CreateSDiv(Constant *LHS, Constant *RHS,
98                           bool isExact = false) const {
99     if (!isExact)
100       return BinaryOperator::CreateSDiv(LHS, RHS);
101     return BinaryOperator::CreateExactSDiv(LHS, RHS);
102   }
CreateExactSDiv(Constant * LHS,Constant * RHS)103   Instruction *CreateExactSDiv(Constant *LHS, Constant *RHS) const {
104     return BinaryOperator::CreateExactSDiv(LHS, RHS);
105   }
CreateFDiv(Constant * LHS,Constant * RHS)106   Instruction *CreateFDiv(Constant *LHS, Constant *RHS) const {
107     return BinaryOperator::CreateFDiv(LHS, RHS);
108   }
CreateURem(Constant * LHS,Constant * RHS)109   Instruction *CreateURem(Constant *LHS, Constant *RHS) const {
110     return BinaryOperator::CreateURem(LHS, RHS);
111   }
CreateSRem(Constant * LHS,Constant * RHS)112   Instruction *CreateSRem(Constant *LHS, Constant *RHS) const {
113     return BinaryOperator::CreateSRem(LHS, RHS);
114   }
CreateFRem(Constant * LHS,Constant * RHS)115   Instruction *CreateFRem(Constant *LHS, Constant *RHS) const {
116     return BinaryOperator::CreateFRem(LHS, RHS);
117   }
118   Instruction *CreateShl(Constant *LHS, Constant *RHS, bool HasNUW = false,
119                          bool HasNSW = false) const {
120     BinaryOperator *BO = BinaryOperator::CreateShl(LHS, RHS);
121     if (HasNUW) BO->setHasNoUnsignedWrap();
122     if (HasNSW) BO->setHasNoSignedWrap();
123     return BO;
124   }
125   Instruction *CreateLShr(Constant *LHS, Constant *RHS,
126                           bool isExact = false) const {
127     if (!isExact)
128       return BinaryOperator::CreateLShr(LHS, RHS);
129     return BinaryOperator::CreateExactLShr(LHS, RHS);
130   }
131   Instruction *CreateAShr(Constant *LHS, Constant *RHS,
132                           bool isExact = false) const {
133     if (!isExact)
134       return BinaryOperator::CreateAShr(LHS, RHS);
135     return BinaryOperator::CreateExactAShr(LHS, RHS);
136   }
CreateAnd(Constant * LHS,Constant * RHS)137   Instruction *CreateAnd(Constant *LHS, Constant *RHS) const {
138     return BinaryOperator::CreateAnd(LHS, RHS);
139   }
CreateOr(Constant * LHS,Constant * RHS)140   Instruction *CreateOr(Constant *LHS, Constant *RHS) const {
141     return BinaryOperator::CreateOr(LHS, RHS);
142   }
CreateXor(Constant * LHS,Constant * RHS)143   Instruction *CreateXor(Constant *LHS, Constant *RHS) const {
144     return BinaryOperator::CreateXor(LHS, RHS);
145   }
146 
CreateBinOp(Instruction::BinaryOps Opc,Constant * LHS,Constant * RHS)147   Instruction *CreateBinOp(Instruction::BinaryOps Opc,
148                            Constant *LHS, Constant *RHS) const {
149     return BinaryOperator::Create(Opc, LHS, RHS);
150   }
151 
152   //===--------------------------------------------------------------------===//
153   // Unary Operators
154   //===--------------------------------------------------------------------===//
155 
156   Instruction *CreateNeg(Constant *C,
157                          bool HasNUW = false, bool HasNSW = false) const {
158     BinaryOperator *BO = BinaryOperator::CreateNeg(C);
159     if (HasNUW) BO->setHasNoUnsignedWrap();
160     if (HasNSW) BO->setHasNoSignedWrap();
161     return BO;
162   }
CreateNSWNeg(Constant * C)163   Instruction *CreateNSWNeg(Constant *C) const {
164     return BinaryOperator::CreateNSWNeg(C);
165   }
CreateNUWNeg(Constant * C)166   Instruction *CreateNUWNeg(Constant *C) const {
167     return BinaryOperator::CreateNUWNeg(C);
168   }
CreateFNeg(Constant * C)169   Instruction *CreateFNeg(Constant *C) const {
170     return BinaryOperator::CreateFNeg(C);
171   }
CreateNot(Constant * C)172   Instruction *CreateNot(Constant *C) const {
173     return BinaryOperator::CreateNot(C);
174   }
175 
176   //===--------------------------------------------------------------------===//
177   // Memory Instructions
178   //===--------------------------------------------------------------------===//
179 
CreateGetElementPtr(Type * Ty,Constant * C,ArrayRef<Constant * > IdxList)180   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
181                                 ArrayRef<Constant *> IdxList) const {
182     return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
183   }
CreateGetElementPtr(Type * Ty,Constant * C,Constant * Idx)184   Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
185     // This form of the function only exists to avoid ambiguous overload
186     // warnings about whether to convert Idx to ArrayRef<Constant *> or
187     // ArrayRef<Value *>.
188     return ConstantExpr::getGetElementPtr(Ty, C, Idx);
189   }
CreateGetElementPtr(Type * Ty,Constant * C,ArrayRef<Value * > IdxList)190   Instruction *CreateGetElementPtr(Type *Ty, Constant *C,
191                                    ArrayRef<Value *> IdxList) const {
192     return GetElementPtrInst::Create(Ty, C, IdxList);
193   }
194 
CreateInBoundsGetElementPtr(Type * Ty,Constant * C,ArrayRef<Constant * > IdxList)195   Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
196                                         ArrayRef<Constant *> IdxList) const {
197     return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
198   }
CreateInBoundsGetElementPtr(Type * Ty,Constant * C,Constant * Idx)199   Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
200                                         Constant *Idx) const {
201     // This form of the function only exists to avoid ambiguous overload
202     // warnings about whether to convert Idx to ArrayRef<Constant *> or
203     // ArrayRef<Value *>.
204     return ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx);
205   }
CreateInBoundsGetElementPtr(Type * Ty,Constant * C,ArrayRef<Value * > IdxList)206   Instruction *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
207                                            ArrayRef<Value *> IdxList) const {
208     return GetElementPtrInst::CreateInBounds(Ty, C, IdxList);
209   }
210 
211   //===--------------------------------------------------------------------===//
212   // Cast/Conversion Operators
213   //===--------------------------------------------------------------------===//
214 
CreateCast(Instruction::CastOps Op,Constant * C,Type * DestTy)215   Instruction *CreateCast(Instruction::CastOps Op, Constant *C,
216                     Type *DestTy) const {
217     return CastInst::Create(Op, C, DestTy);
218   }
CreatePointerCast(Constant * C,Type * DestTy)219   Instruction *CreatePointerCast(Constant *C, Type *DestTy) const {
220     return CastInst::CreatePointerCast(C, DestTy);
221   }
CreateIntCast(Constant * C,Type * DestTy,bool isSigned)222   Instruction *CreateIntCast(Constant *C, Type *DestTy,
223                        bool isSigned) const {
224     return CastInst::CreateIntegerCast(C, DestTy, isSigned);
225   }
CreateFPCast(Constant * C,Type * DestTy)226   Instruction *CreateFPCast(Constant *C, Type *DestTy) const {
227     return CastInst::CreateFPCast(C, DestTy);
228   }
229 
CreateBitCast(Constant * C,Type * DestTy)230   Instruction *CreateBitCast(Constant *C, Type *DestTy) const {
231     return CreateCast(Instruction::BitCast, C, DestTy);
232   }
CreateIntToPtr(Constant * C,Type * DestTy)233   Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const {
234     return CreateCast(Instruction::IntToPtr, C, DestTy);
235   }
CreatePtrToInt(Constant * C,Type * DestTy)236   Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const {
237     return CreateCast(Instruction::PtrToInt, C, DestTy);
238   }
CreateZExtOrBitCast(Constant * C,Type * DestTy)239   Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
240     return CastInst::CreateZExtOrBitCast(C, DestTy);
241   }
CreateSExtOrBitCast(Constant * C,Type * DestTy)242   Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
243     return CastInst::CreateSExtOrBitCast(C, DestTy);
244   }
245 
CreateTruncOrBitCast(Constant * C,Type * DestTy)246   Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
247     return CastInst::CreateTruncOrBitCast(C, DestTy);
248   }
249 
250   //===--------------------------------------------------------------------===//
251   // Compare Instructions
252   //===--------------------------------------------------------------------===//
253 
CreateICmp(CmpInst::Predicate P,Constant * LHS,Constant * RHS)254   Instruction *CreateICmp(CmpInst::Predicate P,
255                           Constant *LHS, Constant *RHS) const {
256     return new ICmpInst(P, LHS, RHS);
257   }
CreateFCmp(CmpInst::Predicate P,Constant * LHS,Constant * RHS)258   Instruction *CreateFCmp(CmpInst::Predicate P,
259                           Constant *LHS, Constant *RHS) const {
260     return new FCmpInst(P, LHS, RHS);
261   }
262 
263   //===--------------------------------------------------------------------===//
264   // Other Instructions
265   //===--------------------------------------------------------------------===//
266 
CreateSelect(Constant * C,Constant * True,Constant * False)267   Instruction *CreateSelect(Constant *C,
268                             Constant *True, Constant *False) const {
269     return SelectInst::Create(C, True, False);
270   }
271 
CreateExtractElement(Constant * Vec,Constant * Idx)272   Instruction *CreateExtractElement(Constant *Vec, Constant *Idx) const {
273     return ExtractElementInst::Create(Vec, Idx);
274   }
275 
CreateInsertElement(Constant * Vec,Constant * NewElt,Constant * Idx)276   Instruction *CreateInsertElement(Constant *Vec, Constant *NewElt,
277                                    Constant *Idx) const {
278     return InsertElementInst::Create(Vec, NewElt, Idx);
279   }
280 
CreateShuffleVector(Constant * V1,Constant * V2,Constant * Mask)281   Instruction *CreateShuffleVector(Constant *V1, Constant *V2,
282                                    Constant *Mask) const {
283     return new ShuffleVectorInst(V1, V2, Mask);
284   }
285 
CreateExtractValue(Constant * Agg,ArrayRef<unsigned> IdxList)286   Instruction *CreateExtractValue(Constant *Agg,
287                                   ArrayRef<unsigned> IdxList) const {
288     return ExtractValueInst::Create(Agg, IdxList);
289   }
290 
CreateInsertValue(Constant * Agg,Constant * Val,ArrayRef<unsigned> IdxList)291   Instruction *CreateInsertValue(Constant *Agg, Constant *Val,
292                                  ArrayRef<unsigned> IdxList) const {
293     return InsertValueInst::Create(Agg, Val, IdxList);
294   }
295 };
296 
297 }
298 
299 #endif
300