[llvm] 9641a20 - [DAG] Add initial SelectionDAG::canCreateUndefOrPoison support
Simon Pilgrim via llvm-commits
llvm-commits at lists.llvm.org
Mon Aug 8 07:16:14 PDT 2022
Author: Simon Pilgrim
Date: 2022-08-08T15:16:06+01:00
New Revision: 9641a201a565346bfddfc02b13b2b583c056e61d
URL: https://github.com/llvm/llvm-project/commit/9641a201a565346bfddfc02b13b2b583c056e61d
DIFF: https://github.com/llvm/llvm-project/commit/9641a201a565346bfddfc02b13b2b583c056e61d.diff
LOG: [DAG] Add initial SelectionDAG::canCreateUndefOrPoison support
This patch adds basic support for a DAG variant of the canCreateUndefOrPoison call and updates DAGCombiner::visitFREEZE to use it, further Opcodes (including target specific Opcodes) can be handled when we have test coverage.
So far, I've left visitFREEZE to just use this for unary nodes (which currently means the existing BITCAST/FREEZE cases) - later patches will add other unary opcodes (with test coverage) and we can also refactor visitFREEZE to support a general number of operands like we do in InstCombinerImpl::pushFreezeToPreventPoisonFromPropagating.
I'm not aware of any vector test freeze coverage so the DemandedElts (and the Depth) args are not being used yet - but they are in place. Similarly we will be able to handle poison generating SDNodeFlags as and when it becomes an issue.
Part of the work for D106675 / PR50468
Differential Revision: https://reviews.llvm.org/D130646
Added:
Modified:
llvm/include/llvm/CodeGen/SelectionDAG.h
llvm/include/llvm/CodeGen/TargetLowering.h
llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h
index c22c987fc666..7417ff472f03 100644
--- a/llvm/include/llvm/CodeGen/SelectionDAG.h
+++ b/llvm/include/llvm/CodeGen/SelectionDAG.h
@@ -1973,6 +1973,32 @@ class SelectionDAG {
/*PoisonOnly*/ true, Depth);
}
+ /// Return true if Op can create undef or poison from non-undef & non-poison
+ /// operands. The DemandedElts argument limits the check to the requested
+ /// vector elements.
+ ///
+ /// \p ConsiderFlags controls whether poison producing flags on the
+ /// instruction are considered. This can be used to see if the instruction
+ /// could still introduce undef or poison even without poison generating flags
+ /// which might be on the instruction. (i.e. could the result of
+ /// Op->dropPoisonGeneratingFlags() still create poison or undef)
+ bool canCreateUndefOrPoison(SDValue Op, const APInt &DemandedElts,
+ bool PoisonOnly = false,
+ bool ConsiderFlags = true,
+ unsigned Depth = 0) const;
+
+ /// Return true if Op can create undef or poison from non-undef & non-poison
+ /// operands.
+ ///
+ /// \p ConsiderFlags controls whether poison producing flags on the
+ /// instruction are considered. This can be used to see if the instruction
+ /// could still introduce undef or poison even without poison generating flags
+ /// which might be on the instruction. (i.e. could the result of
+ /// Op->dropPoisonGeneratingFlags() still create poison or undef)
+ bool canCreateUndefOrPoison(SDValue Op, bool PoisonOnly = false,
+ bool ConsiderFlags = true,
+ unsigned Depth = 0) const;
+
/// Return true if the specified operand is an ISD::ADD with a ConstantSDNode
/// on the right-hand side, or if it is an ISD::OR with a ConstantSDNode that
/// is guaranteed to have the same semantics as an ADD. This handles the
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index a06194417317..251fda1bae86 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -3776,6 +3776,14 @@ class TargetLowering : public TargetLoweringBase {
SDValue Op, const APInt &DemandedElts, const SelectionDAG &DAG,
bool PoisonOnly, unsigned Depth) const;
+ /// Return true if Op can create undef or poison from non-undef & non-poison
+ /// operands. The DemandedElts argument limits the check to the requested
+ /// vector elements.
+ virtual bool
+ canCreateUndefOrPoisonForTargetNode(SDValue Op, const APInt &DemandedElts,
+ const SelectionDAG &DAG, bool PoisonOnly,
+ bool ConsiderFlags, unsigned Depth) const;
+
/// Tries to build a legal vector shuffle using the provided parameters
/// or equivalent variations. The Mask argument maybe be modified as the
/// function tries
diff erent variations.
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 28ea2a458d7c..8f2b1089129b 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -13863,13 +13863,15 @@ SDValue DAGCombiner::visitFREEZE(SDNode *N) {
if (DAG.isGuaranteedNotToBeUndefOrPoison(N0, /*PoisonOnly*/ false))
return N0;
- // Fold freeze(bitcast(x)) -> bitcast(freeze(x)).
- // TODO: Replace with pushFreezeToPreventPoisonFromPropagating fold.
- if (N0.getOpcode() == ISD::BITCAST)
- return DAG.getBitcast(N->getValueType(0),
- DAG.getNode(ISD::FREEZE, SDLoc(N0),
- N0.getOperand(0).getValueType(),
- N0.getOperand(0)));
+ // Fold freeze(unaryop(x)) -> unaryop(freeze(x)).
+ // TODO: Replace with pushFreezeToPreventPoisonFromPropagating fold and
+ // support getNumOperands() >= 1.
+ if (N0.getNumOperands() == 1 &&
+ !DAG.canCreateUndefOrPoison(N0, /*PoisonOnly*/ false) && N0->hasOneUse())
+ return DAG.getNode(N0.getOpcode(), SDLoc(N0), N->getValueType(0),
+ DAG.getNode(ISD::FREEZE, SDLoc(N0),
+ N0.getOperand(0).getValueType(),
+ N0.getOperand(0)));
return SDValue();
}
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index f6f06bb0bb60..3515791bdb83 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -4535,6 +4535,48 @@ bool SelectionDAG::isGuaranteedNotToBeUndefOrPoison(SDValue Op,
return false;
}
+bool SelectionDAG::canCreateUndefOrPoison(SDValue Op, bool PoisonOnly,
+ bool ConsiderFlags,
+ unsigned Depth) const {
+ // TODO: Assume we don't know anything for now.
+ EVT VT = Op.getValueType();
+ if (VT.isScalableVector())
+ return true;
+
+ APInt DemandedElts = VT.isVector()
+ ? APInt::getAllOnes(VT.getVectorNumElements())
+ : APInt(1, 1);
+ return canCreateUndefOrPoison(Op, DemandedElts, PoisonOnly, ConsiderFlags,
+ Depth);
+}
+
+bool SelectionDAG::canCreateUndefOrPoison(SDValue Op, const APInt &DemandedElts,
+ bool PoisonOnly, bool ConsiderFlags,
+ unsigned Depth) const {
+ // TODO: Assume we don't know anything for now.
+ EVT VT = Op.getValueType();
+ if (VT.isScalableVector())
+ return true;
+
+ unsigned Opcode = Op.getOpcode();
+ switch (Opcode) {
+ case ISD::BITCAST:
+ case ISD::FREEZE:
+ return false;
+
+ default:
+ // Allow the target to implement this method for its nodes.
+ if (Opcode >= ISD::BUILTIN_OP_END || Opcode == ISD::INTRINSIC_WO_CHAIN ||
+ Opcode == ISD::INTRINSIC_W_CHAIN || Opcode == ISD::INTRINSIC_VOID)
+ return TLI->canCreateUndefOrPoisonForTargetNode(
+ Op, DemandedElts, *this, PoisonOnly, ConsiderFlags, Depth);
+ break;
+ }
+
+ // Be conservative and return true.
+ return true;
+}
+
bool SelectionDAG::isBaseWithConstantOffset(SDValue Op) const {
if ((Op.getOpcode() != ISD::ADD && Op.getOpcode() != ISD::OR) ||
!isa<ConstantSDNode>(Op.getOperand(1)))
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index f5b0c485982f..8aefb5b363d5 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -3580,6 +3580,19 @@ bool TargetLowering::isGuaranteedNotToBeUndefOrPoisonForTargetNode(
return false;
}
+bool TargetLowering::canCreateUndefOrPoisonForTargetNode(
+ SDValue Op, const APInt &DemandedElts, const SelectionDAG &DAG,
+ bool PoisonOnly, bool ConsiderFlags, unsigned Depth) const {
+ assert((Op.getOpcode() >= ISD::BUILTIN_OP_END ||
+ Op.getOpcode() == ISD::INTRINSIC_WO_CHAIN ||
+ Op.getOpcode() == ISD::INTRINSIC_W_CHAIN ||
+ Op.getOpcode() == ISD::INTRINSIC_VOID) &&
+ "Should use canCreateUndefOrPoison if you don't know whether Op"
+ " is a target node!");
+ // Be conservative and return true.
+ return true;
+}
+
bool TargetLowering::isKnownNeverNaNForTargetNode(SDValue Op,
const SelectionDAG &DAG,
bool SNaN,
More information about the llvm-commits
mailing list