contrib/llvm/include/llvm/IR/ConstantFolder.h

   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