LLVM  10.0.0svn
TargetFolder.h
Go to the documentation of this file.
1 //====- TargetFolder.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 TargetFolder class, a helper for IRBuilder.
10 // It provides IRBuilder with a set of methods for creating constants with
11 // target dependent folding, in addition to the same target-independent
12 // folding that the ConstantFolder class provides. For general constant
13 // creation and folding, use ConstantExpr and the routines in
14 // llvm/Analysis/ConstantFolding.h.
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #ifndef LLVM_ANALYSIS_TARGETFOLDER_H
19 #define LLVM_ANALYSIS_TARGETFOLDER_H
20 
21 #include "llvm/ADT/ArrayRef.h"
23 #include "llvm/IR/Constants.h"
24 #include "llvm/IR/InstrTypes.h"
25 
26 namespace llvm {
27 
28 class DataLayout;
29 
30 /// TargetFolder - Create constants with target dependent folding.
31 class TargetFolder {
32  const DataLayout &DL;
33 
34  /// Fold - Fold the constant using target specific information.
35  Constant *Fold(Constant *C) const {
36  if (Constant *CF = ConstantFoldConstant(C, DL))
37  return CF;
38  return C;
39  }
40 
41 public:
42  explicit TargetFolder(const DataLayout &DL) : DL(DL) {}
43 
44  //===--------------------------------------------------------------------===//
45  // Binary Operators
46  //===--------------------------------------------------------------------===//
47 
49  bool HasNUW = false, bool HasNSW = false) const {
50  return Fold(ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW));
51  }
52  Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
53  return Fold(ConstantExpr::getFAdd(LHS, RHS));
54  }
56  bool HasNUW = false, bool HasNSW = false) const {
57  return Fold(ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW));
58  }
59  Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
60  return Fold(ConstantExpr::getFSub(LHS, RHS));
61  }
63  bool HasNUW = false, bool HasNSW = false) const {
64  return Fold(ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW));
65  }
66  Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
67  return Fold(ConstantExpr::getFMul(LHS, RHS));
68  }
69  Constant *CreateUDiv(Constant *LHS, Constant *RHS, bool isExact = false)const{
70  return Fold(ConstantExpr::getUDiv(LHS, RHS, isExact));
71  }
72  Constant *CreateSDiv(Constant *LHS, Constant *RHS, bool isExact = false)const{
73  return Fold(ConstantExpr::getSDiv(LHS, RHS, isExact));
74  }
75  Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
76  return Fold(ConstantExpr::getFDiv(LHS, RHS));
77  }
78  Constant *CreateURem(Constant *LHS, Constant *RHS) const {
79  return Fold(ConstantExpr::getURem(LHS, RHS));
80  }
81  Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
82  return Fold(ConstantExpr::getSRem(LHS, RHS));
83  }
84  Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
85  return Fold(ConstantExpr::getFRem(LHS, RHS));
86  }
88  bool HasNUW = false, bool HasNSW = false) const {
89  return Fold(ConstantExpr::getShl(LHS, RHS, HasNUW, HasNSW));
90  }
91  Constant *CreateLShr(Constant *LHS, Constant *RHS, bool isExact = false)const{
92  return Fold(ConstantExpr::getLShr(LHS, RHS, isExact));
93  }
94  Constant *CreateAShr(Constant *LHS, Constant *RHS, bool isExact = false)const{
95  return Fold(ConstantExpr::getAShr(LHS, RHS, isExact));
96  }
97  Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
98  return Fold(ConstantExpr::getAnd(LHS, RHS));
99  }
100  Constant *CreateOr(Constant *LHS, Constant *RHS) const {
101  return Fold(ConstantExpr::getOr(LHS, RHS));
102  }
103  Constant *CreateXor(Constant *LHS, Constant *RHS) const {
104  return Fold(ConstantExpr::getXor(LHS, RHS));
105  }
106 
108  Constant *LHS, Constant *RHS) const {
109  return Fold(ConstantExpr::get(Opc, LHS, RHS));
110  }
111 
112  //===--------------------------------------------------------------------===//
113  // Unary Operators
114  //===--------------------------------------------------------------------===//
115 
117  bool HasNUW = false, bool HasNSW = false) const {
118  return Fold(ConstantExpr::getNeg(C, HasNUW, HasNSW));
119  }
121  return Fold(ConstantExpr::getFNeg(C));
122  }
124  return Fold(ConstantExpr::getNot(C));
125  }
126 
128  return Fold(ConstantExpr::get(Opc, C));
129  }
130 
131  //===--------------------------------------------------------------------===//
132  // Memory Instructions
133  //===--------------------------------------------------------------------===//
134 
136  ArrayRef<Constant *> IdxList) const {
137  return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
138  }
140  // This form of the function only exists to avoid ambiguous overload
141  // warnings about whether to convert Idx to ArrayRef<Constant *> or
142  // ArrayRef<Value *>.
143  return Fold(ConstantExpr::getGetElementPtr(Ty, C, Idx));
144  }
146  ArrayRef<Value *> IdxList) const {
147  return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
148  }
149 
151  ArrayRef<Constant *> IdxList) const {
152  return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList));
153  }
155  Constant *Idx) const {
156  // This form of the function only exists to avoid ambiguous overload
157  // warnings about whether to convert Idx to ArrayRef<Constant *> or
158  // ArrayRef<Value *>.
159  return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx));
160  }
162  ArrayRef<Value *> IdxList) const {
163  return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList));
164  }
165 
166  //===--------------------------------------------------------------------===//
167  // Cast/Conversion Operators
168  //===--------------------------------------------------------------------===//
169 
171  Type *DestTy) const {
172  if (C->getType() == DestTy)
173  return C; // avoid calling Fold
174  return Fold(ConstantExpr::getCast(Op, C, DestTy));
175  }
177  bool isSigned) const {
178  if (C->getType() == DestTy)
179  return C; // avoid calling Fold
180  return Fold(ConstantExpr::getIntegerCast(C, DestTy, isSigned));
181  }
182  Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
183  if (C->getType() == DestTy)
184  return C; // avoid calling Fold
185  return Fold(ConstantExpr::getPointerCast(C, DestTy));
186  }
187  Constant *CreateFPCast(Constant *C, Type *DestTy) const {
188  if (C->getType() == DestTy)
189  return C; // avoid calling Fold
190  return Fold(ConstantExpr::getFPCast(C, DestTy));
191  }
192  Constant *CreateBitCast(Constant *C, Type *DestTy) const {
193  return CreateCast(Instruction::BitCast, C, DestTy);
194  }
195  Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
196  return CreateCast(Instruction::IntToPtr, C, DestTy);
197  }
198  Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
199  return CreateCast(Instruction::PtrToInt, C, DestTy);
200  }
202  if (C->getType() == DestTy)
203  return C; // avoid calling Fold
204  return Fold(ConstantExpr::getZExtOrBitCast(C, DestTy));
205  }
207  if (C->getType() == DestTy)
208  return C; // avoid calling Fold
209  return Fold(ConstantExpr::getSExtOrBitCast(C, DestTy));
210  }
212  if (C->getType() == DestTy)
213  return C; // avoid calling Fold
214  return Fold(ConstantExpr::getTruncOrBitCast(C, DestTy));
215  }
216 
218  Type *DestTy) const {
219  if (C->getType() == DestTy)
220  return C; // avoid calling Fold
221  return Fold(ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy));
222  }
223 
224  //===--------------------------------------------------------------------===//
225  // Compare Instructions
226  //===--------------------------------------------------------------------===//
227 
229  Constant *RHS) const {
230  return Fold(ConstantExpr::getCompare(P, LHS, RHS));
231  }
233  Constant *RHS) const {
234  return Fold(ConstantExpr::getCompare(P, LHS, RHS));
235  }
236 
237  //===--------------------------------------------------------------------===//
238  // Other Instructions
239  //===--------------------------------------------------------------------===//
240 
241  Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
242  return Fold(ConstantExpr::getSelect(C, True, False));
243  }
244 
246  return Fold(ConstantExpr::getExtractElement(Vec, Idx));
247  }
248 
250  Constant *Idx) const {
251  return Fold(ConstantExpr::getInsertElement(Vec, NewElt, Idx));
252  }
253 
255  Constant *Mask) const {
256  return Fold(ConstantExpr::getShuffleVector(V1, V2, Mask));
257  }
258 
260  ArrayRef<unsigned> IdxList) const {
261  return Fold(ConstantExpr::getExtractValue(Agg, IdxList));
262  }
263 
265  ArrayRef<unsigned> IdxList) const {
266  return Fold(ConstantExpr::getInsertValue(Agg, Val, IdxList));
267  }
268 };
269 
270 }
271 
272 #endif
uint64_t CallInst * C
Constant * CreateCast(Instruction::CastOps Op, Constant *C, Type *DestTy) const
Definition: TargetFolder.h:170
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
Constant * CreateExtractValue(Constant *Agg, ArrayRef< unsigned > IdxList) const
Definition: TargetFolder.h:259
static Constant * getFAdd(Constant *C1, Constant *C2)
Definition: Constants.cpp:2244
static Constant * getPointerBitCastOrAddrSpaceCast(Constant *C, Type *Ty)
Create a BitCast or AddrSpaceCast for a pointer type depending on the address space.
Definition: Constants.cpp:1620
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList, bool InBounds=false, Optional< unsigned > InRangeIndex=None, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1153
Constant * CreateBinOp(Instruction::BinaryOps Opc, Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:107
Constant * CreateFNeg(Constant *C) const
Definition: TargetFolder.h:120
Constant * CreateAdd(Constant *LHS, Constant *RHS, bool HasNUW=false, bool HasNSW=false) const
Definition: TargetFolder.h:48
Constant * CreateShl(Constant *LHS, Constant *RHS, bool HasNUW=false, bool HasNSW=false) const
Definition: TargetFolder.h:87
Constant * CreateNot(Constant *C) const
Definition: TargetFolder.h:123
Constant * CreatePtrToInt(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:198
Constant * CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const
Definition: TargetFolder.h:127
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2102
static Constant * getCompare(unsigned short pred, Constant *C1, Constant *C2, bool OnlyIfReduced=false)
Return an ICmp or FCmp comparison operator constant expression.
Definition: Constants.cpp:1955
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2248
Constant * CreateZExtOrBitCast(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:201
Constant * CreateFAdd(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:52
Constant * CreatePointerCast(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:182
Constant * CreateShuffleVector(Constant *V1, Constant *V2, Constant *Mask) const
Definition: TargetFolder.h:254
Constant * CreateXor(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:103
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2124
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2237
static Constant * getFMul(Constant *C1, Constant *C2)
Definition: Constants.cpp:2266
Constant * CreateFRem(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:84
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1631
Constant * CreateSExtOrBitCast(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:206
static Constant * getLShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2315
Constant * CreateSub(Constant *LHS, Constant *RHS, bool HasNUW=false, bool HasNSW=false) const
Definition: TargetFolder.h:55
Constant * CreateMul(Constant *LHS, Constant *RHS, bool HasNUW=false, bool HasNSW=false) const
Definition: TargetFolder.h:62
Constant * CreateUDiv(Constant *LHS, Constant *RHS, bool isExact=false) const
Definition: TargetFolder.h:69
Constant * CreateURem(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:78
Constant * CreateNeg(Constant *C, bool HasNUW=false, bool HasNSW=false) const
Definition: TargetFolder.h:116
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Attempt to fold the constant using the specified DataLayout.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
static Constant * getFPCast(Constant *C, Type *Ty)
Create a FPExt, Bitcast or FPTrunc for fp -> fp casts.
Definition: Constants.cpp:1643
static Constant * getAShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2320
Constant * CreateTruncOrBitCast(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:211
Constant * CreateFMul(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:66
static Constant * getSelect(Constant *C, Constant *V1, Constant *V2, Type *OnlyIfReducedTy=nullptr)
Select constant expr.
Definition: Constants.cpp:1977
Constant * CreateFSub(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:59
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
TargetFolder - Create constants with target dependent folding.
Definition: TargetFolder.h:31
Constant * CreateFDiv(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:75
static Constant * getUDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2270
static Constant * getFDiv(Constant *C1, Constant *C2)
Definition: Constants.cpp:2280
Constant * CreateIntCast(Constant *C, Type *DestTy, bool isSigned) const
Definition: TargetFolder.h:176
Constant * CreateAnd(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:97
static Constant * getInsertValue(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2170
#define P(N)
static Constant * getFNeg(Constant *C)
Definition: Constants.cpp:2225
static Constant * getFRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2292
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important base class in LLVM.
Definition: Constant.h:41
Constant * CreateInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Value *> IdxList) const
Definition: TargetFolder.h:161
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Constant * CreateSDiv(Constant *LHS, Constant *RHS, bool isExact=false) const
Definition: TargetFolder.h:72
static Constant * getAnd(Constant *C1, Constant *C2)
Definition: Constants.cpp:2296
static Constant * getSExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1593
static Constant * getShuffleVector(Constant *V1, Constant *V2, Constant *Mask, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2147
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:732
Constant * CreateSelect(Constant *C, Constant *True, Constant *False) const
Definition: TargetFolder.h:241
Constant * CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const
Definition: TargetFolder.h:139
static Constant * getNot(Constant *C)
Definition: Constants.cpp:2231
Constant * CreateExtractElement(Constant *Vec, Constant *Idx) const
Definition: TargetFolder.h:245
Constant * CreateICmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:228
Constant * CreateLShr(Constant *LHS, Constant *RHS, bool isExact=false) const
Definition: TargetFolder.h:91
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
Definition: Constants.cpp:1605
static Constant * getSDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2275
Constant * CreateBitCast(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:192
Constant * CreatePointerBitCastOrAddrSpaceCast(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:217
Constant * CreateInsertValue(Constant *Agg, Constant *Val, ArrayRef< unsigned > IdxList) const
Definition: TargetFolder.h:264
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1548
static Constant * getZExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1587
Constant * CreateGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList) const
Definition: TargetFolder.h:135
static Constant * getFSub(Constant *C1, Constant *C2)
Definition: Constants.cpp:2255
static Constant * getTruncOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1599
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2218
Constant * CreateFCmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:232
Constant * CreateOr(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:100
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList)
Create an "inbounds" getelementptr.
Definition: Constants.h:1180
Constant * CreateIntToPtr(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:195
static Constant * getOr(Constant *C1, Constant *C2)
Definition: Constants.cpp:2300
Constant * CreateGetElementPtr(Type *Ty, Constant *C, ArrayRef< Value *> IdxList) const
Definition: TargetFolder.h:145
static Constant * getShl(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2308
Constant * CreateAShr(Constant *LHS, Constant *RHS, bool isExact=false) const
Definition: TargetFolder.h:94
Constant * CreateInBoundsGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const
Definition: TargetFolder.h:154
Constant * CreateSRem(Constant *LHS, Constant *RHS) const
Definition: TargetFolder.h:81
static Constant * getSRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2288
Constant * CreateInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList) const
Definition: TargetFolder.h:150
static Constant * getURem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2284
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:80
Constant * CreateInsertElement(Constant *Vec, Constant *NewElt, Constant *Idx) const
Definition: TargetFolder.h:249
static Constant * getExtractValue(Constant *Agg, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2194
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2259
TargetFolder(const DataLayout &DL)
Definition: TargetFolder.h:42
Constant * CreateFPCast(Constant *C, Type *DestTy) const
Definition: TargetFolder.h:187
static Constant * getXor(Constant *C1, Constant *C2)
Definition: Constants.cpp:2304
static Constant * get(unsigned Opcode, Constant *C1, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a unary operator constant expression, folding if possible.
Definition: Constants.cpp:1824