[llvm] 0b88ada - [InstSimplify] Add MaxRecurse argument to simplifyInstructionWithOperands (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Fri Apr 14 02:19:28 PDT 2023
Author: Nikita Popov
Date: 2023-04-14T11:19:19+02:00
New Revision: 0b88adacd6967d9ce47cc863e36ad1f02db6fbc9
URL: https://github.com/llvm/llvm-project/commit/0b88adacd6967d9ce47cc863e36ad1f02db6fbc9
DIFF: https://github.com/llvm/llvm-project/commit/0b88adacd6967d9ce47cc863e36ad1f02db6fbc9.diff
LOG: [InstSimplify] Add MaxRecurse argument to simplifyInstructionWithOperands (NFC)
Added:
Modified:
llvm/lib/Analysis/InstructionSimplify.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index 9cb6ba83c77c..e1c1210f4899 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -6681,7 +6681,8 @@ Value *llvm::simplifyLoadInst(LoadInst *LI, Value *PtrOp,
static Value *simplifyInstructionWithOperands(Instruction *I,
ArrayRef<Value *> NewOps,
- const SimplifyQuery &SQ) {
+ const SimplifyQuery &SQ,
+ unsigned MaxRecurse) {
const SimplifyQuery Q = SQ.CxtI ? SQ : SQ.getWithInstruction(I);
switch (I->getOpcode()) {
@@ -6694,85 +6695,98 @@ static Value *simplifyInstructionWithOperands(Instruction *I,
}
return nullptr;
case Instruction::FNeg:
- return simplifyFNegInst(NewOps[0], I->getFastMathFlags(), Q);
+ return simplifyFNegInst(NewOps[0], I->getFastMathFlags(), Q, MaxRecurse);
case Instruction::FAdd:
- return simplifyFAddInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
+ return simplifyFAddInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q,
+ MaxRecurse);
case Instruction::Add:
- return simplifyAddInst(NewOps[0], NewOps[1],
- Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
- Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
+ return simplifyAddInst(
+ NewOps[0], NewOps[1], Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
+ Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q, MaxRecurse);
case Instruction::FSub:
- return simplifyFSubInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
+ return simplifyFSubInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q,
+ MaxRecurse);
case Instruction::Sub:
- return simplifySubInst(NewOps[0], NewOps[1],
- Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
- Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
+ return simplifySubInst(
+ NewOps[0], NewOps[1], Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
+ Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q, MaxRecurse);
case Instruction::FMul:
- return simplifyFMulInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
+ return simplifyFMulInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q,
+ MaxRecurse);
case Instruction::Mul:
- return simplifyMulInst(NewOps[0], NewOps[1],
- Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
- Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
+ return simplifyMulInst(
+ NewOps[0], NewOps[1], Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
+ Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q, MaxRecurse);
case Instruction::SDiv:
return simplifySDivInst(NewOps[0], NewOps[1],
- Q.IIQ.isExact(cast<BinaryOperator>(I)), Q);
+ Q.IIQ.isExact(cast<BinaryOperator>(I)), Q,
+ MaxRecurse);
case Instruction::UDiv:
return simplifyUDivInst(NewOps[0], NewOps[1],
- Q.IIQ.isExact(cast<BinaryOperator>(I)), Q);
+ Q.IIQ.isExact(cast<BinaryOperator>(I)), Q,
+ MaxRecurse);
case Instruction::FDiv:
- return simplifyFDivInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
+ return simplifyFDivInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q,
+ MaxRecurse);
case Instruction::SRem:
- return simplifySRemInst(NewOps[0], NewOps[1], Q);
+ return simplifySRemInst(NewOps[0], NewOps[1], Q, MaxRecurse);
case Instruction::URem:
- return simplifyURemInst(NewOps[0], NewOps[1], Q);
+ return simplifyURemInst(NewOps[0], NewOps[1], Q, MaxRecurse);
case Instruction::FRem:
- return simplifyFRemInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
+ return simplifyFRemInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q,
+ MaxRecurse);
case Instruction::Shl:
- return simplifyShlInst(NewOps[0], NewOps[1],
- Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
- Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
+ return simplifyShlInst(
+ NewOps[0], NewOps[1], Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
+ Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q, MaxRecurse);
case Instruction::LShr:
return simplifyLShrInst(NewOps[0], NewOps[1],
- Q.IIQ.isExact(cast<BinaryOperator>(I)), Q);
+ Q.IIQ.isExact(cast<BinaryOperator>(I)), Q,
+ MaxRecurse);
case Instruction::AShr:
return simplifyAShrInst(NewOps[0], NewOps[1],
- Q.IIQ.isExact(cast<BinaryOperator>(I)), Q);
+ Q.IIQ.isExact(cast<BinaryOperator>(I)), Q,
+ MaxRecurse);
case Instruction::And:
- return simplifyAndInst(NewOps[0], NewOps[1], Q);
+ return simplifyAndInst(NewOps[0], NewOps[1], Q, MaxRecurse);
case Instruction::Or:
- return simplifyOrInst(NewOps[0], NewOps[1], Q);
+ return simplifyOrInst(NewOps[0], NewOps[1], Q, MaxRecurse);
case Instruction::Xor:
- return simplifyXorInst(NewOps[0], NewOps[1], Q);
+ return simplifyXorInst(NewOps[0], NewOps[1], Q, MaxRecurse);
case Instruction::ICmp:
return simplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), NewOps[0],
- NewOps[1], Q);
+ NewOps[1], Q, MaxRecurse);
case Instruction::FCmp:
return simplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), NewOps[0],
- NewOps[1], I->getFastMathFlags(), Q);
+ NewOps[1], I->getFastMathFlags(), Q, MaxRecurse);
case Instruction::Select:
- return simplifySelectInst(NewOps[0], NewOps[1], NewOps[2], Q);
+ return simplifySelectInst(NewOps[0], NewOps[1], NewOps[2], Q, MaxRecurse);
break;
case Instruction::GetElementPtr: {
auto *GEPI = cast<GetElementPtrInst>(I);
return simplifyGEPInst(GEPI->getSourceElementType(), NewOps[0],
- ArrayRef(NewOps).slice(1), GEPI->isInBounds(), Q);
+ ArrayRef(NewOps).slice(1), GEPI->isInBounds(), Q,
+ MaxRecurse);
}
case Instruction::InsertValue: {
InsertValueInst *IV = cast<InsertValueInst>(I);
- return simplifyInsertValueInst(NewOps[0], NewOps[1], IV->getIndices(), Q);
+ return simplifyInsertValueInst(NewOps[0], NewOps[1], IV->getIndices(), Q,
+ MaxRecurse);
}
case Instruction::InsertElement:
return simplifyInsertElementInst(NewOps[0], NewOps[1], NewOps[2], Q);
case Instruction::ExtractValue: {
auto *EVI = cast<ExtractValueInst>(I);
- return simplifyExtractValueInst(NewOps[0], EVI->getIndices(), Q);
+ return simplifyExtractValueInst(NewOps[0], EVI->getIndices(), Q,
+ MaxRecurse);
}
case Instruction::ExtractElement:
- return simplifyExtractElementInst(NewOps[0], NewOps[1], Q);
+ return simplifyExtractElementInst(NewOps[0], NewOps[1], Q, MaxRecurse);
case Instruction::ShuffleVector: {
auto *SVI = cast<ShuffleVectorInst>(I);
return simplifyShuffleVectorInst(NewOps[0], NewOps[1],
- SVI->getShuffleMask(), SVI->getType(), Q);
+ SVI->getShuffleMask(), SVI->getType(), Q,
+ MaxRecurse);
}
case Instruction::PHI:
return simplifyPHINode(cast<PHINode>(I), NewOps, Q);
@@ -6785,7 +6799,8 @@ static Value *simplifyInstructionWithOperands(Instruction *I,
#define HANDLE_CAST_INST(num, opc, clas) case Instruction::opc:
#include "llvm/IR/Instruction.def"
#undef HANDLE_CAST_INST
- return simplifyCastInst(I->getOpcode(), NewOps[0], I->getType(), Q);
+ return simplifyCastInst(I->getOpcode(), NewOps[0], I->getType(), Q,
+ MaxRecurse);
case Instruction::Alloca:
// No simplifications for Alloca and it can't be constant folded.
return nullptr;
@@ -6799,12 +6814,12 @@ Value *llvm::simplifyInstructionWithOperands(Instruction *I,
const SimplifyQuery &SQ) {
assert(NewOps.size() == I->getNumOperands() &&
"Number of operands should match the instruction!");
- return ::simplifyInstructionWithOperands(I, NewOps, SQ);
+ return ::simplifyInstructionWithOperands(I, NewOps, SQ, RecursionLimit);
}
Value *llvm::simplifyInstruction(Instruction *I, const SimplifyQuery &SQ) {
SmallVector<Value *, 8> Ops(I->operands());
- Value *Result = ::simplifyInstructionWithOperands(I, Ops, SQ);
+ Value *Result = ::simplifyInstructionWithOperands(I, Ops, SQ, RecursionLimit);
/// If called on unreachable code, the instruction may simplify to itself.
/// Make life easier for users by detecting that case here, and returning a
More information about the llvm-commits
mailing list