[llvm-branch-commits] [llvm] [LoongArch] Lower splat of variable-index extract to [x]vreplve (PR #244542)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Fri Nov 20 01:22:25 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-loongarch

Author: hev (heiher)

<details>
<summary>Changes</summary>

Lower a splat of a variable-index extract_vector_elt to [x]vreplve. For 256-bit vectors, each 128-bit lane must splat the element at the same position within the lane, which is the per-lane semantics of xvreplve.

Also, [x]vreplve only uses the low bits of the index, so drop redundant masking of it.

Assisted-By: LLM

---

Patch is 21.66 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/244542.diff


3 Files Affected:

- (modified) llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp (+110) 
- (modified) llvm/test/CodeGen/LoongArch/lasx/splat-extract-var-idx.ll (+25-199) 
- (modified) llvm/test/CodeGen/LoongArch/lsx/splat-extract-var-idx.ll (+4-43) 


``````````diff
diff --git a/llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp b/llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp
index 15e2e198abeae1..d53ee0151d4654 100644
--- a/llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp
+++ b/llvm/lib/Target/LoongArch/LoongArchISelLowering.cpp
@@ -3652,6 +3652,89 @@ static SDValue lower256BitShuffle(const SDLoc &DL, ArrayRef<int> Mask, MVT VT,
   return SDValue();
 }
 
+/// Lower \p Elts to [X]VREPLVE Src, Idx if each 128-bit lane L is a splat of
+/// (extract_vector_elt Src, Idx + L * N), where N is the number of elements
+/// per lane. For 256-bit vectors, Idx must be known to be less than N.
+static SDValue
+lowerSplatOfExtractAsVREPLVE(const SDLoc &DL, MVT VT, ArrayRef<SDValue> Elts,
+                             SelectionDAG &DAG,
+                             const LoongArchSubtarget &Subtarget) {
+  unsigned NumElts = Elts.size();
+  unsigned NumLanes = VT.getSizeInBits() / 128;
+  unsigned NumLaneElts = NumElts / NumLanes;
+  SDValue Src, Idx;
+
+  for (unsigned L = 0; L < NumLanes; ++L) {
+    SDValue LaneElt;
+    for (SDValue Elt : Elts.slice(L * NumLaneElts, NumLaneElts)) {
+      if (!Elt || Elt.isUndef())
+        continue;
+      if (!LaneElt)
+        LaneElt = Elt;
+      else if (LaneElt != Elt)
+        return SDValue();
+    }
+
+    if (!LaneElt || LaneElt.getOpcode() != ISD::EXTRACT_VECTOR_ELT)
+      return SDValue();
+    SDValue Vec = LaneElt.getOperand(0);
+    SDValue EltIdx = LaneElt.getOperand(1);
+    if (isa<ConstantSDNode>(EltIdx))
+      return SDValue();
+
+    if (L == 0) {
+      EVT SrcVT = Vec.getValueType();
+      if (SrcVT.getSizeInBits() != VT.getSizeInBits() ||
+          SrcVT.getVectorNumElements() != NumElts)
+        return SDValue();
+      Src = Vec;
+      Idx = EltIdx;
+      continue;
+    }
+
+    // Must select the same position within the lane.
+    if (Vec != Src || !DAG.isADDLike(EltIdx) || EltIdx.getOperand(0) != Idx)
+      return SDValue();
+    auto *Offset = dyn_cast<ConstantSDNode>(EltIdx.getOperand(1));
+    if (!Offset || Offset->getZExtValue() != L * NumLaneElts)
+      return SDValue();
+  }
+
+  if (NumLanes > 1 && DAG.computeKnownBits(Idx).getMaxValue().uge(NumLaneElts))
+    return SDValue();
+
+  MVT IntVT = VT.changeVectorElementTypeToInteger();
+  Idx = DAG.getZExtOrTrunc(Idx, DL, Subtarget.getGRLenVT());
+  SDValue Res = DAG.getNode(LoongArchISD::VREPLVE, DL, IntVT,
+                            DAG.getBitcast(IntVT, Src), Idx);
+  return DAG.getBitcast(VT, Res);
+}
+
+/// Lower a VECTOR_SHUFFLE of BUILD_VECTORs to [X]VREPLVE.
+static SDValue
+lowerVECTOR_SHUFFLE_VREPLVE(const SDLoc &DL, ArrayRef<int> Mask, MVT VT,
+                            SDValue V1, SDValue V2, SelectionDAG &DAG,
+                            const LoongArchSubtarget &Subtarget) {
+  int NumElts = Mask.size();
+  SmallVector<SDValue, 32> Elts;
+  for (int M : Mask) {
+    if (M < 0) {
+      Elts.push_back(SDValue());
+      continue;
+    }
+    SDValue V = M < NumElts ? V1 : V2;
+    if (V.isUndef()) {
+      Elts.push_back(SDValue());
+      continue;
+    }
+    if (V.getOpcode() != ISD::BUILD_VECTOR)
+      return SDValue();
+    Elts.push_back(V.getOperand(M % NumElts));
+  }
+
+  return lowerSplatOfExtractAsVREPLVE(DL, VT, Elts, DAG, Subtarget);
+}
+
 SDValue LoongArchTargetLowering::lowerVECTOR_SHUFFLE(SDValue Op,
                                                      SelectionDAG &DAG) const {
   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
@@ -3692,6 +3775,10 @@ SDValue LoongArchTargetLowering::lowerVECTOR_SHUFFLE(SDValue Op,
                       [&](int M) { return -1 <= M && M < MaskUpperLimit; }) &&
          "Out of bounds shuffle index");
 
+  if (SDValue Result =
+          lowerVECTOR_SHUFFLE_VREPLVE(DL, OrigMask, VT, V1, V2, DAG, Subtarget))
+    return Result;
+
   // For each vector width, delegate to a specialized lowering routine.
   if (VT.is128BitVector())
     return lower128BitShuffle(DL, OrigMask, VT, V1, V2, DAG, Subtarget);
@@ -3924,6 +4011,11 @@ SDValue LoongArchTargetLowering::lowerBUILD_VECTOR(SDValue Op,
     return Result;
   }
 
+  // Lower per-lane splat of a variable-index extract to [X]VREPLVE.
+  if (SDValue Result = lowerSplatOfExtractAsVREPLVE(
+          DL, VT, SmallVector<SDValue>(Node->op_values()), DAG, Subtarget))
+    return Result;
+
   if (DAG.isSplatValue(Op, /*AllowUndefs=*/false))
     return Op;
 
@@ -8958,6 +9050,22 @@ performSPLIT_PAIR_F64Combine(SDNode *N, SelectionDAG &DAG,
   return SDValue();
 }
 
+/// Do target-specific dag combines on LoongArchISD::VREPLVE nodes.
+static SDValue performVREPLVECombine(SDNode *N, SelectionDAG &DAG,
+                                     TargetLowering::DAGCombinerInfo &DCI,
+                                     const LoongArchSubtarget &Subtarget) {
+  // [X]VREPLVE only uses the low log2(N) bits of the index, where N is the
+  // number of elements per 128-bit lane.
+  SDValue Idx = N->getOperand(1);
+  unsigned NumLaneElts = 128 / N->getSimpleValueType(0).getScalarSizeInBits();
+  APInt DemandedBits =
+      APInt::getLowBitsSet(Idx.getValueSizeInBits(), Log2_32(NumLaneElts));
+  const TargetLowering &TLI = DAG.getTargetLoweringInfo();
+  if (TLI.SimplifyDemandedBits(Idx, DemandedBits, DCI))
+    return SDValue(N, 0);
+  return SDValue();
+}
+
 /// Do target-specific dag combines on LoongArchISD::VANDN nodes.
 static SDValue performVANDNCombine(SDNode *N, SelectionDAG &DAG,
                                    TargetLowering::DAGCombinerInfo &DCI,
@@ -9862,6 +9970,8 @@ SDValue LoongArchTargetLowering::PerformDAGCombine(SDNode *N,
     return performSPLIT_PAIR_F64Combine(N, DAG, DCI, Subtarget);
   case LoongArchISD::VANDN:
     return performVANDNCombine(N, DAG, DCI, Subtarget);
+  case LoongArchISD::VREPLVE:
+    return performVREPLVECombine(N, DAG, DCI, Subtarget);
   case ISD::CONCAT_VECTORS:
     return performCONCAT_VECTORSCombine(N, DAG, DCI, Subtarget);
   case ISD::VSELECT:
diff --git a/llvm/test/CodeGen/LoongArch/lasx/splat-extract-var-idx.ll b/llvm/test/CodeGen/LoongArch/lasx/splat-extract-var-idx.ll
index 8592555717ed96..44c440240a7fe0 100644
--- a/llvm/test/CodeGen/LoongArch/lasx/splat-extract-var-idx.ll
+++ b/llvm/test/CodeGen/LoongArch/lasx/splat-extract-var-idx.ll
@@ -25,7 +25,6 @@ declare <32 x i8> @llvm.loongarch.lasx.xvreplve.b(<32 x i8>, i32)
 define <32 x i8> @intrinsic_xvreplve_b_mask(<32 x i8> %a, i32 %b) nounwind {
 ; CHECK-LABEL: intrinsic_xvreplve_b_mask:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    andi $a0, $a0, 15
 ; CHECK-NEXT:    xvreplve.b $xr0, $xr0, $a0
 ; CHECK-NEXT:    ret
 entry:
@@ -38,7 +37,6 @@ entry:
 define <32 x i8> @intrinsic_xvreplve_b_mask31(<32 x i8> %a, i32 %b) nounwind {
 ; CHECK-LABEL: intrinsic_xvreplve_b_mask31:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    andi $a0, $a0, 31
 ; CHECK-NEXT:    xvreplve.b $xr0, $xr0, $a0
 ; CHECK-NEXT:    ret
 entry:
@@ -61,39 +59,10 @@ entry:
 }
 ;; Splat of a[idx] in the low lane and a[idx + 16] in the high lane is XVREPLVE.
 define <32 x i8> @lane_splat_extract_v32i8(<32 x i8> %a, i32 %b) nounwind {
-; LA32-LABEL: lane_splat_extract_v32i8:
-; LA32:       # %bb.0: # %entry
-; LA32-NEXT:    andi $a1, $a0, 15
-; LA32-NEXT:    movgr2fr.w $fa1, $a1
-; LA32-NEXT:    xvpermi.q $xr2, $xr0, 1
-; LA32-NEXT:    xvshuf.b $xr1, $xr2, $xr0, $xr1
-; LA32-NEXT:    vpickve2gr.b $a1, $vr1, 0
-; LA32-NEXT:    xvreplgr2vr.b $xr1, $a1
-; LA32-NEXT:    ori $a1, $zero, 1
-; LA32-NEXT:    bstrins.w $a0, $a1, 31, 4
-; LA32-NEXT:    movgr2fr.w $fa3, $a0
-; LA32-NEXT:    xvshuf.b $xr0, $xr2, $xr0, $xr3
-; LA32-NEXT:    vpickve2gr.b $a0, $vr0, 0
-; LA32-NEXT:    xvreplgr2vr.b $xr0, $a0
-; LA32-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA32-NEXT:    ret
-;
-; LA64-LABEL: lane_splat_extract_v32i8:
-; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    andi $a1, $a0, 15
-; LA64-NEXT:    movgr2fr.w $fa1, $a1
-; LA64-NEXT:    xvpermi.q $xr2, $xr0, 1
-; LA64-NEXT:    xvshuf.b $xr1, $xr2, $xr0, $xr1
-; LA64-NEXT:    vpickve2gr.b $a1, $vr1, 0
-; LA64-NEXT:    xvreplgr2vr.b $xr1, $a1
-; LA64-NEXT:    ori $a1, $zero, 1
-; LA64-NEXT:    bstrins.d $a0, $a1, 63, 4
-; LA64-NEXT:    movgr2fr.w $fa3, $a0
-; LA64-NEXT:    xvshuf.b $xr0, $xr2, $xr0, $xr3
-; LA64-NEXT:    vpickve2gr.b $a0, $vr0, 0
-; LA64-NEXT:    xvreplgr2vr.b $xr0, $a0
-; LA64-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA64-NEXT:    ret
+; CHECK-LABEL: lane_splat_extract_v32i8:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    xvreplve.b $xr0, $xr0, $a0
+; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 15
   %e0 = extractelement <32 x i8> %a, i32 %idx
@@ -108,39 +77,10 @@ entry:
 }
 
 define <16 x i16> @lane_splat_extract_v16i16(<16 x i16> %a, i32 %b) nounwind {
-; LA32-LABEL: lane_splat_extract_v16i16:
-; LA32:       # %bb.0: # %entry
-; LA32-NEXT:    andi $a1, $a0, 7
-; LA32-NEXT:    movgr2fr.w $fa1, $a1
-; LA32-NEXT:    xvpermi.q $xr2, $xr0, 1
-; LA32-NEXT:    xvshuf.h $xr1, $xr2, $xr0
-; LA32-NEXT:    vpickve2gr.h $a1, $vr1, 0
-; LA32-NEXT:    xvreplgr2vr.h $xr1, $a1
-; LA32-NEXT:    ori $a1, $zero, 1
-; LA32-NEXT:    bstrins.w $a0, $a1, 31, 3
-; LA32-NEXT:    movgr2fr.w $fa3, $a0
-; LA32-NEXT:    xvshuf.h $xr3, $xr2, $xr0
-; LA32-NEXT:    vpickve2gr.h $a0, $vr3, 0
-; LA32-NEXT:    xvreplgr2vr.h $xr0, $a0
-; LA32-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA32-NEXT:    ret
-;
-; LA64-LABEL: lane_splat_extract_v16i16:
-; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    andi $a1, $a0, 7
-; LA64-NEXT:    movgr2fr.w $fa1, $a1
-; LA64-NEXT:    xvpermi.q $xr2, $xr0, 1
-; LA64-NEXT:    xvshuf.h $xr1, $xr2, $xr0
-; LA64-NEXT:    vpickve2gr.h $a1, $vr1, 0
-; LA64-NEXT:    xvreplgr2vr.h $xr1, $a1
-; LA64-NEXT:    ori $a1, $zero, 1
-; LA64-NEXT:    bstrins.d $a0, $a1, 63, 3
-; LA64-NEXT:    movgr2fr.w $fa3, $a0
-; LA64-NEXT:    xvshuf.h $xr3, $xr2, $xr0
-; LA64-NEXT:    vpickve2gr.h $a0, $vr3, 0
-; LA64-NEXT:    xvreplgr2vr.h $xr0, $a0
-; LA64-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA64-NEXT:    ret
+; CHECK-LABEL: lane_splat_extract_v16i16:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    xvreplve.h $xr0, $xr0, $a0
+; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 7
   %e0 = extractelement <16 x i16> %a, i32 %idx
@@ -155,37 +95,10 @@ entry:
 }
 
 define <8 x i32> @lane_splat_extract_v8i32(<8 x i32> %a, i32 %b) nounwind {
-; LA32-LABEL: lane_splat_extract_v8i32:
-; LA32:       # %bb.0: # %entry
-; LA32-NEXT:    andi $a1, $a0, 3
-; LA32-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA32-NEXT:    xvperm.w $xr1, $xr0, $xr1
-; LA32-NEXT:    xvpickve2gr.w $a1, $xr1, 0
-; LA32-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA32-NEXT:    ori $a1, $zero, 1
-; LA32-NEXT:    bstrins.w $a0, $a1, 31, 2
-; LA32-NEXT:    xvreplgr2vr.w $xr2, $a0
-; LA32-NEXT:    xvperm.w $xr0, $xr0, $xr2
-; LA32-NEXT:    xvpickve2gr.w $a0, $xr0, 0
-; LA32-NEXT:    xvreplgr2vr.w $xr0, $a0
-; LA32-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA32-NEXT:    ret
-;
-; LA64-LABEL: lane_splat_extract_v8i32:
-; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    andi $a1, $a0, 3
-; LA64-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA64-NEXT:    xvperm.w $xr1, $xr0, $xr1
-; LA64-NEXT:    xvpickve2gr.w $a1, $xr1, 0
-; LA64-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA64-NEXT:    ori $a1, $zero, 1
-; LA64-NEXT:    bstrins.d $a0, $a1, 63, 2
-; LA64-NEXT:    xvreplgr2vr.w $xr2, $a0
-; LA64-NEXT:    xvperm.w $xr0, $xr0, $xr2
-; LA64-NEXT:    xvpickve2gr.w $a0, $xr0, 0
-; LA64-NEXT:    xvreplgr2vr.w $xr0, $a0
-; LA64-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA64-NEXT:    ret
+; CHECK-LABEL: lane_splat_extract_v8i32:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    xvreplve.w $xr0, $xr0, $a0
+; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 3
   %e0 = extractelement <8 x i32> %a, i32 %idx
@@ -236,19 +149,7 @@ define <4 x i64> @lane_splat_extract_v4i64(<4 x i64> %a, i32 %b) nounwind {
 ;
 ; LA64-LABEL: lane_splat_extract_v4i64:
 ; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    andi $a1, $a0, 1
-; LA64-NEXT:    movgr2fr.w $fa1, $a1
-; LA64-NEXT:    xvpermi.q $xr2, $xr0, 1
-; LA64-NEXT:    xvshuf.d $xr1, $xr2, $xr0
-; LA64-NEXT:    xvpickve2gr.d $a1, $xr1, 0
-; LA64-NEXT:    xvreplgr2vr.d $xr1, $a1
-; LA64-NEXT:    ori $a1, $zero, 1
-; LA64-NEXT:    bstrins.d $a0, $a1, 63, 1
-; LA64-NEXT:    movgr2fr.w $fa3, $a0
-; LA64-NEXT:    xvshuf.d $xr3, $xr2, $xr0
-; LA64-NEXT:    xvpickve2gr.d $a0, $xr3, 0
-; LA64-NEXT:    xvreplgr2vr.d $xr0, $a0
-; LA64-NEXT:    xvpermi.q $xr0, $xr1, 48
+; LA64-NEXT:    xvreplve.d $xr0, $xr0, $a0
 ; LA64-NEXT:    ret
 entry:
   %idx = and i32 %b, 1
@@ -264,33 +165,10 @@ entry:
 }
 
 define <8 x float> @lane_splat_extract_v8f32(<8 x float> %a, i32 %b) nounwind {
-; LA32-LABEL: lane_splat_extract_v8f32:
-; LA32:       # %bb.0: # %entry
-; LA32-NEXT:    andi $a1, $a0, 3
-; LA32-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA32-NEXT:    xvperm.w $xr1, $xr0, $xr1
-; LA32-NEXT:    xvreplve0.w $xr1, $xr1
-; LA32-NEXT:    ori $a1, $zero, 1
-; LA32-NEXT:    bstrins.w $a0, $a1, 31, 2
-; LA32-NEXT:    xvreplgr2vr.w $xr2, $a0
-; LA32-NEXT:    xvperm.w $xr0, $xr0, $xr2
-; LA32-NEXT:    xvreplve0.w $xr0, $xr0
-; LA32-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA32-NEXT:    ret
-;
-; LA64-LABEL: lane_splat_extract_v8f32:
-; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    andi $a1, $a0, 3
-; LA64-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA64-NEXT:    xvperm.w $xr1, $xr0, $xr1
-; LA64-NEXT:    xvreplve0.w $xr1, $xr1
-; LA64-NEXT:    ori $a1, $zero, 1
-; LA64-NEXT:    bstrins.d $a0, $a1, 63, 2
-; LA64-NEXT:    xvreplgr2vr.w $xr2, $a0
-; LA64-NEXT:    xvperm.w $xr0, $xr0, $xr2
-; LA64-NEXT:    xvreplve0.w $xr0, $xr0
-; LA64-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA64-NEXT:    ret
+; CHECK-LABEL: lane_splat_extract_v8f32:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    xvreplve.w $xr0, $xr0, $a0
+; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 3
   %e0 = extractelement <8 x float> %a, i32 %idx
@@ -305,35 +183,10 @@ entry:
 }
 
 define <4 x double> @lane_splat_extract_v4f64(<4 x double> %a, i32 %b) nounwind {
-; LA32-LABEL: lane_splat_extract_v4f64:
-; LA32:       # %bb.0: # %entry
-; LA32-NEXT:    andi $a1, $a0, 1
-; LA32-NEXT:    movgr2fr.w $fa1, $a1
-; LA32-NEXT:    xvpermi.q $xr2, $xr0, 1
-; LA32-NEXT:    xvshuf.d $xr1, $xr2, $xr0
-; LA32-NEXT:    xvreplve0.d $xr1, $xr1
-; LA32-NEXT:    ori $a1, $zero, 1
-; LA32-NEXT:    bstrins.w $a0, $a1, 31, 1
-; LA32-NEXT:    movgr2fr.w $fa3, $a0
-; LA32-NEXT:    xvshuf.d $xr3, $xr2, $xr0
-; LA32-NEXT:    xvreplve0.d $xr0, $xr3
-; LA32-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA32-NEXT:    ret
-;
-; LA64-LABEL: lane_splat_extract_v4f64:
-; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    andi $a1, $a0, 1
-; LA64-NEXT:    movgr2fr.w $fa1, $a1
-; LA64-NEXT:    xvpermi.q $xr2, $xr0, 1
-; LA64-NEXT:    xvshuf.d $xr1, $xr2, $xr0
-; LA64-NEXT:    xvreplve0.d $xr1, $xr1
-; LA64-NEXT:    ori $a1, $zero, 1
-; LA64-NEXT:    bstrins.d $a0, $a1, 63, 1
-; LA64-NEXT:    movgr2fr.w $fa3, $a0
-; LA64-NEXT:    xvshuf.d $xr3, $xr2, $xr0
-; LA64-NEXT:    xvreplve0.d $xr0, $xr3
-; LA64-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA64-NEXT:    ret
+; CHECK-LABEL: lane_splat_extract_v4f64:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    xvreplve.d $xr0, $xr0, $a0
+; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 1
   %e0 = extractelement <4 x double> %a, i32 %idx
@@ -349,37 +202,10 @@ entry:
 
 ;; The high lane index may also be formed by an add.
 define <8 x i32> @lane_splat_extract_v8i32_add(<8 x i32> %a, i32 %b) nounwind {
-; LA32-LABEL: lane_splat_extract_v8i32_add:
-; LA32:       # %bb.0: # %entry
-; LA32-NEXT:    andi $a1, $a0, 3
-; LA32-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA32-NEXT:    xvperm.w $xr1, $xr0, $xr1
-; LA32-NEXT:    xvpickve2gr.w $a1, $xr1, 0
-; LA32-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA32-NEXT:    ori $a1, $zero, 1
-; LA32-NEXT:    bstrins.w $a0, $a1, 31, 2
-; LA32-NEXT:    xvreplgr2vr.w $xr2, $a0
-; LA32-NEXT:    xvperm.w $xr0, $xr0, $xr2
-; LA32-NEXT:    xvpickve2gr.w $a0, $xr0, 0
-; LA32-NEXT:    xvreplgr2vr.w $xr0, $a0
-; LA32-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA32-NEXT:    ret
-;
-; LA64-LABEL: lane_splat_extract_v8i32_add:
-; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    andi $a1, $a0, 3
-; LA64-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA64-NEXT:    xvperm.w $xr1, $xr0, $xr1
-; LA64-NEXT:    xvpickve2gr.w $a1, $xr1, 0
-; LA64-NEXT:    xvreplgr2vr.w $xr1, $a1
-; LA64-NEXT:    ori $a1, $zero, 1
-; LA64-NEXT:    bstrins.d $a0, $a1, 63, 2
-; LA64-NEXT:    xvreplgr2vr.w $xr2, $a0
-; LA64-NEXT:    xvperm.w $xr0, $xr0, $xr2
-; LA64-NEXT:    xvpickve2gr.w $a0, $xr0, 0
-; LA64-NEXT:    xvreplgr2vr.w $xr0, $a0
-; LA64-NEXT:    xvpermi.q $xr0, $xr1, 48
-; LA64-NEXT:    ret
+; CHECK-LABEL: lane_splat_extract_v8i32_add:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    xvreplve.w $xr0, $xr0, $a0
+; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 3
   %e0 = extractelement <8 x i32> %a, i32 %idx
diff --git a/llvm/test/CodeGen/LoongArch/lsx/splat-extract-var-idx.ll b/llvm/test/CodeGen/LoongArch/lsx/splat-extract-var-idx.ll
index e4299afa743363..131cbfcbb6cc3f 100644
--- a/llvm/test/CodeGen/LoongArch/lsx/splat-extract-var-idx.ll
+++ b/llvm/test/CodeGen/LoongArch/lsx/splat-extract-var-idx.ll
@@ -5,11 +5,7 @@
 define <16 x i8> @splat_extract_v16i8(<16 x i8> %a, i32 %b) nounwind {
 ; CHECK-LABEL: splat_extract_v16i8:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    andi $a0, $a0, 15
 ; CHECK-NEXT:    vreplve.b $vr0, $vr0, $a0
-; CHECK-NEXT:    movfr2gr.s $a0, $fa0
-; CHECK-NEXT:    srai.w $a0, $a0, 24
-; CHECK-NEXT:    vreplgr2vr.b $vr0, $a0
 ; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 15
@@ -22,11 +18,7 @@ entry:
 define <8 x i16> @splat_extract_v8i16(<8 x i16> %a, i32 %b) nounwind {
 ; CHECK-LABEL: splat_extract_v8i16:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    andi $a0, $a0, 7
 ; CHECK-NEXT:    vreplve.h $vr0, $vr0, $a0
-; CHECK-NEXT:    movfr2gr.s $a0, $fa0
-; CHECK-NEXT:    srai.w $a0, $a0, 16
-; CHECK-NEXT:    vreplgr2vr.h $vr0, $a0
 ; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 7
@@ -39,10 +31,7 @@ entry:
 define <4 x i32> @splat_extract_v4i32(<4 x i32> %a, i32 %b) nounwind {
 ; CHECK-LABEL: splat_extract_v4i32:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    andi $a0, $a0, 3
 ; CHECK-NEXT:    vreplve.w $vr0, $vr0, $a0
-; CHECK-NEXT:    movfr2gr.s $a0, $fa0
-; CHECK-NEXT:    vreplgr2vr.w $vr0, $a0
 ; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 3
@@ -70,10 +59,7 @@ define <2 x i64> @splat_extract_v2i64(<2 x i64> %a, i32 %b) nounwind {
 ;
 ; LA64-LABEL: splat_extract_v2i64:
 ; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    andi $a0, $a0, 1
 ; LA64-NEXT:    vreplve.d $vr0, $vr0, $a0
-; LA64-NEXT:    movfr2gr.d $a0, $fa0
-; LA64-NEXT:    vreplgr2vr.d $vr0, $a0
 ; LA64-NEXT:    ret
 entry:
   %idx = and i32 %b, 1
@@ -86,9 +72,7 @@ entry:
 define <4 x float> @splat_extract_v4f32(<4 x float> %a, i32 %b) nounwind {
 ; CHECK-LABEL: splat_extract_v4f32:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    andi $a0, $a0, 3
 ; CHECK-NEXT:    vreplve.w $vr0, $vr0, $a0
-; CHECK-NEXT:    vreplvei.w $vr0, $vr0, 0
 ; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 3
@@ -101,9 +85,7 @@ entry:
 define <2 x double> @splat_extract_v2f64(<2 x double> %a, i32 %b) nounwind {
 ; CHECK-LABEL: splat_extract_v2f64:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    andi $a0, $a0, 1
 ; CHECK-NEXT:    vreplve.d $vr0, $vr0, $a0
-; CHECK-NEXT:    vreplvei.d $vr0, $vr0, 0
 ; CHECK-NEXT:    ret
 entry:
   %idx = and i32 %b, 1
@@ -115,20 +97,10 @@ entry:
 
 ;; Unmasked index: out-of-range extract yields poison, so VREPLVE is still fine.
 define <4 x i32> @splat_extract_v4i32_nomask(<4 x i32> %a, i32 %b) nounwind {
-; LA32-LABEL: splat_extract_v4i32_nomask:
-; LA32:       # %bb.0: # %entry
-; LA32-NEXT:    vreplve.w $vr0, $vr0, $a0
-; LA32-NEXT:    movfr2gr.s $a0, $fa0
-; LA32-NEXT:    vreplgr2vr.w $vr0, $a0
-; LA32-NEXT:    ret
-;
-; LA64-LABEL: splat_extract_v4i32_nomask:
-; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    bstrpick.d $a0, $a0, 31, 0
-; LA64-NEXT:    vreplve.w $vr0, $vr0, $a0
-; LA64-NEXT:    movfr2gr.s $a0, $fa0
-; LA64-NEXT:    vreplgr2vr.w $vr0, $a0
-; LA64-NEXT:    ret
+; CHECK-LABEL: splat_extract_v4i32_nomask:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    vreplve.w $vr0, $vr0, $a0
+; CHECK-NEXT:    ret
 entry:
   %e = extractelement <4 x i32> %a, i32 %b
   %ins = insertelement <4 x i32> poison, i32 %e, i64 0
@@ -140,11 +112,7 @@ entry:
 define <16 x i8> @splat_extract_v16i8_mask255(<16 x i8> %a, i32 %b) nounwind {
 ; CHECK-LABEL: splat_extract_v16i8_mask255:...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/244542


More information about the llvm-branch-commits mailing list