[llvm] 762aa86 - [AArch64] Canonicalize NVCAST to bitcast under LE (#223388)

via llvm-commits llvm-commits at lists.llvm.org
Wed Sep 16 04:20:37 PDT 2026


Author: David Green
Date: 2026-09-16T12:20:31+01:00
New Revision: 762aa86b8ebff9b840e2ec76e015b28051ea7158

URL: https://github.com/llvm/llvm-project/commit/762aa86b8ebff9b840e2ec76e015b28051ea7158
DIFF: https://github.com/llvm/llvm-project/commit/762aa86b8ebff9b840e2ec76e015b28051ea7158.diff

LOG: [AArch64] Canonicalize NVCAST to bitcast under LE (#223388)

A NVCAST is equivalent to a BITCAST under LE. This canonicalises the
NVCAST to BITCAST under LE like we do for ARM, so there is only one
representation, then fixes up the places that were assuming nvcast.

Added: 
    

Modified: 
    llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
    llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
    llvm/lib/Target/AArch64/AArch64InstrInfo.td
    llvm/test/CodeGen/AArch64/arm64-build-vector.ll
    llvm/test/CodeGen/AArch64/cttz-of-bool-vector-bitcast.ll
    llvm/test/CodeGen/AArch64/partial-reduction-add-predicated.ll
    llvm/test/CodeGen/AArch64/zext-shuffle.ll

Removed: 
    


################################################################################
diff  --git a/llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp b/llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
index 531478517ef9a..eec871fef671c 100644
--- a/llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
+++ b/llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
@@ -638,9 +638,11 @@ static APInt DecodeFMOVImm(uint64_t Imm, unsigned RegWidth) {
 }
 
 // Decodes the raw integer splat value from a NEON splat operation.
-static std::optional<APInt> DecodeNEONSplat(SDValue N) {
+static std::optional<APInt> DecodeNEONSplat(SDValue N,
+                                            const AArch64Subtarget *Subtarget) {
   assert(N.getValueType().isInteger() && "Only integers are supported");
-  if (N->getOpcode() == AArch64ISD::NVCAST)
+  if (N->getOpcode() == AArch64ISD::NVCAST ||
+      (N->getOpcode() == ISD::BITCAST && Subtarget->isLittleEndian()))
     N = N->getOperand(0);
   unsigned SplatWidth = N.getScalarValueSizeInBits();
   if (N.getOpcode() == AArch64ISD::FMOV)
@@ -669,9 +671,10 @@ static std::optional<APInt> DecodeNEONSplat(SDValue N) {
 
 // If \p N is a NEON splat operation (movi, fmov, etc), return the splat value
 // matching the element size of N.
-static std::optional<APInt> GetNEONSplatValue(SDValue N) {
+static std::optional<APInt>
+GetNEONSplatValue(SDValue N, const AArch64Subtarget *Subtarget) {
   unsigned SplatWidth = N.getScalarValueSizeInBits();
-  if (std::optional<APInt> SplatVal = DecodeNEONSplat(N)) {
+  if (std::optional<APInt> SplatVal = DecodeNEONSplat(N, Subtarget)) {
     if (SplatVal->getBitWidth() <= SplatWidth)
       return APInt::getSplat(SplatWidth, *SplatVal);
     if (SplatVal->isSplat(SplatWidth))
@@ -682,7 +685,7 @@ static std::optional<APInt> GetNEONSplatValue(SDValue N) {
 
 bool AArch64DAGToDAGISel::SelectNEONSplatOfSVELogicalImm(SDValue N,
                                                          SDValue &Imm) {
-  std::optional<APInt> ImmVal = GetNEONSplatValue(N);
+  std::optional<APInt> ImmVal = GetNEONSplatValue(N, Subtarget);
   if (!ImmVal)
     return false;
   uint64_t Encoding;
@@ -696,7 +699,7 @@ bool AArch64DAGToDAGISel::SelectNEONSplatOfSVELogicalImm(SDValue N,
 
 bool AArch64DAGToDAGISel::SelectNEONSplatOfSVEAddSubImm(SDValue N, SDValue &Imm,
                                                         SDValue &Shift) {
-  if (std::optional<APInt> ImmVal = GetNEONSplatValue(N))
+  if (std::optional<APInt> ImmVal = GetNEONSplatValue(N, Subtarget))
     return SelectSVEAddSubImm(SDLoc(N), *ImmVal,
                               N.getValueType().getScalarType().getSimpleVT(),
                               Imm, Shift,
@@ -706,13 +709,13 @@ bool AArch64DAGToDAGISel::SelectNEONSplatOfSVEAddSubImm(SDValue N, SDValue &Imm,
 
 bool AArch64DAGToDAGISel::SelectNEONSplatOfSVEArithSImm(SDValue N,
                                                         SDValue &Imm) {
-  if (std::optional<APInt> ImmVal = GetNEONSplatValue(N))
+  if (std::optional<APInt> ImmVal = GetNEONSplatValue(N, Subtarget))
     return SelectSVESignedArithImm(SDLoc(N), *ImmVal, Imm);
   return false;
 }
 
 bool AArch64DAGToDAGISel::SelectNEONSplatOfSImm8(SDValue N, SDValue &Imm) {
-  std::optional<APInt> ImmAPIntVal = GetNEONSplatValue(N);
+  std::optional<APInt> ImmAPIntVal = GetNEONSplatValue(N, Subtarget);
   if (!ImmAPIntVal)
     return false;
 
@@ -725,7 +728,7 @@ bool AArch64DAGToDAGISel::SelectNEONSplatOfSImm8(SDValue N, SDValue &Imm) {
 }
 
 bool AArch64DAGToDAGISel::SelectNEONSplatOfUImm8(SDValue N, SDValue &Imm) {
-  std::optional<APInt> ImmAPIntVal = GetNEONSplatValue(N);
+  std::optional<APInt> ImmAPIntVal = GetNEONSplatValue(N, Subtarget);
   if (!ImmAPIntVal)
     return false;
 

diff  --git a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
index 10efd38fcea31..c3f932cf2739f 100644
--- a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
+++ b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
@@ -26766,8 +26766,10 @@ static SDValue trySimplifySrlAddToRshrnb(SDValue Srl, SelectionDAG &DAG,
   return DAG.getNode(AArch64ISD::NVCAST, DL, VT, Rshrnb);
 }
 
-static SDValue isNVCastToHalfWidthElements(SDValue V) {
-  if (V.getOpcode() != AArch64ISD::NVCAST)
+static SDValue isNVCastToHalfWidthElements(SDValue V,
+                                           const AArch64Subtarget *Subtarget) {
+  if (V.getOpcode() != AArch64ISD::NVCAST &&
+      (V.getOpcode() != ISD::BITCAST || !Subtarget->isLittleEndian()))
     return SDValue();
 
   SDValue Op = V.getOperand(0);
@@ -26816,14 +26818,14 @@ static SDValue performUzpCombine(SDNode *N, SelectionDAG &DAG,
   if (SDValue Urshr = tryCombineExtendRShTrunc(N, DAG))
     return Urshr;
 
-  if (SDValue PreCast = isNVCastToHalfWidthElements(Op0)) {
+  if (SDValue PreCast = isNVCastToHalfWidthElements(Op0, Subtarget)) {
     if (SDValue Rshrnb = trySimplifySrlAddToRshrnb(PreCast, DAG, Subtarget)) {
       Rshrnb = DAG.getNode(AArch64ISD::NVCAST, DL, ResVT, Rshrnb);
       return DAG.getNode(AArch64ISD::UZP1, DL, ResVT, Rshrnb, Op1);
     }
   }
 
-  if (SDValue PreCast = isNVCastToHalfWidthElements(Op1)) {
+  if (SDValue PreCast = isNVCastToHalfWidthElements(Op1, Subtarget)) {
     if (SDValue Rshrnb = trySimplifySrlAddToRshrnb(PreCast, DAG, Subtarget)) {
       Rshrnb = DAG.getNode(AArch64ISD::NVCAST, DL, ResVT, Rshrnb);
       return DAG.getNode(AArch64ISD::UZP1, DL, ResVT, Op0, Rshrnb);
@@ -26831,7 +26833,7 @@ static SDValue performUzpCombine(SDNode *N, SelectionDAG &DAG,
   }
 
   // uzp1<ty>(nvcast(unpklo(uzp1<ty>(x, y))), z) => uzp1<ty>(x, z)
-  if (SDValue PreCast = isNVCastToHalfWidthElements(Op0)) {
+  if (SDValue PreCast = isNVCastToHalfWidthElements(Op0, Subtarget)) {
     if (PreCast.getOpcode() == AArch64ISD::UUNPKLO) {
       if (PreCast.getOperand(0).getOpcode() == AArch64ISD::UZP1) {
         SDValue X = PreCast.getOperand(0).getOperand(0);
@@ -26841,7 +26843,7 @@ static SDValue performUzpCombine(SDNode *N, SelectionDAG &DAG,
   }
 
   // uzp1<ty>(x, nvcast(unpkhi(uzp1<ty>(y, z)))) => uzp1<ty>(x, z)
-  if (SDValue PreCast = isNVCastToHalfWidthElements(Op1)) {
+  if (SDValue PreCast = isNVCastToHalfWidthElements(Op1, Subtarget)) {
     if (PreCast.getOpcode() == AArch64ISD::UUNPKHI) {
       if (PreCast.getOperand(0).getOpcode() == AArch64ISD::UZP1) {
         SDValue Z = PreCast.getOperand(0).getOperand(1);
@@ -26852,8 +26854,8 @@ static SDValue performUzpCombine(SDNode *N, SelectionDAG &DAG,
 
   // uzp1(nvcast(x >> k), nvcast(y >> k)) -> uzp2(nvcast(x), nvcast(y))
   // where 'k' is 'sizeof(eltty(x))/2'.
-  if (SDValue PreCastOp0 = isNVCastToHalfWidthElements(Op0)) {
-    if (SDValue PreCastOp1 = isNVCastToHalfWidthElements(Op1)) {
+  if (SDValue PreCastOp0 = isNVCastToHalfWidthElements(Op0, Subtarget)) {
+    if (SDValue PreCastOp1 = isNVCastToHalfWidthElements(Op1, Subtarget)) {
       if (PreCastOp0.getOpcode() == ISD::SRL &&
           PreCastOp1.getOpcode() == ISD::SRL &&
           PreCastOp0.getOperand(1) == PreCastOp1.getOperand(1)) {
@@ -30372,8 +30374,10 @@ static SDValue performDUPCombine(SDNode *N,
   return SDValue();
 }
 
-/// Get rid of unnecessary NVCASTs (that don't change the type).
-static SDValue performNVCASTCombine(SDNode *N, SelectionDAG &DAG) {
+/// Get rid of unnecessary NVCASTs (that don't change the type). Under LE a
+/// NVCAST is converted to a bitcast.
+static SDValue performNVCASTCombine(SDNode *N, SelectionDAG &DAG,
+                                    const AArch64Subtarget *Subtarget) {
   EVT VT = N->getValueType(0);
   SDValue Op = N->getOperand(0);
 
@@ -30383,6 +30387,9 @@ static SDValue performNVCASTCombine(SDNode *N, SelectionDAG &DAG) {
   if (Op.isUndef())
     return DAG.getUNDEF(VT);
 
+  if (Subtarget->isLittleEndian())
+    return DAG.getBitcast(VT, Op);
+
   if (Op.getOpcode() == AArch64ISD::NVCAST)
     return DAG.getNode(AArch64ISD::NVCAST, SDLoc(N), VT, Op.getOperand(0));
 
@@ -31807,7 +31814,7 @@ SDValue AArch64TargetLowering::PerformDAGCombine(SDNode *N,
   case AArch64ISD::DUPLANE128:
     return performDupLane128Combine(N, DAG);
   case AArch64ISD::NVCAST:
-    return performNVCASTCombine(N, DAG);
+    return performNVCASTCombine(N, DAG, Subtarget);
   case AArch64ISD::SPLICE:
     return performSpliceCombine(N, DAG);
   case AArch64ISD::UUNPKLO:
@@ -36043,6 +36050,14 @@ bool AArch64TargetLowering::canCreateUndefOrPoisonForTargetNode(
 }
 
 bool AArch64TargetLowering::isTargetCanonicalConstantNode(SDValue Op) const {
+  // Peek through bitcasts/extracts/inserts to see if we have a vector
+  // load/broadcast from memory.
+  while (
+      Op.getOpcode() == ISD::BITCAST || Op.getOpcode() == AArch64ISD::NVCAST ||
+      Op.getOpcode() == ISD::EXTRACT_SUBVECTOR ||
+      (Op.getOpcode() == ISD::INSERT_SUBVECTOR && Op.getOperand(0).isUndef()))
+    Op = Op.getOperand(Op.getOpcode() == ISD::INSERT_SUBVECTOR ? 1 : 0);
+
   return Op.getOpcode() == AArch64ISD::DUP ||
          Op.getOpcode() == AArch64ISD::MOVI ||
          Op.getOpcode() == AArch64ISD::MOVIshift ||
@@ -36054,8 +36069,7 @@ bool AArch64TargetLowering::isTargetCanonicalConstantNode(SDValue Op) const {
          // ISel will select fmov(mov i64 0x8000000000000000), resulting in a
          // fmov from fpr to gpr, which is more expensive than fneg(movi(0))
          (Op.getOpcode() == ISD::FNEG &&
-          Op.getOperand(0).getOpcode() == AArch64ISD::MOVIedit &&
-          Op.getOperand(0).getConstantOperandVal(0) == 0) ||
+          isTargetCanonicalConstantNode(Op.getOperand(0))) ||
          (Op.getOpcode() == ISD::EXTRACT_SUBVECTOR &&
           Op.getOperand(0).getOpcode() == AArch64ISD::DUP) ||
          TargetLowering::isTargetCanonicalConstantNode(Op);

diff  --git a/llvm/lib/Target/AArch64/AArch64InstrInfo.td b/llvm/lib/Target/AArch64/AArch64InstrInfo.td
index ac2f9b16ca229..0d8099b911894 100644
--- a/llvm/lib/Target/AArch64/AArch64InstrInfo.td
+++ b/llvm/lib/Target/AArch64/AArch64InstrInfo.td
@@ -9137,13 +9137,14 @@ def : Pat<(v2i64 (AArch64uaddlv (v2i32 V64:$Rn))),
           (v2i64 (INSERT_SUBREG (v2i64 (IMPLICIT_DEF)), (UADDLPv2i32_v1i64 V64:$Rn), dsub))>;
 
 // uaddlp from shuffle + zext
-def : Pat<(add (AArch64bici (v8i16 (bitconvert v16i8:$src)), (i32 255), (i32 8)),
-               (AArch64vlshr (v8i16 (AArch64NvCast v16i8:$src)), (i32 8))),
+def : Pat<(add (AArch64bici (v8i16 V128:$src), (i32 255), (i32 8)),
+               (AArch64vlshr (v8i16 V128:$src), (i32 8))),
           (UADDLPv16i8_v8i16 V128:$src)>;
 
-def : Pat<(add (and (v4i32 (bitconvert v8i16:$src)),
-                    (v4i32 (AArch64NvCast (v2i64 (AArch64movi_edit (i32 51)))))),
-               (AArch64vlshr (v4i32 (AArch64NvCast v8i16:$src)), (i32 16))),
+let Predicates = [IsLE] in
+def : Pat<(add (and (v4i32 V128:$src),
+                    (v4i32 (bitconvert (v2i64 (AArch64movi_edit (i32 51)))))),
+               (AArch64vlshr (v4i32 V128:$src), (i32 16))),
           (UADDLPv8i16_v4i32 V128:$src)>;
 
 def : Pat<(add (v2i64 (zext (v2i32 (AArch64zip1 (v2i32 (extract_subvector v4i32:$src, (i64 0))),
@@ -10061,7 +10062,7 @@ defm : CVTFRecipPat<v8f16, v8i16, V128, fixedpoint_recip_v8f16>;
 
 def VImm0080:         PatLeaf<(AArch64movi_shift (i32 128), (i32 0))>;
 def VImm00008000:     PatLeaf<(AArch64movi_shift (i32 128), (i32 8))>;
-def VImm0000000080000000: PatLeaf<(AArch64NvCast (v2f64 (fneg (AArch64NvCast (v4i32 (AArch64movi_shift (i32 128), (i32 24)))))))>;
+def VImm0000000080000000: PatLeaf<(bitconvert (v2f64 (fneg (bitconvert (v4i32 (AArch64movi_shift (i32 128), (i32 24)))))))>;
 
 // RADDHN patterns for when RSHRN shifts by half the size of the vector element
 def : Pat<(v8i8 (trunc (AArch64vlshr (add (v8i16 V128:$Vn), VImm0080), (i32 8)))),
@@ -10069,6 +10070,7 @@ def : Pat<(v8i8 (trunc (AArch64vlshr (add (v8i16 V128:$Vn), VImm0080), (i32 8)))
 def : Pat<(v4i16 (trunc (AArch64vlshr (add (v4i32 V128:$Vn), VImm00008000), (i32 16)))),
           (RADDHNv4i32_v4i16 V128:$Vn, (v4i32 (MOVIv2d_ns (i32 0))))>;
 let AddedComplexity = 5 in
+let Predicates = [IsLE] in
 def : Pat<(v2i32 (trunc (AArch64vlshr (add (v2i64 V128:$Vn), VImm0000000080000000), (i32 32)))),
           (RADDHNv2i64_v2i32 V128:$Vn, (v2i64 (MOVIv2d_ns (i32 0))))>;
 def : Pat<(v8i8 (int_aarch64_neon_rshrn (v8i16 V128:$Vn), (i32 8))),
@@ -10092,6 +10094,7 @@ def : Pat<(v8i16 (concat_vectors
                  (INSERT_SUBREG (IMPLICIT_DEF), V64:$Vd, dsub), V128:$Vn,
                  (v4i32 (MOVIv2d_ns (i32 0))))>;
 let AddedComplexity = 5 in
+let Predicates = [IsLE] in
 def : Pat<(v4i32 (concat_vectors
                  (v2i32 V64:$Vd),
                  (v2i32 (trunc (AArch64vlshr (add (v2i64 V128:$Vn), VImm0000000080000000), (i32 32)))))),

diff  --git a/llvm/test/CodeGen/AArch64/arm64-build-vector.ll b/llvm/test/CodeGen/AArch64/arm64-build-vector.ll
index f4865fcee5c28..a31f782d3df18 100644
--- a/llvm/test/CodeGen/AArch64/arm64-build-vector.ll
+++ b/llvm/test/CodeGen/AArch64/arm64-build-vector.ll
@@ -74,8 +74,8 @@ define void @widen_f16_build_vector(ptr %addr) {
 ; CHECK-SD-LABEL: widen_f16_build_vector:
 ; CHECK-SD:       // %bb.0:
 ; CHECK-SD-NEXT:    mov w8, #13294 // =0x33ee
-; CHECK-SD-NEXT:    movk w8, #13294, lsl #16
-; CHECK-SD-NEXT:    str w8, [x0]
+; CHECK-SD-NEXT:    dup v0.4h, w8
+; CHECK-SD-NEXT:    str s0, [x0]
 ; CHECK-SD-NEXT:    ret
 ;
 ; CHECK-GI-LABEL: widen_f16_build_vector:

diff  --git a/llvm/test/CodeGen/AArch64/cttz-of-bool-vector-bitcast.ll b/llvm/test/CodeGen/AArch64/cttz-of-bool-vector-bitcast.ll
index f7186dbd2cc7c..955408cc35f75 100644
--- a/llvm/test/CodeGen/AArch64/cttz-of-bool-vector-bitcast.ll
+++ b/llvm/test/CodeGen/AArch64/cttz-of-bool-vector-bitcast.ll
@@ -880,7 +880,6 @@ define i2 @cttz_v2i8(<2 x i8> %v) {
 ; CHECK-LE-LABEL: cttz_v2i8:
 ; CHECK-LE:       // %bb.0:
 ; CHECK-LE-NEXT:    shl v0.2s, v0.2s, #24
-; CHECK-LE-NEXT:    sshr v0.2s, v0.2s, #24
 ; CHECK-LE-NEXT:    cmlt v0.2s, v0.2s, #0
 ; CHECK-LE-NEXT:    fmov x8, d0
 ; CHECK-LE-NEXT:    rbit x8, x8
@@ -911,7 +910,6 @@ define i4 @cttz_v4i8(<4 x i8> %v) {
 ; CHECK-LE-LABEL: cttz_v4i8:
 ; CHECK-LE:       // %bb.0:
 ; CHECK-LE-NEXT:    shl v0.4h, v0.4h, #8
-; CHECK-LE-NEXT:    sshr v0.4h, v0.4h, #8
 ; CHECK-LE-NEXT:    cmlt v0.4h, v0.4h, #0
 ; CHECK-LE-NEXT:    fmov x8, d0
 ; CHECK-LE-NEXT:    rbit x8, x8

diff  --git a/llvm/test/CodeGen/AArch64/partial-reduction-add-predicated.ll b/llvm/test/CodeGen/AArch64/partial-reduction-add-predicated.ll
index e616467480670..5fc22030b80f9 100644
--- a/llvm/test/CodeGen/AArch64/partial-reduction-add-predicated.ll
+++ b/llvm/test/CodeGen/AArch64/partial-reduction-add-predicated.ll
@@ -126,12 +126,11 @@ define <4 x float> @predicated_fpext_fmul_fixed_length(<4 x float> %acc, <8 x i1
 ; CHECK-LABEL: predicated_fpext_fmul_fixed_length:
 ; CHECK:       // %bb.0:
 ; CHECK-NEXT:    ushll v1.8h, v1.8b, #0
-; CHECK-NEXT:    movi v3.8h, #60, lsl #8
 ; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
 ; CHECK-NEXT:    // kill: def $q2 killed $q2 def $z2
 ; CHECK-NEXT:    shl v1.8h, v1.8h, #15
 ; CHECK-NEXT:    cmlt v1.8h, v1.8h, #0
-; CHECK-NEXT:    and v1.16b, v1.16b, v3.16b
+; CHECK-NEXT:    and z1.h, z1.h, #0x3c00
 ; CHECK-NEXT:    fdot z0.s, z2.h, z1.h
 ; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret

diff  --git a/llvm/test/CodeGen/AArch64/zext-shuffle.ll b/llvm/test/CodeGen/AArch64/zext-shuffle.ll
index 0b50735e0a367..56fe2249b6d75 100644
--- a/llvm/test/CodeGen/AArch64/zext-shuffle.ll
+++ b/llvm/test/CodeGen/AArch64/zext-shuffle.ll
@@ -339,23 +339,18 @@ define <8 x i32> @v8i32_371115(<16 x i8> %a, <16 x i8> %b) {
 define <8 x i64> @zext_add(<32 x i16> %l) {
 ; CHECK-LABEL: zext_add:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    movi v4.2d, #0x00ffff0000ffff
-; CHECK-NEXT:    uzp1 v5.4s, v0.4s, v1.4s
+; CHECK-NEXT:    uzp1 v4.4s, v0.4s, v1.4s
 ; CHECK-NEXT:    uzp2 v0.4s, v0.4s, v1.4s
 ; CHECK-NEXT:    uzp1 v1.4s, v2.4s, v3.4s
 ; CHECK-NEXT:    uzp2 v2.4s, v2.4s, v3.4s
-; CHECK-NEXT:    and v3.16b, v5.16b, v4.16b
-; CHECK-NEXT:    and v6.16b, v0.16b, v4.16b
-; CHECK-NEXT:    and v7.16b, v1.16b, v4.16b
-; CHECK-NEXT:    and v4.16b, v2.16b, v4.16b
-; CHECK-NEXT:    usra v3.4s, v5.4s, #16
-; CHECK-NEXT:    usra v6.4s, v0.4s, #16
-; CHECK-NEXT:    usra v7.4s, v1.4s, #16
-; CHECK-NEXT:    usra v4.4s, v2.4s, #16
-; CHECK-NEXT:    uaddl v0.2d, v3.2s, v6.2s
-; CHECK-NEXT:    uaddl2 v1.2d, v3.4s, v6.4s
-; CHECK-NEXT:    uaddl2 v3.2d, v7.4s, v4.4s
-; CHECK-NEXT:    uaddl v2.2d, v7.2s, v4.2s
+; CHECK-NEXT:    uaddlp v3.4s, v4.8h
+; CHECK-NEXT:    uaddlp v4.4s, v0.8h
+; CHECK-NEXT:    uaddlp v5.4s, v1.8h
+; CHECK-NEXT:    uaddlp v2.4s, v2.8h
+; CHECK-NEXT:    uaddl v0.2d, v3.2s, v4.2s
+; CHECK-NEXT:    uaddl2 v1.2d, v3.4s, v4.4s
+; CHECK-NEXT:    uaddl2 v3.2d, v5.4s, v2.4s
+; CHECK-NEXT:    uaddl v2.2d, v5.2s, v2.2s
 ; CHECK-NEXT:    ret
     %s1 = shufflevector <32 x i16> %l, <32 x i16> undef, <8 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28>
     %z1 = zext <8 x i16> %s1 to <8 x i64>
@@ -387,25 +382,20 @@ define <8 x i64> @zext_load_add(ptr %p) {
 ;
 ; CHECK-IADISABLED-LABEL: zext_load_add:
 ; CHECK-IADISABLED:       // %bb.0:
-; CHECK-IADISABLED-NEXT:    ldp q2, q1, [x0]
-; CHECK-IADISABLED-NEXT:    movi v0.2d, #0x00ffff0000ffff
-; CHECK-IADISABLED-NEXT:    ldp q4, q3, [x0, #32]
-; CHECK-IADISABLED-NEXT:    uzp1 v5.4s, v2.4s, v1.4s
-; CHECK-IADISABLED-NEXT:    uzp2 v1.4s, v2.4s, v1.4s
-; CHECK-IADISABLED-NEXT:    uzp1 v2.4s, v4.4s, v3.4s
-; CHECK-IADISABLED-NEXT:    uzp2 v3.4s, v4.4s, v3.4s
-; CHECK-IADISABLED-NEXT:    and v4.16b, v5.16b, v0.16b
-; CHECK-IADISABLED-NEXT:    and v6.16b, v1.16b, v0.16b
-; CHECK-IADISABLED-NEXT:    and v7.16b, v2.16b, v0.16b
-; CHECK-IADISABLED-NEXT:    and v16.16b, v3.16b, v0.16b
-; CHECK-IADISABLED-NEXT:    usra v4.4s, v5.4s, #16
-; CHECK-IADISABLED-NEXT:    usra v6.4s, v1.4s, #16
-; CHECK-IADISABLED-NEXT:    usra v7.4s, v2.4s, #16
-; CHECK-IADISABLED-NEXT:    usra v16.4s, v3.4s, #16
-; CHECK-IADISABLED-NEXT:    uaddl v0.2d, v4.2s, v6.2s
-; CHECK-IADISABLED-NEXT:    uaddl2 v1.2d, v4.4s, v6.4s
-; CHECK-IADISABLED-NEXT:    uaddl2 v3.2d, v7.4s, v16.4s
-; CHECK-IADISABLED-NEXT:    uaddl v2.2d, v7.2s, v16.2s
+; CHECK-IADISABLED-NEXT:    ldp q1, q0, [x0]
+; CHECK-IADISABLED-NEXT:    ldp q3, q2, [x0, #32]
+; CHECK-IADISABLED-NEXT:    uzp1 v4.4s, v1.4s, v0.4s
+; CHECK-IADISABLED-NEXT:    uzp2 v0.4s, v1.4s, v0.4s
+; CHECK-IADISABLED-NEXT:    uzp1 v1.4s, v3.4s, v2.4s
+; CHECK-IADISABLED-NEXT:    uzp2 v2.4s, v3.4s, v2.4s
+; CHECK-IADISABLED-NEXT:    uaddlp v3.4s, v4.8h
+; CHECK-IADISABLED-NEXT:    uaddlp v4.4s, v0.8h
+; CHECK-IADISABLED-NEXT:    uaddlp v5.4s, v1.8h
+; CHECK-IADISABLED-NEXT:    uaddlp v2.4s, v2.8h
+; CHECK-IADISABLED-NEXT:    uaddl v0.2d, v3.2s, v4.2s
+; CHECK-IADISABLED-NEXT:    uaddl2 v1.2d, v3.4s, v4.4s
+; CHECK-IADISABLED-NEXT:    uaddl2 v3.2d, v5.4s, v2.4s
+; CHECK-IADISABLED-NEXT:    uaddl v2.2d, v5.2s, v2.2s
 ; CHECK-IADISABLED-NEXT:    ret
     %l = load <32 x i16>, ptr %p
     %s1 = shufflevector <32 x i16> %l, <32 x i16> undef, <8 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28>


        


More information about the llvm-commits mailing list