[llvm] 818fd11 - [SelectionDAG] Merge consecutive loads feeding as shuffle operands (#207303)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Jul 21 03:12:10 PDT 2026
Author: Sushant Gokhale
Date: 2026-07-21T10:12:04Z
New Revision: 818fd11b95108b1b2a879f474f3c3bf54630b01b
URL: https://github.com/llvm/llvm-project/commit/818fd11b95108b1b2a879f474f3c3bf54630b01b
DIFF: https://github.com/llvm/llvm-project/commit/818fd11b95108b1b2a879f474f3c3bf54630b01b.diff
LOG: [SelectionDAG] Merge consecutive loads feeding as shuffle operands (#207303)
Perform the following fold given loadA and loadB can be proven
consecutive:
```
concat(shuffle(loadA, loadB, mask0), shuffle(loadA, loadB, mask1))
-> shuffle(loadAB, poison, concat(mask0, mask1))
```
Added:
llvm/test/CodeGen/AArch64/merge-loads-feeding-as-shuffleops.ll
Modified:
llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
llvm/test/CodeGen/Thumb2/mve-vst2.ll
Removed:
################################################################################
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 32e6d65159b5e..adc8661e58224 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -27197,6 +27197,89 @@ static SDValue combineConcatVectorOfShuffleAndItsOperands(
return DAG.getVectorShuffle(VT, dl, ShufOps[0], ShufOps[1], Mask);
}
+// concat(shuffle(loadA, loadB, mask0), shuffle(loadA, loadB, mask1))
+// -> shuffle(loadAB, poison, concat(mask0, mask1))
+// only if loadA and loadB can be proven consecutive.
+static SDValue combineConcatVectorOfShuffles(SDNode *N, SelectionDAG &DAG,
+ const TargetLowering &TLI,
+ bool LegalOperations) {
+ SDValue A, B;
+ ArrayRef<int> M0, M1;
+ if (!sd_match(N,
+ m_Node(ISD::CONCAT_VECTORS,
+ m_OneUse(m_Shuffle(m_NUses<2>(m_Value(A)),
+ m_NUses<2>(m_Value(B)), m_Mask(M0))),
+ m_OneUse(m_Shuffle(m_Deferred(A), m_Deferred(B),
+ m_Mask(M1))))))
+ return SDValue();
+ auto *LoadA = dyn_cast<LoadSDNode>(A.getNode());
+ auto *LoadB = dyn_cast<LoadSDNode>(B.getNode());
+ if (!LoadA || !LoadB || !ISD::isNON_EXTLoad(LoadA) ||
+ !ISD::isNON_EXTLoad(LoadB))
+ return SDValue();
+
+ // Check if the address spaces of both loads are the same.
+ if (LoadA->getAddressSpace() != LoadB->getAddressSpace())
+ return SDValue();
+
+ // Check if the loads are consecutive.
+ LoadSDNode *Base = nullptr;
+ if (DAG.areNonVolatileConsecutiveLoads(
+ LoadB, LoadA, LoadB->getMemoryVT().getStoreSize(), /*Dist=*/1)) {
+ Base = LoadA;
+ } else if (DAG.areNonVolatileConsecutiveLoads(
+ LoadA, LoadB, LoadA->getMemoryVT().getStoreSize(),
+ /*Dist=*/1)) {
+ Base = LoadB;
+ } else {
+ return SDValue(); // not adjacent
+ }
+
+ unsigned Fast = 0;
+ Align NewAlign = Base->getAlign();
+ EVT WideVT =
+ LoadA->getMemoryVT().getDoubleNumVectorElementsVT(*DAG.getContext());
+ if (!TLI.allowsMemoryAccess(*DAG.getContext(), DAG.getDataLayout(), WideVT,
+ Base->getAddressSpace(), NewAlign,
+ Base->getMemOperand()->getFlags(), &Fast) ||
+ !Fast)
+ return SDValue();
+
+ // Create a shuffle of the wide load.
+ SmallVector<int, 32> Mask;
+ if (Base == LoadA) {
+ llvm::append_range(Mask, M0);
+ llvm::append_range(Mask, M1);
+ } else {
+ SmallVector<int, 16> C0(M0), C1(M1);
+ ShuffleVectorSDNode::commuteMask(C0);
+ ShuffleVectorSDNode::commuteMask(C1);
+ llvm::append_range(Mask, C0);
+ llvm::append_range(Mask, C1);
+ }
+
+ // Check if the wide load, new shuffle and it's mask is legal.
+ if (LegalOperations &&
+ (!TLI.isOperationLegal(ISD::LOAD, WideVT) ||
+ !TLI.isOperationLegalOrCustom(ISD::VECTOR_SHUFFLE, WideVT) ||
+ !TLI.isShuffleMaskLegal(Mask, WideVT)))
+ return SDValue();
+
+ // Create a wide load of twice the size of the original load.
+ MachineFunction &MF = DAG.getMachineFunction();
+ MachineMemOperand *WideMMO = MF.getMachineMemOperand(
+ Base->getMemOperand(), /*Offset=*/0, WideVT.getStoreSize());
+ SDValue WideLoad = DAG.getLoad(WideVT, SDLoc(N), Base->getChain(),
+ Base->getBasePtr(), WideMMO);
+ // Redirect old chain users to the new chain.
+ DAG.makeEquivalentMemoryOrdering(LoadA, WideLoad);
+ DAG.makeEquivalentMemoryOrdering(LoadB, WideLoad);
+
+ // Create a new shuffle with the new mask.
+ return DAG.getVectorShuffle(WideVT, SDLoc(N), WideLoad, DAG.getPOISON(WideVT),
+ Mask);
+}
+
static SDValue combineConcatVectorOfSplats(SDNode *N, SelectionDAG &DAG,
const TargetLowering &TLI,
bool LegalTypes,
@@ -27370,6 +27453,9 @@ SDValue DAGCombiner::visitCONCAT_VECTORS(SDNode *N) {
N, DAG, TLI, LegalTypes, LegalOperations))
return V;
+ if (SDValue V = combineConcatVectorOfShuffles(N, DAG, TLI, LegalOperations))
+ return V;
+
// Type legalization of vectors and DAG canonicalization of SHUFFLE_VECTOR
// nodes often generate nop CONCAT_VECTOR nodes. Scan the CONCAT_VECTOR
// operands and look for a CONCAT operations that place the incoming vectors
diff --git a/llvm/test/CodeGen/AArch64/merge-loads-feeding-as-shuffleops.ll b/llvm/test/CodeGen/AArch64/merge-loads-feeding-as-shuffleops.ll
new file mode 100644
index 0000000000000..9cfd380719853
--- /dev/null
+++ b/llvm/test/CodeGen/AArch64/merge-loads-feeding-as-shuffleops.ll
@@ -0,0 +1,246 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 6
+; RUN: llc -mtriple=aarch64 -aarch64-sve-vector-bits-min=128 -mattr=+sve < %s | FileCheck %s --check-prefix=VBITS_GE_128
+; RUN: llc -mtriple=aarch64 -aarch64-sve-vector-bits-min=256 -mattr=+sve < %s | FileCheck %s --check-prefix=VBITS_GE_256
+; RUN: llc -mtriple=aarch64_be -aarch64-sve-vector-bits-min=256 -mattr=+sve < %s | FileCheck %s --check-prefix=BE_VBITS_GE_256
+
+define void @combine_loads_v16i8_v32i8(ptr %a) {
+; VBITS_GE_128-LABEL: combine_loads_v16i8_v32i8:
+; VBITS_GE_128: // %bb.0:
+; VBITS_GE_128-NEXT: ldp q1, q0, [x0]
+; VBITS_GE_128-NEXT: ext v2.16b, v1.16b, v0.16b, #1
+; VBITS_GE_128-NEXT: ext v0.16b, v1.16b, v0.16b, #2
+; VBITS_GE_128-NEXT: stp q2, q0, [x0]
+; VBITS_GE_128-NEXT: ret
+;
+; VBITS_GE_256-LABEL: combine_loads_v16i8_v32i8:
+; VBITS_GE_256: // %bb.0:
+; VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; VBITS_GE_256-NEXT: adrp x8, .LCPI0_0
+; VBITS_GE_256-NEXT: add x8, x8, :lo12:.LCPI0_0
+; VBITS_GE_256-NEXT: ld1b { z0.b }, p0/z, [x8]
+; VBITS_GE_256-NEXT: ld1b { z1.b }, p0/z, [x0]
+; VBITS_GE_256-NEXT: tbl z0.b, { z1.b }, z0.b
+; VBITS_GE_256-NEXT: st1b { z0.b }, p0, [x0]
+; VBITS_GE_256-NEXT: ret
+;
+; BE_VBITS_GE_256-LABEL: combine_loads_v16i8_v32i8:
+; BE_VBITS_GE_256: // %bb.0:
+; BE_VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; BE_VBITS_GE_256-NEXT: adrp x8, .LCPI0_0
+; BE_VBITS_GE_256-NEXT: add x8, x8, :lo12:.LCPI0_0
+; BE_VBITS_GE_256-NEXT: ld1b { z0.b }, p0/z, [x8]
+; BE_VBITS_GE_256-NEXT: ld1b { z1.b }, p0/z, [x0]
+; BE_VBITS_GE_256-NEXT: tbl z0.b, { z1.b }, z0.b
+; BE_VBITS_GE_256-NEXT: st1b { z0.b }, p0, [x0]
+; BE_VBITS_GE_256-NEXT: ret
+ %gep = getelementptr <16 x i8>, ptr %a, i64 1
+ %l1 = load <16 x i8>, ptr %a
+ %l2 = load <16 x i8>, ptr %gep
+ %result = shufflevector <16 x i8> %l1, <16 x i8> %l2, <32 x i32><i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16,i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17>
+ store <32 x i8> %result, ptr %a
+ ret void
+}
+
+define void @combine_loads_v16i8_v16i8_
diff _load_chain(ptr %a, ptr %b) {
+; VBITS_GE_128-LABEL: combine_loads_v16i8_v16i8_
diff _load_chain:
+; VBITS_GE_128: // %bb.0:
+; VBITS_GE_128-NEXT: ldr q0, [x0]
+; VBITS_GE_128-NEXT: strb wzr, [x1]
+; VBITS_GE_128-NEXT: ldr q1, [x0, #16]
+; VBITS_GE_128-NEXT: ext v2.16b, v0.16b, v1.16b, #1
+; VBITS_GE_128-NEXT: ext v0.16b, v0.16b, v1.16b, #2
+; VBITS_GE_128-NEXT: stp q2, q0, [x0]
+; VBITS_GE_128-NEXT: ret
+;
+; VBITS_GE_256-LABEL: combine_loads_v16i8_v16i8_
diff _load_chain:
+; VBITS_GE_256: // %bb.0:
+; VBITS_GE_256-NEXT: ldr q0, [x0]
+; VBITS_GE_256-NEXT: strb wzr, [x1]
+; VBITS_GE_256-NEXT: ptrue p0.b, vl16
+; VBITS_GE_256-NEXT: ldr q1, [x0, #16]
+; VBITS_GE_256-NEXT: ext v2.16b, v0.16b, v1.16b, #2
+; VBITS_GE_256-NEXT: ext v0.16b, v0.16b, v1.16b, #1
+; VBITS_GE_256-NEXT: splice z0.b, p0, z0.b, z2.b
+; VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; VBITS_GE_256-NEXT: st1b { z0.b }, p0, [x0]
+; VBITS_GE_256-NEXT: ret
+;
+; BE_VBITS_GE_256-LABEL: combine_loads_v16i8_v16i8_
diff _load_chain:
+; BE_VBITS_GE_256: // %bb.0:
+; BE_VBITS_GE_256-NEXT: add x8, x0, #16
+; BE_VBITS_GE_256-NEXT: ld1 { v0.16b }, [x0]
+; BE_VBITS_GE_256-NEXT: strb wzr, [x1]
+; BE_VBITS_GE_256-NEXT: ld1 { v1.16b }, [x8]
+; BE_VBITS_GE_256-NEXT: ptrue p0.b, vl16
+; BE_VBITS_GE_256-NEXT: ext v2.16b, v0.16b, v1.16b, #2
+; BE_VBITS_GE_256-NEXT: ext v0.16b, v0.16b, v1.16b, #1
+; BE_VBITS_GE_256-NEXT: splice z0.b, p0, z0.b, z2.b
+; BE_VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; BE_VBITS_GE_256-NEXT: st1b { z0.b }, p0, [x0]
+; BE_VBITS_GE_256-NEXT: ret
+ %gep = getelementptr <16 x i8>, ptr %a, i64 1
+ %l1 = load <16 x i8>, ptr %a
+ store i8 0, ptr %b
+ %l2 = load <16 x i8>, ptr %gep
+ %result = shufflevector <16 x i8> %l1, <16 x i8> %l2, <32 x i32><i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16,i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17>
+ store <32 x i8> %result, ptr %a
+ ret void
+}
+
+define void @combine_loads_v16i8_v32i8_
diff _shuffle_order(ptr %a) {
+; VBITS_GE_128-LABEL: combine_loads_v16i8_v32i8_
diff _shuffle_order:
+; VBITS_GE_128: // %bb.0:
+; VBITS_GE_128-NEXT: ldp q0, q1, [x0]
+; VBITS_GE_128-NEXT: ext v2.16b, v1.16b, v0.16b, #1
+; VBITS_GE_128-NEXT: ext v0.16b, v1.16b, v0.16b, #2
+; VBITS_GE_128-NEXT: stp q2, q0, [x0]
+; VBITS_GE_128-NEXT: ret
+;
+; VBITS_GE_256-LABEL: combine_loads_v16i8_v32i8_
diff _shuffle_order:
+; VBITS_GE_256: // %bb.0:
+; VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; VBITS_GE_256-NEXT: adrp x8, .LCPI2_0
+; VBITS_GE_256-NEXT: add x8, x8, :lo12:.LCPI2_0
+; VBITS_GE_256-NEXT: ld1b { z0.b }, p0/z, [x8]
+; VBITS_GE_256-NEXT: ld1b { z1.b }, p0/z, [x0]
+; VBITS_GE_256-NEXT: tbl z0.b, { z1.b }, z0.b
+; VBITS_GE_256-NEXT: st1b { z0.b }, p0, [x0]
+; VBITS_GE_256-NEXT: ret
+;
+; BE_VBITS_GE_256-LABEL: combine_loads_v16i8_v32i8_
diff _shuffle_order:
+; BE_VBITS_GE_256: // %bb.0:
+; BE_VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; BE_VBITS_GE_256-NEXT: adrp x8, .LCPI2_0
+; BE_VBITS_GE_256-NEXT: add x8, x8, :lo12:.LCPI2_0
+; BE_VBITS_GE_256-NEXT: ld1b { z0.b }, p0/z, [x8]
+; BE_VBITS_GE_256-NEXT: ld1b { z1.b }, p0/z, [x0]
+; BE_VBITS_GE_256-NEXT: tbl z0.b, { z1.b }, z0.b
+; BE_VBITS_GE_256-NEXT: st1b { z0.b }, p0, [x0]
+; BE_VBITS_GE_256-NEXT: ret
+ %gep = getelementptr <16 x i8>, ptr %a, i64 1
+ %l1 = load <16 x i8>, ptr %a
+ %l2 = load <16 x i8>, ptr %gep
+ %result = shufflevector <16 x i8> %l2, <16 x i8> %l1, <32 x i32><i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16,i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17>
+ store <32 x i8> %result, ptr %a
+ ret void
+}
+
+define void @combine_loads_v8i16_v16i16(ptr %a) {
+; VBITS_GE_128-LABEL: combine_loads_v8i16_v16i16:
+; VBITS_GE_128: // %bb.0:
+; VBITS_GE_128-NEXT: ldp q1, q0, [x0]
+; VBITS_GE_128-NEXT: ext v2.16b, v1.16b, v0.16b, #2
+; VBITS_GE_128-NEXT: ext v0.16b, v1.16b, v0.16b, #4
+; VBITS_GE_128-NEXT: stp q2, q0, [x0]
+; VBITS_GE_128-NEXT: ret
+;
+; VBITS_GE_256-LABEL: combine_loads_v8i16_v16i16:
+; VBITS_GE_256: // %bb.0:
+; VBITS_GE_256-NEXT: ptrue p0.h, vl16
+; VBITS_GE_256-NEXT: adrp x8, .LCPI3_0
+; VBITS_GE_256-NEXT: add x8, x8, :lo12:.LCPI3_0
+; VBITS_GE_256-NEXT: ld1h { z0.h }, p0/z, [x8]
+; VBITS_GE_256-NEXT: ld1h { z1.h }, p0/z, [x0]
+; VBITS_GE_256-NEXT: tbl z0.h, { z1.h }, z0.h
+; VBITS_GE_256-NEXT: st1h { z0.h }, p0, [x0]
+; VBITS_GE_256-NEXT: ret
+;
+; BE_VBITS_GE_256-LABEL: combine_loads_v8i16_v16i16:
+; BE_VBITS_GE_256: // %bb.0:
+; BE_VBITS_GE_256-NEXT: ptrue p0.h, vl16
+; BE_VBITS_GE_256-NEXT: adrp x8, .LCPI3_0
+; BE_VBITS_GE_256-NEXT: add x8, x8, :lo12:.LCPI3_0
+; BE_VBITS_GE_256-NEXT: ld1h { z0.h }, p0/z, [x8]
+; BE_VBITS_GE_256-NEXT: ld1h { z1.h }, p0/z, [x0]
+; BE_VBITS_GE_256-NEXT: tbl z0.h, { z1.h }, z0.h
+; BE_VBITS_GE_256-NEXT: st1h { z0.h }, p0, [x0]
+; BE_VBITS_GE_256-NEXT: ret
+ %gep = getelementptr <8 x i16>, ptr %a, i64 1
+ %l1 = load <8 x i16>, ptr %a
+ %l2 = load <8 x i16>, ptr %gep
+ %result = shufflevector <8 x i16> %l1, <8 x i16> %l2, <16 x i32><i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9>
+ store <16 x i16> %result, ptr %a
+ ret void
+}
+
+define void @combine_loads_v16i8_v16i8_multi_use_load(ptr %a, ptr %b) {
+; VBITS_GE_128-LABEL: combine_loads_v16i8_v16i8_multi_use_load:
+; VBITS_GE_128: // %bb.0:
+; VBITS_GE_128-NEXT: ldp q0, q1, [x0]
+; VBITS_GE_128-NEXT: ext v2.16b, v0.16b, v1.16b, #1
+; VBITS_GE_128-NEXT: ext v1.16b, v0.16b, v1.16b, #2
+; VBITS_GE_128-NEXT: stp q2, q1, [x0]
+; VBITS_GE_128-NEXT: str q0, [x1]
+; VBITS_GE_128-NEXT: ret
+;
+; VBITS_GE_256-LABEL: combine_loads_v16i8_v16i8_multi_use_load:
+; VBITS_GE_256: // %bb.0:
+; VBITS_GE_256-NEXT: ldp q0, q1, [x0]
+; VBITS_GE_256-NEXT: ptrue p0.b, vl16
+; VBITS_GE_256-NEXT: ext v2.16b, v0.16b, v1.16b, #2
+; VBITS_GE_256-NEXT: ext v1.16b, v0.16b, v1.16b, #1
+; VBITS_GE_256-NEXT: splice z1.b, p0, z1.b, z2.b
+; VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; VBITS_GE_256-NEXT: st1b { z1.b }, p0, [x0]
+; VBITS_GE_256-NEXT: str q0, [x1]
+; VBITS_GE_256-NEXT: ret
+;
+; BE_VBITS_GE_256-LABEL: combine_loads_v16i8_v16i8_multi_use_load:
+; BE_VBITS_GE_256: // %bb.0:
+; BE_VBITS_GE_256-NEXT: add x8, x0, #16
+; BE_VBITS_GE_256-NEXT: ld1 { v0.16b }, [x0]
+; BE_VBITS_GE_256-NEXT: ptrue p0.b, vl16
+; BE_VBITS_GE_256-NEXT: ld1 { v1.16b }, [x8]
+; BE_VBITS_GE_256-NEXT: ext v2.16b, v0.16b, v1.16b, #2
+; BE_VBITS_GE_256-NEXT: ext v1.16b, v0.16b, v1.16b, #1
+; BE_VBITS_GE_256-NEXT: splice z1.b, p0, z1.b, z2.b
+; BE_VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; BE_VBITS_GE_256-NEXT: st1b { z1.b }, p0, [x0]
+; BE_VBITS_GE_256-NEXT: st1 { v0.16b }, [x1]
+; BE_VBITS_GE_256-NEXT: ret
+ %gep = getelementptr <16 x i8>, ptr %a, i64 1
+ %l1 = load <16 x i8>, ptr %a
+ %l2 = load <16 x i8>, ptr %gep
+ %result = shufflevector <16 x i8> %l1, <16 x i8> %l2, <32 x i32><i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16,i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17>
+ store <32 x i8> %result, ptr %a
+ store <16 x i8> %l1, ptr %b
+ ret void
+}
+
+define void @combine_loads_v16i8_v32i8_shuffle_with_poison_mask_indices(ptr %a, ptr %b) {
+; VBITS_GE_128-LABEL: combine_loads_v16i8_v32i8_shuffle_with_poison_mask_indices:
+; VBITS_GE_128: // %bb.0:
+; VBITS_GE_128-NEXT: ldp q1, q0, [x0]
+; VBITS_GE_128-NEXT: ext v2.16b, v1.16b, v0.16b, #1
+; VBITS_GE_128-NEXT: ext v0.16b, v1.16b, v0.16b, #2
+; VBITS_GE_128-NEXT: stp q2, q0, [x0]
+; VBITS_GE_128-NEXT: ret
+;
+; VBITS_GE_256-LABEL: combine_loads_v16i8_v32i8_shuffle_with_poison_mask_indices:
+; VBITS_GE_256: // %bb.0:
+; VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; VBITS_GE_256-NEXT: adrp x8, .LCPI5_0
+; VBITS_GE_256-NEXT: add x8, x8, :lo12:.LCPI5_0
+; VBITS_GE_256-NEXT: ld1b { z0.b }, p0/z, [x8]
+; VBITS_GE_256-NEXT: ld1b { z1.b }, p0/z, [x0]
+; VBITS_GE_256-NEXT: tbl z0.b, { z1.b }, z0.b
+; VBITS_GE_256-NEXT: st1b { z0.b }, p0, [x0]
+; VBITS_GE_256-NEXT: ret
+;
+; BE_VBITS_GE_256-LABEL: combine_loads_v16i8_v32i8_shuffle_with_poison_mask_indices:
+; BE_VBITS_GE_256: // %bb.0:
+; BE_VBITS_GE_256-NEXT: ptrue p0.b, vl32
+; BE_VBITS_GE_256-NEXT: adrp x8, .LCPI5_0
+; BE_VBITS_GE_256-NEXT: add x8, x8, :lo12:.LCPI5_0
+; BE_VBITS_GE_256-NEXT: ld1b { z0.b }, p0/z, [x8]
+; BE_VBITS_GE_256-NEXT: ld1b { z1.b }, p0/z, [x0]
+; BE_VBITS_GE_256-NEXT: tbl z0.b, { z1.b }, z0.b
+; BE_VBITS_GE_256-NEXT: st1b { z0.b }, p0, [x0]
+; BE_VBITS_GE_256-NEXT: ret
+ %gep = getelementptr <16 x i8>, ptr %a, i64 1
+ %l1 = load <16 x i8>, ptr %a
+ %l2 = load <16 x i8>, ptr %gep
+ %result = shufflevector <16 x i8> %l1, <16 x i8> %l2, <32 x i32><i32 1, i32 2, i32 poison, i32 poison, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16,i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 poison, i32 15, i32 poison, i32 17>
+ store <32 x i8> %result, ptr %a
+ ret void
+}
diff --git a/llvm/test/CodeGen/Thumb2/mve-vst2.ll b/llvm/test/CodeGen/Thumb2/mve-vst2.ll
index fa7b0e4d6bcc8..2129ea7f3764e 100644
--- a/llvm/test/CodeGen/Thumb2/mve-vst2.ll
+++ b/llvm/test/CodeGen/Thumb2/mve-vst2.ll
@@ -6,11 +6,12 @@
define void @vst2_v2i32(ptr %src, ptr %dst) {
; CHECK-LABEL: vst2_v2i32:
; CHECK: @ %bb.0: @ %entry
-; CHECK-NEXT: ldm.w r0, {r2, r3, r12}
-; CHECK-NEXT: ldr r0, [r0, #12]
-; CHECK-NEXT: vmov q0[2], q0[0], r2, r3
-; CHECK-NEXT: vmov q0[3], q0[1], r12, r0
-; CHECK-NEXT: vstrw.32 q0, [r1]
+; CHECK-NEXT: vldrw.u32 q0, [r0]
+; CHECK-NEXT: vmov.f32 s4, s0
+; CHECK-NEXT: vmov.f32 s5, s2
+; CHECK-NEXT: vmov.f32 s6, s1
+; CHECK-NEXT: vmov.f32 s7, s3
+; CHECK-NEXT: vstrw.32 q1, [r1]
; CHECK-NEXT: bx lr
entry:
%l1 = load <2 x i32>, ptr %src, align 4
@@ -363,11 +364,12 @@ entry:
define void @vst2_v2f32(ptr %src, ptr %dst) {
; CHECK-LABEL: vst2_v2f32:
; CHECK: @ %bb.0: @ %entry
-; CHECK-NEXT: vldr s0, [r0]
-; CHECK-NEXT: vldr s2, [r0, #4]
-; CHECK-NEXT: vldr s1, [r0, #8]
-; CHECK-NEXT: vldr s3, [r0, #12]
-; CHECK-NEXT: vstrw.32 q0, [r1]
+; CHECK-NEXT: vldrw.u32 q0, [r0]
+; CHECK-NEXT: vmov.f32 s4, s0
+; CHECK-NEXT: vmov.f32 s5, s2
+; CHECK-NEXT: vmov.f32 s6, s1
+; CHECK-NEXT: vmov.f32 s7, s3
+; CHECK-NEXT: vstrw.32 q1, [r1]
; CHECK-NEXT: bx lr
entry:
%l1 = load <2 x float>, ptr %src, align 4
More information about the llvm-commits
mailing list