LLVM 17.0.0git
InstSimplifyFolder.h
Go to the documentation of this file.
1//===- InstSimplifyFolder.h - InstSimplify 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 InstSimplifyFolder class, a helper for IRBuilder.
10// It provides IRBuilder with a set of methods for folding operations to
11// existing values using InstructionSimplify. At the moment, only a subset of
12// the implementation uses InstructionSimplify. The rest of the implementation
13// only folds constants.
14//
15// The folder also applies target-specific constant folding.
16//
17//===----------------------------------------------------------------------===//
18
19#ifndef LLVM_ANALYSIS_INSTSIMPLIFYFOLDER_H
20#define LLVM_ANALYSIS_INSTSIMPLIFYFOLDER_H
21
22#include "llvm/ADT/ArrayRef.h"
26#include "llvm/IR/Instruction.h"
27
28namespace llvm {
29class Constant;
30
31/// InstSimplifyFolder - Use InstructionSimplify to fold operations to existing
32/// values. Also applies target-specific constant folding when not using
33/// InstructionSimplify.
34class InstSimplifyFolder final : public IRBuilderFolder {
35 TargetFolder ConstFolder;
37
38 virtual void anchor();
39
40public:
41 InstSimplifyFolder(const DataLayout &DL) : ConstFolder(DL), SQ(DL) {}
42
43 //===--------------------------------------------------------------------===//
44 // Value-based folders.
45 //
46 // Return an existing value or a constant if the operation can be simplified.
47 // Otherwise return nullptr.
48 //===--------------------------------------------------------------------===//
49
51 Value *RHS) const override {
52 return simplifyBinOp(Opc, LHS, RHS, SQ);
53 }
54
56 bool IsExact) const override {
57 return simplifyBinOp(Opc, LHS, RHS, SQ);
58 }
59
61 bool HasNUW, bool HasNSW) const override {
62 return simplifyBinOp(Opc, LHS, RHS, SQ);
63 }
64
66 FastMathFlags FMF) const override {
67 return simplifyBinOp(Opc, LHS, RHS, FMF, SQ);
68 }
69
71 FastMathFlags FMF) const override {
72 return simplifyUnOp(Opc, V, FMF, SQ);
73 }
74
76 return simplifyICmpInst(P, LHS, RHS, SQ);
77 }
78
80 bool IsInBounds = false) const override {
81 return simplifyGEPInst(Ty, Ptr, IdxList, IsInBounds, SQ);
82 }
83
84 Value *FoldSelect(Value *C, Value *True, Value *False) const override {
85 return simplifySelectInst(C, True, False, SQ);
86 }
87
89 ArrayRef<unsigned> IdxList) const override {
90 return simplifyExtractValueInst(Agg, IdxList, SQ);
91 };
92
94 ArrayRef<unsigned> IdxList) const override {
95 return simplifyInsertValueInst(Agg, Val, IdxList, SQ);
96 }
97
98 Value *FoldExtractElement(Value *Vec, Value *Idx) const override {
99 return simplifyExtractElementInst(Vec, Idx, SQ);
100 }
101
103 Value *Idx) const override {
104 return simplifyInsertElementInst(Vec, NewElt, Idx, SQ);
105 }
106
108 ArrayRef<int> Mask) const override {
110 cast<VectorType>(V1->getType())->getElementType(), Mask.size(),
111 isa<ScalableVectorType>(V1->getType()));
112 return simplifyShuffleVectorInst(V1, V2, Mask, RetTy, SQ);
113 }
114
115 //===--------------------------------------------------------------------===//
116 // Cast/Conversion Operators
117 //===--------------------------------------------------------------------===//
118
120 Type *DestTy) const override {
121 if (C->getType() == DestTy)
122 return C; // avoid calling Fold
123 return ConstFolder.CreateCast(Op, C, DestTy);
124 }
126 bool isSigned) const override {
127 if (C->getType() == DestTy)
128 return C; // avoid calling Fold
129 return ConstFolder.CreateIntCast(C, DestTy, isSigned);
130 }
131 Value *CreatePointerCast(Constant *C, Type *DestTy) const override {
132 if (C->getType() == DestTy)
133 return C; // avoid calling Fold
134 return ConstFolder.CreatePointerCast(C, DestTy);
135 }
136 Value *CreateFPCast(Constant *C, Type *DestTy) const override {
137 if (C->getType() == DestTy)
138 return C; // avoid calling Fold
139 return ConstFolder.CreateFPCast(C, DestTy);
140 }
141 Value *CreateBitCast(Constant *C, Type *DestTy) const override {
142 return ConstFolder.CreateBitCast(C, DestTy);
143 }
144 Value *CreateIntToPtr(Constant *C, Type *DestTy) const override {
145 return ConstFolder.CreateIntToPtr(C, DestTy);
146 }
147 Value *CreatePtrToInt(Constant *C, Type *DestTy) const override {
148 return ConstFolder.CreatePtrToInt(C, DestTy);
149 }
150 Value *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
151 if (C->getType() == DestTy)
152 return C; // avoid calling Fold
153 return ConstFolder.CreateZExtOrBitCast(C, DestTy);
154 }
155 Value *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
156 if (C->getType() == DestTy)
157 return C; // avoid calling Fold
158 return ConstFolder.CreateSExtOrBitCast(C, DestTy);
159 }
160 Value *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
161 if (C->getType() == DestTy)
162 return C; // avoid calling Fold
163 return ConstFolder.CreateTruncOrBitCast(C, DestTy);
164 }
165
167 Type *DestTy) const override {
168 if (C->getType() == DestTy)
169 return C; // avoid calling Fold
170 return ConstFolder.CreatePointerBitCastOrAddrSpaceCast(C, DestTy);
171 }
172
173 //===--------------------------------------------------------------------===//
174 // Compare Instructions
175 //===--------------------------------------------------------------------===//
176
178 Constant *RHS) const override {
179 return ConstFolder.CreateFCmp(P, LHS, RHS);
180 }
181};
182
183} // end namespace llvm
184
185#endif // LLVM_ANALYSIS_INSTSIMPLIFYFOLDER_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
return RetTy
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static bool isSigned(unsigned int Opcode)
#define P(N)
Value * RHS
Value * LHS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:718
This is an important base class in LLVM.
Definition: Constant.h:41
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:114
Convenience struct for specifying and reasoning about fast-math flags.
Definition: FMF.h:21
IRBuilderFolder - Interface for constant folding in IRBuilder.
InstSimplifyFolder - Use InstructionSimplify to fold operations to existing values.
Value * FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override
Value * CreateIntCast(Constant *C, Type *DestTy, bool isSigned) const override
Value * CreatePtrToInt(Constant *C, Type *DestTy) const override
Value * FoldExactBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, bool IsExact) const override
Value * FoldUnOpFMF(Instruction::UnaryOps Opc, Value *V, FastMathFlags FMF) const override
InstSimplifyFolder(const DataLayout &DL)
Value * CreateSExtOrBitCast(Constant *C, Type *DestTy) const override
Value * FoldBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS) const override
Value * FoldInsertElement(Value *Vec, Value *NewElt, Value *Idx) const override
Value * FoldNoWrapBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, bool HasNUW, bool HasNSW) const override
Value * CreateZExtOrBitCast(Constant *C, Type *DestTy) const override
Value * FoldSelect(Value *C, Value *True, Value *False) const override
Value * FoldBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, FastMathFlags FMF) const override
Value * FoldGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, bool IsInBounds=false) const override
Value * CreateBitCast(Constant *C, Type *DestTy) const override
Value * CreateFPCast(Constant *C, Type *DestTy) const override
Value * FoldInsertValue(Value *Agg, Value *Val, ArrayRef< unsigned > IdxList) const override
Value * CreateFCmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const override
Value * FoldShuffleVector(Value *V1, Value *V2, ArrayRef< int > Mask) const override
Value * FoldExtractElement(Value *Vec, Value *Idx) const override
Value * CreateIntToPtr(Constant *C, Type *DestTy) const override
Value * CreateTruncOrBitCast(Constant *C, Type *DestTy) const override
Value * FoldExtractValue(Value *Agg, ArrayRef< unsigned > IdxList) const override
Value * CreatePointerBitCastOrAddrSpaceCast(Constant *C, Type *DestTy) const override
Value * CreateCast(Instruction::CastOps Op, Constant *C, Type *DestTy) const override
Value * CreatePointerCast(Constant *C, Type *DestTy) const override
TargetFolder - Create constants with target dependent folding.
Definition: TargetFolder.h:34
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:682
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Value * simplifyUnOp(unsigned Opcode, Value *Op, const SimplifyQuery &Q)
Given operand for a UnaryOperator, fold the result or return null.
Value * simplifyShuffleVectorInst(Value *Op0, Value *Op1, ArrayRef< int > Mask, Type *RetTy, const SimplifyQuery &Q)
Given operands for a ShuffleVectorInst, fold the result or return null.
Value * simplifyExtractValueInst(Value *Agg, ArrayRef< unsigned > Idxs, const SimplifyQuery &Q)
Given operands for an ExtractValueInst, fold the result or return null.
Value * simplifyInsertValueInst(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const SimplifyQuery &Q)
Given operands for an InsertValueInst, fold the result or return null.
Value * simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an ICmpInst, fold the result or return null.
Value * simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a BinaryOperator, fold the result or return null.
Value * simplifyInsertElementInst(Value *Vec, Value *Elt, Value *Idx, const SimplifyQuery &Q)
Given operands for an InsertElement, fold the result or return null.
Value * simplifyGEPInst(Type *SrcTy, Value *Ptr, ArrayRef< Value * > Indices, bool InBounds, const SimplifyQuery &Q)
Given operands for a GetElementPtrInst, fold the result or return null.
Value * simplifyExtractElementInst(Value *Vec, Value *Idx, const SimplifyQuery &Q)
Given operands for an ExtractElementInst, fold the result or return null.
Value * simplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, const SimplifyQuery &Q)
Given operands for a SelectInst, fold the result or return null.