include/llvm/IR/ConstantFolder.h

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