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

>From ea8ea6081afb1851929426f0128510c20f04cf66 Mon Sep 17 00:00:00 2001
From: Mitch <[email protected]>
Date: Fri, 23 Oct 2026 10:10:23 -0600
Subject: [PATCH] [SelectionDAG] Don't CSE freeze of undef

Each freeze of undef may have its own arbitrary value.

This also folds a bitcast of a one-use frozen undef into a frozen undef.

Assisted-By: Claude Opus 5.5 <[email protected]>
---
 llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp |   4 +
 .../lib/CodeGen/SelectionDAG/SelectionDAG.cpp |   8 +-
 llvm/test/CodeGen/AArch64/freeze.ll           |  73 ++++++----
 llvm/test/CodeGen/AMDGPU/permute_i8.ll        |   6 +-
 ...-alloca-vector-dynamic-idx-bitcasts-llc.ll | 134 +++---------------
 llvm/test/CodeGen/Hexagon/pr196966.ll         |  41 ++----
 llvm/test/CodeGen/SystemZ/pr60413.ll          |  32 -----
 llvm/test/CodeGen/X86/freeze-vector.ll        |  39 ++---
 llvm/test/CodeGen/X86/freeze.ll               |   3 -
 .../unittests/CodeGen/SelectionDAGCSETest.cpp |  20 +++
 10 files changed, 138 insertions(+), 222 deletions(-)

diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp 
b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 0bd1ccb51aec60..057fcda5260c20 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -18480,6 +18480,10 @@ SDValue DAGCombiner::visitBITCAST(SDNode *N) {
   if (SDValue R = propagateUnaryUndef(DAG, N0, VT))
     return R;
 
+  // A bitcast of an otherwise unused frozen undef is itself a frozen undef.
+  if (ISD::isFreezeUndef(N0) && N0.hasOneUse())
+    return DAG.getFreeze(DAG.getUNDEF(VT));
+
   // If the input is a BUILD_VECTOR with all constant elements, fold this now.
   // Only do this before legalize types, unless both types are integer and the
   // scalar type is legal. Only do this before legalize ops, since the target
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp 
b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index c07494f5a05026..5798df03a61722 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -1060,6 +1060,9 @@ static bool doNotCSE(SDNode *N) {
   case ISD::HANDLENODE:
   case ISD::EH_LABEL:
     return true;   // Never CSE these nodes.
+  case ISD::FREEZE:
+    // Each freeze of undef is a distinct value.
+    return N->getOperand(0).isUndef();
   }
 
   // Check that remaining values produced are not flags.
@@ -7603,7 +7606,8 @@ SDValue SelectionDAG::getNode(unsigned Opcode, const 
SDLoc &DL, EVT VT,
   SDNode *N;
   SDVTList VTs = getVTList(VT);
   SDValue Ops[] = {N1};
-  if (VT != MVT::Glue) { // Don't CSE glue producing nodes
+  // Don't CSE glue producing nodes or freezes of undef.
+  if (VT != MVT::Glue && !(Opcode == ISD::FREEZE && N1.isUndef())) {
     SDNodeKey ID(Opcode, VTs, Ops);
     FoldingSetInsertToken InsertToken;
     if (SDNode *E = lookupNode(ID, DL, InsertToken)) {
@@ -12495,7 +12499,7 @@ SDNode *SelectionDAG::UpdateNodeOperands(SDNode *N, 
SDValue Op) {
 
   updateDivergence(N);
   // If this gets put into a CSE map, add it.
-  if (InsertToken)
+  if (InsertToken && !doNotCSE(N))
     CSEMap.insert(N, InsertToken);
   return N;
 }
diff --git a/llvm/test/CodeGen/AArch64/freeze.ll 
b/llvm/test/CodeGen/AArch64/freeze.ll
index 3476dc0c815737..a660c52c567ede 100644
--- a/llvm/test/CodeGen/AArch64/freeze.ll
+++ b/llvm/test/CodeGen/AArch64/freeze.ll
@@ -118,11 +118,17 @@ define <16 x i8> @freeze_v16i8() {
 }
 
 define <32 x i8> @freeze_v32i8() {
-; CHECK-LABEL: freeze_v32i8:
-; CHECK:       // %bb.0:
-; CHECK-NEXT:    add v0.16b, v0.16b, v0.16b
-; CHECK-NEXT:    mov v1.16b, v0.16b
-; CHECK-NEXT:    ret
+; CHECK-SD-LABEL: freeze_v32i8:
+; CHECK-SD:       // %bb.0:
+; CHECK-SD-NEXT:    add v0.16b, v0.16b, v0.16b
+; CHECK-SD-NEXT:    add v1.16b, v0.16b, v0.16b
+; CHECK-SD-NEXT:    ret
+;
+; CHECK-GI-LABEL: freeze_v32i8:
+; CHECK-GI:       // %bb.0:
+; CHECK-GI-NEXT:    add v0.16b, v0.16b, v0.16b
+; CHECK-GI-NEXT:    mov v1.16b, v0.16b
+; CHECK-GI-NEXT:    ret
   %y1 = freeze <32 x i8> undef
   %t1 = add <32 x i8> %y1, %y1
   ret <32 x i8> %t1
@@ -177,11 +183,17 @@ define <8 x i16> @freeze_v8i16() {
 }
 
 define <16 x i16> @freeze_v16i16() {
-; CHECK-LABEL: freeze_v16i16:
-; CHECK:       // %bb.0:
-; CHECK-NEXT:    add v0.8h, v0.8h, v0.8h
-; CHECK-NEXT:    mov v1.16b, v0.16b
-; CHECK-NEXT:    ret
+; CHECK-SD-LABEL: freeze_v16i16:
+; CHECK-SD:       // %bb.0:
+; CHECK-SD-NEXT:    add v0.8h, v0.8h, v0.8h
+; CHECK-SD-NEXT:    add v1.8h, v0.8h, v0.8h
+; CHECK-SD-NEXT:    ret
+;
+; CHECK-GI-LABEL: freeze_v16i16:
+; CHECK-GI:       // %bb.0:
+; CHECK-GI-NEXT:    add v0.8h, v0.8h, v0.8h
+; CHECK-GI-NEXT:    mov v1.16b, v0.16b
+; CHECK-GI-NEXT:    ret
   %y1 = freeze <16 x i16> undef
   %t1 = add <16 x i16> %y1, %y1
   ret <16 x i16> %t1
@@ -218,11 +230,17 @@ define <4 x i32> @freeze_v4i32() {
 }
 
 define <8 x i32> @freeze_v8i32() {
-; CHECK-LABEL: freeze_v8i32:
-; CHECK:       // %bb.0:
-; CHECK-NEXT:    add v0.4s, v0.4s, v0.4s
-; CHECK-NEXT:    mov v1.16b, v0.16b
-; CHECK-NEXT:    ret
+; CHECK-SD-LABEL: freeze_v8i32:
+; CHECK-SD:       // %bb.0:
+; CHECK-SD-NEXT:    add v0.4s, v0.4s, v0.4s
+; CHECK-SD-NEXT:    add v1.4s, v0.4s, v0.4s
+; CHECK-SD-NEXT:    ret
+;
+; CHECK-GI-LABEL: freeze_v8i32:
+; CHECK-GI:       // %bb.0:
+; CHECK-GI-NEXT:    add v0.4s, v0.4s, v0.4s
+; CHECK-GI-NEXT:    mov v1.16b, v0.16b
+; CHECK-GI-NEXT:    ret
   %y1 = freeze <8 x i32> undef
   %t1 = add <8 x i32> %y1, %y1
   ret <8 x i32> %t1
@@ -243,7 +261,8 @@ define <3 x i64> @freeze_v3i64() {
 ; CHECK-SD:       // %bb.0:
 ; CHECK-SD-NEXT:    add v0.2d, v0.2d, v0.2d
 ; CHECK-SD-NEXT:    mov d1, v0.d[1]
-; CHECK-SD-NEXT:    fmov d2, d0
+; CHECK-SD-NEXT:    add d2, d0, d0
+; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
 ; CHECK-SD-NEXT:    ret
 ;
 ; CHECK-GI-LABEL: freeze_v3i64:
@@ -260,11 +279,17 @@ define <3 x i64> @freeze_v3i64() {
 }
 
 define <4 x i64> @freeze_v4i64() {
-; CHECK-LABEL: freeze_v4i64:
-; CHECK:       // %bb.0:
-; CHECK-NEXT:    add v0.2d, v0.2d, v0.2d
-; CHECK-NEXT:    mov v1.16b, v0.16b
-; CHECK-NEXT:    ret
+; CHECK-SD-LABEL: freeze_v4i64:
+; CHECK-SD:       // %bb.0:
+; CHECK-SD-NEXT:    add v0.2d, v0.2d, v0.2d
+; CHECK-SD-NEXT:    add v1.2d, v0.2d, v0.2d
+; CHECK-SD-NEXT:    ret
+;
+; CHECK-GI-LABEL: freeze_v4i64:
+; CHECK-GI:       // %bb.0:
+; CHECK-GI-NEXT:    add v0.2d, v0.2d, v0.2d
+; CHECK-GI-NEXT:    mov v1.16b, v0.16b
+; CHECK-GI-NEXT:    ret
   %y1 = freeze <4 x i64> undef
   %t1 = add <4 x i64> %y1, %y1
   ret <4 x i64> %t1
@@ -318,9 +343,9 @@ define <4 x ptr> @freeze_v4p0() {
 ; CHECK-SD-LABEL: freeze_v4p0:
 ; CHECK-SD:       // %bb.0:
 ; CHECK-SD-NEXT:    mov w8, #4 // =0x4
-; CHECK-SD-NEXT:    dup v0.2d, x8
-; CHECK-SD-NEXT:    add v0.2d, v0.2d, v0.2d
-; CHECK-SD-NEXT:    mov v1.16b, v0.16b
+; CHECK-SD-NEXT:    dup v1.2d, x8
+; CHECK-SD-NEXT:    add v0.2d, v0.2d, v1.2d
+; CHECK-SD-NEXT:    add v1.2d, v0.2d, v1.2d
 ; CHECK-SD-NEXT:    ret
 ;
 ; CHECK-GI-LABEL: freeze_v4p0:
diff --git a/llvm/test/CodeGen/AMDGPU/permute_i8.ll 
b/llvm/test/CodeGen/AMDGPU/permute_i8.ll
index 90e655d7bf8b56..0e67c1c517b684 100644
--- a/llvm/test/CodeGen/AMDGPU/permute_i8.ll
+++ b/llvm/test/CodeGen/AMDGPU/permute_i8.ll
@@ -3769,6 +3769,7 @@ define hidden void @any_extend_to_perm_wide_src(ptr 
addrspace(1) %in0, ptr addrs
 ; GFX10-NEXT:    ; kill: killed $vgpr0 killed $vgpr1
 ; GFX10-NEXT:    ; kill: killed $vgpr2 killed $vgpr3
 ; GFX10-NEXT:    s_lshl_b32 s4, s4, 8
+; GFX10-NEXT:    s_lshl_b32 s5, s4, 8
 ; GFX10-NEXT:    s_waitcnt vmcnt(2)
 ; GFX10-NEXT:    v_lshrrev_b64 v[0:1], 24, v[6:7]
 ; GFX10-NEXT:    s_waitcnt vmcnt(1)
@@ -3778,7 +3779,7 @@ define hidden void @any_extend_to_perm_wide_src(ptr 
addrspace(1) %in0, ptr addrs
 ; GFX10-NEXT:    v_or_b32_sdwa v3, v8, s4 dst_sel:WORD_1 dst_unused:UNUSED_PAD 
src0_sel:DWORD src1_sel:DWORD
 ; GFX10-NEXT:    v_perm_b32 v0, v1, v0, 0xc0c0004
 ; GFX10-NEXT:    v_perm_b32 v1, s4, v2, 0xc0c0004
-; GFX10-NEXT:    v_or_b32_sdwa v2, v9, s4 dst_sel:DWORD dst_unused:UNUSED_PAD 
src0_sel:BYTE_0 src1_sel:DWORD
+; GFX10-NEXT:    v_or_b32_sdwa v2, v9, s5 dst_sel:DWORD dst_unused:UNUSED_PAD 
src0_sel:BYTE_0 src1_sel:DWORD
 ; GFX10-NEXT:    v_lshl_or_b32 v0, v0, 16, v1
 ; GFX10-NEXT:    v_or_b32_sdwa v1, v3, v2 dst_sel:DWORD dst_unused:UNUSED_PAD 
src0_sel:DWORD src1_sel:WORD_0
 ; GFX10-NEXT:    global_store_dwordx2 v[4:5], v[0:1], off
@@ -3795,6 +3796,7 @@ define hidden void @any_extend_to_perm_wide_src(ptr 
addrspace(1) %in0, ptr addrs
 ; GFX9-NEXT:    s_mov_b32 s4, 0xc0c0004
 ; GFX9-NEXT:    v_mov_b32_e32 v14, 0xc0c0004
 ; GFX9-NEXT:    s_lshl_b32 s5, s4, 8
+; GFX9-NEXT:    s_lshl_b32 s6, s4, 8
 ; GFX9-NEXT:    s_waitcnt vmcnt(2)
 ; GFX9-NEXT:    v_lshrrev_b64 v[0:1], 8, v[6:7]
 ; GFX9-NEXT:    s_waitcnt vmcnt(1)
@@ -3802,7 +3804,7 @@ define hidden void @any_extend_to_perm_wide_src(ptr 
addrspace(1) %in0, ptr addrs
 ; GFX9-NEXT:    v_lshrrev_b64 v[2:3], 16, v[8:9]
 ; GFX9-NEXT:    s_waitcnt vmcnt(0)
 ; GFX9-NEXT:    v_or_b32_sdwa v3, v12, s5 dst_sel:WORD_1 dst_unused:UNUSED_PAD 
src0_sel:DWORD src1_sel:DWORD
-; GFX9-NEXT:    v_or_b32_sdwa v6, v13, s5 dst_sel:DWORD dst_unused:UNUSED_PAD 
src0_sel:BYTE_0 src1_sel:DWORD
+; GFX9-NEXT:    v_or_b32_sdwa v6, v13, s6 dst_sel:DWORD dst_unused:UNUSED_PAD 
src0_sel:BYTE_0 src1_sel:DWORD
 ; GFX9-NEXT:    v_perm_b32 v1, v2, v1, s4
 ; GFX9-NEXT:    v_perm_b32 v0, s4, v0, v14
 ; GFX9-NEXT:    v_lshl_or_b32 v0, v1, 16, v0
diff --git 
a/llvm/test/CodeGen/AMDGPU/promote-alloca-vector-dynamic-idx-bitcasts-llc.ll 
b/llvm/test/CodeGen/AMDGPU/promote-alloca-vector-dynamic-idx-bitcasts-llc.ll
index 10287c131acdbb..c73d31c368846b 100644
--- a/llvm/test/CodeGen/AMDGPU/promote-alloca-vector-dynamic-idx-bitcasts-llc.ll
+++ b/llvm/test/CodeGen/AMDGPU/promote-alloca-vector-dynamic-idx-bitcasts-llc.ll
@@ -6,140 +6,46 @@
 define amdgpu_kernel void @test_bitcast_llc_v128i8_v16i8(ptr addrspace(1) 
%out, i32 %idx) {
 ; GFX9-LABEL: test_bitcast_llc_v128i8_v16i8:
 ; GFX9:       ; %bb.0: ; %entry
-; GFX9-NEXT:    s_load_dwordx2 s[0:1], s[4:5], 0x0
 ; GFX9-NEXT:    s_load_dword s2, s[4:5], 0x8
-; GFX9-NEXT:    v_mov_b32_e32 v0, 0x6050400
-; GFX9-NEXT:    v_mov_b32_e32 v36, 0
+; GFX9-NEXT:    s_load_dwordx2 s[0:1], s[4:5], 0x0
+; GFX9-NEXT:    v_mov_b32_e32 v4, 0
 ; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
-; GFX9-NEXT:    v_perm_b32 v0, s0, s0, v0
-; GFX9-NEXT:    v_lshlrev_b32_e32 v1, 16, v0
-; GFX9-NEXT:    v_or_b32_sdwa v0, v0, v1 dst_sel:DWORD dst_unused:UNUSED_PAD 
src0_sel:WORD_0 src1_sel:DWORD
 ; GFX9-NEXT:    s_lshl_b32 s2, s2, 2
-; GFX9-NEXT:    v_mov_b32_e32 v1, v0
-; GFX9-NEXT:    v_mov_b32_e32 v2, v0
-; GFX9-NEXT:    v_mov_b32_e32 v3, v0
-; GFX9-NEXT:    v_mov_b32_e32 v4, v0
-; GFX9-NEXT:    v_mov_b32_e32 v5, v0
-; GFX9-NEXT:    v_mov_b32_e32 v6, v0
-; GFX9-NEXT:    v_mov_b32_e32 v7, v0
-; GFX9-NEXT:    v_mov_b32_e32 v8, v0
-; GFX9-NEXT:    v_mov_b32_e32 v9, v0
-; GFX9-NEXT:    v_mov_b32_e32 v10, v0
-; GFX9-NEXT:    v_mov_b32_e32 v11, v0
-; GFX9-NEXT:    v_mov_b32_e32 v12, v0
-; GFX9-NEXT:    v_mov_b32_e32 v13, v0
-; GFX9-NEXT:    v_mov_b32_e32 v14, v0
-; GFX9-NEXT:    v_mov_b32_e32 v15, v0
-; GFX9-NEXT:    v_mov_b32_e32 v16, v0
-; GFX9-NEXT:    v_mov_b32_e32 v17, v0
-; GFX9-NEXT:    v_mov_b32_e32 v18, v0
-; GFX9-NEXT:    v_mov_b32_e32 v19, v0
-; GFX9-NEXT:    v_mov_b32_e32 v20, v0
-; GFX9-NEXT:    v_mov_b32_e32 v21, v0
-; GFX9-NEXT:    v_mov_b32_e32 v22, v0
-; GFX9-NEXT:    v_mov_b32_e32 v23, v0
-; GFX9-NEXT:    v_mov_b32_e32 v24, v0
-; GFX9-NEXT:    v_mov_b32_e32 v25, v0
-; GFX9-NEXT:    v_mov_b32_e32 v26, v0
-; GFX9-NEXT:    v_mov_b32_e32 v27, v0
-; GFX9-NEXT:    v_mov_b32_e32 v28, v0
-; GFX9-NEXT:    v_mov_b32_e32 v29, v0
-; GFX9-NEXT:    v_mov_b32_e32 v30, v0
-; GFX9-NEXT:    v_mov_b32_e32 v31, v0
 ; GFX9-NEXT:    s_set_gpr_idx_on s2, gpr_idx(SRC0)
-; GFX9-NEXT:    v_mov_b32_e32 v35, v3
-; GFX9-NEXT:    v_mov_b32_e32 v34, v2
-; GFX9-NEXT:    v_mov_b32_e32 v33, v1
-; GFX9-NEXT:    v_mov_b32_e32 v32, v0
+; GFX9-NEXT:    v_mov_b32_e32 v3, v3
+; GFX9-NEXT:    v_mov_b32_e32 v2, v2
+; GFX9-NEXT:    v_mov_b32_e32 v1, v1
+; GFX9-NEXT:    v_mov_b32_e32 v0, v0
 ; GFX9-NEXT:    s_set_gpr_idx_off
-; GFX9-NEXT:    global_store_dwordx4 v36, v[32:35], s[0:1]
+; GFX9-NEXT:    global_store_dwordx4 v4, v[0:3], s[0:1]
 ; GFX9-NEXT:    s_endpgm
 ;
 ; GFX11-LABEL: test_bitcast_llc_v128i8_v16i8:
 ; GFX11:       ; %bb.0: ; %entry
-; GFX11-NEXT:    v_perm_b32 v0, s0, s0, 0x6050400
 ; GFX11-NEXT:    s_clause 0x1
-; GFX11-NEXT:    s_load_b64 s[0:1], s[4:5], 0x0
 ; GFX11-NEXT:    s_load_b32 s2, s[4:5], 0x8
-; GFX11-NEXT:    v_mov_b32_e32 v35, 0
-; GFX11-NEXT:    v_and_b32_e32 v1, 0xffff, v0
-; GFX11-NEXT:    v_lshlrev_b32_e32 v0, 16, v0
-; GFX11-NEXT:    s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | 
instid1(VALU_DEP_1)
-; GFX11-NEXT:    v_or_b32_e32 v0, v1, v0
-; GFX11-NEXT:    v_mov_b32_e32 v1, v0
-; GFX11-NEXT:    v_mov_b32_e32 v2, v0
-; GFX11-NEXT:    v_mov_b32_e32 v3, v0
-; GFX11-NEXT:    v_mov_b32_e32 v31, v0
-; GFX11-NEXT:    v_mov_b32_e32 v4, v0
+; GFX11-NEXT:    s_load_b64 s[0:1], s[4:5], 0x0
+; GFX11-NEXT:    v_mov_b32_e32 v4, 0
 ; GFX11-NEXT:    s_waitcnt lgkmcnt(0)
 ; GFX11-NEXT:    s_lshl_b32 m0, s2, 2
-; GFX11-NEXT:    v_mov_b32_e32 v5, v0
-; GFX11-NEXT:    v_mov_b32_e32 v6, v0
-; GFX11-NEXT:    v_mov_b32_e32 v7, v0
-; GFX11-NEXT:    v_mov_b32_e32 v8, v0
-; GFX11-NEXT:    v_mov_b32_e32 v9, v0
-; GFX11-NEXT:    v_mov_b32_e32 v10, v0
-; GFX11-NEXT:    v_mov_b32_e32 v11, v0
-; GFX11-NEXT:    v_mov_b32_e32 v12, v0
-; GFX11-NEXT:    v_mov_b32_e32 v13, v0
-; GFX11-NEXT:    v_mov_b32_e32 v14, v0
-; GFX11-NEXT:    v_mov_b32_e32 v15, v0
-; GFX11-NEXT:    v_mov_b32_e32 v16, v0
-; GFX11-NEXT:    v_mov_b32_e32 v17, v0
-; GFX11-NEXT:    v_mov_b32_e32 v18, v0
-; GFX11-NEXT:    v_mov_b32_e32 v19, v0
-; GFX11-NEXT:    v_mov_b32_e32 v20, v0
-; GFX11-NEXT:    v_mov_b32_e32 v21, v0
-; GFX11-NEXT:    v_mov_b32_e32 v22, v0
-; GFX11-NEXT:    v_mov_b32_e32 v23, v0
-; GFX11-NEXT:    v_mov_b32_e32 v24, v0
-; GFX11-NEXT:    v_mov_b32_e32 v25, v0
-; GFX11-NEXT:    v_mov_b32_e32 v26, v0
-; GFX11-NEXT:    v_mov_b32_e32 v27, v0
-; GFX11-NEXT:    v_mov_b32_e32 v28, v0
-; GFX11-NEXT:    v_mov_b32_e32 v29, v0
-; GFX11-NEXT:    v_mov_b32_e32 v30, v0
-; GFX11-NEXT:    v_movrels_b32_e32 v34, v3
-; GFX11-NEXT:    v_movrels_b32_e32 v33, v2
-; GFX11-NEXT:    v_movrels_b32_e32 v32, v1
-; GFX11-NEXT:    v_movrels_b32_e32 v31, v0
-; GFX11-NEXT:    global_store_b128 v35, v[31:34], s[0:1]
+; GFX11-NEXT:    v_movrels_b32_e32 v3, v3
+; GFX11-NEXT:    v_movrels_b32_e32 v2, v2
+; GFX11-NEXT:    v_movrels_b32_e32 v1, v1
+; GFX11-NEXT:    v_movrels_b32_e32 v0, v0
+; GFX11-NEXT:    global_store_b128 v4, v[0:3], s[0:1]
 ; GFX11-NEXT:    s_endpgm
 ;
 ; GFX12-LABEL: test_bitcast_llc_v128i8_v16i8:
 ; GFX12:       ; %bb.0: ; %entry
-; GFX12-NEXT:    v_perm_b32 v0, s0, s0, 0x6050400
 ; GFX12-NEXT:    s_load_b96 s[0:2], s[4:5], 0x0
-; GFX12-NEXT:    v_mov_b32_e32 v35, 0
-; GFX12-NEXT:    s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | 
instid1(VALU_DEP_1)
-; GFX12-NEXT:    v_and_b32_e32 v1, 0xffff, v0
-; GFX12-NEXT:    v_lshlrev_b32_e32 v0, 16, v0
-; GFX12-NEXT:    v_or_b32_e32 v0, v1, v0
-; GFX12-NEXT:    s_delay_alu instid0(VALU_DEP_1)
-; GFX12-NEXT:    v_dual_mov_b32 v1, v0 :: v_dual_mov_b32 v4, v0
-; GFX12-NEXT:    v_dual_mov_b32 v2, v0 :: v_dual_mov_b32 v3, v0
-; GFX12-NEXT:    v_mov_b32_e32 v6, v0
+; GFX12-NEXT:    v_mov_b32_e32 v4, 0
 ; GFX12-NEXT:    s_wait_kmcnt 0x0
 ; GFX12-NEXT:    s_lshl_b32 m0, s2, 2
-; GFX12-NEXT:    v_mov_b32_e32 v31, v0
-; GFX12-NEXT:    v_dual_mov_b32 v5, v0 :: v_dual_mov_b32 v8, v0
-; GFX12-NEXT:    v_dual_mov_b32 v7, v0 :: v_dual_mov_b32 v10, v0
-; GFX12-NEXT:    v_dual_mov_b32 v9, v0 :: v_dual_mov_b32 v12, v0
-; GFX12-NEXT:    v_dual_mov_b32 v11, v0 :: v_dual_mov_b32 v14, v0
-; GFX12-NEXT:    v_dual_mov_b32 v13, v0 :: v_dual_mov_b32 v16, v0
-; GFX12-NEXT:    v_dual_mov_b32 v15, v0 :: v_dual_mov_b32 v18, v0
-; GFX12-NEXT:    v_dual_mov_b32 v17, v0 :: v_dual_mov_b32 v20, v0
-; GFX12-NEXT:    v_dual_mov_b32 v19, v0 :: v_dual_mov_b32 v22, v0
-; GFX12-NEXT:    v_dual_mov_b32 v21, v0 :: v_dual_mov_b32 v24, v0
-; GFX12-NEXT:    v_dual_mov_b32 v23, v0 :: v_dual_mov_b32 v26, v0
-; GFX12-NEXT:    v_dual_mov_b32 v25, v0 :: v_dual_mov_b32 v28, v0
-; GFX12-NEXT:    v_dual_mov_b32 v27, v0 :: v_dual_mov_b32 v30, v0
-; GFX12-NEXT:    v_mov_b32_e32 v29, v0
-; GFX12-NEXT:    v_movrels_b32_e32 v34, v3
-; GFX12-NEXT:    v_movrels_b32_e32 v33, v2
-; GFX12-NEXT:    v_movrels_b32_e32 v32, v1
-; GFX12-NEXT:    v_movrels_b32_e32 v31, v0
-; GFX12-NEXT:    global_store_b128 v35, v[31:34], s[0:1]
+; GFX12-NEXT:    v_movrels_b32_e32 v3, v3
+; GFX12-NEXT:    v_movrels_b32_e32 v2, v2
+; GFX12-NEXT:    v_movrels_b32_e32 v1, v1
+; GFX12-NEXT:    v_movrels_b32_e32 v0, v0
+; GFX12-NEXT:    global_store_b128 v4, v[0:3], s[0:1]
 ; GFX12-NEXT:    s_endpgm
 entry:
   %alloca = freeze <128 x i8> poison
diff --git a/llvm/test/CodeGen/Hexagon/pr196966.ll 
b/llvm/test/CodeGen/Hexagon/pr196966.ll
index cba853ef529e4a..8612395feb8e40 100644
--- a/llvm/test/CodeGen/Hexagon/pr196966.ll
+++ b/llvm/test/CodeGen/Hexagon/pr196966.ll
@@ -34,46 +34,33 @@ define void @pr196966(ptr %base) {
 ; CHECK-NEXT:     r0 = add(r29,#0)
 ; CHECK-NEXT:    }
 ; CHECK-NEXT:    {
-; CHECK-NEXT:     r0 = p0
-; CHECK-NEXT:     r1 = add(r16,#6)
-; CHECK-NEXT:     r5:4 = memd(r29+#8)
-; CHECK-NEXT:     r3:2 = memd(r29+#24)
-; CHECK-NEXT:    }
-; CHECK-NEXT:    {
-; CHECK-NEXT:     r0 |= asl(r0,#8)
-; CHECK-NEXT:     r5 = add(r16,#20)
+; CHECK-NEXT:     r6 = add(r16,#6)
+; CHECK-NEXT:     r1:0 = memd(r29+#24)
+; CHECK-NEXT:     r5:4 = memd(r29+#0)
 ; CHECK-NEXT:    }
 ; CHECK-NEXT:    {
+; CHECK-NEXT:     r5:4 = extractu(r5:4,#16,#32)
 ; CHECK-NEXT:     p0 = bitsclr(r0,#4)
-; CHECK-NEXT:     if (p0.new) jump:t .LBB0_3
+; CHECK-NEXT:     r3:2 = memd(r29+#8)
 ; CHECK-NEXT:    }
-; CHECK-NEXT:  // %bb.2: // %cond.store3
 ; CHECK-NEXT:    {
-; CHECK-NEXT:     r7:6 = memd(r29+#0)
+; CHECK-NEXT:     p1 = bitsclr(r0,#32)
+; CHECK-NEXT:     p2 = !tstbit(r0,#13)
+; CHECK-NEXT:     r3 = add(r16,#20)
+; CHECK-NEXT:     if (!p0) memh(r0+#0) = r4
 ; CHECK-NEXT:    }
 ; CHECK-NEXT:    {
-; CHECK-NEXT:     r7:6 = extractu(r7:6,#16,#32)
+; CHECK-NEXT:     p0 = !tstbit(r0,#15)
+; CHECK-NEXT:     if (!p1) memh(r3+#0) = r2.h
+; CHECK-NEXT:     if (!p2) memh(r6+#0) = r0.h
 ; CHECK-NEXT:    }
 ; CHECK-NEXT:    {
-; CHECK-NEXT:     memh(r0+#0) = r6
-; CHECK-NEXT:    }
-; CHECK-NEXT:  .LBB0_3: // %else4
-; CHECK-NEXT:    {
-; CHECK-NEXT:     p0 = bitsclr(r0,#32)
-; CHECK-NEXT:     p1 = !tstbit(r0,#13)
 ; CHECK-NEXT:     r17:16 = memd(r30+#-8)
-; CHECK-NEXT:     if (!p0.new) memh(r5+#0) = r4.h
-; CHECK-NEXT:    } // 8-byte Folded Reload
-; CHECK-NEXT:    {
-; CHECK-NEXT:     p2 = !tstbit(r0,#15)
-; CHECK-NEXT:     if (!p1) memh(r1+#0) = r2.h
-; CHECK-NEXT:    }
-; CHECK-NEXT:    {
 ; CHECK-NEXT:     r31:30 = deallocframe(r30):raw
-; CHECK-NEXT:     if (!p2) memh(r0+#0) = r3.h
-; CHECK-NEXT:    }
+; CHECK-NEXT:    } // 8-byte Folded Reload
 ; CHECK-NEXT:    {
 ; CHECK-NEXT:     jumpr r31
+; CHECK-NEXT:     if (!p0) memh(r0+#0) = r1.h
 ; CHECK-NEXT:    }
 entry:
   %mb = icmp ne ptr %base, null
diff --git a/llvm/test/CodeGen/SystemZ/pr60413.ll 
b/llvm/test/CodeGen/SystemZ/pr60413.ll
index 8a6a30318ae583..97cf1050408dd5 100644
--- a/llvm/test/CodeGen/SystemZ/pr60413.ll
+++ b/llvm/test/CodeGen/SystemZ/pr60413.ll
@@ -74,38 +74,6 @@ define dso_local void @m() local_unnamed_addr #1 {
 ; CHECK-NEXT:    rosbg %r2, %r3, 32, 61, 2
 ; CHECK-NEXT:    rosbg %r2, %r5, 32, 62, 1
 ; CHECK-NEXT:    or %r2, %r14
-; CHECK-NEXT:    vlgvb %r4, %v0, 1
-; CHECK-NEXT:    vlgvb %r3, %v0, 0
-; CHECK-NEXT:    risbg %r3, %r3, 48, 176, 15
-; CHECK-NEXT:    rosbg %r3, %r4, 49, 49, 14
-; CHECK-NEXT:    vlgvb %r4, %v0, 2
-; CHECK-NEXT:    rosbg %r3, %r4, 50, 50, 13
-; CHECK-NEXT:    vlgvb %r4, %v0, 3
-; CHECK-NEXT:    rosbg %r3, %r4, 51, 51, 12
-; CHECK-NEXT:    vlgvb %r4, %v0, 4
-; CHECK-NEXT:    rosbg %r3, %r4, 52, 52, 11
-; CHECK-NEXT:    vlgvb %r4, %v0, 5
-; CHECK-NEXT:    rosbg %r3, %r4, 53, 53, 10
-; CHECK-NEXT:    vlgvb %r4, %v0, 6
-; CHECK-NEXT:    rosbg %r3, %r4, 54, 54, 9
-; CHECK-NEXT:    vlgvb %r4, %v0, 7
-; CHECK-NEXT:    rosbg %r3, %r4, 55, 55, 8
-; CHECK-NEXT:    vlgvb %r4, %v0, 8
-; CHECK-NEXT:    rosbg %r3, %r4, 56, 56, 7
-; CHECK-NEXT:    vlgvb %r4, %v0, 9
-; CHECK-NEXT:    rosbg %r3, %r4, 57, 57, 6
-; CHECK-NEXT:    vlgvb %r4, %v0, 10
-; CHECK-NEXT:    rosbg %r3, %r4, 58, 58, 5
-; CHECK-NEXT:    vlgvb %r4, %v0, 11
-; CHECK-NEXT:    rosbg %r3, %r4, 59, 59, 4
-; CHECK-NEXT:    vlgvb %r4, %v0, 12
-; CHECK-NEXT:    rosbg %r3, %r4, 60, 60, 3
-; CHECK-NEXT:    vlgvb %r4, %v0, 13
-; CHECK-NEXT:    rosbg %r3, %r4, 61, 61, 2
-; CHECK-NEXT:    vlgvb %r4, %v0, 14
-; CHECK-NEXT:    rosbg %r3, %r4, 62, 62, 1
-; CHECK-NEXT:    vlgvb %r4, %v0, 15
-; CHECK-NEXT:    rosbg %r3, %r4, 63, 63, 0
 ; CHECK-NEXT:    xilf %r3, 4294967295
 ; CHECK-NEXT:    or %r3, %r2
 ; CHECK-NEXT:    tmll %r3, 65535
diff --git a/llvm/test/CodeGen/X86/freeze-vector.ll 
b/llvm/test/CodeGen/X86/freeze-vector.ll
index b97d75802d050e..2327dac331088d 100644
--- a/llvm/test/CodeGen/X86/freeze-vector.ll
+++ b/llvm/test/CodeGen/X86/freeze-vector.ll
@@ -389,17 +389,20 @@ define void @freeze_two_frozen_buildvectors(ptr %origin0, 
ptr %origin1, ptr %dst
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT:    movl (%esi), %esi
+; X86-NEXT:    andl $15, %esi
 ; X86-NEXT:    movl (%edx), %edx
-; X86-NEXT:    vmovd %eax, %xmm0
-; X86-NEXT:    vpinsrd $1, (%esi), %xmm0, %xmm1
-; X86-NEXT:    vpinsrd $2, %eax, %xmm1, %xmm1
-; X86-NEXT:    vpinsrd $3, %eax, %xmm1, %xmm1
+; X86-NEXT:    andl $15, %edx
+; X86-NEXT:    vmovd %esi, %xmm0
+; X86-NEXT:    vpshufd {{.*#+}} xmm0 = xmm0[0,0,1,1]
+; X86-NEXT:    vpxor %xmm1, %xmm1, %xmm1
+; X86-NEXT:    vpblendw {{.*#+}} xmm0 = xmm1[0,1],xmm0[2,3],xmm1[4,5,6,7]
 ; X86-NEXT:    vbroadcastss {{.*#+}} xmm2 = [7,7,7,7]
-; X86-NEXT:    vpand %xmm2, %xmm1, %xmm1
-; X86-NEXT:    vmovdqa %xmm1, (%ecx)
-; X86-NEXT:    vpinsrd $1, %eax, %xmm0, %xmm0
-; X86-NEXT:    vpinsrd $2, %edx, %xmm0, %xmm0
-; X86-NEXT:    vpinsrd $3, %eax, %xmm0, %xmm0
+; X86-NEXT:    vpand %xmm2, %xmm0, %xmm0
+; X86-NEXT:    vmovdqa %xmm0, (%ecx)
+; X86-NEXT:    vmovd %edx, %xmm0
+; X86-NEXT:    vpshufd {{.*#+}} xmm0 = xmm0[0,1,0,1]
+; X86-NEXT:    vpblendw {{.*#+}} xmm0 = xmm1[0,1,2,3],xmm0[4,5],xmm1[6,7]
 ; X86-NEXT:    vpand %xmm2, %xmm0, %xmm0
 ; X86-NEXT:    vmovdqa %xmm0, (%eax)
 ; X86-NEXT:    popl %esi
@@ -408,16 +411,16 @@ define void @freeze_two_frozen_buildvectors(ptr %origin0, 
ptr %origin1, ptr %dst
 ; X64-LABEL: freeze_two_frozen_buildvectors:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl (%rsi), %eax
-; X64-NEXT:    vmovd %eax, %xmm0
-; X64-NEXT:    vpinsrd $1, (%rdi), %xmm0, %xmm1
-; X64-NEXT:    vpinsrd $2, %eax, %xmm1, %xmm1
-; X64-NEXT:    vpinsrd $3, %eax, %xmm1, %xmm1
+; X64-NEXT:    vmovd {{.*#+}} xmm0 = mem[0],zero,zero,zero
+; X64-NEXT:    vpbroadcastd %xmm0, %xmm0
+; X64-NEXT:    vpxor %xmm1, %xmm1, %xmm1
+; X64-NEXT:    vpblendd {{.*#+}} xmm0 = xmm1[0],xmm0[1],xmm1[2,3]
 ; X64-NEXT:    vpbroadcastd {{.*#+}} xmm2 = [7,7,7,7]
-; X64-NEXT:    vpand %xmm2, %xmm1, %xmm1
-; X64-NEXT:    vmovdqa %xmm1, (%rdx)
-; X64-NEXT:    vpinsrd $1, %eax, %xmm0, %xmm0
-; X64-NEXT:    vpinsrd $2, %eax, %xmm0, %xmm0
-; X64-NEXT:    vpinsrd $3, %eax, %xmm0, %xmm0
+; X64-NEXT:    vpand %xmm2, %xmm0, %xmm0
+; X64-NEXT:    vmovdqa %xmm0, (%rdx)
+; X64-NEXT:    vmovd %eax, %xmm0
+; X64-NEXT:    vpbroadcastd %xmm0, %xmm0
+; X64-NEXT:    vpblendd {{.*#+}} xmm0 = xmm1[0,1],xmm0[2],xmm1[3]
 ; X64-NEXT:    vpand %xmm2, %xmm0, %xmm0
 ; X64-NEXT:    vmovdqa %xmm0, (%rcx)
 ; X64-NEXT:    retq
diff --git a/llvm/test/CodeGen/X86/freeze.ll b/llvm/test/CodeGen/X86/freeze.ll
index de5ca17bdb2622..5ea78f884e9803 100644
--- a/llvm/test/CodeGen/X86/freeze.ll
+++ b/llvm/test/CodeGen/X86/freeze.ll
@@ -89,7 +89,6 @@ define ptr @freeze_ptr() {
 define i32 @freeze_struct() {
 ; X86ASM-LABEL: freeze_struct:
 ; X86ASM:       # %bb.0:
-; X86ASM-NEXT:    # implicit-def: $eax
 ; X86ASM-NEXT:    addl %eax, %eax
 ; X86ASM-NEXT:    retq
   %y1 = freeze %struct.T undef
@@ -102,7 +101,6 @@ define i32 @freeze_struct() {
 define i32 @freeze_anonstruct() {
 ; X86ASM-LABEL: freeze_anonstruct:
 ; X86ASM:       # %bb.0:
-; X86ASM-NEXT:    # implicit-def: $eax
 ; X86ASM-NEXT:    addl %eax, %eax
 ; X86ASM-NEXT:    retq
   %y1 = freeze {i32, i32} undef
@@ -129,7 +127,6 @@ define i32 @freeze_anonstruct2() {
 define i64 @freeze_array() {
 ; X86ASM-LABEL: freeze_array:
 ; X86ASM:       # %bb.0:
-; X86ASM-NEXT:    # implicit-def: $rax
 ; X86ASM-NEXT:    addq %rax, %rax
 ; X86ASM-NEXT:    retq
   %y1 = freeze [2 x i64] undef
diff --git a/llvm/unittests/CodeGen/SelectionDAGCSETest.cpp 
b/llvm/unittests/CodeGen/SelectionDAGCSETest.cpp
index ea073bc6b8c55e..3859a02cd1d62f 100644
--- a/llvm/unittests/CodeGen/SelectionDAGCSETest.cpp
+++ b/llvm/unittests/CodeGen/SelectionDAGCSETest.cpp
@@ -87,6 +87,26 @@ TEST_F(SelectionDAGCSETest, FPEnvMem) {
             DAG->getSetFPEnv(getChain(), Loc, Ptr, MVT::i32, MMO).getNode());
 }
 
+TEST_F(SelectionDAGCSETest, FreezeUndef) {
+  SDValue Undef = DAG->getUNDEF(MVT::i32);
+  EXPECT_NE(DAG->getFreeze(Undef).getNode(), DAG->getFreeze(Undef).getNode());
+
+  auto Load = [&] {
+    return DAG->getLoad(MVT::i32, Loc, getChain(),
+                        DAG->CreateStackTemporary(MVT::i32),
+                        MachinePointerInfo());
+  };
+  SDValue X = Load(), Y = Load();
+  SDNode *FX = DAG->getFreeze(X).getNode();
+  SDNode *FY = DAG->getFreeze(Y).getNode();
+  EXPECT_EQ(FX, DAG->getFreeze(X).getNode());
+
+  // A freeze whose operand becomes undef must leave the CSE map.
+  EXPECT_EQ(DAG->UpdateNodeOperands(FX, Undef), FX);
+  EXPECT_EQ(DAG->UpdateNodeOperands(FY, Undef), FY);
+  EXPECT_NE(DAG->getFreeze(X).getNode(), FX);
+}
+
 TEST_F(SelectionDAGCSETest, LifetimeNode) {
   SDValue FIPtr = DAG->CreateStackTemporary(MVT::i32);
   int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();

_______________________________________________
llvm-branch-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits

Reply via email to