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"
23 #include "llvm/Analysis/InstructionSimplify.h"
24 #include "llvm/Analysis/TargetFolder.h"
25 #include "llvm/IR/IRBuilderFolder.h"
26 #include "llvm/IR/Instruction.h"
27 
28 namespace llvm {
29 class Constant;
30 
31 /// InstSimplifyFolder - Use InstructionSimplify to fold operations to existing
32 /// values. Also applies target-specific constant folding when not using
33 /// InstructionSimplify.
34 class InstSimplifyFolder final : public IRBuilderFolder {
35   TargetFolder ConstFolder;
36   SimplifyQuery SQ;
37 
38   virtual void anchor();
39 
40 public:
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 
50   Value *FoldBinOp(Instruction::BinaryOps Opc, Value *LHS,
51                    Value *RHS) const override {
52     return simplifyBinOp(Opc, LHS, RHS, SQ);
53   }
54 
55   Value *FoldExactBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
56                         bool IsExact) const override {
57     return simplifyBinOp(Opc, LHS, RHS, SQ);
58   }
59 
60   Value *FoldNoWrapBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
61                          bool HasNUW, bool HasNSW) const override {
62     return simplifyBinOp(Opc, LHS, RHS, SQ);
63   }
64 
65   Value *FoldBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
66                       FastMathFlags FMF) const override {
67     return simplifyBinOp(Opc, LHS, RHS, FMF, SQ);
68   }
69 
70   Value *FoldUnOpFMF(Instruction::UnaryOps Opc, Value *V,
71                       FastMathFlags FMF) const override {
72     return simplifyUnOp(Opc, V, FMF, SQ);
73   }
74 
75   Value *FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override {
76     return simplifyICmpInst(P, LHS, RHS, SQ);
77   }
78 
79   Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
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 
88   Value *FoldExtractValue(Value *Agg,
89                           ArrayRef<unsigned> IdxList) const override {
90     return simplifyExtractValueInst(Agg, IdxList, SQ);
91   };
92 
93   Value *FoldInsertValue(Value *Agg, Value *Val,
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 
102   Value *FoldInsertElement(Value *Vec, Value *NewElt,
103                            Value *Idx) const override {
104     return simplifyInsertElementInst(Vec, NewElt, Idx, SQ);
105   }
106 
107   Value *FoldShuffleVector(Value *V1, Value *V2,
108                            ArrayRef<int> Mask) const override {
109     Type *RetTy = VectorType::get(
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 
119   Value *CreateCast(Instruction::CastOps Op, Constant *C,
120                     Type *DestTy) const override {
121     if (C->getType() == DestTy)
122       return C; // avoid calling Fold
123     return ConstFolder.CreateCast(Op, C, DestTy);
124   }
125   Value *CreateIntCast(Constant *C, Type *DestTy,
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 
166   Value *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
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 
177   Value *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
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
186