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