[llvm-branch-commits] [llvm] [LoongArch] Remove redundant divisor guards from vector div/rem (PR #244485)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Nov 19 18:19:27 PST 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-loongarch
Author: hev (heiher)
<details>
<summary>Changes</summary>
The Rust portable implementations of the [x]vdiv/[x]vmod intrinsics guard the divisor against zero and signed overflow, e.g.
```
%bz = icmp eq %b, 0
%guard = or %bz, (and (icmp eq %a, MIN), (icmp eq %b, -1))
%d = select %guard, splat (1), %b
%q = sdiv %a, %d
%r = select %bz, splat (0), %q
```
The hardware already returns 0 for x / 0 and x % 0, MIN for MIN / -1 and 0 for MIN % -1, so the guards are redundant. Fold them into new VDIV/VDIV_U/VMOD/VMOD_U nodes to emit a single [x]vdiv/[x]vmod.
Assisted-by: LLM
---
Patch is 32.21 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/244485.diff
5 Files Affected:
- (modified) llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp (+123)
- (modified) llvm/lib/Target/LoongArch/LoongArchLASXInstrInfo.td (+4)
- (modified) llvm/lib/Target/LoongArch/LoongArchLSXInstrInfo.td (+11)
- (modified) llvm/test/CodeGen/LoongArch/lasx/guarded-div-rem.ll (+16-146)
- (modified) llvm/test/CodeGen/LoongArch/lsx/guarded-div-rem.ll (+16-146)
``````````diff
diff --git a/llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp b/llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp
index c263ed4570bde..91e76ea6b9338 100644
--- a/llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp
+++ b/llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp
@@ -546,6 +546,7 @@ LoongArchTargetLowering::LoongArchTargetLowering(const TargetMachine &TM,
setTargetDAGCombine(ISD::ZERO_EXTEND);
setTargetDAGCombine(ISD::SIGN_EXTEND);
setTargetDAGCombine(ISD::MUL);
+ setTargetDAGCombine({ISD::SREM, ISD::UREM});
}
// Set DAG combine for 'LASX' feature.
@@ -9380,9 +9381,128 @@ performCONCAT_VECTORSCombine(SDNode *N, SelectionDAG &DAG,
return SDValue();
}
+// Match (seteq X, splat(C)) where C satisfies Pred.
+static bool isSetEqSplat(SDValue V, SDValue X,
+ function_ref<bool(const APInt &)> Pred) {
+ if (V.getOpcode() != ISD::SETCC ||
+ cast<CondCodeSDNode>(V.getOperand(2))->get() != ISD::SETEQ)
+ return false;
+
+ SDValue LHS = V.getOperand(0);
+ SDValue RHS = V.getOperand(1);
+ if (RHS == X)
+ std::swap(LHS, RHS);
+ if (LHS != X)
+ return false;
+
+ ConstantSDNode *C = isConstOrConstSplat(RHS, /*AllowUndefs=*/false,
+ /*AllowTruncation=*/true);
+ return C && Pred(C->getAPIntValue().trunc(X.getScalarValueSizeInBits()));
+}
+
+// The [x]vdiv/[x]vmod instructions return x / 0 = 0, x % 0 = 0,
+// MIN / -1 = MIN and MIN % -1 = 0. Return true if, in the lanes where Cond is
+// set, dividing A by 1 gives the same result as the instruction with B. For
+// division, the caller must zero the lanes where B is zero.
+static bool isRedundantDivisorGuard(SDValue Cond, SDValue A, SDValue B,
+ unsigned Opc, unsigned Depth = 0) {
+ if (Depth >= 6)
+ return false;
+
+ switch (Cond.getOpcode()) {
+ case ISD::OR:
+ return isRedundantDivisorGuard(Cond.getOperand(0), A, B, Opc, Depth + 1) &&
+ isRedundantDivisorGuard(Cond.getOperand(1), A, B, Opc, Depth + 1);
+ case ISD::AND: {
+ SDValue Op0 = Cond.getOperand(0);
+ SDValue Op1 = Cond.getOperand(1);
+ if (isRedundantDivisorGuard(Op0, A, B, Opc, Depth + 1) ||
+ isRedundantDivisorGuard(Op1, A, B, Opc, Depth + 1))
+ return true;
+
+ // MIN / -1 = MIN / 1.
+ auto IsOverflow = [&](SDValue X, SDValue Y) {
+ return isSetEqSplat(
+ X, A, [](const APInt &C) { return C.isMinSignedValue(); }) &&
+ isSetEqSplat(Y, B, [](const APInt &C) { return C.isAllOnes(); });
+ };
+ return Opc == ISD::SDIV && (IsOverflow(Op0, Op1) || IsOverflow(Op1, Op0));
+ }
+ default:
+ break;
+ }
+
+ // x / 1 = x and x % 1 = x % 0 = 0.
+ if (isSetEqSplat(Cond, B, [](const APInt &C) { return C.isOne(); }) ||
+ isSetEqSplat(Cond, B, [](const APInt &C) { return C.isZero(); }))
+ return true;
+
+ // x % -1 = x % 1 = 0.
+ return Opc == ISD::SREM &&
+ isSetEqSplat(Cond, B, [](const APInt &C) { return C.isAllOnes(); });
+}
+
+// Match B guarded by a redundant select or umax, and return B.
+static SDValue matchGuardedDivisor(SDValue D, SDValue A, unsigned Opc) {
+ // umax(b, 1) == select(b == 0, 1, b).
+ if (D.getOpcode() == ISD::UMAX && isOneOrOneSplat(D.getOperand(1)))
+ return D.getOperand(0);
+
+ if (D.getOpcode() == ISD::VSELECT && isOneOrOneSplat(D.getOperand(1)) &&
+ isRedundantDivisorGuard(D.getOperand(0), A, D.getOperand(2), Opc))
+ return D.getOperand(2);
+
+ return SDValue();
+}
+
+// (srem/urem a, (guarded b)) -> (VMOD/VMOD_U a, b)
+static SDValue performREMCombine(SDNode *N, SelectionDAG &DAG,
+ TargetLowering::DAGCombinerInfo &DCI,
+ const LoongArchSubtarget &Subtarget) {
+ EVT VT = N->getValueType(0);
+ if (!VT.isVector() || !DAG.getTargetLoweringInfo().isTypeLegal(VT))
+ return SDValue();
+
+ unsigned Opc = N->getOpcode();
+ SDValue A = N->getOperand(0);
+ SDValue B = matchGuardedDivisor(N->getOperand(1), A, Opc);
+ if (!B)
+ return SDValue();
+
+ return DAG.getNode(Opc == ISD::SREM ? LoongArchISD::VMOD
+ : LoongArchISD::VMOD_U,
+ SDLoc(N), VT, A, B);
+}
+
+// (vselect (seteq b, 0), 0, (sdiv/udiv a, (guarded b))) -> (VDIV/VDIV_U a, b)
+static SDValue combineGuardedVectorDiv(SDNode *N, SelectionDAG &DAG) {
+ EVT VT = N->getValueType(0);
+ if (!VT.isVector() || !DAG.getTargetLoweringInfo().isTypeLegal(VT))
+ return SDValue();
+
+ SDValue Div = N->getOperand(2);
+ unsigned Opc = Div.getOpcode();
+ if ((Opc != ISD::SDIV && Opc != ISD::UDIV) || !Div.hasOneUse() ||
+ !ISD::isConstantSplatVectorAllZeros(N->getOperand(1)))
+ return SDValue();
+
+ SDValue A = Div.getOperand(0);
+ SDValue B = matchGuardedDivisor(Div.getOperand(1), A, Opc);
+ if (!B || !isSetEqSplat(N->getOperand(0), B,
+ [](const APInt &C) { return C.isZero(); }))
+ return SDValue();
+
+ return DAG.getNode(Opc == ISD::SDIV ? LoongArchISD::VDIV
+ : LoongArchISD::VDIV_U,
+ SDLoc(N), VT, A, B);
+}
+
static SDValue performVSELECTCombine(SDNode *N, SelectionDAG &DAG,
TargetLowering::DAGCombinerInfo &DCI,
const LoongArchSubtarget &Subtarget) {
+ if (SDValue V = combineGuardedVectorDiv(N, DAG))
+ return V;
+
if (DCI.isBeforeLegalizeOps())
return SDValue();
@@ -9864,6 +9984,9 @@ SDValue LoongArchTargetLowering::PerformDAGCombine(SDNode *N,
break;
case ISD::MUL:
return performMULCombine(N, DAG, DCI, Subtarget);
+ case ISD::SREM:
+ case ISD::UREM:
+ return performREMCombine(N, DAG, DCI, Subtarget);
}
return SDValue();
}
diff --git a/llvm/lib/Target/LoongArch/LoongArchLASXInstrInfo.td b/llvm/lib/Target/LoongArch/LoongArchLASXInstrInfo.td
index 79d897646d3ba..2ae9e62d3e2ad 100644
--- a/llvm/lib/Target/LoongArch/LoongArchLASXInstrInfo.td
+++ b/llvm/lib/Target/LoongArch/LoongArchLASXInstrInfo.td
@@ -2103,10 +2103,14 @@ defm : PatXrXrXr<mulsub, "XVMSUB">;
// XVDIV_{B/H/W/D}[U]
defm : PatXrXr<sdiv, "XVDIV">;
defm : PatXrXrU<udiv, "XVDIV">;
+defm : PatXrXr<loongarch_vdiv, "XVDIV">;
+defm : PatXrXrU<loongarch_vdiv_u, "XVDIV">;
// XVMOD_{B/H/W/D}[U]
defm : PatXrXr<srem, "XVMOD">;
defm : PatXrXrU<urem, "XVMOD">;
+defm : PatXrXr<loongarch_vmod, "XVMOD">;
+defm : PatXrXrU<loongarch_vmod_u, "XVMOD">;
// XVAND_V
foreach vt = [v32i8, v16i16, v8i32, v4i64] in
diff --git a/llvm/lib/Target/LoongArch/LoongArchLSXInstrInfo.td b/llvm/lib/Target/LoongArch/LoongArchLSXInstrInfo.td
index 3f60a13e433f0..d04963a217f60 100644
--- a/llvm/lib/Target/LoongArch/LoongArchLSXInstrInfo.td
+++ b/llvm/lib/Target/LoongArch/LoongArchLSXInstrInfo.td
@@ -75,6 +75,13 @@ def loongarch_vilvl: SDNode<"LoongArchISD::VILVL", SDT_LoongArchV2R>;
def loongarch_vilvh: SDNode<"LoongArchISD::VILVH", SDT_LoongArchV2R>;
def loongarch_vandn: SDNode<"LoongArchISD::VANDN", SDT_LoongArchV2R>;
+// Vector div/rem with defined results: x / 0 = 0, x % 0 = 0, MIN / -1 = MIN
+// and MIN % -1 = 0.
+def loongarch_vdiv : SDNode<"LoongArchISD::VDIV", SDT_LoongArchV2R>;
+def loongarch_vdiv_u : SDNode<"LoongArchISD::VDIV_U", SDT_LoongArchV2R>;
+def loongarch_vmod : SDNode<"LoongArchISD::VMOD", SDT_LoongArchV2R>;
+def loongarch_vmod_u : SDNode<"LoongArchISD::VMOD_U", SDT_LoongArchV2R>;
+
def loongarch_vshuf4i: SDNode<"LoongArchISD::VSHUF4I", SDT_LoongArchV1RUimm>;
def loongarch_vshuf4i_d : SDNode<"LoongArchISD::VSHUF4I_D", SDT_LoongArchV2RUimm>;
def loongarch_vreplvei: SDNode<"LoongArchISD::VREPLVEI", SDT_LoongArchV1RUimm>;
@@ -2351,10 +2358,14 @@ defm : PatVrVrVr<mulsub, "VMSUB">;
// VDIV_{B/H/W/D}[U]
defm : PatVrVr<sdiv, "VDIV">;
defm : PatVrVrU<udiv, "VDIV">;
+defm : PatVrVr<loongarch_vdiv, "VDIV">;
+defm : PatVrVrU<loongarch_vdiv_u, "VDIV">;
// VMOD_{B/H/W/D}[U]
defm : PatVrVr<srem, "VMOD">;
defm : PatVrVrU<urem, "VMOD">;
+defm : PatVrVr<loongarch_vmod, "VMOD">;
+defm : PatVrVrU<loongarch_vmod_u, "VMOD">;
// VAND_V
foreach vt = [v16i8, v8i16, v4i32, v2i64] in
diff --git a/llvm/test/CodeGen/LoongArch/lasx/guarded-div-rem.ll b/llvm/test/CodeGen/LoongArch/lasx/guarded-div-rem.ll
index ded1fac16a984..550826b8104c8 100644
--- a/llvm/test/CodeGen/LoongArch/lasx/guarded-div-rem.ll
+++ b/llvm/test/CodeGen/LoongArch/lasx/guarded-div-rem.ll
@@ -1,6 +1,6 @@
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 6
-; RUN: llc --mtriple=loongarch32 --mattr=+32s,+lasx < %s | FileCheck %s --check-prefixes=CHECK,LA32
-; RUN: llc --mtriple=loongarch64 --mattr=+lasx < %s | FileCheck %s --check-prefixes=CHECK,LA64
+; RUN: llc --mtriple=loongarch32 --mattr=+32s,+lasx < %s | FileCheck %s
+; RUN: llc --mtriple=loongarch64 --mattr=+lasx < %s | FileCheck %s
; The divisor guards are redundant, as the hardware returns x / 0 = 0,
; x % 0 = 0, MIN / -1 = MIN and MIN % -1 = 0.
@@ -8,15 +8,7 @@
define <32 x i8> @lasx_xvdiv_b(<32 x i8> %a, <32 x i8> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_b:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.b $xr2, $xr1, 0
-; CHECK-NEXT: xvrepli.b $xr3, -128
-; CHECK-NEXT: xvseq.b $xr3, $xr0, $xr3
-; CHECK-NEXT: xvseqi.b $xr4, $xr1, -1
-; CHECK-NEXT: xvand.v $xr3, $xr3, $xr4
-; CHECK-NEXT: xvor.v $xr3, $xr2, $xr3
-; CHECK-NEXT: xvbitseli.b $xr3, $xr1, 1
-; CHECK-NEXT: xvdiv.b $xr0, $xr0, $xr3
-; CHECK-NEXT: xvandn.v $xr0, $xr2, $xr0
+; CHECK-NEXT: xvdiv.b $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
%bz = icmp eq <32 x i8> %b, zeroinitializer
@@ -33,10 +25,7 @@ entry:
define <32 x i8> @lasx_xvdiv_bu(<32 x i8> %a, <32 x i8> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_bu:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.bu $xr2, $xr1, 1
-; CHECK-NEXT: xvdiv.bu $xr0, $xr0, $xr2
-; CHECK-NEXT: xvseqi.b $xr1, $xr1, 0
-; CHECK-NEXT: xvandn.v $xr0, $xr1, $xr0
+; CHECK-NEXT: xvdiv.bu $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
%bz = icmp eq <32 x i8> %b, zeroinitializer
@@ -49,14 +38,7 @@ entry:
define <32 x i8> @lasx_xvmod_b(<32 x i8> %a, <32 x i8> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_b:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.b $xr2, $xr1, 0
-; CHECK-NEXT: xvrepli.b $xr3, -128
-; CHECK-NEXT: xvseq.b $xr3, $xr0, $xr3
-; CHECK-NEXT: xvseqi.b $xr4, $xr1, -1
-; CHECK-NEXT: xvand.v $xr3, $xr3, $xr4
-; CHECK-NEXT: xvor.v $xr2, $xr2, $xr3
-; CHECK-NEXT: xvbitseli.b $xr2, $xr1, 1
-; CHECK-NEXT: xvmod.b $xr0, $xr0, $xr2
+; CHECK-NEXT: xvmod.b $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
%bz = icmp eq <32 x i8> %b, zeroinitializer
@@ -72,7 +54,6 @@ entry:
define <32 x i8> @lasx_xvmod_bu(<32 x i8> %a, <32 x i8> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_bu:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.bu $xr1, $xr1, 1
; CHECK-NEXT: xvmod.bu $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
@@ -84,16 +65,7 @@ entry:
define <16 x i16> @lasx_xvdiv_h(<16 x i16> %a, <16 x i16> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_h:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.h $xr2, $xr1, 0
-; CHECK-NEXT: xvldi $xr3, -2688
-; CHECK-NEXT: xvseq.h $xr3, $xr0, $xr3
-; CHECK-NEXT: xvseqi.h $xr4, $xr1, -1
-; CHECK-NEXT: xvand.v $xr3, $xr3, $xr4
-; CHECK-NEXT: xvor.v $xr3, $xr2, $xr3
-; CHECK-NEXT: xvrepli.h $xr4, 1
-; CHECK-NEXT: xvbitsel.v $xr1, $xr1, $xr4, $xr3
; CHECK-NEXT: xvdiv.h $xr0, $xr0, $xr1
-; CHECK-NEXT: xvandn.v $xr0, $xr2, $xr0
; CHECK-NEXT: ret
entry:
%bz = icmp eq <16 x i16> %b, zeroinitializer
@@ -110,10 +82,7 @@ entry:
define <16 x i16> @lasx_xvdiv_hu(<16 x i16> %a, <16 x i16> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_hu:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.hu $xr2, $xr1, 1
-; CHECK-NEXT: xvdiv.hu $xr0, $xr0, $xr2
-; CHECK-NEXT: xvseqi.h $xr1, $xr1, 0
-; CHECK-NEXT: xvandn.v $xr0, $xr1, $xr0
+; CHECK-NEXT: xvdiv.hu $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
%bz = icmp eq <16 x i16> %b, zeroinitializer
@@ -126,14 +95,6 @@ entry:
define <16 x i16> @lasx_xvmod_h(<16 x i16> %a, <16 x i16> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_h:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.h $xr2, $xr1, 0
-; CHECK-NEXT: xvldi $xr3, -2688
-; CHECK-NEXT: xvseq.h $xr3, $xr0, $xr3
-; CHECK-NEXT: xvseqi.h $xr4, $xr1, -1
-; CHECK-NEXT: xvand.v $xr3, $xr3, $xr4
-; CHECK-NEXT: xvor.v $xr2, $xr2, $xr3
-; CHECK-NEXT: xvrepli.h $xr3, 1
-; CHECK-NEXT: xvbitsel.v $xr1, $xr1, $xr3, $xr2
; CHECK-NEXT: xvmod.h $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
@@ -150,7 +111,6 @@ entry:
define <16 x i16> @lasx_xvmod_hu(<16 x i16> %a, <16 x i16> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_hu:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.hu $xr1, $xr1, 1
; CHECK-NEXT: xvmod.hu $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
@@ -162,16 +122,7 @@ entry:
define <8 x i32> @lasx_xvdiv_w(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_w:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.w $xr2, $xr1, 0
-; CHECK-NEXT: xvldi $xr3, -3200
-; CHECK-NEXT: xvseq.w $xr3, $xr0, $xr3
-; CHECK-NEXT: xvseqi.w $xr4, $xr1, -1
-; CHECK-NEXT: xvand.v $xr3, $xr3, $xr4
-; CHECK-NEXT: xvor.v $xr3, $xr2, $xr3
-; CHECK-NEXT: xvrepli.w $xr4, 1
-; CHECK-NEXT: xvbitsel.v $xr1, $xr1, $xr4, $xr3
; CHECK-NEXT: xvdiv.w $xr0, $xr0, $xr1
-; CHECK-NEXT: xvandn.v $xr0, $xr2, $xr0
; CHECK-NEXT: ret
entry:
%bz = icmp eq <8 x i32> %b, zeroinitializer
@@ -188,10 +139,7 @@ entry:
define <8 x i32> @lasx_xvdiv_wu(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_wu:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.wu $xr2, $xr1, 1
-; CHECK-NEXT: xvdiv.wu $xr0, $xr0, $xr2
-; CHECK-NEXT: xvseqi.w $xr1, $xr1, 0
-; CHECK-NEXT: xvandn.v $xr0, $xr1, $xr0
+; CHECK-NEXT: xvdiv.wu $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
%bz = icmp eq <8 x i32> %b, zeroinitializer
@@ -204,14 +152,6 @@ entry:
define <8 x i32> @lasx_xvmod_w(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_w:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.w $xr2, $xr1, 0
-; CHECK-NEXT: xvldi $xr3, -3200
-; CHECK-NEXT: xvseq.w $xr3, $xr0, $xr3
-; CHECK-NEXT: xvseqi.w $xr4, $xr1, -1
-; CHECK-NEXT: xvand.v $xr3, $xr3, $xr4
-; CHECK-NEXT: xvor.v $xr2, $xr2, $xr3
-; CHECK-NEXT: xvrepli.w $xr3, 1
-; CHECK-NEXT: xvbitsel.v $xr1, $xr1, $xr3, $xr2
; CHECK-NEXT: xvmod.w $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
@@ -228,7 +168,6 @@ entry:
define <8 x i32> @lasx_xvmod_wu(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_wu:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.wu $xr1, $xr1, 1
; CHECK-NEXT: xvmod.wu $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
@@ -238,35 +177,10 @@ entry:
}
define <4 x i64> @lasx_xvdiv_d(<4 x i64> %a, <4 x i64> %b) nounwind {
-; LA32-LABEL: lasx_xvdiv_d:
-; LA32: # %bb.0: # %entry
-; LA32-NEXT: pcalau12i $a0, %pc_hi20(.LCPI12_0)
-; LA32-NEXT: xvld $xr2, $a0, %pc_lo12(.LCPI12_0)
-; LA32-NEXT: xvseqi.d $xr3, $xr1, 0
-; LA32-NEXT: xvseq.d $xr2, $xr0, $xr2
-; LA32-NEXT: xvseqi.d $xr4, $xr1, -1
-; LA32-NEXT: xvand.v $xr2, $xr2, $xr4
-; LA32-NEXT: xvor.v $xr2, $xr3, $xr2
-; LA32-NEXT: xvrepli.d $xr4, 1
-; LA32-NEXT: xvbitsel.v $xr1, $xr1, $xr4, $xr2
-; LA32-NEXT: xvdiv.d $xr0, $xr0, $xr1
-; LA32-NEXT: xvandn.v $xr0, $xr3, $xr0
-; LA32-NEXT: ret
-;
-; LA64-LABEL: lasx_xvdiv_d:
-; LA64: # %bb.0: # %entry
-; LA64-NEXT: xvseqi.d $xr2, $xr1, 0
-; LA64-NEXT: lu52i.d $a0, $zero, -2048
-; LA64-NEXT: xvreplgr2vr.d $xr3, $a0
-; LA64-NEXT: xvseq.d $xr3, $xr0, $xr3
-; LA64-NEXT: xvseqi.d $xr4, $xr1, -1
-; LA64-NEXT: xvand.v $xr3, $xr3, $xr4
-; LA64-NEXT: xvor.v $xr3, $xr2, $xr3
-; LA64-NEXT: xvrepli.d $xr4, 1
-; LA64-NEXT: xvbitsel.v $xr1, $xr1, $xr4, $xr3
-; LA64-NEXT: xvdiv.d $xr0, $xr0, $xr1
-; LA64-NEXT: xvandn.v $xr0, $xr2, $xr0
-; LA64-NEXT: ret
+; CHECK-LABEL: lasx_xvdiv_d:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: xvdiv.d $xr0, $xr0, $xr1
+; CHECK-NEXT: ret
entry:
%bz = icmp eq <4 x i64> %b, zeroinitializer
%amin = icmp eq <4 x i64> %a, splat (i64 -9223372036854775808)
@@ -282,10 +196,7 @@ entry:
define <4 x i64> @lasx_xvdiv_du(<4 x i64> %a, <4 x i64> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_du:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.du $xr2, $xr1, 1
-; CHECK-NEXT: xvdiv.du $xr0, $xr0, $xr2
-; CHECK-NEXT: xvseqi.d $xr1, $xr1, 0
-; CHECK-NEXT: xvandn.v $xr0, $xr1, $xr0
+; CHECK-NEXT: xvdiv.du $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
%bz = icmp eq <4 x i64> %b, zeroinitializer
@@ -296,33 +207,10 @@ entry:
}
define <4 x i64> @lasx_xvmod_d(<4 x i64> %a, <4 x i64> %b) nounwind {
-; LA32-LABEL: lasx_xvmod_d:
-; LA32: # %bb.0: # %entry
-; LA32-NEXT: pcalau12i $a0, %pc_hi20(.LCPI14_0)
-; LA32-NEXT: xvld $xr2, $a0, %pc_lo12(.LCPI14_0)
-; LA32-NEXT: xvseqi.d $xr3, $xr1, 0
-; LA32-NEXT: xvseq.d $xr2, $xr0, $xr2
-; LA32-NEXT: xvseqi.d $xr4, $xr1, -1
-; LA32-NEXT: xvand.v $xr2, $xr2, $xr4
-; LA32-NEXT: xvor.v $xr2, $xr3, $xr2
-; LA32-NEXT: xvrepli.d $xr3, 1
-; LA32-NEXT: xvbitsel.v $xr1, $xr1, $xr3, $xr2
-; LA32-NEXT: xvmod.d $xr0, $xr0, $xr1
-; LA32-NEXT: ret
-;
-; LA64-LABEL: lasx_xvmod_d:
-; LA64: # %bb.0: # %entry
-; LA64-NEXT: xvseqi.d $xr2, $xr1, 0
-; LA64-NEXT: lu52i.d $a0, $zero, -2048
-; LA64-NEXT: xvreplgr2vr.d $xr3, $a0
-; LA64-NEXT: xvseq.d $xr3, $xr0, $xr3
-; LA64-NEXT: xvseqi.d $xr4, $xr1, -1
-; LA64-NEXT: xvand.v $xr3, $xr3, $xr4
-; LA64-NEXT: xvor.v $xr2, $xr2, $xr3
-; LA64-NEXT: xvrepli.d $xr3, 1
-; LA64-NEXT: xvbitsel.v $xr1, $xr1, $xr3, $xr2
-; LA64-NEXT: xvmod.d $xr0, $xr0, $xr1
-; LA64-NEXT: ret
+; CHECK-LABEL: lasx_xvmod_d:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: xvmod.d $xr0, $xr0, $xr1
+; CHECK-NEXT: ret
entry:
%bz = icmp eq <4 x i64> %b, zeroinitializer
%amin = icmp eq <4 x i64> %a, splat (i64 -9223372036854775808)
@@ -337,7 +225,6 @@ entry:
define <4 x i64> @lasx_xvmod_du(<4 x i64> %a, <4 x i64> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_du:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.du $xr1, $xr1, 1
; CHECK-NEXT: xvmod.du $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
@@ -350,11 +237,7 @@ entry:
define <8 x i32> @lasx_xvdiv_w_select_zero_guard(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_w_select_zero_guard:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.w $xr2, $xr1, 0
-; CHECK-NEXT: xvrepli.w $xr3, 1
-; CHECK-NEXT: xvbitsel.v $xr1, $xr1, $xr3, $xr2
; CHECK-NEXT: xvdiv.w $xr0, $xr0, $xr1
-; CHECK-NEXT: xvandn.v $xr0, $xr2, $xr0
; CHECK-NEXT: ret
entry:
%bz = icmp eq <8 x i32> %b, zeroinitializer
@@ -367,11 +250,7 @@ entry:
define <8 x i32> @lasx_xvdiv_wu_select_guard(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvdiv_wu_select_guard:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.w $xr2, $xr1, 0
-; CHECK-NEXT: xvrepli.w $xr3, 1
-; CHECK-NEXT: xvbitsel.v $xr1, $xr1, $xr3, $xr2
; CHECK-NEXT: xvdiv.wu $xr0, $xr0, $xr1
-; CHECK-NEXT: xvandn.v $xr0, $xr2, $xr0
; CHECK-NEXT: ret
entry:
%bz = icmp eq <8 x i32> %b, zeroinitializer
@@ -384,7 +263,6 @@ entry:
define <8 x i32> @lasx_xvmod_w_umax_guard(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_w_umax_guard:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvmaxi.wu $xr1, $xr1, 1
; CHECK-NEXT: xvmod.w $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
@@ -397,11 +275,6 @@ entry:
define <8 x i32> @lasx_xvmod_w_minus_one_guard(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_w_minus_one_guard:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: xvseqi.w $xr2, $xr1, 0
-; CHECK-NEXT: xvseqi.w $xr3, $xr1, -1
-; CHECK-NEXT: xvor.v $xr2, $xr2, $xr3
-; CHECK-NEXT: xvrepli.w $xr3, 1
-; CHECK-NEXT: xvbitsel.v $xr1, $xr1, $xr3, $xr2
; CHECK-NEXT: xvmod.w $xr0, $xr0, $xr1
; CHECK-NEXT: ret
entry:
@@ -416,9 +289,6 @@ entry:
define <8 x i32> @lasx_xvmod_wu_select_guard(<8 x i32> %a, <8 x i32> %b) nounwind {
; CHECK-LABEL: lasx_xvmod_wu_select_guard:
; CHECK: # %...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/244485
More information about the llvm-branch-commits
mailing list