[llvm] 8d4d498 - [DAG] Use SelectionDAG::FoldConstantArithmetic directly to match constant operands
Simon Pilgrim via llvm-commits
llvm-commits at lists.llvm.org
Sat May 14 06:19:23 PDT 2022
Author: Simon Pilgrim
Date: 2022-05-14T14:19:12+01:00
New Revision: 8d4d4988e43e8a164637c436437809c787a2b59f
URL: https://github.com/llvm/llvm-project/commit/8d4d4988e43e8a164637c436437809c787a2b59f
DIFF: https://github.com/llvm/llvm-project/commit/8d4d4988e43e8a164637c436437809c787a2b59f.diff
LOG: [DAG] Use SelectionDAG::FoldConstantArithmetic directly to match constant operands
SelectionDAG::FoldConstantArithmetic determines if operands are foldable constants, so we don't need to bother with isConstantOrConstantVector / Opaque tests before calling it directly.
Added:
Modified:
llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
Removed:
################################################################################
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 9c052a650bd9a..9ea18070821a0 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -3477,44 +3477,31 @@ SDValue DAGCombiner::visitSUB(SDNode *N) {
return N0.getOperand(0);
// fold (A+C1)-C2 -> A+(C1-C2)
- if (N0.getOpcode() == ISD::ADD &&
- isConstantOrConstantVector(N1, /* NoOpaques */ true) &&
- isConstantOrConstantVector(N0.getOperand(1), /* NoOpaques */ true)) {
- SDValue NewC =
- DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, {N0.getOperand(1), N1});
- assert(NewC && "Constant folding failed");
- return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), NewC);
+ if (N0.getOpcode() == ISD::ADD) {
+ SDValue N01 = N0.getOperand(1);
+ if (SDValue NewC = DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, {N01, N1}))
+ return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), NewC);
}
// fold C2-(A+C1) -> (C2-C1)-A
if (N1.getOpcode() == ISD::ADD) {
SDValue N11 = N1.getOperand(1);
- if (isConstantOrConstantVector(N0, /* NoOpaques */ true) &&
- isConstantOrConstantVector(N11, /* NoOpaques */ true)) {
- SDValue NewC = DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, {N0, N11});
- assert(NewC && "Constant folding failed");
+ if (SDValue NewC = DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, {N0, N11}))
return DAG.getNode(ISD::SUB, DL, VT, NewC, N1.getOperand(0));
- }
}
// fold (A-C1)-C2 -> A-(C1+C2)
- if (N0.getOpcode() == ISD::SUB &&
- isConstantOrConstantVector(N1, /* NoOpaques */ true) &&
- isConstantOrConstantVector(N0.getOperand(1), /* NoOpaques */ true)) {
- SDValue NewC =
- DAG.FoldConstantArithmetic(ISD::ADD, DL, VT, {N0.getOperand(1), N1});
- assert(NewC && "Constant folding failed");
- return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), NewC);
+ if (N0.getOpcode() == ISD::SUB) {
+ SDValue N01 = N0.getOperand(1);
+ if (SDValue NewC = DAG.FoldConstantArithmetic(ISD::ADD, DL, VT, {N01, N1}))
+ return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), NewC);
}
// fold (c1-A)-c2 -> (c1-c2)-A
- if (N0.getOpcode() == ISD::SUB &&
- isConstantOrConstantVector(N1, /* NoOpaques */ true) &&
- isConstantOrConstantVector(N0.getOperand(0), /* NoOpaques */ true)) {
- SDValue NewC =
- DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, {N0.getOperand(0), N1});
- assert(NewC && "Constant folding failed");
- return DAG.getNode(ISD::SUB, DL, VT, NewC, N0.getOperand(1));
+ if (N0.getOpcode() == ISD::SUB) {
+ SDValue N00 = N0.getOperand(0);
+ if (SDValue NewC = DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, {N00, N1}))
+ return DAG.getNode(ISD::SUB, DL, VT, NewC, N0.getOperand(1));
}
// fold ((A+(B+or-C))-B) -> A+or-C
@@ -4032,11 +4019,10 @@ SDValue DAGCombiner::visitMUL(SDNode *N) {
}
// (mul (shl X, c1), c2) -> (mul X, c2 << c1)
- if (N0.getOpcode() == ISD::SHL &&
- isConstantOrConstantVector(N1, /* NoOpaques */ true) &&
- isConstantOrConstantVector(N0.getOperand(1), /* NoOpaques */ true)) {
- SDValue C3 = DAG.getNode(ISD::SHL, SDLoc(N), VT, N1, N0.getOperand(1));
- if (isConstantOrConstantVector(C3))
+ if (N0.getOpcode() == ISD::SHL) {
+ SDValue N01 = N0.getOperand(1);
+ if (SDValue C3 =
+ DAG.FoldConstantArithmetic(ISD::SHL, SDLoc(N), VT, {N1, N01}))
return DAG.getNode(ISD::MUL, SDLoc(N), VT, N0.getOperand(0), C3);
}
@@ -9024,11 +9010,10 @@ SDValue DAGCombiner::visitSHL(SDNode *N) {
}
// fold (shl (mul x, c1), c2) -> (mul x, c1 << c2)
- if (N0.getOpcode() == ISD::MUL && N0->hasOneUse() &&
- isConstantOrConstantVector(N1, /* No Opaques */ true) &&
- isConstantOrConstantVector(N0.getOperand(1), /* No Opaques */ true)) {
- SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N1), VT, N0.getOperand(1), N1);
- if (isConstantOrConstantVector(Shl))
+ if (N0.getOpcode() == ISD::MUL && N0->hasOneUse()) {
+ SDValue N01 = N0.getOperand(1);
+ if (SDValue Shl =
+ DAG.FoldConstantArithmetic(ISD::SHL, SDLoc(N1), VT, {N01, N1}))
return DAG.getNode(ISD::MUL, SDLoc(N), VT, N0.getOperand(0), Shl);
}
More information about the llvm-commits
mailing list