1 //===-- llvm/Support/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_SUPPORT_CONSTANTFOLDER_H 18 #define LLVM_SUPPORT_CONSTANTFOLDER_H 19 20 #include "llvm/Constants.h" 21 #include "llvm/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(Constant * C,ArrayRef<Constant * > IdxList)121 Constant *CreateGetElementPtr(Constant *C, 122 ArrayRef<Constant *> IdxList) const { 123 return ConstantExpr::getGetElementPtr(C, IdxList); 124 } CreateGetElementPtr(Constant * C,Constant * Idx)125 Constant *CreateGetElementPtr(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(C, Idx); 130 } CreateGetElementPtr(Constant * C,ArrayRef<Value * > IdxList)131 Constant *CreateGetElementPtr(Constant *C, 132 ArrayRef<Value *> IdxList) const { 133 return ConstantExpr::getGetElementPtr(C, IdxList); 134 } 135 CreateInBoundsGetElementPtr(Constant * C,ArrayRef<Constant * > IdxList)136 Constant *CreateInBoundsGetElementPtr(Constant *C, 137 ArrayRef<Constant *> IdxList) const { 138 return ConstantExpr::getInBoundsGetElementPtr(C, IdxList); 139 } CreateInBoundsGetElementPtr(Constant * C,Constant * Idx)140 Constant *CreateInBoundsGetElementPtr(Constant *C, Constant *Idx) const { 141 // This form of the function only exists to avoid ambiguous overload 142 // warnings about whether to convert Idx to ArrayRef<Constant *> or 143 // ArrayRef<Value *>. 144 return ConstantExpr::getInBoundsGetElementPtr(C, Idx); 145 } CreateInBoundsGetElementPtr(Constant * C,ArrayRef<Value * > IdxList)146 Constant *CreateInBoundsGetElementPtr(Constant *C, 147 ArrayRef<Value *> IdxList) const { 148 return ConstantExpr::getInBoundsGetElementPtr(C, IdxList); 149 } 150 151 //===--------------------------------------------------------------------===// 152 // Cast/Conversion Operators 153 //===--------------------------------------------------------------------===// 154 CreateCast(Instruction::CastOps Op,Constant * C,Type * DestTy)155 Constant *CreateCast(Instruction::CastOps Op, Constant *C, 156 Type *DestTy) const { 157 return ConstantExpr::getCast(Op, C, DestTy); 158 } CreatePointerCast(Constant * C,Type * DestTy)159 Constant *CreatePointerCast(Constant *C, Type *DestTy) const { 160 return ConstantExpr::getPointerCast(C, DestTy); 161 } CreateIntCast(Constant * C,Type * DestTy,bool isSigned)162 Constant *CreateIntCast(Constant *C, Type *DestTy, 163 bool isSigned) const { 164 return ConstantExpr::getIntegerCast(C, DestTy, isSigned); 165 } CreateFPCast(Constant * C,Type * DestTy)166 Constant *CreateFPCast(Constant *C, Type *DestTy) const { 167 return ConstantExpr::getFPCast(C, DestTy); 168 } 169 CreateBitCast(Constant * C,Type * DestTy)170 Constant *CreateBitCast(Constant *C, Type *DestTy) const { 171 return CreateCast(Instruction::BitCast, C, DestTy); 172 } CreateIntToPtr(Constant * C,Type * DestTy)173 Constant *CreateIntToPtr(Constant *C, Type *DestTy) const { 174 return CreateCast(Instruction::IntToPtr, C, DestTy); 175 } CreatePtrToInt(Constant * C,Type * DestTy)176 Constant *CreatePtrToInt(Constant *C, Type *DestTy) const { 177 return CreateCast(Instruction::PtrToInt, C, DestTy); 178 } CreateZExtOrBitCast(Constant * C,Type * DestTy)179 Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const { 180 return ConstantExpr::getZExtOrBitCast(C, DestTy); 181 } CreateSExtOrBitCast(Constant * C,Type * DestTy)182 Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const { 183 return ConstantExpr::getSExtOrBitCast(C, DestTy); 184 } 185 CreateTruncOrBitCast(Constant * C,Type * DestTy)186 Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const { 187 return ConstantExpr::getTruncOrBitCast(C, DestTy); 188 } 189 190 //===--------------------------------------------------------------------===// 191 // Compare Instructions 192 //===--------------------------------------------------------------------===// 193 CreateICmp(CmpInst::Predicate P,Constant * LHS,Constant * RHS)194 Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS, 195 Constant *RHS) const { 196 return ConstantExpr::getCompare(P, LHS, RHS); 197 } CreateFCmp(CmpInst::Predicate P,Constant * LHS,Constant * RHS)198 Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS, 199 Constant *RHS) const { 200 return ConstantExpr::getCompare(P, LHS, RHS); 201 } 202 203 //===--------------------------------------------------------------------===// 204 // Other Instructions 205 //===--------------------------------------------------------------------===// 206 CreateSelect(Constant * C,Constant * True,Constant * False)207 Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const { 208 return ConstantExpr::getSelect(C, True, False); 209 } 210 CreateExtractElement(Constant * Vec,Constant * Idx)211 Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const { 212 return ConstantExpr::getExtractElement(Vec, Idx); 213 } 214 CreateInsertElement(Constant * Vec,Constant * NewElt,Constant * Idx)215 Constant *CreateInsertElement(Constant *Vec, Constant *NewElt, 216 Constant *Idx) const { 217 return ConstantExpr::getInsertElement(Vec, NewElt, Idx); 218 } 219 CreateShuffleVector(Constant * V1,Constant * V2,Constant * Mask)220 Constant *CreateShuffleVector(Constant *V1, Constant *V2, 221 Constant *Mask) const { 222 return ConstantExpr::getShuffleVector(V1, V2, Mask); 223 } 224 CreateExtractValue(Constant * Agg,ArrayRef<unsigned> IdxList)225 Constant *CreateExtractValue(Constant *Agg, 226 ArrayRef<unsigned> IdxList) const { 227 return ConstantExpr::getExtractValue(Agg, IdxList); 228 } 229 CreateInsertValue(Constant * Agg,Constant * Val,ArrayRef<unsigned> IdxList)230 Constant *CreateInsertValue(Constant *Agg, Constant *Val, 231 ArrayRef<unsigned> IdxList) const { 232 return ConstantExpr::getInsertValue(Agg, Val, IdxList); 233 } 234 }; 235 236 } 237 238 #endif 239