Skip to content

[SlotIndexes] Further pack indices to improve spill placement time - #182640

Merged
boomanaiden154 merged 2 commits into
llvm:mainfrom
boomanaiden154:regalloc-slotindex-2-20-26
Feb 27, 2026
Merged

[SlotIndexes] Further pack indices to improve spill placement time#182640
boomanaiden154 merged 2 commits into
llvm:mainfrom
boomanaiden154:regalloc-slotindex-2-20-26

Conversation

@boomanaiden154

@boomanaiden154 boomanaiden154 commented Feb 21, 2026

Copy link
Copy Markdown
Contributor

This patch makes it so that renumbering indices when inserting instructions into the SlotIndexes analysis renumbers the entire list if the list is otherwise densely packed. This fixes a case we saw on AArch64 with a lot of spills where every single spill instruction insertion required a renumbering of most of the instructions in a large function, making the operation approximately quadratic.

This is not NFC as heuristics depend on the SlotIndex numbers, although this should mostly be a wash as LRs should be extended ~equally.

@boomanaiden154
[SlotIndexes] Further pack indices to improve spill placement time
a68fe52 
This patch makes it so that renumbering indices when inserting
instructions into the SlotIndexes analysis renumbers the entire list if
the list is otherwise densely packed. This fixes a case we saw on
AArch64 with a lot of spills where every single spill instruction
insertion required a renumbering of most of the instructions in a large
function, making the operation approximately quadratic.

This is not NFC as heuristics depend on the SlotIndex numbers, although
this should mostly be a wash as LRs should be extended ~equally.
@llvmbot

llvmbot commented Feb 21, 2026 •
edited
Loading

Copy link
Copy Markdown
Member

@llvm/pr-subscribers-backend-aarch64
@llvm/pr-subscribers-backend-amdgpu

@llvm/pr-subscribers-backend-x86

Author: Aiden Grossman (boomanaiden154)

Changes

This patch makes it so that renumbering indices when inserting instructions into the SlotIndexes analysis renumbers the entire list if the list is otherwise densely packed. This fixes a case we saw on AArch64 with a lot of spills where every single spill instruction insertion required a renumbering of most of the instructions in a large function, making the operation approximately quadratic.

This is not NFC as heuristics depend on the SlotIndex numbers, although this should mostly be a wash as LRs should be extended ~equally.

Patch is 20.54 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/182640.diff

5 Files Affected:

  • (modified) llvm/lib/CodeGen/SlotIndexes.cpp (+7)
  • (modified) llvm/test/CodeGen/AMDGPU/remat-sop.mir (+6-6)
  • (modified) llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll (+111-111)
  • (modified) llvm/test/CodeGen/X86/statepoint-live-in.ll (+2-2)
  • (modified) llvm/test/CodeGen/X86/statepoint-regs.ll (+2-2)
diff --git a/llvm/lib/CodeGen/SlotIndexes.cpp b/llvm/lib/CodeGen/SlotIndexes.cpp
index 62e7f86a846ac..88bb1d3cd1113 100644
--- a/llvm/lib/CodeGen/SlotIndexes.cpp
+++ b/llvm/lib/CodeGen/SlotIndexes.cpp
@@ -182,6 +182,13 @@ void SlotIndexes::renumberIndexes(IndexList::iterator curItr) {
 
   LLVM_DEBUG(dbgs() << "\n*** Renumbered SlotIndexes " << startItr->getIndex()
                     << '-' << index << " ***\n");
+
+  // If we repack all the way to the end, add spacing in between the
+  // instructions so that future renumberings are able to catch up
+  // without also renumbering all the way to the end.
+  if (index == getLastIndex().getIndex())
+    packIndexes();
+
   ++NumLocalRenum;
 }
 
diff --git a/llvm/test/CodeGen/AMDGPU/remat-sop.mir b/llvm/test/CodeGen/AMDGPU/remat-sop.mir
index cb652db425421..a1754e4cf3917 100644
--- a/llvm/test/CodeGen/AMDGPU/remat-sop.mir
+++ b/llvm/test/CodeGen/AMDGPU/remat-sop.mir
@@ -615,9 +615,9 @@ body:             |
     ; GCN-NEXT: renamable $sgpr1 = COPY killed renamable $sgpr3
     ; GCN-NEXT: SI_SPILL_S32_SAVE killed renamable $sgpr1, %stack.2, implicit $exec, implicit $sp_reg :: (store (s32) into %stack.2, addrspace 5)
     ; GCN-NEXT: renamable $sgpr0_sgpr1 = S_GETPC_B64_pseudo
-    ; GCN-NEXT: SI_SPILL_S32_SAVE killed renamable $sgpr0, %stack.5, implicit $exec, implicit $sp_reg :: (store (s32) into %stack.5, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr0 = COPY killed renamable $sgpr1
     ; GCN-NEXT: SI_SPILL_S32_SAVE killed renamable $sgpr0, %stack.4, implicit $exec, implicit $sp_reg :: (store (s32) into %stack.4, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr0 = COPY killed renamable $sgpr1
+    ; GCN-NEXT: SI_SPILL_S32_SAVE killed renamable $sgpr0, %stack.5, implicit $exec, implicit $sp_reg :: (store (s32) into %stack.5, addrspace 5)
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.1, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.1, addrspace 5)
     ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.3, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.3, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADD_U32 killed renamable $sgpr1, killed renamable $sgpr0, implicit-def $scc
@@ -625,16 +625,16 @@ body:             |
     ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.2, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.2, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADDC_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc, implicit $scc
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.3, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.3, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.5, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.5, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.4, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.4, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADD_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.0, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.0, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.4, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.4, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.5, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.5, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADDC_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc, implicit $scc
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.1, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.1, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.5, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.5, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.4, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.4, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADD_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.2, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.2, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.4, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.4, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.5, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.5, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADDC_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc, implicit $scc
     ; GCN-NEXT: S_ENDPGM 0
     %0:sreg_64 = S_GETPC_B64_pseudo
diff --git a/llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll b/llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll
index 33356e922fbae..869f60c93c826 100644
--- a/llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll
+++ b/llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll
@@ -159,138 +159,138 @@ define zeroext i32 @test1(i64 %0, ptr %1) {
 ; CHECK-NEXT:    std 4, 488(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 488
 ; CHECK-NEXT:    ori 4, 4, 18432
-; CHECK-NEXT:    std 4, 480(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 248(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 537
+; CHECK-NEXT:    ld 22, 248(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 7168
-; CHECK-NEXT:    std 4, 472(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 240(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 36
+; CHECK-NEXT:    ld 21, 240(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 40704
-; CHECK-NEXT:    std 4, 464(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 232(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 85
+; CHECK-NEXT:    ld 20, 232(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 29440
-; CHECK-NEXT:    std 4, 456(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 480(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 134
 ; CHECK-NEXT:    ori 4, 4, 18176
 ; CHECK-NEXT:    std 4, 448(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 183
 ; CHECK-NEXT:    ori 4, 4, 6912
-; CHECK-NEXT:    std 4, 440(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 432(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 231
 ; CHECK-NEXT:    ori 4, 4, 61184
-; CHECK-NEXT:    std 4, 432(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 416(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 280
 ; CHECK-NEXT:    ori 4, 4, 49920
-; CHECK-NEXT:    std 4, 424(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 400(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 329
 ; CHECK-NEXT:    ori 4, 4, 38656
-; CHECK-NEXT:    std 4, 416(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 216(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 378
 ; CHECK-NEXT:    ori 4, 4, 27392
-; CHECK-NEXT:    std 4, 408(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 200(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 427
 ; CHECK-NEXT:    ori 4, 4, 16128
-; CHECK-NEXT:    std 4, 400(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 184(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 476
+; CHECK-NEXT:    ld 30, 184(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 4864
-; CHECK-NEXT:    std 4, 248(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 168(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 524
+; CHECK-NEXT:    ld 29, 168(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 59136
-; CHECK-NEXT:    std 4, 240(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 152(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 573
+; CHECK-NEXT:    ld 28, 152(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 47872
-; CHECK-NEXT:    std 4, 232(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 136(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 24
+; CHECK-NEXT:    ld 27, 136(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 27136
-; CHECK-NEXT:    std 4, 224(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 120(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 73
+; CHECK-NEXT:    ld 26, 120(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 15872
-; CHECK-NEXT:    std 4, 216(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 104(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 122
+; CHECK-NEXT:    ld 25, 104(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 4608
-; CHECK-NEXT:    std 4, 208(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 88(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 170
+; CHECK-NEXT:    ld 24, 88(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 58880
-; CHECK-NEXT:    std 4, 200(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 80(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 219
+; CHECK-NEXT:    ld 2, 80(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 47616
-; CHECK-NEXT:    std 4, 192(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 72(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 36352
 ; CHECK-NEXT:    lis 5, 317
-; CHECK-NEXT:    ld 30, 192(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 184(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 64(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 25088
 ; CHECK-NEXT:    lis 5, 366
-; CHECK-NEXT:    ld 29, 184(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 176(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 23, 64(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 56(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 13824
 ; CHECK-NEXT:    lis 5, 415
-; CHECK-NEXT:    ld 28, 176(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 168(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 48(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 2560
 ; CHECK-NEXT:    lis 5, 463
-; CHECK-NEXT:    ld 27, 168(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 160(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 40(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 56832
 ; CHECK-NEXT:    lis 5, 512
-; CHECK-NEXT:    ld 26, 160(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 152(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 472(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 45568
 ; CHECK-NEXT:    lis 5, 561
-; CHECK-NEXT:    ld 25, 152(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 144(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 464(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 34304
 ; CHECK-NEXT:    lis 5, 12
-; CHECK-NEXT:    ld 24, 144(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 136(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 456(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 13568
 ; CHECK-NEXT:    lis 5, 61
-; CHECK-NEXT:    ld 23, 136(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 128(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 440(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 2304
 ; CHECK-NEXT:    lis 5, 109
-; CHECK-NEXT:    std 4, 120(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 424(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 56576
 ; CHECK-NEXT:    lis 5, 158
-; CHECK-NEXT:    ld 0, 120(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 112(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 408(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 45312
 ; CHECK-NEXT:    lis 5, 207
-; CHECK-NEXT:    ld 22, 112(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 104(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 224(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 34048
 ; CHECK-NEXT:    lis 5, 256
-; CHECK-NEXT:    ld 21, 104(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 96(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 208(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 22784
-; CHECK-NEXT:    ld 5, 248(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 20, 96(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 88(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 5, 72(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 192(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 6, 11520
-; CHECK-NEXT:    ld 6, 240(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 19, 88(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 80(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 6, 48(1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld 19, 192(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 176(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 7, 256
-; CHECK-NEXT:    ld 7, 232(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 18, 80(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 72(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 7, 40(1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld 18, 176(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 160(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 8, 54528
 ; CHECK-NEXT:    ld 8, 224(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 17, 72(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 64(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 17, 160(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 144(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 9, 43264
 ; CHECK-NEXT:    ld 9, 216(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 16, 64(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 56(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 16, 144(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 128(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 10, 32000
 ; CHECK-NEXT:    ld 10, 208(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 15, 56(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 48(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 15, 128(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 112(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 11, 20736
 ; CHECK-NEXT:    ld 11, 200(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 14, 48(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 40(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 14, 112(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 96(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    li 4, 0
-; CHECK-NEXT:    ld 31, 40(1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld 31, 96(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    .p2align 4
 ; CHECK-NEXT:  .LBB0_1: # =>This Loop Header: Depth=1
 ; CHECK-NEXT:    # Child Loop BB0_2 Depth 2
@@ -298,19 +298,17 @@ define zeroext i32 @test1(i64 %0, ptr %1) {
 ; CHECK-NEXT:    li 4, 83
 ; CHECK-NEXT:    mtctr 4
 ; CHECK-NEXT:    ld 12, 256(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 4, 128(1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld 4, 56(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    .p2align 5
 ; CHECK-NEXT:  .LBB0_2: # Parent Loop BB0_1 Depth=1
 ; CHECK-NEXT:    # => This Inner Loop Header: Depth=2
-; CHECK-NEXT:    ld 2, 560(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdux 3, 12, 2
-; CHECK-NEXT:    ld 2, 552(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 5
-; CHECK-NEXT:    stdx 3, 12, 6
-; CHECK-NEXT:    stdx 3, 12, 7
-; CHECK-NEXT:    stdx 3, 12, 8
+; CHECK-NEXT:    ld 0, 560(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdux 3, 12, 0
+; CHECK-NEXT:    ld 0, 552(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 22
+; CHECK-NEXT:    stdx 3, 12, 21
+; CHECK-NEXT:    stdx 3, 12, 20
 ; CHECK-NEXT:    stdx 3, 12, 9
-; CHECK-NEXT:    stdx 3, 12, 10
 ; CHECK-NEXT:    stdx 3, 12, 11
 ; CHECK-NEXT:    stdx 3, 12, 30
 ; CHECK-NEXT:    stdx 3, 12, 29
@@ -319,12 +317,14 @@ define zeroext i32 @test1(i64 %0, ptr %1) {
 ; CHECK-NEXT:    stdx 3, 12, 26
 ; CHECK-NEXT:    stdx 3, 12, 25
 ; CHECK-NEXT:    stdx 3, 12, 24
+; CHECK-NEXT:    stdx 3, 12, 2
+; CHECK-NEXT:    stdx 3, 12, 5
 ; CHECK-NEXT:    stdx 3, 12, 23
 ; CHECK-NEXT:    stdx 3, 12, 4
-; CHECK-NEXT:    stdx 3, 12, 0
-; CHECK-NEXT:    stdx 3, 12, 22
-; CHECK-NEXT:    stdx 3, 12, 21
-; CHECK-NEXT:    stdx 3, 12, 20
+; CHECK-NEXT:    stdx 3, 12, 6
+; CHECK-NEXT:    stdx 3, 12, 7
+; CHECK-NEXT:    stdx 3, 12, 8
+; CHECK-NEXT:    stdx 3, 12, 10
 ; CHECK-NEXT:    stdx 3, 12, 19
 ; CHECK-NEXT:    stdx 3, 12, 18
 ; CHECK-NEXT:    stdx 3, 12, 17
@@ -332,45 +332,45 @@ define zeroext i32 @test1(i64 %0, ptr %1) {
 ; CHECK-NEXT:    stdx 3, 12, 15
 ; CHECK-NEXT:    stdx 3, 12, 14
 ; CHECK-NEXT:    stdx 3, 12, 31
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 544(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 536(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 528(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 520(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 512(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 504(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 496(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 488(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 480(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 472(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 464(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 456(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 448(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 440(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 432(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 424(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 416(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 408(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 400(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 544(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 536(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 528(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 520(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 512(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 504(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 496(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 488(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 480(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 448(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 432(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 416(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 400(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 472(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 464(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 456(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 440(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 424(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 408(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
 ; CHECK-NEXT:    bdnz .LBB0_2
 ; CHECK-NEXT:  # %bb.3:
 ; CHECK-NEXT:    ld 12, 384(1) # 8-byte Folded Reload
diff --git a/llvm/test/CodeGen/X86/statepoint-live-in.ll b/llvm/test/CodeGen/X86/statepoint-live-in.ll
index 787a33aa49b20..9cf647f8100cd 100644
--- a/llvm/test/CodeGen/X86/statepoint-live-in.ll
+++ b/llvm/test/CodeGen/X86/statepoint-live-in.ll
@@ -372,8 +372,8 @@ define void @test10(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32
 ; CHECK-NEXT:    .cfi_offset %r14, -32
 ; CHECK-NEXT:    .cfi_offset %r15, -24
 ; CHECK-NEXT:    .cfi_offset %rbp, -16
-; CHECK-NEXT:    movl %r9d, %ebp
-; CHECK-NEXT:    movl %r8d, %ebx
+; CHECK-NEXT:    movl %r9d, %ebx
+; CHECK-NEXT:    movl %r8d, %ebp
 ; CHECK-NEXT:    movl %ecx, %r14d
 ; CHECK-NEXT:    movl %edx, %r15d
 ; CHECK-NEXT:    movl %esi, %r12d
diff --git a/llvm/test/CodeGen/X86/statepoint-regs.ll b/llvm/test/CodeGen/X86/statepoint-regs.ll
index 5c26e29dce45e..cbbdae1616fe8 10064...
[truncated]

@llvmbot

llvmbot commented Feb 21, 2026

Copy link
Copy Markdown
Member

@llvm/pr-subscribers-backend-powerpc

Author: Aiden Grossman (boomanaiden154)

Changes

This patch makes it so that renumbering indices when inserting instructions into the SlotIndexes analysis renumbers the entire list if the list is otherwise densely packed. This fixes a case we saw on AArch64 with a lot of spills where every single spill instruction insertion required a renumbering of most of the instructions in a large function, making the operation approximately quadratic.

This is not NFC as heuristics depend on the SlotIndex numbers, although this should mostly be a wash as LRs should be extended ~equally.

Patch is 20.54 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/182640.diff

5 Files Affected:

  • (modified) llvm/lib/CodeGen/SlotIndexes.cpp (+7)
  • (modified) llvm/test/CodeGen/AMDGPU/remat-sop.mir (+6-6)
  • (modified) llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll (+111-111)
  • (modified) llvm/test/CodeGen/X86/statepoint-live-in.ll (+2-2)
  • (modified) llvm/test/CodeGen/X86/statepoint-regs.ll (+2-2)
diff --git a/llvm/lib/CodeGen/SlotIndexes.cpp b/llvm/lib/CodeGen/SlotIndexes.cpp
index 62e7f86a846ac..88bb1d3cd1113 100644
--- a/llvm/lib/CodeGen/SlotIndexes.cpp
+++ b/llvm/lib/CodeGen/SlotIndexes.cpp
@@ -182,6 +182,13 @@ void SlotIndexes::renumberIndexes(IndexList::iterator curItr) {
 
   LLVM_DEBUG(dbgs() << "\n*** Renumbered SlotIndexes " << startItr->getIndex()
                     << '-' << index << " ***\n");
+
+  // If we repack all the way to the end, add spacing in between the
+  // instructions so that future renumberings are able to catch up
+  // without also renumbering all the way to the end.
+  if (index == getLastIndex().getIndex())
+    packIndexes();
+
   ++NumLocalRenum;
 }
 
diff --git a/llvm/test/CodeGen/AMDGPU/remat-sop.mir b/llvm/test/CodeGen/AMDGPU/remat-sop.mir
index cb652db425421..a1754e4cf3917 100644
--- a/llvm/test/CodeGen/AMDGPU/remat-sop.mir
+++ b/llvm/test/CodeGen/AMDGPU/remat-sop.mir
@@ -615,9 +615,9 @@ body:             |
     ; GCN-NEXT: renamable $sgpr1 = COPY killed renamable $sgpr3
     ; GCN-NEXT: SI_SPILL_S32_SAVE killed renamable $sgpr1, %stack.2, implicit $exec, implicit $sp_reg :: (store (s32) into %stack.2, addrspace 5)
     ; GCN-NEXT: renamable $sgpr0_sgpr1 = S_GETPC_B64_pseudo
-    ; GCN-NEXT: SI_SPILL_S32_SAVE killed renamable $sgpr0, %stack.5, implicit $exec, implicit $sp_reg :: (store (s32) into %stack.5, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr0 = COPY killed renamable $sgpr1
     ; GCN-NEXT: SI_SPILL_S32_SAVE killed renamable $sgpr0, %stack.4, implicit $exec, implicit $sp_reg :: (store (s32) into %stack.4, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr0 = COPY killed renamable $sgpr1
+    ; GCN-NEXT: SI_SPILL_S32_SAVE killed renamable $sgpr0, %stack.5, implicit $exec, implicit $sp_reg :: (store (s32) into %stack.5, addrspace 5)
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.1, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.1, addrspace 5)
     ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.3, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.3, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADD_U32 killed renamable $sgpr1, killed renamable $sgpr0, implicit-def $scc
@@ -625,16 +625,16 @@ body:             |
     ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.2, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.2, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADDC_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc, implicit $scc
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.3, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.3, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.5, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.5, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.4, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.4, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADD_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.0, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.0, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.4, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.4, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.5, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.5, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADDC_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc, implicit $scc
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.1, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.1, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.5, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.5, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.4, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.4, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADD_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc
     ; GCN-NEXT: renamable $sgpr0 = SI_SPILL_S32_RESTORE %stack.2, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.2, addrspace 5)
-    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.4, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.4, addrspace 5)
+    ; GCN-NEXT: renamable $sgpr1 = SI_SPILL_S32_RESTORE %stack.5, implicit $exec, implicit $sp_reg :: (load (s32) from %stack.5, addrspace 5)
     ; GCN-NEXT: dead renamable $sgpr0 = S_ADDC_U32 killed renamable $sgpr0, killed renamable $sgpr1, implicit-def $scc, implicit $scc
     ; GCN-NEXT: S_ENDPGM 0
     %0:sreg_64 = S_GETPC_B64_pseudo
diff --git a/llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll b/llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll
index 33356e922fbae..869f60c93c826 100644
--- a/llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll
+++ b/llvm/test/CodeGen/PowerPC/rematerializable-instruction-machine-licm.ll
@@ -159,138 +159,138 @@ define zeroext i32 @test1(i64 %0, ptr %1) {
 ; CHECK-NEXT:    std 4, 488(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 488
 ; CHECK-NEXT:    ori 4, 4, 18432
-; CHECK-NEXT:    std 4, 480(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 248(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 537
+; CHECK-NEXT:    ld 22, 248(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 7168
-; CHECK-NEXT:    std 4, 472(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 240(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 36
+; CHECK-NEXT:    ld 21, 240(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 40704
-; CHECK-NEXT:    std 4, 464(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 232(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 85
+; CHECK-NEXT:    ld 20, 232(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 29440
-; CHECK-NEXT:    std 4, 456(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 480(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 134
 ; CHECK-NEXT:    ori 4, 4, 18176
 ; CHECK-NEXT:    std 4, 448(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 183
 ; CHECK-NEXT:    ori 4, 4, 6912
-; CHECK-NEXT:    std 4, 440(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 432(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 231
 ; CHECK-NEXT:    ori 4, 4, 61184
-; CHECK-NEXT:    std 4, 432(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 416(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 280
 ; CHECK-NEXT:    ori 4, 4, 49920
-; CHECK-NEXT:    std 4, 424(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 400(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 329
 ; CHECK-NEXT:    ori 4, 4, 38656
-; CHECK-NEXT:    std 4, 416(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 216(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 378
 ; CHECK-NEXT:    ori 4, 4, 27392
-; CHECK-NEXT:    std 4, 408(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 200(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 427
 ; CHECK-NEXT:    ori 4, 4, 16128
-; CHECK-NEXT:    std 4, 400(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 184(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 476
+; CHECK-NEXT:    ld 30, 184(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 4864
-; CHECK-NEXT:    std 4, 248(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 168(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 524
+; CHECK-NEXT:    ld 29, 168(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 59136
-; CHECK-NEXT:    std 4, 240(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 152(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 573
+; CHECK-NEXT:    ld 28, 152(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 47872
-; CHECK-NEXT:    std 4, 232(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 136(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 24
+; CHECK-NEXT:    ld 27, 136(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 27136
-; CHECK-NEXT:    std 4, 224(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 120(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 73
+; CHECK-NEXT:    ld 26, 120(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 15872
-; CHECK-NEXT:    std 4, 216(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 104(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 122
+; CHECK-NEXT:    ld 25, 104(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 4608
-; CHECK-NEXT:    std 4, 208(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 88(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 170
+; CHECK-NEXT:    ld 24, 88(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 58880
-; CHECK-NEXT:    std 4, 200(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 80(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    lis 4, 219
+; CHECK-NEXT:    ld 2, 80(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    ori 4, 4, 47616
-; CHECK-NEXT:    std 4, 192(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 72(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 36352
 ; CHECK-NEXT:    lis 5, 317
-; CHECK-NEXT:    ld 30, 192(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 184(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 64(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 25088
 ; CHECK-NEXT:    lis 5, 366
-; CHECK-NEXT:    ld 29, 184(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 176(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 23, 64(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 56(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 13824
 ; CHECK-NEXT:    lis 5, 415
-; CHECK-NEXT:    ld 28, 176(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 168(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 48(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 2560
 ; CHECK-NEXT:    lis 5, 463
-; CHECK-NEXT:    ld 27, 168(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 160(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 40(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 56832
 ; CHECK-NEXT:    lis 5, 512
-; CHECK-NEXT:    ld 26, 160(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 152(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 472(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 45568
 ; CHECK-NEXT:    lis 5, 561
-; CHECK-NEXT:    ld 25, 152(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 144(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 464(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 34304
 ; CHECK-NEXT:    lis 5, 12
-; CHECK-NEXT:    ld 24, 144(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 136(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 456(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 13568
 ; CHECK-NEXT:    lis 5, 61
-; CHECK-NEXT:    ld 23, 136(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 128(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 440(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 2304
 ; CHECK-NEXT:    lis 5, 109
-; CHECK-NEXT:    std 4, 120(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 424(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 56576
 ; CHECK-NEXT:    lis 5, 158
-; CHECK-NEXT:    ld 0, 120(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 112(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 408(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 45312
 ; CHECK-NEXT:    lis 5, 207
-; CHECK-NEXT:    ld 22, 112(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 104(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 224(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 34048
 ; CHECK-NEXT:    lis 5, 256
-; CHECK-NEXT:    ld 21, 104(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 96(1) # 8-byte Folded Spill
+; CHECK-NEXT:    std 4, 208(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 5, 22784
-; CHECK-NEXT:    ld 5, 248(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 20, 96(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 88(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 5, 72(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 192(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 6, 11520
-; CHECK-NEXT:    ld 6, 240(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 19, 88(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 80(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 6, 48(1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld 19, 192(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 176(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 7, 256
-; CHECK-NEXT:    ld 7, 232(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 18, 80(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 72(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 7, 40(1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld 18, 176(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 160(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 8, 54528
 ; CHECK-NEXT:    ld 8, 224(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 17, 72(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 64(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 17, 160(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 144(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 9, 43264
 ; CHECK-NEXT:    ld 9, 216(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 16, 64(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 56(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 16, 144(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 128(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 10, 32000
 ; CHECK-NEXT:    ld 10, 208(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 15, 56(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 48(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 15, 128(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 112(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    ori 4, 11, 20736
 ; CHECK-NEXT:    ld 11, 200(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 14, 48(1) # 8-byte Folded Reload
-; CHECK-NEXT:    std 4, 40(1) # 8-byte Folded Spill
+; CHECK-NEXT:    ld 14, 112(1) # 8-byte Folded Reload
+; CHECK-NEXT:    std 4, 96(1) # 8-byte Folded Spill
 ; CHECK-NEXT:    li 4, 0
-; CHECK-NEXT:    ld 31, 40(1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld 31, 96(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    .p2align 4
 ; CHECK-NEXT:  .LBB0_1: # =>This Loop Header: Depth=1
 ; CHECK-NEXT:    # Child Loop BB0_2 Depth 2
@@ -298,19 +298,17 @@ define zeroext i32 @test1(i64 %0, ptr %1) {
 ; CHECK-NEXT:    li 4, 83
 ; CHECK-NEXT:    mtctr 4
 ; CHECK-NEXT:    ld 12, 256(1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld 4, 128(1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld 4, 56(1) # 8-byte Folded Reload
 ; CHECK-NEXT:    .p2align 5
 ; CHECK-NEXT:  .LBB0_2: # Parent Loop BB0_1 Depth=1
 ; CHECK-NEXT:    # => This Inner Loop Header: Depth=2
-; CHECK-NEXT:    ld 2, 560(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdux 3, 12, 2
-; CHECK-NEXT:    ld 2, 552(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 5
-; CHECK-NEXT:    stdx 3, 12, 6
-; CHECK-NEXT:    stdx 3, 12, 7
-; CHECK-NEXT:    stdx 3, 12, 8
+; CHECK-NEXT:    ld 0, 560(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdux 3, 12, 0
+; CHECK-NEXT:    ld 0, 552(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 22
+; CHECK-NEXT:    stdx 3, 12, 21
+; CHECK-NEXT:    stdx 3, 12, 20
 ; CHECK-NEXT:    stdx 3, 12, 9
-; CHECK-NEXT:    stdx 3, 12, 10
 ; CHECK-NEXT:    stdx 3, 12, 11
 ; CHECK-NEXT:    stdx 3, 12, 30
 ; CHECK-NEXT:    stdx 3, 12, 29
@@ -319,12 +317,14 @@ define zeroext i32 @test1(i64 %0, ptr %1) {
 ; CHECK-NEXT:    stdx 3, 12, 26
 ; CHECK-NEXT:    stdx 3, 12, 25
 ; CHECK-NEXT:    stdx 3, 12, 24
+; CHECK-NEXT:    stdx 3, 12, 2
+; CHECK-NEXT:    stdx 3, 12, 5
 ; CHECK-NEXT:    stdx 3, 12, 23
 ; CHECK-NEXT:    stdx 3, 12, 4
-; CHECK-NEXT:    stdx 3, 12, 0
-; CHECK-NEXT:    stdx 3, 12, 22
-; CHECK-NEXT:    stdx 3, 12, 21
-; CHECK-NEXT:    stdx 3, 12, 20
+; CHECK-NEXT:    stdx 3, 12, 6
+; CHECK-NEXT:    stdx 3, 12, 7
+; CHECK-NEXT:    stdx 3, 12, 8
+; CHECK-NEXT:    stdx 3, 12, 10
 ; CHECK-NEXT:    stdx 3, 12, 19
 ; CHECK-NEXT:    stdx 3, 12, 18
 ; CHECK-NEXT:    stdx 3, 12, 17
@@ -332,45 +332,45 @@ define zeroext i32 @test1(i64 %0, ptr %1) {
 ; CHECK-NEXT:    stdx 3, 12, 15
 ; CHECK-NEXT:    stdx 3, 12, 14
 ; CHECK-NEXT:    stdx 3, 12, 31
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 544(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 536(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 528(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 520(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 512(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 504(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 496(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 488(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 480(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 472(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 464(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 456(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 448(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 440(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 432(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 424(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 416(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 408(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
-; CHECK-NEXT:    ld 2, 400(1) # 8-byte Folded Reload
-; CHECK-NEXT:    stdx 3, 12, 2
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 544(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 536(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 528(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 520(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 512(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 504(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 496(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 488(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 480(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 448(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 432(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 416(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 400(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 472(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 464(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 456(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 440(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 424(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
+; CHECK-NEXT:    ld 0, 408(1) # 8-byte Folded Reload
+; CHECK-NEXT:    stdx 3, 12, 0
 ; CHECK-NEXT:    bdnz .LBB0_2
 ; CHECK-NEXT:  # %bb.3:
 ; CHECK-NEXT:    ld 12, 384(1) # 8-byte Folded Reload
diff --git a/llvm/test/CodeGen/X86/statepoint-live-in.ll b/llvm/test/CodeGen/X86/statepoint-live-in.ll
index 787a33aa49b20..9cf647f8100cd 100644
--- a/llvm/test/CodeGen/X86/statepoint-live-in.ll
+++ b/llvm/test/CodeGen/X86/statepoint-live-in.ll
@@ -372,8 +372,8 @@ define void @test10(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32
 ; CHECK-NEXT:    .cfi_offset %r14, -32
 ; CHECK-NEXT:    .cfi_offset %r15, -24
 ; CHECK-NEXT:    .cfi_offset %rbp, -16
-; CHECK-NEXT:    movl %r9d, %ebp
-; CHECK-NEXT:    movl %r8d, %ebx
+; CHECK-NEXT:    movl %r9d, %ebx
+; CHECK-NEXT:    movl %r8d, %ebp
 ; CHECK-NEXT:    movl %ecx, %r14d
 ; CHECK-NEXT:    movl %edx, %r15d
 ; CHECK-NEXT:    movl %esi, %r12d
diff --git a/llvm/test/CodeGen/X86/statepoint-regs.ll b/llvm/test/CodeGen/X86/statepoint-regs.ll
index 5c26e29dce45e..cbbdae1616fe8 10064...
[truncated]

mshockwave
mshockwave reviewed Feb 23, 2026
View reviewed changes
Comment thread llvm/lib/CodeGen/SlotIndexes.cpp Outdated
// If we repack all the way to the end, add spacing in between the
// instructions so that future renumberings are able to catch up
// without also renumbering all the way to the end.
if (index == getLastIndex().getIndex())

@mshockwave mshockwave Feb 23, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

but what if curItr is already one of the last instructions in this list? Such that maybe only one or two renumberings happened. Do we still want to repack?
Should we decide whether to repack based on how many renumbering happened?

@boomanaiden154 boomanaiden154 Feb 23, 2026

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Good point. I've updated it so that now we just look at whether or not we've renumbered more than ~20% of a function in a single go. I wanted to avoid the need for heuristics with a numerical constant, but it probably works better.

@mshockwave mshockwave Feb 24, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I would have picked 50% but at the same time I don't have a concrete data to prove that it will be better than 20%. So I'm fine sticking to 20% for now.

mshockwave
mshockwave approved these changes Feb 24, 2026
View reviewed changes

@mshockwave mshockwave left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM

arsenm
arsenm reviewed Feb 24, 2026
View reviewed changes
Comment thread llvm/test/CodeGen/AMDGPU/amdgcn.bitcast.1024bit.ll

@arsenm arsenm Feb 24, 2026

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This did increase instruction count

@boomanaiden154 boomanaiden154 Feb 24, 2026

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah. I want to do at least a round of performance testing on x86 before landing this.

@boomanaiden154

boomanaiden154 commented Feb 25, 2026

Copy link
Copy Markdown
Contributor Author

@arsenm So it looks like there is essentially no difference on LLVM test suite in terms of instructions inserted for x86, and our internal load testing is almost exactly performance neutral (and well within the noise margins). x86 I think should generally hit this pretty hard given the increased register pressure due to a low number of GPRs. Do you think that is sufficient enough evidence that this change is in aggregate performance neutral such that we can move forward with this?

@boomanaiden154
boomanaiden154 merged commit 403fd76 into llvm:main Feb 27, 2026
11 checks passed
@boomanaiden154
boomanaiden154 deleted the regalloc-slotindex-2-20-26 branch February 27, 2026 18:55
@llvm-ci

llvm-ci commented Feb 27, 2026

Copy link
Copy Markdown

LLVM Buildbot has detected a new failure on builder openmp-offload-amdgpu-runtime-2 running on rocm-worker-hw-02 while building llvm at step 2 "checkout".

Full details are available at: https://lab.llvm.org/buildbot/#/builders/10/builds/23541

Here is the relevant piece of the build log for the reference 
Step 2 (checkout) failure: update (failure)
git version 2.34.1
fatal: unable to access 'https://github.com/llvm/llvm-project.git/': Could not resolve host: github.com
fatal: unable to access 'https://github.com/llvm/llvm-project.git/': Could not resolve host: github.com

@llvm-ci

llvm-ci commented Feb 27, 2026

Copy link
Copy Markdown

LLVM Buildbot has detected a new failure on builder bolt-aarch64-ubuntu-clang running on bolt-worker-aarch64 while building llvm at step 5 "build-clang-bolt".

Full details are available at: https://lab.llvm.org/buildbot/#/builders/128/builds/11176

Here is the relevant piece of the build log for the reference 
Step 5 (build-clang-bolt) failure: build (failure)
...
30.956 [7/3/3385] Linking CXX static library lib/libclangExtractAPI.a
31.131 [7/2/3386] Linking CXX static library lib/libclangDriver.a
31.215 [6/2/3387] Linking CXX static library lib/libclangCrossTU.a
31.695 [5/2/3388] Linking CXX static library lib/libclangStaticAnalyzerCore.a
31.838 [4/2/3389] Linking CXX static library lib/libclangCodeGen.a
32.593 [4/1/3390] Linking CXX static library lib/libclangStaticAnalyzerCheckers.a
32.680 [3/1/3391] Linking CXX static library lib/libclangStaticAnalyzerFrontend.a
32.754 [2/1/3392] Linking CXX static library lib/libclangFrontendTool.a
33.628 [1/1/3393] Linking CXX executable bin/clang-23
446.313 [0/1/3394] Creating executable symlink bin/clang
FAILED: bin/clang 
/usr/bin/cmake -E cmake_symlink_executable bin/clang-23 bin/clang && cd /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/tools/clang/tools/driver && /usr/bin/cmake -E create_symlink clang-23 /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/./bin/clang++ && cd /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/tools/clang/tools/driver && /usr/bin/cmake -E create_symlink clang-23 /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/./bin/clang-cl && cd /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/tools/clang/tools/driver && /usr/bin/cmake -E create_symlink clang-23 /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/./bin/clang-cpp && cd /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/tools/clang/tools/driver && /usr/bin/python3 /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/llvm-project/clang/tools/driver/../../utils/perf-training/perf-helper.py bolt-optimize --method INSTRUMENT --input /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/bin/clang-23 --instrumented-output /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/./bin/clang-bolt.inst --fdata /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/tools/clang/tools/driver/../../utils/perf-training/prof.fdata --perf-training-binary-dir /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/tools/clang/tools/driver/../../utils/perf-training --readelf /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/bin/llvm-readobj --bolt /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/bin/llvm-bolt --lit /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/./bin/llvm-lit --merge-fdata /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/bin/merge-fdata
Running: /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/bin/llvm-bolt /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/bin/clang-23 -o /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/./bin/clang-bolt.inst -instrument --instrumentation-file-append-pid --instrumentation-file=/home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/tools/clang/tools/driver/../../utils/perf-training/prof.fdata
BOLT-INFO: shared object or position-independent executable detected
BOLT-INFO: Target architecture: aarch64
BOLT-INFO: BOLT version: <unknown>
BOLT-INFO: first alloc address is 0x0
BOLT-INFO: creating new program header table at address 0x8e00000, offset 0x8e00000
BOLT-INFO: enabling relocation mode
BOLT-INFO: forcing -jump-tables=move for instrumentation
BOLT-INFO: PointerAuthCFIAnalyzer ran on 2 functions. Ignored 0 functions (0.00%) because of CFI inconsistencies
BOLT-INFO: number of removed linker-inserted veneers: 0
BOLT-INFO: 0 out of 159344 functions in the binary (0.0%) have non-empty execution profile
BOLT-INSTRUMENTER: Number of indirect call site descriptors: 61703
BOLT-INSTRUMENTER: Number of indirect call target descriptors: 157101
BOLT-INSTRUMENTER: Number of function descriptors: 157083
BOLT-INSTRUMENTER: Number of branch counters: 2066685
BOLT-INSTRUMENTER: Number of ST leaf node counters: 1050831
BOLT-INSTRUMENTER: Number of direct call counters: 0
BOLT-INSTRUMENTER: Total number of counters: 3117516
BOLT-INSTRUMENTER: Total size of counters: 24940128 bytes (static alloc memory)
BOLT-INSTRUMENTER: Total size of string table emitted: 16517143 bytes in file
BOLT-INSTRUMENTER: Total size of descriptors: 230680024 bytes in file
BOLT-INSTRUMENTER: Profile will be saved to file /home/buildbot/workspace/bolt-aarch64-ubuntu-clang/build/tools/clang/tools/driver/../../utils/perf-training/prof.fdata
BOLT-INFO: removed 20975 empty blocks
BOLT-INFO: merged 7 duplicate CFG edges
BOLT-INFO: Starting stub-insertion pass
BOLT-INFO: Inserted 1485 stubs in the hot area and 0 stubs in the cold area. Shared 188726 times, iterated 4 times.
BOLT-INFO: rewritten pac-ret DWARF info in 2 out of 159644 functions (0.00%).
BOLT-INFO: padding code to 0x13800000 to accommodate hot text
BOLT-INFO: output linked against instrumentation runtime library, lib entry point is 0x165688f0
BOLT-INFO: clear procedure is 0x16567570
BOLT-INFO: patched build-id (flipped last bit)
BOLT-INFO: setting __bolt_runtime_start to 0x165688f0
BOLT-INFO: setting __bolt_runtime_fini to 0x16568990
BOLT-INFO: setting __hot_start to 0x9000000
BOLT-INFO: setting __hot_end to 0x1376eb44
BOLT-INFO: runtime library finalization was hooked via DT_FINI, set to 0x16568990
BOLT-INFO: runtime library initialization was hooked via ELF Header Entry Point, set to 0x165688f0

sujianIBM pushed a commit to sujianIBM/llvm-project that referenced this pull request Mar 5, 2026
@boomanaiden154 @sujianIBM
[SlotIndexes] Further pack indices to improve spill placement time (l…
2009263 
…lvm#182640)

This patch makes it so that renumbering indices when inserting
instructions into the SlotIndexes analysis renumbers the entire list if
the list is otherwise densely packed. This fixes a case we saw on
AArch64 with a lot of spills where every single spill instruction
insertion required a renumbering of most of the instructions in a large
function, making the operation approximately quadratic.

This is not NFC as heuristics depend on the SlotIndex numbers, although
this should mostly be a wash as LRs should be extended ~equally.
This was referenced Apr 15, 2026
Closed
Closed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@arsenm arsenm arsenm approved these changes
@mshockwave mshockwave mshockwave approved these changes
@MatzeB MatzeB Awaiting requested review from MatzeB
@jayfoad jayfoad Awaiting requested review from jayfoad
@mtrofin mtrofin Awaiting requested review from mtrofin

Assignees

No one assigned

Labels

backend:AArch64 backend:AMDGPU backend:PowerPC backend:X86 llvm:codegen

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

5 participants

@boomanaiden154 @llvmbot @llvm-ci @arsenm @mshockwave