[llvm-branch-commits] [llvm] [CodeGen] Lower FREEZE of a defined value to COPY (PR #240470)

Mitch Briles via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Tue Nov 10 01:54:06 PST 2026


https://github.com/MitchBriles updated https://github.com/llvm/llvm-project/pull/240470

>From 47853efef98e48eb308c743814dd425a336f6a67 Mon Sep 17 00:00:00 2001
From: Mitch <mitchbriles at gmail.com>
Date: Fri, 23 Oct 2026 09:51:47 -0600
Subject: [PATCH 1/2] Precommit FinalizeISel FREEZE tests

Assisted-By: Claude Opus 5.5 <noreply at anthropic.com>
---
 .../CodeGen/AArch64/finalize-isel-freeze.mir  | 411 ++++++++++++++++++
 1 file changed, 411 insertions(+)
 create mode 100644 llvm/test/CodeGen/AArch64/finalize-isel-freeze.mir

diff --git a/llvm/test/CodeGen/AArch64/finalize-isel-freeze.mir b/llvm/test/CodeGen/AArch64/finalize-isel-freeze.mir
new file mode 100644
index 0000000000000..d1ae7f7230934
--- /dev/null
+++ b/llvm/test/CodeGen/AArch64/finalize-isel-freeze.mir
@@ -0,0 +1,411 @@
+# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py UTC_ARGS: --version 6
+# RUN: llc -mtriple=aarch64-- -run-pass=finalize-isel -o - %s | FileCheck %s
+# RUN: llc -mtriple=aarch64-- -passes=finalize-isel -o - %s | FileCheck %s
+
+---
+name: freeze_implicit_def
+tracksRegLiveness: true
+body: |
+  bb.0:
+    ; CHECK-LABEL: name: freeze_implicit_def
+    ; CHECK: [[DEF:%[0-9]+]]:gpr32 = IMPLICIT_DEF
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[DEF]]
+    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $w0
+    %0:gpr32 = IMPLICIT_DEF
+    %1:gpr32 = FREEZE %0
+    $w0 = COPY %1
+    RET_ReallyLR implicit $w0
+...
+---
+name: freeze_copy_of_implicit_def
+tracksRegLiveness: true
+body: |
+  bb.0:
+    ; CHECK-LABEL: name: freeze_copy_of_implicit_def
+    ; CHECK: [[DEF:%[0-9]+]]:gpr32 = IMPLICIT_DEF
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY [[DEF]]
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[COPY]]
+    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $w0
+    %0:gpr32 = IMPLICIT_DEF
+    %1:gpr32 = COPY %0
+    %2:gpr32 = FREEZE %1
+    $w0 = COPY %2
+    RET_ReallyLR implicit $w0
+...
+---
+name: freeze_instruction
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $w0, $w1
+
+    ; CHECK-LABEL: name: freeze_instruction
+    ; CHECK: liveins: $w0, $w1
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY $w1
+    ; CHECK-NEXT: [[ADDWrr:%[0-9]+]]:gpr32 = ADDWrr [[COPY]], [[COPY1]]
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[ADDWrr]]
+    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $w0
+    %0:gpr32 = COPY $w0
+    %1:gpr32 = COPY $w1
+    %2:gpr32 = ADDWrr %0, %1
+    %3:gpr32 = FREEZE %2
+    $w0 = COPY %3
+    RET_ReallyLR implicit $w0
+...
+---
+name: freeze_physreg_copy
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $w0
+
+    ; CHECK-LABEL: name: freeze_physreg_copy
+    ; CHECK: liveins: $w0
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[COPY]]
+    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $w0
+    %0:gpr32 = COPY $w0
+    %1:gpr32 = FREEZE %0
+    $w0 = COPY %1
+    RET_ReallyLR implicit $w0
+...
+---
+name: freeze_tied_undef_input
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $w0
+
+    ; CHECK-LABEL: name: freeze_tied_undef_input
+    ; CHECK: liveins: $w0
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
+    ; CHECK-NEXT: [[DEF:%[0-9]+]]:fpr128 = IMPLICIT_DEF
+    ; CHECK-NEXT: [[INSvi32gpr:%[0-9]+]]:fpr128 = INSvi32gpr [[DEF]], 1, [[COPY]]
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:fpr128 = FREEZE [[INSvi32gpr]]
+    ; CHECK-NEXT: $q0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $q0
+    %0:gpr32 = COPY $w0
+    %1:fpr128 = IMPLICIT_DEF
+    %2:fpr128 = INSvi32gpr %1, 1, %0
+    %3:fpr128 = FREEZE %2
+    $q0 = COPY %3
+    RET_ReallyLR implicit $q0
+...
+---
+name: freeze_remat_undef_input
+tracksRegLiveness: true
+body: |
+  bb.0:
+    ; CHECK-LABEL: name: freeze_remat_undef_input
+    ; CHECK: [[DEF:%[0-9]+]]:gpr64sp = IMPLICIT_DEF
+    ; CHECK-NEXT: [[ADDXri:%[0-9]+]]:gpr64sp = ADDXri [[DEF]], 1, 0
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr64 = FREEZE [[ADDXri]]
+    ; CHECK-NEXT: $x0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $x0
+    %0:gpr64sp = IMPLICIT_DEF
+    %1:gpr64sp = ADDXri %0, 1, 0
+    %2:gpr64 = FREEZE %1
+    $x0 = COPY %2
+    RET_ReallyLR implicit $x0
+...
+---
+name: freeze_remat_chain_undef_input
+tracksRegLiveness: true
+body: |
+  bb.0:
+    ; CHECK-LABEL: name: freeze_remat_chain_undef_input
+    ; CHECK: [[DEF:%[0-9]+]]:gpr64sp = IMPLICIT_DEF
+    ; CHECK-NEXT: [[ADDXri:%[0-9]+]]:gpr64sp = ADDXri [[DEF]], 1, 0
+    ; CHECK-NEXT: [[ADDXri1:%[0-9]+]]:gpr64sp = ADDXri [[ADDXri]], 1, 0
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr64 = FREEZE [[ADDXri1]]
+    ; CHECK-NEXT: $x0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $x0
+    %0:gpr64sp = IMPLICIT_DEF
+    %1:gpr64sp = ADDXri %0, 1, 0
+    %2:gpr64sp = ADDXri %1, 1, 0
+    %3:gpr64 = FREEZE %2
+    $x0 = COPY %3
+    RET_ReallyLR implicit $x0
+...
+---
+name: freeze_undef_use
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $w0
+
+    ; CHECK-LABEL: name: freeze_undef_use
+    ; CHECK: liveins: $w0
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE undef [[COPY]]
+    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $w0
+    %0:gpr32 = COPY $w0
+    %1:gpr32 = FREEZE undef %0
+    $w0 = COPY %1
+    RET_ReallyLR implicit $w0
+...
+---
+name: freeze_of_freeze
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $w0
+
+    ; CHECK-LABEL: name: freeze_of_freeze
+    ; CHECK: liveins: $w0
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[COPY]]
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[FREEZE]]
+    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:gpr32 = FREEZE [[COPY1]]
+    ; CHECK-NEXT: [[DEF:%[0-9]+]]:gpr32 = IMPLICIT_DEF
+    ; CHECK-NEXT: [[FREEZE2:%[0-9]+]]:gpr32 = FREEZE [[DEF]]
+    ; CHECK-NEXT: [[COPY2:%[0-9]+]]:gpr32 = COPY [[FREEZE2]]
+    ; CHECK-NEXT: [[FREEZE3:%[0-9]+]]:gpr32 = FREEZE [[COPY2]]
+    ; CHECK-NEXT: $w0 = COPY [[FREEZE1]]
+    ; CHECK-NEXT: $w1 = COPY [[FREEZE3]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $w0, implicit $w1
+    %0:gpr32 = COPY $w0
+    %1:gpr32 = FREEZE %0
+    %2:gpr32 = COPY %1
+    %3:gpr32 = FREEZE %2
+    %4:gpr32 = IMPLICIT_DEF
+    %5:gpr32 = FREEZE %4
+    %6:gpr32 = COPY %5
+    %7:gpr32 = FREEZE %6
+    $w0 = COPY %3
+    $w1 = COPY %7
+    RET_ReallyLR implicit $w0, implicit $w1
+...
+---
+name: freeze_phi
+tracksRegLiveness: true
+body: |
+  ; CHECK-LABEL: name: freeze_phi
+  ; CHECK: bb.0:
+  ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
+  ; CHECK-NEXT:   liveins: $w0, $w1
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr32 = COPY $w0
+  ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr32 = COPY $w1
+  ; CHECK-NEXT:   CBZW [[COPY]], %bb.2
+  ; CHECK-NEXT:   B %bb.1
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT: bb.1:
+  ; CHECK-NEXT:   successors: %bb.2(0x80000000)
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT:   [[DEF:%[0-9]+]]:gpr32 = IMPLICIT_DEF
+  ; CHECK-NEXT:   B %bb.2
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT: bb.2:
+  ; CHECK-NEXT:   [[PHI:%[0-9]+]]:gpr32 = PHI [[COPY1]], %bb.0, [[DEF]], %bb.1
+  ; CHECK-NEXT:   [[PHI1:%[0-9]+]]:gpr32 = PHI [[COPY1]], %bb.0, [[COPY]], %bb.1
+  ; CHECK-NEXT:   [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[PHI]]
+  ; CHECK-NEXT:   [[FREEZE1:%[0-9]+]]:gpr32 = FREEZE [[PHI1]]
+  ; CHECK-NEXT:   $w0 = COPY [[FREEZE]]
+  ; CHECK-NEXT:   $w1 = COPY [[FREEZE1]]
+  ; CHECK-NEXT:   RET_ReallyLR implicit $w0, implicit $w1
+  bb.0:
+    successors: %bb.1, %bb.2
+    liveins: $w0, $w1
+
+    %0:gpr32 = COPY $w0
+    %1:gpr32 = COPY $w1
+    CBZW %0, %bb.2
+    B %bb.1
+
+  bb.1:
+    %2:gpr32 = IMPLICIT_DEF
+    B %bb.2
+
+  bb.2:
+    %3:gpr32 = PHI %1, %bb.0, %2, %bb.1
+    %4:gpr32 = PHI %1, %bb.0, %0, %bb.1
+    %5:gpr32 = FREEZE %3
+    %6:gpr32 = FREEZE %4
+    $w0 = COPY %5
+    $w1 = COPY %6
+    RET_ReallyLR implicit $w0, implicit $w1
+...
+---
+name: freeze_loop_phi
+tracksRegLiveness: true
+body: |
+  ; CHECK-LABEL: name: freeze_loop_phi
+  ; CHECK: bb.0:
+  ; CHECK-NEXT:   successors: %bb.1(0x80000000)
+  ; CHECK-NEXT:   liveins: $w0, $w1
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr32 = COPY $w0
+  ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr32 = COPY $w1
+  ; CHECK-NEXT:   [[DEF:%[0-9]+]]:gpr32 = IMPLICIT_DEF
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT: bb.1:
+  ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT:   [[PHI:%[0-9]+]]:gpr32 = PHI [[COPY]], %bb.0, %4, %bb.1
+  ; CHECK-NEXT:   [[PHI1:%[0-9]+]]:gpr32 = PHI [[DEF]], %bb.0, %6, %bb.1
+  ; CHECK-NEXT:   [[COPY2:%[0-9]+]]:gpr32 = COPY [[PHI]]
+  ; CHECK-NEXT:   [[COPY3:%[0-9]+]]:gpr32 = COPY [[PHI1]]
+  ; CHECK-NEXT:   CBZW [[COPY1]], %bb.1
+  ; CHECK-NEXT:   B %bb.2
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT: bb.2:
+  ; CHECK-NEXT:   [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[PHI]]
+  ; CHECK-NEXT:   [[FREEZE1:%[0-9]+]]:gpr32 = FREEZE [[PHI1]]
+  ; CHECK-NEXT:   $w0 = COPY [[FREEZE]]
+  ; CHECK-NEXT:   $w1 = COPY [[FREEZE1]]
+  ; CHECK-NEXT:   RET_ReallyLR implicit $w0, implicit $w1
+  bb.0:
+    successors: %bb.1
+    liveins: $w0, $w1
+
+    %0:gpr32 = COPY $w0
+    %1:gpr32 = COPY $w1
+    %2:gpr32 = IMPLICIT_DEF
+
+  bb.1:
+    successors: %bb.1, %bb.2
+
+    %3:gpr32 = PHI %0, %bb.0, %4, %bb.1
+    %5:gpr32 = PHI %2, %bb.0, %6, %bb.1
+    %4:gpr32 = COPY %3
+    %6:gpr32 = COPY %5
+    CBZW %1, %bb.1
+    B %bb.2
+
+  bb.2:
+    %7:gpr32 = FREEZE %3
+    %8:gpr32 = FREEZE %5
+    $w0 = COPY %7
+    $w1 = COPY %8
+    RET_ReallyLR implicit $w0, implicit $w1
+...
+---
+name: freeze_reg_sequence
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $q0, $q1
+
+    ; CHECK-LABEL: name: freeze_reg_sequence
+    ; CHECK: liveins: $q0, $q1
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:fpr128 = COPY $q0
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:fpr128 = COPY $q1
+    ; CHECK-NEXT: [[DEF:%[0-9]+]]:fpr128 = IMPLICIT_DEF
+    ; CHECK-NEXT: [[REG_SEQUENCE:%[0-9]+]]:qq = REG_SEQUENCE [[COPY]], %subreg.qsub0, [[COPY1]], %subreg.qsub1
+    ; CHECK-NEXT: [[REG_SEQUENCE1:%[0-9]+]]:qq = REG_SEQUENCE [[COPY]], %subreg.qsub0, [[DEF]], %subreg.qsub1
+    ; CHECK-NEXT: [[REG_SEQUENCE2:%[0-9]+]]:qq = REG_SEQUENCE [[COPY]], %subreg.qsub0
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:qq = FREEZE [[REG_SEQUENCE]]
+    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:qq = FREEZE [[REG_SEQUENCE1]]
+    ; CHECK-NEXT: [[FREEZE2:%[0-9]+]]:qq = FREEZE [[REG_SEQUENCE2]]
+    ; CHECK-NEXT: $q0_q1 = COPY [[FREEZE]]
+    ; CHECK-NEXT: $q2_q3 = COPY [[FREEZE1]]
+    ; CHECK-NEXT: $q4_q5 = COPY [[FREEZE2]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $q0_q1, implicit $q2_q3, implicit $q4_q5
+    %0:fpr128 = COPY $q0
+    %1:fpr128 = COPY $q1
+    %2:fpr128 = IMPLICIT_DEF
+    %3:qq = REG_SEQUENCE %0, %subreg.qsub0, %1, %subreg.qsub1
+    %4:qq = REG_SEQUENCE %0, %subreg.qsub0, %2, %subreg.qsub1
+    %5:qq = REG_SEQUENCE %0, %subreg.qsub0
+    %6:qq = FREEZE %3
+    %7:qq = FREEZE %4
+    %8:qq = FREEZE %5
+    $q0_q1 = COPY %6
+    $q2_q3 = COPY %7
+    $q4_q5 = COPY %8
+    RET_ReallyLR implicit $q0_q1, implicit $q2_q3, implicit $q4_q5
+...
+---
+name: freeze_insert_subreg
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $q0, $d1
+
+    ; CHECK-LABEL: name: freeze_insert_subreg
+    ; CHECK: liveins: $q0, $d1
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:fpr128 = COPY $q0
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:fpr64 = COPY $d1
+    ; CHECK-NEXT: [[DEF:%[0-9]+]]:fpr128 = IMPLICIT_DEF
+    ; CHECK-NEXT: [[INSERT_SUBREG:%[0-9]+]]:fpr128 = INSERT_SUBREG [[COPY]], [[COPY1]], %subreg.dsub
+    ; CHECK-NEXT: [[INSERT_SUBREG1:%[0-9]+]]:fpr128 = INSERT_SUBREG [[DEF]], [[COPY1]], %subreg.dsub
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:fpr128 = FREEZE [[INSERT_SUBREG]]
+    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:fpr128 = FREEZE [[INSERT_SUBREG1]]
+    ; CHECK-NEXT: $q0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: $q1 = COPY [[FREEZE1]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $q0, implicit $q1
+    %0:fpr128 = COPY $q0
+    %1:fpr64 = COPY $d1
+    %2:fpr128 = IMPLICIT_DEF
+    %3:fpr128 = INSERT_SUBREG %0, %1, %subreg.dsub
+    %4:fpr128 = INSERT_SUBREG %2, %1, %subreg.dsub
+    %5:fpr128 = FREEZE %3
+    %6:fpr128 = FREEZE %4
+    $q0 = COPY %5
+    $q1 = COPY %6
+    RET_ReallyLR implicit $q0, implicit $q1
+...
+---
+name: freeze_subreg_to_reg
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $w0
+
+    ; CHECK-LABEL: name: freeze_subreg_to_reg
+    ; CHECK: liveins: $w0
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
+    ; CHECK-NEXT: [[ADDWrr:%[0-9]+]]:gpr32 = ADDWrr [[COPY]], [[COPY]]
+    ; CHECK-NEXT: [[SUBREG_TO_REG:%[0-9]+]]:gpr64 = SUBREG_TO_REG [[ADDWrr]], %subreg.sub_32
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr64 = FREEZE [[SUBREG_TO_REG]]
+    ; CHECK-NEXT: $x0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $x0
+    %0:gpr32 = COPY $w0
+    %1:gpr32 = ADDWrr %0, %0
+    %2:gpr64 = SUBREG_TO_REG %1, %subreg.sub_32
+    %3:gpr64 = FREEZE %2
+    $x0 = COPY %3
+    RET_ReallyLR implicit $x0
+...
+---
+name: freeze_subreg_use
+tracksRegLiveness: true
+body: |
+  bb.0:
+    liveins: $x0
+
+    ; CHECK-LABEL: name: freeze_subreg_use
+    ; CHECK: liveins: $x0
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr64 = COPY $x0
+    ; CHECK-NEXT: [[DEF:%[0-9]+]]:gpr32 = IMPLICIT_DEF
+    ; CHECK-NEXT: [[INSERT_SUBREG:%[0-9]+]]:gpr64 = INSERT_SUBREG [[COPY]], [[DEF]], %subreg.sub_32
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[COPY]].sub_32
+    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:gpr32 = FREEZE [[INSERT_SUBREG]].sub_32
+    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: $w1 = COPY [[FREEZE1]]
+    ; CHECK-NEXT: RET_ReallyLR implicit $w0, implicit $w1
+    %0:gpr64 = COPY $x0
+    %1:gpr32 = IMPLICIT_DEF
+    %2:gpr64 = INSERT_SUBREG %0, %1, %subreg.sub_32
+    %3:gpr32 = FREEZE %0.sub_32
+    %4:gpr32 = FREEZE %2.sub_32
+    $w0 = COPY %3
+    $w1 = COPY %4
+    RET_ReallyLR implicit $w0, implicit $w1
+...

>From 0924ca01c64c9d48e505eb1541862afbbac7ffdb Mon Sep 17 00:00:00 2001
From: Mitch <mitchbriles at gmail.com>
Date: Mon, 9 Nov 2026 01:53:25 -0700
Subject: [PATCH 2/2] [CodeGen] Lower FREEZE of a defined value to COPY

A FREEZE is only needed when its operand may be undefined. FinalizeISel
now turns every other FREEZE into a COPY, right after instruction
selection.

Assisted-By: Claude Opus 5.5 <noreply at anthropic.com>
---
 llvm/lib/CodeGen/FinalizeISel.cpp             | 116 ++++++++++++++++++
 .../lib/CodeGen/SelectionDAG/InstrEmitter.cpp |  20 +++
 .../CodeGen/AArch64/finalize-isel-freeze.mir  |  72 +++++------
 3 files changed, 172 insertions(+), 36 deletions(-)

diff --git a/llvm/lib/CodeGen/FinalizeISel.cpp b/llvm/lib/CodeGen/FinalizeISel.cpp
index da2936bdd4b11..7e8faf40f0361 100644
--- a/llvm/lib/CodeGen/FinalizeISel.cpp
+++ b/llvm/lib/CodeGen/FinalizeISel.cpp
@@ -15,13 +15,16 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/FinalizeISel.h"
+#include "llvm/ADT/BitVector.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/InitializePasses.h"
+#include "llvm/Support/Debug.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "finalize-isel"
@@ -41,9 +44,115 @@ namespace {
   };
 } // end anonymous namespace
 
+/// Return true if \p MI copies its inputs into its result, or may be
+/// rematerialized. Either way, an undefined input can make different uses of
+/// the result observe different values.
+static bool passesUndefThrough(const MachineInstr &MI,
+                               const TargetInstrInfo &TII) {
+  switch (MI.getOpcode()) {
+  case TargetOpcode::PHI:
+  case TargetOpcode::COPY:
+  case TargetOpcode::INSERT_SUBREG:
+  case TargetOpcode::SUBREG_TO_REG:
+  case TargetOpcode::REG_SEQUENCE:
+    return true;
+  default:
+    return TII.isReMaterializable(MI);
+  }
+}
+
+/// Return true if the register use \p MO may read an undefined value. Either it
+/// is marked undef, or it reads a virtual register without a single definition.
+/// A live-in virtual register without a definition holds the incoming physical
+/// register value.
+static bool mayReadUndef(const MachineOperand &MO,
+                         const MachineRegisterInfo &MRI) {
+  if (MO.isUndef())
+    return true;
+  Register Reg = MO.getReg();
+  return Reg.isVirtual() && !MRI.hasOneDef(Reg) && !MRI.getLiveInPhysReg(Reg);
+}
+
+/// Return true if \p MI may define an undefined register, i.e. an IMPLICIT_DEF,
+/// a partial register definition, or an instruction that copies or may
+/// rematerialize an undefined operand.
+static bool definesUndef(const MachineInstr &MI, const MachineRegisterInfo &MRI,
+                         const TargetInstrInfo &TII) {
+  if (MI.isImplicitDef())
+    return true;
+  for (const MachineOperand &Def : MI.all_defs())
+    if (Def.getSubReg())
+      return true;
+  if (MI.isRegSequence()) {
+    LaneBitmask Covered;
+    for (unsigned I = 2, E = MI.getNumOperands(); I < E; I += 2)
+      Covered |= MRI.getTargetRegisterInfo()->getSubRegIndexLaneMask(
+          MI.getOperand(I).getImm());
+    if ((MRI.getMaxLaneMaskForVReg(MI.getOperand(0).getReg()) & ~Covered).any())
+      return true;
+  }
+  return passesUndefThrough(MI, TII) &&
+         any_of(MI.all_uses(), [&](const MachineOperand &Use) {
+           return mayReadUndef(Use, MRI);
+         });
+}
+
+/// Add the virtual registers defined by \p MI to \p MayBeUndef.
+static void markDefsUndef(const MachineInstr &MI, BitVector &MayBeUndef,
+                          SmallVectorImpl<Register> &Worklist) {
+  for (const MachineOperand &Def : MI.all_defs()) {
+    Register Reg = Def.getReg();
+    if (Reg.isVirtual() && !MayBeUndef.test(Reg.virtRegIndex())) {
+      MayBeUndef.set(Reg.virtRegIndex());
+      Worklist.push_back(Reg);
+    }
+  }
+}
+
+/// A FREEZE is only needed if its input may be undefined. Turn every other
+/// FREEZE into a COPY right after instruction selection.
+static bool lowerDefinedFreezes(MachineFunction &MF) {
+  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
+  const MachineRegisterInfo &MRI = MF.getRegInfo();
+  SmallVector<MachineInstr *, 8> Freezes;
+  BitVector MayBeUndef(MRI.getNumVirtRegs());
+  SmallVector<Register, 16> Worklist;
+  for (MachineBasicBlock &MBB : MF) {
+    for (MachineInstr &MI : MBB) {
+      if (MI.isDebugInstr())
+        continue;
+      if (MI.getOpcode() == TargetOpcode::FREEZE)
+        Freezes.push_back(&MI);
+      else if (definesUndef(MI, MRI, TII))
+        markDefsUndef(MI, MayBeUndef, Worklist);
+    }
+  }
+
+  while (!Worklist.empty()) {
+    Register Reg = Worklist.pop_back_val();
+    for (const MachineInstr &UseMI : MRI.use_nodbg_instructions(Reg))
+      if (passesUndefThrough(UseMI, TII))
+        markDefsUndef(UseMI, MayBeUndef, Worklist);
+  }
+
+  bool Changed = false;
+  for (MachineInstr *MI : Freezes) {
+    const MachineOperand &Src = MI->getOperand(1);
+    if (mayReadUndef(Src, MRI) ||
+        (Src.getReg().isVirtual() &&
+         MayBeUndef.test(Src.getReg().virtRegIndex())))
+      continue;
+    LLVM_DEBUG(dbgs() << "Converting to COPY: " << *MI);
+    MI->setDesc(TII.get(TargetOpcode::COPY));
+    Changed = true;
+  }
+  return Changed;
+}
+
 static std::pair<bool, bool> runImpl(MachineFunction &MF) {
   bool Changed = false;
   bool PreserveCFG = true;
+  bool SawFreeze = false;
   const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
   const TargetLowering *TLI = MF.getSubtarget().getTargetLowering();
 
@@ -58,6 +167,10 @@ static std::pair<bool, bool> runImpl(MachineFunction &MF) {
          MBBI != MBBE; ) {
       MachineInstr &MI = *MBBI++;
 
+      // A FREEZE emitted by a custom inserter before MBBI is missed, and stays.
+      if (MI.getOpcode() == TargetOpcode::FREEZE)
+        SawFreeze = true;
+
       // Set AdjustsStack to true if the instruction selector emits a stack
       // frame setup instruction or a stack aligning inlineasm.
       if (TII->isFrameInstr(MI) || MI.isStackAligningInlineAsm())
@@ -78,6 +191,9 @@ static std::pair<bool, bool> runImpl(MachineFunction &MF) {
       }
     }
   }
+
+  if (SawFreeze)
+    Changed |= lowerDefinedFreezes(MF);
   return {Changed, PreserveCFG};
 }
 
diff --git a/llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp b/llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp
index b100b988555e3..08871f898068e 100644
--- a/llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp
@@ -1103,6 +1103,26 @@ EmitMachineNode(SDNode *Node, bool IsClone, bool IsCloned,
   // hook knows where in the block to insert the replacement code.
   MBB->insert(InsertPos, MIB);
 
+  // A FREEZE doesn't change register class. Classes without a common subclass
+  // are split with a COPY:
+  //   %d:sgpr_32 = FREEZE %s:vgpr_32
+  // becomes
+  //   %f:vgpr_32 = FREEZE %s:vgpr_32
+  //   %d:sgpr_32 = COPY %f:vgpr_32
+  if (Opc == TargetOpcode::FREEZE) {
+    Register DstReg = MIB->getOperand(0).getReg();
+    Register SrcReg = MIB->getOperand(1).getReg();
+    const TargetRegisterClass *SrcRC =
+        SrcReg.isVirtual() ? MRI->getRegClass(SrcReg) : nullptr;
+    if (SrcRC && !TRI->getCommonSubClass(MRI->getRegClass(DstReg), SrcRC)) {
+      Register FrozenReg = MRI->createVirtualRegister(SrcRC);
+      MIB->getOperand(0).setReg(FrozenReg);
+      BuildMI(*MBB, InsertPos, MIB->getDebugLoc(), TII->get(TargetOpcode::COPY),
+              DstReg)
+          .addReg(FrozenReg);
+    }
+  }
+
   // The MachineInstr may also define physregs instead of virtregs.  These
   // physreg values can reach other instructions in different ways:
   //
diff --git a/llvm/test/CodeGen/AArch64/finalize-isel-freeze.mir b/llvm/test/CodeGen/AArch64/finalize-isel-freeze.mir
index d1ae7f7230934..695a3c2602c83 100644
--- a/llvm/test/CodeGen/AArch64/finalize-isel-freeze.mir
+++ b/llvm/test/CodeGen/AArch64/finalize-isel-freeze.mir
@@ -47,8 +47,8 @@ body: |
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY $w1
     ; CHECK-NEXT: [[ADDWrr:%[0-9]+]]:gpr32 = ADDWrr [[COPY]], [[COPY1]]
-    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[ADDWrr]]
-    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: [[COPY2:%[0-9]+]]:gpr32 = COPY [[ADDWrr]]
+    ; CHECK-NEXT: $w0 = COPY [[COPY2]]
     ; CHECK-NEXT: RET_ReallyLR implicit $w0
     %0:gpr32 = COPY $w0
     %1:gpr32 = COPY $w1
@@ -68,8 +68,8 @@ body: |
     ; CHECK: liveins: $w0
     ; CHECK-NEXT: {{  $}}
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
-    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[COPY]]
-    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
+    ; CHECK-NEXT: $w0 = COPY [[COPY1]]
     ; CHECK-NEXT: RET_ReallyLR implicit $w0
     %0:gpr32 = COPY $w0
     %1:gpr32 = FREEZE %0
@@ -89,8 +89,8 @@ body: |
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
     ; CHECK-NEXT: [[DEF:%[0-9]+]]:fpr128 = IMPLICIT_DEF
     ; CHECK-NEXT: [[INSvi32gpr:%[0-9]+]]:fpr128 = INSvi32gpr [[DEF]], 1, [[COPY]]
-    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:fpr128 = FREEZE [[INSvi32gpr]]
-    ; CHECK-NEXT: $q0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:fpr128 = COPY [[INSvi32gpr]]
+    ; CHECK-NEXT: $q0 = COPY [[COPY1]]
     ; CHECK-NEXT: RET_ReallyLR implicit $q0
     %0:gpr32 = COPY $w0
     %1:fpr128 = IMPLICIT_DEF
@@ -165,15 +165,15 @@ body: |
     ; CHECK: liveins: $w0
     ; CHECK-NEXT: {{  $}}
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
-    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[COPY]]
-    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[FREEZE]]
-    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:gpr32 = FREEZE [[COPY1]]
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
+    ; CHECK-NEXT: [[COPY2:%[0-9]+]]:gpr32 = COPY [[COPY1]]
+    ; CHECK-NEXT: [[COPY3:%[0-9]+]]:gpr32 = COPY [[COPY2]]
     ; CHECK-NEXT: [[DEF:%[0-9]+]]:gpr32 = IMPLICIT_DEF
-    ; CHECK-NEXT: [[FREEZE2:%[0-9]+]]:gpr32 = FREEZE [[DEF]]
-    ; CHECK-NEXT: [[COPY2:%[0-9]+]]:gpr32 = COPY [[FREEZE2]]
-    ; CHECK-NEXT: [[FREEZE3:%[0-9]+]]:gpr32 = FREEZE [[COPY2]]
-    ; CHECK-NEXT: $w0 = COPY [[FREEZE1]]
-    ; CHECK-NEXT: $w1 = COPY [[FREEZE3]]
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[DEF]]
+    ; CHECK-NEXT: [[COPY4:%[0-9]+]]:gpr32 = COPY [[FREEZE]]
+    ; CHECK-NEXT: [[COPY5:%[0-9]+]]:gpr32 = COPY [[COPY4]]
+    ; CHECK-NEXT: $w0 = COPY [[COPY3]]
+    ; CHECK-NEXT: $w1 = COPY [[COPY5]]
     ; CHECK-NEXT: RET_ReallyLR implicit $w0, implicit $w1
     %0:gpr32 = COPY $w0
     %1:gpr32 = FREEZE %0
@@ -211,9 +211,9 @@ body: |
   ; CHECK-NEXT:   [[PHI:%[0-9]+]]:gpr32 = PHI [[COPY1]], %bb.0, [[DEF]], %bb.1
   ; CHECK-NEXT:   [[PHI1:%[0-9]+]]:gpr32 = PHI [[COPY1]], %bb.0, [[COPY]], %bb.1
   ; CHECK-NEXT:   [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[PHI]]
-  ; CHECK-NEXT:   [[FREEZE1:%[0-9]+]]:gpr32 = FREEZE [[PHI1]]
+  ; CHECK-NEXT:   [[COPY2:%[0-9]+]]:gpr32 = COPY [[PHI1]]
   ; CHECK-NEXT:   $w0 = COPY [[FREEZE]]
-  ; CHECK-NEXT:   $w1 = COPY [[FREEZE1]]
+  ; CHECK-NEXT:   $w1 = COPY [[COPY2]]
   ; CHECK-NEXT:   RET_ReallyLR implicit $w0, implicit $w1
   bb.0:
     successors: %bb.1, %bb.2
@@ -261,10 +261,10 @@ body: |
   ; CHECK-NEXT:   B %bb.2
   ; CHECK-NEXT: {{  $}}
   ; CHECK-NEXT: bb.2:
-  ; CHECK-NEXT:   [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[PHI]]
-  ; CHECK-NEXT:   [[FREEZE1:%[0-9]+]]:gpr32 = FREEZE [[PHI1]]
-  ; CHECK-NEXT:   $w0 = COPY [[FREEZE]]
-  ; CHECK-NEXT:   $w1 = COPY [[FREEZE1]]
+  ; CHECK-NEXT:   [[COPY4:%[0-9]+]]:gpr32 = COPY [[PHI]]
+  ; CHECK-NEXT:   [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[PHI1]]
+  ; CHECK-NEXT:   $w0 = COPY [[COPY4]]
+  ; CHECK-NEXT:   $w1 = COPY [[FREEZE]]
   ; CHECK-NEXT:   RET_ReallyLR implicit $w0, implicit $w1
   bb.0:
     successors: %bb.1
@@ -307,12 +307,12 @@ body: |
     ; CHECK-NEXT: [[REG_SEQUENCE:%[0-9]+]]:qq = REG_SEQUENCE [[COPY]], %subreg.qsub0, [[COPY1]], %subreg.qsub1
     ; CHECK-NEXT: [[REG_SEQUENCE1:%[0-9]+]]:qq = REG_SEQUENCE [[COPY]], %subreg.qsub0, [[DEF]], %subreg.qsub1
     ; CHECK-NEXT: [[REG_SEQUENCE2:%[0-9]+]]:qq = REG_SEQUENCE [[COPY]], %subreg.qsub0
-    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:qq = FREEZE [[REG_SEQUENCE]]
-    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:qq = FREEZE [[REG_SEQUENCE1]]
-    ; CHECK-NEXT: [[FREEZE2:%[0-9]+]]:qq = FREEZE [[REG_SEQUENCE2]]
-    ; CHECK-NEXT: $q0_q1 = COPY [[FREEZE]]
-    ; CHECK-NEXT: $q2_q3 = COPY [[FREEZE1]]
-    ; CHECK-NEXT: $q4_q5 = COPY [[FREEZE2]]
+    ; CHECK-NEXT: [[COPY2:%[0-9]+]]:qq = COPY [[REG_SEQUENCE]]
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:qq = FREEZE [[REG_SEQUENCE1]]
+    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:qq = FREEZE [[REG_SEQUENCE2]]
+    ; CHECK-NEXT: $q0_q1 = COPY [[COPY2]]
+    ; CHECK-NEXT: $q2_q3 = COPY [[FREEZE]]
+    ; CHECK-NEXT: $q4_q5 = COPY [[FREEZE1]]
     ; CHECK-NEXT: RET_ReallyLR implicit $q0_q1, implicit $q2_q3, implicit $q4_q5
     %0:fpr128 = COPY $q0
     %1:fpr128 = COPY $q1
@@ -343,10 +343,10 @@ body: |
     ; CHECK-NEXT: [[DEF:%[0-9]+]]:fpr128 = IMPLICIT_DEF
     ; CHECK-NEXT: [[INSERT_SUBREG:%[0-9]+]]:fpr128 = INSERT_SUBREG [[COPY]], [[COPY1]], %subreg.dsub
     ; CHECK-NEXT: [[INSERT_SUBREG1:%[0-9]+]]:fpr128 = INSERT_SUBREG [[DEF]], [[COPY1]], %subreg.dsub
-    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:fpr128 = FREEZE [[INSERT_SUBREG]]
-    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:fpr128 = FREEZE [[INSERT_SUBREG1]]
-    ; CHECK-NEXT: $q0 = COPY [[FREEZE]]
-    ; CHECK-NEXT: $q1 = COPY [[FREEZE1]]
+    ; CHECK-NEXT: [[COPY2:%[0-9]+]]:fpr128 = COPY [[INSERT_SUBREG]]
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:fpr128 = FREEZE [[INSERT_SUBREG1]]
+    ; CHECK-NEXT: $q0 = COPY [[COPY2]]
+    ; CHECK-NEXT: $q1 = COPY [[FREEZE]]
     ; CHECK-NEXT: RET_ReallyLR implicit $q0, implicit $q1
     %0:fpr128 = COPY $q0
     %1:fpr64 = COPY $d1
@@ -372,8 +372,8 @@ body: |
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr32 = COPY $w0
     ; CHECK-NEXT: [[ADDWrr:%[0-9]+]]:gpr32 = ADDWrr [[COPY]], [[COPY]]
     ; CHECK-NEXT: [[SUBREG_TO_REG:%[0-9]+]]:gpr64 = SUBREG_TO_REG [[ADDWrr]], %subreg.sub_32
-    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr64 = FREEZE [[SUBREG_TO_REG]]
-    ; CHECK-NEXT: $x0 = COPY [[FREEZE]]
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gpr64 = COPY [[SUBREG_TO_REG]]
+    ; CHECK-NEXT: $x0 = COPY [[COPY1]]
     ; CHECK-NEXT: RET_ReallyLR implicit $x0
     %0:gpr32 = COPY $w0
     %1:gpr32 = ADDWrr %0, %0
@@ -395,10 +395,10 @@ body: |
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:gpr64 = COPY $x0
     ; CHECK-NEXT: [[DEF:%[0-9]+]]:gpr32 = IMPLICIT_DEF
     ; CHECK-NEXT: [[INSERT_SUBREG:%[0-9]+]]:gpr64 = INSERT_SUBREG [[COPY]], [[DEF]], %subreg.sub_32
-    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[COPY]].sub_32
-    ; CHECK-NEXT: [[FREEZE1:%[0-9]+]]:gpr32 = FREEZE [[INSERT_SUBREG]].sub_32
-    ; CHECK-NEXT: $w0 = COPY [[FREEZE]]
-    ; CHECK-NEXT: $w1 = COPY [[FREEZE1]]
+    ; CHECK-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]].sub_32
+    ; CHECK-NEXT: [[FREEZE:%[0-9]+]]:gpr32 = FREEZE [[INSERT_SUBREG]].sub_32
+    ; CHECK-NEXT: $w0 = COPY [[COPY1]]
+    ; CHECK-NEXT: $w1 = COPY [[FREEZE]]
     ; CHECK-NEXT: RET_ReallyLR implicit $w0, implicit $w1
     %0:gpr64 = COPY $x0
     %1:gpr32 = IMPLICIT_DEF



More information about the llvm-branch-commits mailing list