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
_______________________________________________
llvm-branch-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits

Reply via email to