[llvm-branch-commits] [llvm] [AArch64] Eliminate shouldCoalesce restriction. (PR #238865)

Gaƫtan Bossu via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Fri Nov 6 02:57:44 PST 2026


https://github.com/gbossu updated https://github.com/llvm/llvm-project/pull/238865

>From 2a2c528609d0cecc0739b1f201e7d00f317f7abe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ga=C3=ABtan=20Bossu?= <gaetan.bossu at arm.com>
Date: Tue, 20 Oct 2026 09:54:34 +0000
Subject: [PATCH] [AArch64] Eliminate shouldCoalesce restriction.

This does not enforce much, we are already very careful about ORRW,
which is only considered as a copy instruction when we can prove it's
not performing a required zero extension.
---
 .../Target/AArch64/AArch64RegisterInfo.cpp    |  9 ----
 .../AArch64/aarch64-matrix-umull-smull.ll     | 45 +++++++++----------
 llvm/test/CodeGen/AArch64/atomicrmw-fadd.ll   |  3 +-
 llvm/test/CodeGen/AArch64/atomicrmw-fmax.ll   |  3 +-
 llvm/test/CodeGen/AArch64/atomicrmw-fmin.ll   |  3 +-
 llvm/test/CodeGen/AArch64/atomicrmw-fsub.ll   |  3 +-
 llvm/test/CodeGen/AArch64/fcvt-i256.ll        |  9 +---
 .../implicit-def-subreg-to-reg-regression.ll  | 13 +++---
 .../predicate-as-counter-loop-rewrites.ll     | 14 +++---
 .../AArch64/subreg-to-reg-coalescing.mir      | 10 ++---
 .../CodeGen/AArch64/zext-reg-coalesce.mir     |  5 +--
 11 files changed, 43 insertions(+), 74 deletions(-)

diff --git a/llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp b/llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp
index d52841923cea86..01adc343224700 100644
--- a/llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp
+++ b/llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp
@@ -1461,15 +1461,6 @@ bool AArch64RegisterInfo::shouldCoalesce(
       !MF.getSubtarget<AArch64Subtarget>().enableSRLTSubregToRegMitigation())
     return false;
 
-  if (MI->isCopy() &&
-      ((DstRC->getID() == AArch64::GPR64RegClassID) ||
-       (DstRC->getID() == AArch64::GPR64commonRegClassID)) &&
-      MI->getOperand(0).getSubReg() && MI->getOperand(1).getSubReg())
-    // Do not coalesce in the case of a 32-bit subregister copy
-    // which implements a 32 to 64 bit zero extension
-    // which relies on the upper 32 bits being zeroed.
-    return false;
-
   auto IsCoalescerBarrier = [](const MachineInstr &MI) {
     switch (MI.getOpcode()) {
     case AArch64::COALESCER_BARRIER_FPR16:
diff --git a/llvm/test/CodeGen/AArch64/aarch64-matrix-umull-smull.ll b/llvm/test/CodeGen/AArch64/aarch64-matrix-umull-smull.ll
index 9de9ca934b4f0d..49ed1093e5906f 100644
--- a/llvm/test/CodeGen/AArch64/aarch64-matrix-umull-smull.ll
+++ b/llvm/test/CodeGen/AArch64/aarch64-matrix-umull-smull.ll
@@ -176,7 +176,6 @@ define void @matrix_mul_double_shuffle(i32 %N, ptr nocapture %C, ptr nocapture r
 ; CHECK-SD-NEXT:    dup v0.4h, w3
 ; CHECK-SD-NEXT:    // kill: def $w0 killed $w0 def $x0
 ; CHECK-SD-NEXT:    and x8, x0, #0xfffffff8
-; CHECK-SD-NEXT:    // kill: def $w0 killed $w0 killed $x0 def $x0
 ; CHECK-SD-NEXT:  .LBB2_1: // %vector.body
 ; CHECK-SD-NEXT:    // =>This Inner Loop Header: Depth=1
 ; CHECK-SD-NEXT:    ldrh w9, [x2], #16
@@ -764,21 +763,20 @@ define i64 @red_mla_dup_ext_u8_s8_s64(ptr noalias noundef readonly captures(none
 ; CHECK-SD-NEXT:    mov x8, xzr
 ; CHECK-SD-NEXT:    b .LBB6_10
 ; CHECK-SD-NEXT:  .LBB6_6: // %vector.ph
-; CHECK-SD-NEXT:    mov w8, w1
+; CHECK-SD-NEXT:    sxtb x8, w1
 ; CHECK-SD-NEXT:    movi v0.2d, #0000000000000000
-; CHECK-SD-NEXT:    movi v1.2d, #0000000000000000
-; CHECK-SD-NEXT:    sxtb x8, w8
-; CHECK-SD-NEXT:    movi v3.2d, #0000000000000000
 ; CHECK-SD-NEXT:    movi v2.2d, #0000000000000000
+; CHECK-SD-NEXT:    movi v3.2d, #0000000000000000
+; CHECK-SD-NEXT:    movi v1.2d, #0000000000000000
+; CHECK-SD-NEXT:    and x11, x9, #0xc
 ; CHECK-SD-NEXT:    movi v6.2d, #0000000000000000
 ; CHECK-SD-NEXT:    movi v4.2d, #0000000000000000
-; CHECK-SD-NEXT:    and x11, x9, #0xc
+; CHECK-SD-NEXT:    and x10, x9, #0xfffffff0
 ; CHECK-SD-NEXT:    movi v7.2d, #0000000000000000
 ; CHECK-SD-NEXT:    movi v5.2d, #0000000000000000
-; CHECK-SD-NEXT:    and x10, x9, #0xfffffff0
+; CHECK-SD-NEXT:    and x12, x9, #0xfffffff0
 ; CHECK-SD-NEXT:    dup v16.4s, w8
 ; CHECK-SD-NEXT:    mov x8, x0
-; CHECK-SD-NEXT:    and x12, x9, #0xfffffff0
 ; CHECK-SD-NEXT:  .LBB6_7: // %vector.body
 ; CHECK-SD-NEXT:    // =>This Inner Loop Header: Depth=1
 ; CHECK-SD-NEXT:    ldr q17, [x8], #16
@@ -789,34 +787,33 @@ define i64 @red_mla_dup_ext_u8_s8_s64(ptr noalias noundef readonly captures(none
 ; CHECK-SD-NEXT:    ushll v20.4s, v17.4h, #0
 ; CHECK-SD-NEXT:    ushll v18.4s, v18.4h, #0
 ; CHECK-SD-NEXT:    ushll2 v17.4s, v17.8h, #0
-; CHECK-SD-NEXT:    smlal2 v2.2d, v16.4s, v19.4s
+; CHECK-SD-NEXT:    smlal2 v1.2d, v16.4s, v19.4s
 ; CHECK-SD-NEXT:    smlal2 v4.2d, v16.4s, v20.4s
 ; CHECK-SD-NEXT:    smlal v6.2d, v16.2s, v20.2s
 ; CHECK-SD-NEXT:    smlal v3.2d, v16.2s, v19.2s
 ; CHECK-SD-NEXT:    smlal2 v0.2d, v16.4s, v18.4s
 ; CHECK-SD-NEXT:    smlal v7.2d, v16.2s, v17.2s
-; CHECK-SD-NEXT:    smlal v1.2d, v16.2s, v18.2s
+; CHECK-SD-NEXT:    smlal v2.2d, v16.2s, v18.2s
 ; CHECK-SD-NEXT:    smlal2 v5.2d, v16.4s, v17.4s
 ; CHECK-SD-NEXT:    b.ne .LBB6_7
 ; CHECK-SD-NEXT:  // %bb.8: // %middle.block
-; CHECK-SD-NEXT:    add v1.2d, v1.2d, v6.2d
+; CHECK-SD-NEXT:    add v2.2d, v2.2d, v6.2d
 ; CHECK-SD-NEXT:    add v3.2d, v3.2d, v7.2d
 ; CHECK-SD-NEXT:    cmp x10, x9
 ; CHECK-SD-NEXT:    add v0.2d, v0.2d, v4.2d
-; CHECK-SD-NEXT:    add v2.2d, v2.2d, v5.2d
-; CHECK-SD-NEXT:    add v1.2d, v1.2d, v3.2d
-; CHECK-SD-NEXT:    add v0.2d, v0.2d, v2.2d
-; CHECK-SD-NEXT:    add v0.2d, v1.2d, v0.2d
+; CHECK-SD-NEXT:    add v1.2d, v1.2d, v5.2d
+; CHECK-SD-NEXT:    add v2.2d, v2.2d, v3.2d
+; CHECK-SD-NEXT:    add v0.2d, v0.2d, v1.2d
+; CHECK-SD-NEXT:    add v0.2d, v2.2d, v0.2d
 ; CHECK-SD-NEXT:    addp d0, v0.2d
 ; CHECK-SD-NEXT:    fmov x8, d0
 ; CHECK-SD-NEXT:    b.eq .LBB6_15
 ; CHECK-SD-NEXT:  // %bb.9: // %vec.epilog.iter.check
 ; CHECK-SD-NEXT:    cbz x11, .LBB6_13
 ; CHECK-SD-NEXT:  .LBB6_10: // %vec.epilog.ph
-; CHECK-SD-NEXT:    mov w11, w1
+; CHECK-SD-NEXT:    sxtb x11, w1
 ; CHECK-SD-NEXT:    movi v0.2d, #0000000000000000
 ; CHECK-SD-NEXT:    movi d3, #0x0000ff000000ff
-; CHECK-SD-NEXT:    sxtb x11, w11
 ; CHECK-SD-NEXT:    fmov d2, x8
 ; CHECK-SD-NEXT:    dup v1.2s, w11
 ; CHECK-SD-NEXT:    mov x11, x10
@@ -871,20 +868,19 @@ define i64 @red_mla_dup_ext_u8_s8_s64(ptr noalias noundef readonly captures(none
 ; CHECK-GI-NEXT:    cmp w2, #16
 ; CHECK-GI-NEXT:    b.lo .LBB6_9
 ; CHECK-GI-NEXT:  // %bb.3: // %vector.ph
-; CHECK-GI-NEXT:    mov w8, w1
+; CHECK-GI-NEXT:    sxtb x8, w1
 ; CHECK-GI-NEXT:    movi v0.2d, #0000000000000000
 ; CHECK-GI-NEXT:    movi v1.2d, #0000000000000000
-; CHECK-GI-NEXT:    sxtb x8, w8
 ; CHECK-GI-NEXT:    movi v2.2d, #0000000000000000
 ; CHECK-GI-NEXT:    movi v3.2d, #0000000000000000
-; CHECK-GI-NEXT:    movi v4.2d, #0000000000000000
-; CHECK-GI-NEXT:    movi v5.2d, #0000000000000000
 ; CHECK-GI-NEXT:    and x10, x9, #0xfffffff0
+; CHECK-GI-NEXT:    movi v4.2d, #0000000000000000
 ; CHECK-GI-NEXT:    dup v16.2s, w8
-; CHECK-GI-NEXT:    movi v6.2d, #0000000000000000
 ; CHECK-GI-NEXT:    and x8, x9, #0xc
-; CHECK-GI-NEXT:    movi v7.2d, #0000000000000000
+; CHECK-GI-NEXT:    movi v5.2d, #0000000000000000
+; CHECK-GI-NEXT:    movi v6.2d, #0000000000000000
 ; CHECK-GI-NEXT:    mov x11, x0
+; CHECK-GI-NEXT:    movi v7.2d, #0000000000000000
 ; CHECK-GI-NEXT:    and x12, x9, #0xfffffff0
 ; CHECK-GI-NEXT:  .LBB6_4: // %vector.body
 ; CHECK-GI-NEXT:    // =>This Inner Loop Header: Depth=1
@@ -930,10 +926,9 @@ define i64 @red_mla_dup_ext_u8_s8_s64(ptr noalias noundef readonly captures(none
 ; CHECK-GI-NEXT:  .LBB6_8: // %vec.epilog.iter.check
 ; CHECK-GI-NEXT:    cbz x8, .LBB6_12
 ; CHECK-GI-NEXT:  .LBB6_9: // %vec.epilog.ph
-; CHECK-GI-NEXT:    mov w8, w1
+; CHECK-GI-NEXT:    sxtb x8, w1
 ; CHECK-GI-NEXT:    mov v0.d[1], xzr
 ; CHECK-GI-NEXT:    movi v1.2d, #0000000000000000
-; CHECK-GI-NEXT:    sxtb x8, w8
 ; CHECK-GI-NEXT:    mov x11, x10
 ; CHECK-GI-NEXT:    and x10, x9, #0xfffffffc
 ; CHECK-GI-NEXT:    dup v2.2s, w8
diff --git a/llvm/test/CodeGen/AArch64/atomicrmw-fadd.ll b/llvm/test/CodeGen/AArch64/atomicrmw-fadd.ll
index 1a68577fbf91c2..35fe4c88b4e5be 100644
--- a/llvm/test/CodeGen/AArch64/atomicrmw-fadd.ll
+++ b/llvm/test/CodeGen/AArch64/atomicrmw-fadd.ll
@@ -916,9 +916,8 @@ define <2 x float> @test_atomicrmw_fadd_v2f32_seq_cst_align8(ptr %ptr, <2 x floa
 ; SOFTFP-NOLSE-NEXT:    mov w0, w22
 ; SOFTFP-NOLSE-NEXT:    mov w1, w21
 ; SOFTFP-NOLSE-NEXT:    bl __addsf3
-; SOFTFP-NOLSE-NEXT:    mov w8, w0
 ; SOFTFP-NOLSE-NEXT:    mov w9, w22
-; SOFTFP-NOLSE-NEXT:    // kill: def $w23 killed $w23 killed $x23 def $x23
+; SOFTFP-NOLSE-NEXT:    mov w8, w0
 ; SOFTFP-NOLSE-NEXT:    orr x8, x8, x24, lsl #32
 ; SOFTFP-NOLSE-NEXT:    orr x9, x9, x23, lsl #32
 ; SOFTFP-NOLSE-NEXT:  .LBB9_2: // %cmpxchg.start
diff --git a/llvm/test/CodeGen/AArch64/atomicrmw-fmax.ll b/llvm/test/CodeGen/AArch64/atomicrmw-fmax.ll
index 794ee795528a32..8d5378b1957cef 100644
--- a/llvm/test/CodeGen/AArch64/atomicrmw-fmax.ll
+++ b/llvm/test/CodeGen/AArch64/atomicrmw-fmax.ll
@@ -824,9 +824,8 @@ define <2 x float> @test_atomicrmw_fmax_v2f32_seq_cst_align8(ptr %ptr, <2 x floa
 ; SOFTFP-NOLSE-NEXT:    mov w0, w22
 ; SOFTFP-NOLSE-NEXT:    mov w1, w21
 ; SOFTFP-NOLSE-NEXT:    bl fmaxf
-; SOFTFP-NOLSE-NEXT:    mov w8, w0
 ; SOFTFP-NOLSE-NEXT:    mov w9, w22
-; SOFTFP-NOLSE-NEXT:    // kill: def $w23 killed $w23 killed $x23 def $x23
+; SOFTFP-NOLSE-NEXT:    mov w8, w0
 ; SOFTFP-NOLSE-NEXT:    orr x8, x8, x24, lsl #32
 ; SOFTFP-NOLSE-NEXT:    orr x9, x9, x23, lsl #32
 ; SOFTFP-NOLSE-NEXT:  .LBB8_2: // %cmpxchg.start
diff --git a/llvm/test/CodeGen/AArch64/atomicrmw-fmin.ll b/llvm/test/CodeGen/AArch64/atomicrmw-fmin.ll
index 60118e3eddd169..dd98dde783c3ad 100644
--- a/llvm/test/CodeGen/AArch64/atomicrmw-fmin.ll
+++ b/llvm/test/CodeGen/AArch64/atomicrmw-fmin.ll
@@ -824,9 +824,8 @@ define <2 x float> @test_atomicrmw_fmin_v2f32_seq_cst_align8(ptr %ptr, <2 x floa
 ; SOFTFP-NOLSE-NEXT:    mov w0, w22
 ; SOFTFP-NOLSE-NEXT:    mov w1, w21
 ; SOFTFP-NOLSE-NEXT:    bl fminf
-; SOFTFP-NOLSE-NEXT:    mov w8, w0
 ; SOFTFP-NOLSE-NEXT:    mov w9, w22
-; SOFTFP-NOLSE-NEXT:    // kill: def $w23 killed $w23 killed $x23 def $x23
+; SOFTFP-NOLSE-NEXT:    mov w8, w0
 ; SOFTFP-NOLSE-NEXT:    orr x8, x8, x24, lsl #32
 ; SOFTFP-NOLSE-NEXT:    orr x9, x9, x23, lsl #32
 ; SOFTFP-NOLSE-NEXT:  .LBB8_2: // %cmpxchg.start
diff --git a/llvm/test/CodeGen/AArch64/atomicrmw-fsub.ll b/llvm/test/CodeGen/AArch64/atomicrmw-fsub.ll
index 18f8cdc79c4a9e..a96009167a080f 100644
--- a/llvm/test/CodeGen/AArch64/atomicrmw-fsub.ll
+++ b/llvm/test/CodeGen/AArch64/atomicrmw-fsub.ll
@@ -916,9 +916,8 @@ define <2 x float> @test_atomicrmw_fsub_v2f32_seq_cst_align8(ptr %ptr, <2 x floa
 ; SOFTFP-NOLSE-NEXT:    mov w0, w22
 ; SOFTFP-NOLSE-NEXT:    mov w1, w21
 ; SOFTFP-NOLSE-NEXT:    bl __subsf3
-; SOFTFP-NOLSE-NEXT:    mov w8, w0
 ; SOFTFP-NOLSE-NEXT:    mov w9, w22
-; SOFTFP-NOLSE-NEXT:    // kill: def $w23 killed $w23 killed $x23 def $x23
+; SOFTFP-NOLSE-NEXT:    mov w8, w0
 ; SOFTFP-NOLSE-NEXT:    orr x8, x8, x24, lsl #32
 ; SOFTFP-NOLSE-NEXT:    orr x9, x9, x23, lsl #32
 ; SOFTFP-NOLSE-NEXT:  .LBB9_2: // %cmpxchg.start
diff --git a/llvm/test/CodeGen/AArch64/fcvt-i256.ll b/llvm/test/CodeGen/AArch64/fcvt-i256.ll
index cb945800c67b44..9f96c78215befc 100644
--- a/llvm/test/CodeGen/AArch64/fcvt-i256.ll
+++ b/llvm/test/CodeGen/AArch64/fcvt-i256.ll
@@ -134,11 +134,9 @@ define float @s256_to_f32(i256 %val) nounwind {
 ; CHECK-NEXT:    stp q0, q0, [sp, #128]
 ; CHECK-NEXT:    ldr x10, [x10]
 ; CHECK-NEXT:    lsl x10, x10, x9
-; CHECK-NEXT:    // kill: def $w10 killed $w10 killed $x10 def $x10
 ; CHECK-NEXT:    b .LBB0_7
 ; CHECK-NEXT:  .LBB0_11: // %itofp-if-then20
 ; CHECK-NEXT:    lsr x10, x10, #3
-; CHECK-NEXT:    // kill: def $w10 killed $w10 killed $x10 def $x10
 ; CHECK-NEXT:    b .LBB0_8
 ; CHECK-NEXT:  .LBB0_12: // %itofp-sw-bb
 ; CHECK-NEXT:    lsl x10, x10, #1
@@ -259,11 +257,9 @@ define float @u256_to_f32(i256 %val) nounwind {
 ; CHECK-NEXT:    stp q0, q0, [sp, #128]
 ; CHECK-NEXT:    ldr x10, [x10]
 ; CHECK-NEXT:    lsl x10, x10, x9
-; CHECK-NEXT:    // kill: def $w10 killed $w10 killed $x10 def $x10
 ; CHECK-NEXT:    b .LBB1_7
 ; CHECK-NEXT:  .LBB1_11: // %itofp-if-then20
 ; CHECK-NEXT:    lsr x10, x10, #3
-; CHECK-NEXT:    // kill: def $w10 killed $w10 killed $x10 def $x10
 ; CHECK-NEXT:    b .LBB1_8
 ; CHECK-NEXT:  .LBB1_12: // %itofp-sw-bb
 ; CHECK-NEXT:    lsl x0, x0, #1
@@ -530,12 +526,10 @@ define double @u256_to_f64(i256 %val) nounwind {
 ; CHECK-NEXT:    ldr x10, [x10]
 ; CHECK-NEXT:    lsl x10, x10, x9
 ; CHECK-NEXT:    lsr x11, x10, #32
-; CHECK-NEXT:    // kill: def $w11 killed $w11 killed $x11 def $x11
 ; CHECK-NEXT:    b .LBB3_7
 ; CHECK-NEXT:  .LBB3_10: // %itofp-if-then20
-; CHECK-NEXT:    extr x8, x12, x11, #35
 ; CHECK-NEXT:    extr x10, x12, x11, #3
-; CHECK-NEXT:    mov w11, w8
+; CHECK-NEXT:    extr x11, x12, x11, #35
 ; CHECK-NEXT:    mov w8, w9
 ; CHECK-NEXT:    b .LBB3_7
 ; CHECK-NEXT:  .LBB3_11: // %itofp-sw-bb
@@ -1350,7 +1344,6 @@ define i256 @f32_to_s256_sat(float %val) nounwind {
 ; CHECK-SD-NEXT:  .LBB8_7: // %fp-to-i-cleanup
 ; CHECK-SD-NEXT:    ret
 ; CHECK-SD-NEXT:  .LBB8_8: // %fp-to-i-if-saturate
-; CHECK-SD-NEXT:    // kill: def $w8 killed $w8 killed $x8 def $x8
 ; CHECK-SD-NEXT:    sbfx x8, x8, #31, #1
 ; CHECK-SD-NEXT:    mvn x0, x8
 ; CHECK-SD-NEXT:    eor x3, x8, #0x7fffffffffffffff
diff --git a/llvm/test/CodeGen/AArch64/implicit-def-subreg-to-reg-regression.ll b/llvm/test/CodeGen/AArch64/implicit-def-subreg-to-reg-regression.ll
index 50fac819d4afe9..ad9c6d7e2843e0 100644
--- a/llvm/test/CodeGen/AArch64/implicit-def-subreg-to-reg-regression.ll
+++ b/llvm/test/CodeGen/AArch64/implicit-def-subreg-to-reg-regression.ll
@@ -34,12 +34,12 @@ define void @widget(i32 %arg, i32 %arg1, ptr %arg2, ptr %arg3, ptr %arg4, i32 %a
 ; CHECK-NEXT:    mov x23, x2
 ; CHECK-NEXT:    mov w24, w1
 ; CHECK-NEXT:    mov w25, w0
-; CHECK-NEXT:    mov w26, w1
+; CHECK-NEXT:    mov w27, w1
 ; CHECK-NEXT:  Lloh0:
-; CHECK-NEXT:    adrp x27, LJTI0_0 at PAGE
+; CHECK-NEXT:    adrp x28, LJTI0_0 at PAGE
 ; CHECK-NEXT:  Lloh1:
-; CHECK-NEXT:    add x27, x27, LJTI0_0 at PAGEOFF
-; CHECK-NEXT:    mov w28, #1 ; =0x1
+; CHECK-NEXT:    add x28, x28, LJTI0_0 at PAGEOFF
+; CHECK-NEXT:    mov w26, #1 ; =0x1
 ; CHECK-NEXT:    ; implicit-def: $w8
 ; CHECK-NEXT:    str x8, [sp, #40] ; 8-byte Spill
 ; CHECK-NEXT:    b LBB0_2
@@ -59,12 +59,12 @@ define void @widget(i32 %arg, i32 %arg1, ptr %arg2, ptr %arg3, ptr %arg4, i32 %a
 ; CHECK-NEXT:  ; %bb.3: ; %bb8
 ; CHECK-NEXT:    ; in Loop: Header=BB0_2 Depth=1
 ; CHECK-NEXT:    adr x8, LBB0_1
-; CHECK-NEXT:    ldrb w9, [x27, x26]
+; CHECK-NEXT:    ldrb w9, [x28, x27]
 ; CHECK-NEXT:    add x8, x8, x9, lsl #2
 ; CHECK-NEXT:    br x8
 ; CHECK-NEXT:  LBB0_4: ; %bb9
 ; CHECK-NEXT:    ; in Loop: Header=BB0_2 Depth=1
-; CHECK-NEXT:    str w28, [x23]
+; CHECK-NEXT:    str w26, [x23]
 ; CHECK-NEXT:    b LBB0_2
 ; CHECK-NEXT:  LBB0_5: ; %bb8
 ; CHECK-NEXT:    ; in Loop: Header=BB0_2 Depth=1
@@ -92,7 +92,6 @@ define void @widget(i32 %arg, i32 %arg1, ptr %arg2, ptr %arg3, ptr %arg4, i32 %a
 ; CHECK-NEXT:    ldr x8, [sp, #40] ; 8-byte Reload
 ; CHECK-NEXT:    mov x0, xzr
 ; CHECK-NEXT:    mov x1, xzr
-; CHECK-NEXT:    ; kill: def $w8 killed $w8 killed $x8 def $x8
 ; CHECK-NEXT:    str x8, [sp]
 ; CHECK-NEXT:    bl _fprintf
 ; CHECK-NEXT:    brk #0x1
diff --git a/llvm/test/CodeGen/AArch64/predicate-as-counter-loop-rewrites.ll b/llvm/test/CodeGen/AArch64/predicate-as-counter-loop-rewrites.ll
index effb11328f08a5..0a14e8a78d3845 100644
--- a/llvm/test/CodeGen/AArch64/predicate-as-counter-loop-rewrites.ll
+++ b/llvm/test/CodeGen/AArch64/predicate-as-counter-loop-rewrites.ll
@@ -166,14 +166,14 @@ exit:
 define void @rewrite_masked_load_store_i8_i32_induction(ptr %x, i32 %n) #0 {
 ; CHECK-LABEL: rewrite_masked_load_store_i8_i32_induction:
 ; CHECK:       // %bb.0: // %entry
-; CHECK-NEXT:    mov w8, w1
-; CHECK-NEXT:    rdvl x9, #2
-; CHECK-NEXT:    whilelo pn8.b, xzr, x8, vlx2
+; CHECK-NEXT:    mov w9, w1
+; CHECK-NEXT:    rdvl x8, #2
+; CHECK-NEXT:    whilelo pn8.b, xzr, x9, vlx2
 ; CHECK-NEXT:  .LBB3_1: // %loop
 ; CHECK-NEXT:    // =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    mov x10, x9
-; CHECK-NEXT:    mov w11, w9
-; CHECK-NEXT:    incb x9, all, mul #2
+; CHECK-NEXT:    mov x10, x8
+; CHECK-NEXT:    mov w11, w8
+; CHECK-NEXT:    incb x8, all, mul #2
 ; CHECK-NEXT:    decb x10, all, mul #2
 ; CHECK-NEXT:    sxtw x10, w10
 ; CHECK-NEXT:    ld1b { z0.b, z1.b }, pn8/z, [x0, x10]
@@ -181,7 +181,7 @@ define void @rewrite_masked_load_store_i8_i32_induction(ptr %x, i32 %n) #0 {
 ; CHECK-NEXT:    add z1.b, z1.b, #1 // =0x1
 ; CHECK-NEXT:    add z0.b, z0.b, #1 // =0x1
 ; CHECK-NEXT:    st1b { z0.b, z1.b }, pn8, [x10]
-; CHECK-NEXT:    whilelo pn8.b, x11, x8, vlx2
+; CHECK-NEXT:    whilelo pn8.b, x11, x9, vlx2
 ; CHECK-NEXT:    b.mi .LBB3_1
 ; CHECK-NEXT:  // %bb.2: // %exit
 ; CHECK-NEXT:    ret
diff --git a/llvm/test/CodeGen/AArch64/subreg-to-reg-coalescing.mir b/llvm/test/CodeGen/AArch64/subreg-to-reg-coalescing.mir
index c9c604e4b5f59d..8f4a68014a1714 100644
--- a/llvm/test/CodeGen/AArch64/subreg-to-reg-coalescing.mir
+++ b/llvm/test/CodeGen/AArch64/subreg-to-reg-coalescing.mir
@@ -41,10 +41,9 @@ body: |
     ; CHECK-LABEL: name: insert_subreg_mix_subreg_to_reg
     ; CHECK: liveins: $w0
     ; CHECK-NEXT: {{  $}}
-    ; CHECK-NEXT: undef %src_as_64b_2.sub_32:gpr64common = COPY $w0
-    ; CHECK-NEXT: undef %src_as_64b.sub_32:gpr64 = COPY %src_as_64b_2.sub_32
+    ; CHECK-NEXT: undef %src_as_64b.sub_32:gpr64common = COPY $w0
     ; CHECK-NEXT: %used:gpr64common = UBFMXri %src_as_64b, 63, 31
-    ; CHECK-NEXT: %result:gpr64common = ADDXri %src_as_64b_2, 1, 0
+    ; CHECK-NEXT: %result:gpr64common = ADDXri %src_as_64b, 1, 0
     ; CHECK-NEXT: $x1 = COPY %used
     ; CHECK-NEXT: $x0 = COPY %result
     ; CHECK-NEXT: RET_ReallyLR implicit $x0, implicit $x1
@@ -92,10 +91,9 @@ body: |
     ; CHECK-LABEL: name: subreg_copy_mix_subreg_to_reg
     ; CHECK: liveins: $w0
     ; CHECK-NEXT: {{  $}}
-    ; CHECK-NEXT: undef %src_as_64b_2.sub_32:gpr64common = COPY $w0
-    ; CHECK-NEXT: undef %src_as_64b.sub_32:gpr64 = COPY %src_as_64b_2.sub_32
+    ; CHECK-NEXT: undef %src_as_64b.sub_32:gpr64common = COPY $w0
     ; CHECK-NEXT: %used:gpr64common = UBFMXri %src_as_64b, 63, 31
-    ; CHECK-NEXT: %result:gpr64common = ADDXri %src_as_64b_2, 1, 0
+    ; CHECK-NEXT: %result:gpr64common = ADDXri %src_as_64b, 1, 0
     ; CHECK-NEXT: $x1 = COPY %used
     ; CHECK-NEXT: $x0 = COPY %result
     ; CHECK-NEXT: RET_ReallyLR implicit $x0, implicit $x1
diff --git a/llvm/test/CodeGen/AArch64/zext-reg-coalesce.mir b/llvm/test/CodeGen/AArch64/zext-reg-coalesce.mir
index 7deef36eb12167..1b7e6442bc6249 100644
--- a/llvm/test/CodeGen/AArch64/zext-reg-coalesce.mir
+++ b/llvm/test/CodeGen/AArch64/zext-reg-coalesce.mir
@@ -9,8 +9,6 @@
 # The test has no zext (ORRW), SUBREG_TO_REG (considered COPY-like) should get safely coalesced.
 # A generic COPY into .sub_32 does NOT encode that upper bits are zeroed and that's fine because
 # the input MIR did not require that.
-#
-# FIXME: Get that COPY coalesced!
 ---
 name:            no_zext_subreg_to_reg
 tracksRegLiveness: true
@@ -23,9 +21,8 @@ body:             |
     ; CHECK-NEXT: {{  $}}
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
     ; CHECK-NEXT: [[LDRSBXui:%[0-9]+]]:gpr64 = LDRSBXui $x1, 0 :: (load (s8))
-    ; CHECK-NEXT: undef [[COPY1:%[0-9]+]].sub_32:gpr64 = COPY [[LDRSBXui]].sub_32
     ; CHECK-NEXT: STRWui [[COPY]], $x1, 0 :: (store (s8))
-    ; CHECK-NEXT: $x0 = COPY [[COPY1]]
+    ; CHECK-NEXT: $x0 = COPY [[LDRSBXui]]
     ; CHECK-NEXT: RET_ReallyLR implicit $x0
     %1:gpr32 = COPY $w0
     %3:gpr64 = LDRSBXui $x1, 0 :: (load (s8))



More information about the llvm-branch-commits mailing list