1 //===-- llvm/Support/ConstantFolder.h - Constant folding helper -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
15 //===----------------------------------------------------------------------===//
17 #ifndef LLVM_SUPPORT_CONSTANTFOLDER_H
18 #define LLVM_SUPPORT_CONSTANTFOLDER_H
20 #include "llvm/Constants.h"
21 #include "llvm/InstrTypes.h"
25 /// ConstantFolder - Create constants with minimum, target independent, folding.
26 class ConstantFolder {
28 explicit ConstantFolder() {}
30 //===--------------------------------------------------------------------===//
32 //===--------------------------------------------------------------------===//
34 Constant *CreateAdd(Constant *LHS, Constant *RHS,
35 bool HasNUW = false, bool HasNSW = false) const {
36 return ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW);
38 Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
39 return ConstantExpr::getFAdd(LHS, RHS);
41 Constant *CreateSub(Constant *LHS, Constant *RHS,
42 bool HasNUW = false, bool HasNSW = false) const {
43 return ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW);
45 Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
46 return ConstantExpr::getFSub(LHS, RHS);
48 Constant *CreateMul(Constant *LHS, Constant *RHS,
49 bool HasNUW = false, bool HasNSW = false) const {
50 return ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW);
52 Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
53 return ConstantExpr::getFMul(LHS, RHS);
55 Constant *CreateUDiv(Constant *LHS, Constant *RHS,
56 bool isExact = false) const {
57 return ConstantExpr::getUDiv(LHS, RHS, isExact);
59 Constant *CreateSDiv(Constant *LHS, Constant *RHS,
60 bool isExact = false) const {
61 return ConstantExpr::getSDiv(LHS, RHS, isExact);
63 Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
64 return ConstantExpr::getFDiv(LHS, RHS);
66 Constant *CreateURem(Constant *LHS, Constant *RHS) const {
67 return ConstantExpr::getURem(LHS, RHS);
69 Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
70 return ConstantExpr::getSRem(LHS, RHS);
72 Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
73 return ConstantExpr::getFRem(LHS, RHS);
75 Constant *CreateShl(Constant *LHS, Constant *RHS,
76 bool HasNUW = false, bool HasNSW = false) const {
77 return ConstantExpr::getShl(LHS, RHS, HasNUW, HasNSW);
79 Constant *CreateLShr(Constant *LHS, Constant *RHS,
80 bool isExact = false) const {
81 return ConstantExpr::getLShr(LHS, RHS, isExact);
83 Constant *CreateAShr(Constant *LHS, Constant *RHS,
84 bool isExact = false) const {
85 return ConstantExpr::getAShr(LHS, RHS, isExact);
87 Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
88 return ConstantExpr::getAnd(LHS, RHS);
90 Constant *CreateOr(Constant *LHS, Constant *RHS) const {
91 return ConstantExpr::getOr(LHS, RHS);
93 Constant *CreateXor(Constant *LHS, Constant *RHS) const {
94 return ConstantExpr::getXor(LHS, RHS);
97 Constant *CreateBinOp(Instruction::BinaryOps Opc,
98 Constant *LHS, Constant *RHS) const {
99 return ConstantExpr::get(Opc, LHS, RHS);
102 //===--------------------------------------------------------------------===//
104 //===--------------------------------------------------------------------===//
106 Constant *CreateNeg(Constant *C,
107 bool HasNUW = false, bool HasNSW = false) const {
108 return ConstantExpr::getNeg(C, HasNUW, HasNSW);
110 Constant *CreateFNeg(Constant *C) const {
111 return ConstantExpr::getFNeg(C);
113 Constant *CreateNot(Constant *C) const {
114 return ConstantExpr::getNot(C);
117 //===--------------------------------------------------------------------===//
118 // Memory Instructions
119 //===--------------------------------------------------------------------===//
121 Constant *CreateGetElementPtr(Constant *C, Constant* const *IdxList,
122 unsigned NumIdx) const {
123 return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx);
125 Constant *CreateGetElementPtr(Constant *C, Value* const *IdxList,
126 unsigned NumIdx) const {
127 return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx);
130 Constant *CreateInBoundsGetElementPtr(Constant *C, Constant* const *IdxList,
131 unsigned NumIdx) const {
132 return ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx);
134 Constant *CreateInBoundsGetElementPtr(Constant *C, Value* const *IdxList,
135 unsigned NumIdx) const {
136 return ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx);
139 //===--------------------------------------------------------------------===//
140 // Cast/Conversion Operators
141 //===--------------------------------------------------------------------===//
143 Constant *CreateCast(Instruction::CastOps Op, Constant *C,
144 Type *DestTy) const {
145 return ConstantExpr::getCast(Op, C, DestTy);
147 Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
148 return ConstantExpr::getPointerCast(C, DestTy);
150 Constant *CreateIntCast(Constant *C, Type *DestTy,
151 bool isSigned) const {
152 return ConstantExpr::getIntegerCast(C, DestTy, isSigned);
154 Constant *CreateFPCast(Constant *C, Type *DestTy) const {
155 return ConstantExpr::getFPCast(C, DestTy);
158 Constant *CreateBitCast(Constant *C, Type *DestTy) const {
159 return CreateCast(Instruction::BitCast, C, DestTy);
161 Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
162 return CreateCast(Instruction::IntToPtr, C, DestTy);
164 Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
165 return CreateCast(Instruction::PtrToInt, C, DestTy);
167 Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
168 return ConstantExpr::getZExtOrBitCast(C, DestTy);
170 Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
171 return ConstantExpr::getSExtOrBitCast(C, DestTy);
174 Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
175 return ConstantExpr::getTruncOrBitCast(C, DestTy);
178 //===--------------------------------------------------------------------===//
179 // Compare Instructions
180 //===--------------------------------------------------------------------===//
182 Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
183 Constant *RHS) const {
184 return ConstantExpr::getCompare(P, LHS, RHS);
186 Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
187 Constant *RHS) const {
188 return ConstantExpr::getCompare(P, LHS, RHS);
191 //===--------------------------------------------------------------------===//
192 // Other Instructions
193 //===--------------------------------------------------------------------===//
195 Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
196 return ConstantExpr::getSelect(C, True, False);
199 Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
200 return ConstantExpr::getExtractElement(Vec, Idx);
203 Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
204 Constant *Idx) const {
205 return ConstantExpr::getInsertElement(Vec, NewElt, Idx);
208 Constant *CreateShuffleVector(Constant *V1, Constant *V2,
209 Constant *Mask) const {
210 return ConstantExpr::getShuffleVector(V1, V2, Mask);
213 Constant *CreateExtractValue(Constant *Agg,
214 ArrayRef<unsigned> IdxList) const {
215 return ConstantExpr::getExtractValue(Agg, IdxList);
218 Constant *CreateInsertValue(Constant *Agg, Constant *Val,
219 ArrayRef<unsigned> IdxList) const {
220 return ConstantExpr::getInsertValue(Agg, Val, IdxList);