Skip to content

Commit 02265ed

Browse files
author
Serguei Katkov
committed
[Live Intervals] Teach Greedy RA to recognize special case live-through
Statepoint instruction has a deopt section which is actually live-through the call. Currently this is handled by special post pass after RA - fixup-statepoint-caller-saved. This change teaches Greedy RA that if segment of live interval is ended with statepoint instruction and its reg is used in deopt bundle then this live interval interferes regmask of this statepoint and as a result caller-saved register cannot be assigned to this live interval. Reviewers: reames, dantrushin Reviewed By: reames Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D100296
1 parent d9b03ef commit 02265ed

File tree

2 files changed

+191
-90
lines changed

2 files changed

+191
-90
lines changed

‎llvm/lib/CodeGen/LiveIntervals.cpp

+28-2
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@
3838
#include "llvm/CodeGen/VirtRegMap.h"
3939
#include "llvm/Config/llvm-config.h"
4040
#include "llvm/IR/InstrTypes.h"
41+
#include "llvm/IR/Statepoint.h"
4142
#include "llvm/MC/LaneBitmask.h"
4243
#include "llvm/MC/MCRegisterInfo.h"
4344
#include "llvm/Pass.h"
@@ -47,6 +48,7 @@
4748
#include "llvm/Support/Debug.h"
4849
#include "llvm/Support/MathExtras.h"
4950
#include "llvm/Support/raw_ostream.h"
51+
#include "llvm/CodeGen/StackMaps.h"
5052
#include <algorithm>
5153
#include <cassert>
5254
#include <cstdint>
@@ -886,6 +888,23 @@ LiveIntervals::addSegmentToEndOfBlock(Register Reg, MachineInstr &startInst) {
886888
//===----------------------------------------------------------------------===//
887889
// Register mask functions
888890
//===----------------------------------------------------------------------===//
891+
/// Check whether use of reg in MI is live-through. Live-through means that
892+
/// the value is alive on exit from Machine instruction. The example of such
893+
/// use is a deopt value in statepoint instruction.
894+
static bool hasLiveThroughUse(const MachineInstr *MI, Register Reg) {
895+
if (MI->getOpcode() != TargetOpcode::STATEPOINT)
896+
return false;
897+
StatepointOpers SO(MI);
898+
if (SO.getFlags() & (uint64_t)StatepointFlags::DeoptLiveIn)
899+
return false;
900+
for (unsigned Idx = SO.getNumDeoptArgsIdx(), E = SO.getNumGCPtrIdx(); Idx < E;
901+
++Idx) {
902+
const MachineOperand &MO = MI->getOperand(Idx);
903+
if (MO.isReg() && MO.getReg() == Reg)
904+
return true;
905+
}
906+
return false;
907+
}
889908

890909
bool LiveIntervals::checkRegMaskInterference(LiveInterval &LI,
891910
BitVector &UsableRegs) {
@@ -934,10 +953,17 @@ bool LiveIntervals::checkRegMaskInterference(LiveInterval &LI,
934953
if (++SlotI == SlotE)
935954
return Found;
936955
}
956+
// If segment ends with live-through use we need to collect its regmask.
957+
if (*SlotI == LiveI->end)
958+
if (MachineInstr *MI = getInstructionFromIndex(*SlotI))
959+
if (hasLiveThroughUse(MI, LI.reg()))
960+
unionBitMask(SlotI++ - Slots.begin());
937961
// *SlotI is beyond the current LI segment.
938-
LiveI = LI.advanceTo(LiveI, *SlotI);
939-
if (LiveI == LiveE)
962+
// Special advance implementation to not miss next LiveI->end.
963+
if (++LiveI == LiveE || SlotI == SlotE || *SlotI > LI.endIndex())
940964
return Found;
965+
while (LiveI->end < *SlotI)
966+
++LiveI;
941967
// Advance SlotI until it overlaps.
942968
while (*SlotI < LiveI->start)
943969
if (++SlotI == SlotE)

‎llvm/test/CodeGen/X86/statepoint-regs.ll

+163-88
Original file line numberDiff line numberDiff line change
@@ -10,12 +10,13 @@ declare void @baz()
1010
define void @test1(i32 %a) gc "statepoint-example" {
1111
; CHECK-LABEL: test1:
1212
; CHECK: ## %bb.0: ## %entry
13-
; CHECK-NEXT: pushq %rax
13+
; CHECK-NEXT: pushq %rbx
1414
; CHECK-NEXT: .cfi_def_cfa_offset 16
15-
; CHECK-NEXT: movl %edi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
16-
; CHECK-NEXT: callq _bar ## 4-byte Folded Reload
15+
; CHECK-NEXT: .cfi_offset %rbx, -16
16+
; CHECK-NEXT: movl %edi, %ebx
17+
; CHECK-NEXT: callq _bar
1718
; CHECK-NEXT: Ltmp0:
18-
; CHECK-NEXT: popq %rax
19+
; CHECK-NEXT: popq %rbx
1920
; CHECK-NEXT: retq
2021
entry:
2122
%statepoint_token1 = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @bar, i32 0, i32 0, i32 0, i32 0) ["deopt" (i32 %a)]
@@ -54,17 +55,41 @@ entry:
5455
define void @test3(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i) gc "statepoint-example" {
5556
; CHECK-LABEL: test3:
5657
; CHECK: ## %bb.0: ## %entry
57-
; CHECK-NEXT: subq $24, %rsp
58+
; CHECK-NEXT: pushq %rbp
59+
; CHECK-NEXT: .cfi_def_cfa_offset 16
60+
; CHECK-NEXT: pushq %r15
61+
; CHECK-NEXT: .cfi_def_cfa_offset 24
62+
; CHECK-NEXT: pushq %r14
5863
; CHECK-NEXT: .cfi_def_cfa_offset 32
59-
; CHECK-NEXT: movl %edi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
60-
; CHECK-NEXT: movl %esi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
61-
; CHECK-NEXT: movl %edx, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
62-
; CHECK-NEXT: movl %ecx, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
63-
; CHECK-NEXT: movl %r8d, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
64-
; CHECK-NEXT: movl %r9d, (%rsp) ## 4-byte Spill
65-
; CHECK-NEXT: callq _bar ## 24-byte Folded Reload
64+
; CHECK-NEXT: pushq %r13
65+
; CHECK-NEXT: .cfi_def_cfa_offset 40
66+
; CHECK-NEXT: pushq %r12
67+
; CHECK-NEXT: .cfi_def_cfa_offset 48
68+
; CHECK-NEXT: pushq %rbx
69+
; CHECK-NEXT: .cfi_def_cfa_offset 56
70+
; CHECK-NEXT: pushq %rax
71+
; CHECK-NEXT: .cfi_def_cfa_offset 64
72+
; CHECK-NEXT: .cfi_offset %rbx, -56
73+
; CHECK-NEXT: .cfi_offset %r12, -48
74+
; CHECK-NEXT: .cfi_offset %r13, -40
75+
; CHECK-NEXT: .cfi_offset %r14, -32
76+
; CHECK-NEXT: .cfi_offset %r15, -24
77+
; CHECK-NEXT: .cfi_offset %rbp, -16
78+
; CHECK-NEXT: movl %r9d, %r14d
79+
; CHECK-NEXT: movl %r8d, %r15d
80+
; CHECK-NEXT: movl %ecx, %r12d
81+
; CHECK-NEXT: movl %edx, %r13d
82+
; CHECK-NEXT: movl %esi, %ebx
83+
; CHECK-NEXT: movl %edi, %ebp
84+
; CHECK-NEXT: callq _bar
6685
; CHECK-NEXT: Ltmp3:
67-
; CHECK-NEXT: addq $24, %rsp
86+
; CHECK-NEXT: addq $8, %rsp
87+
; CHECK-NEXT: popq %rbx
88+
; CHECK-NEXT: popq %r12
89+
; CHECK-NEXT: popq %r13
90+
; CHECK-NEXT: popq %r14
91+
; CHECK-NEXT: popq %r15
92+
; CHECK-NEXT: popq %rbp
6893
; CHECK-NEXT: retq
6994
entry:
7095
%statepoint_token1 = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @bar, i32 0, i32 0, i32 0, i32 0) ["deopt" (i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i)]
@@ -78,17 +103,41 @@ entry:
78103
define void @test4(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i, i32 %j, i32 %k, i32 %l, i32 %m, i32 %n, i32 %o, i32 %p, i32 %q, i32 %r, i32 %s, i32 %t, i32 %u, i32 %v, i32 %w, i32 %x, i32 %y, i32 %z) gc "statepoint-example" {
79104
; CHECK-LABEL: test4:
80105
; CHECK: ## %bb.0: ## %entry
81-
; CHECK-NEXT: subq $24, %rsp
106+
; CHECK-NEXT: pushq %rbp
107+
; CHECK-NEXT: .cfi_def_cfa_offset 16
108+
; CHECK-NEXT: pushq %r15
109+
; CHECK-NEXT: .cfi_def_cfa_offset 24
110+
; CHECK-NEXT: pushq %r14
82111
; CHECK-NEXT: .cfi_def_cfa_offset 32
83-
; CHECK-NEXT: movl %edi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
84-
; CHECK-NEXT: movl %esi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
85-
; CHECK-NEXT: movl %edx, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
86-
; CHECK-NEXT: movl %ecx, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
87-
; CHECK-NEXT: movl %r8d, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
88-
; CHECK-NEXT: movl %r9d, (%rsp) ## 4-byte Spill
89-
; CHECK-NEXT: callq _bar ## 24-byte Folded Reload
112+
; CHECK-NEXT: pushq %r13
113+
; CHECK-NEXT: .cfi_def_cfa_offset 40
114+
; CHECK-NEXT: pushq %r12
115+
; CHECK-NEXT: .cfi_def_cfa_offset 48
116+
; CHECK-NEXT: pushq %rbx
117+
; CHECK-NEXT: .cfi_def_cfa_offset 56
118+
; CHECK-NEXT: pushq %rax
119+
; CHECK-NEXT: .cfi_def_cfa_offset 64
120+
; CHECK-NEXT: .cfi_offset %rbx, -56
121+
; CHECK-NEXT: .cfi_offset %r12, -48
122+
; CHECK-NEXT: .cfi_offset %r13, -40
123+
; CHECK-NEXT: .cfi_offset %r14, -32
124+
; CHECK-NEXT: .cfi_offset %r15, -24
125+
; CHECK-NEXT: .cfi_offset %rbp, -16
126+
; CHECK-NEXT: movl %r9d, %r14d
127+
; CHECK-NEXT: movl %r8d, %r15d
128+
; CHECK-NEXT: movl %ecx, %r12d
129+
; CHECK-NEXT: movl %edx, %r13d
130+
; CHECK-NEXT: movl %esi, %ebx
131+
; CHECK-NEXT: movl %edi, %ebp
132+
; CHECK-NEXT: callq _bar
90133
; CHECK-NEXT: Ltmp4:
91-
; CHECK-NEXT: addq $24, %rsp
134+
; CHECK-NEXT: addq $8, %rsp
135+
; CHECK-NEXT: popq %rbx
136+
; CHECK-NEXT: popq %r12
137+
; CHECK-NEXT: popq %r13
138+
; CHECK-NEXT: popq %r14
139+
; CHECK-NEXT: popq %r15
140+
; CHECK-NEXT: popq %rbp
92141
; CHECK-NEXT: retq
93142
entry:
94143
%statepoint_token1 = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @bar, i32 0, i32 0, i32 0, i32 0) ["deopt" (i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i, i32 %j, i32 %k, i32 %l, i32 %m, i32 %n, i32 %o, i32 %p, i32 %q, i32 %r, i32 %s, i32 %t, i32 %u, i32 %v, i32 %w, i32 %x, i32 %y, i32 %z)]
@@ -185,34 +234,34 @@ define void @test7(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %
185234
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
186235
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
187236
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
188-
; CHECK-NEXT: movl %edi, %edi
189-
; CHECK-NEXT: movl %esi, %esi
190-
; CHECK-NEXT: movl %edx, %edx
191-
; CHECK-NEXT: movl %ecx, %ecx
192-
; CHECK-NEXT: movl %r8d, %r8d
193-
; CHECK-NEXT: movl %r9d, %r9d
237+
; CHECK-NEXT: movl %edi, %r13d
238+
; CHECK-NEXT: movl %esi, %ebx
239+
; CHECK-NEXT: movl %edx, %ebp
240+
; CHECK-NEXT: movl %ecx, %r14d
241+
; CHECK-NEXT: movl %r8d, %r15d
242+
; CHECK-NEXT: movl %r9d, %r12d
243+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
244+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
245+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
246+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
247+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
248+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
249+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
250+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
251+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
252+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
253+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
254+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
255+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
256+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
257+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
258+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
259+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
260+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
194261
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
195262
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
196263
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
197264
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
198-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %ebp
199-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r13d
200-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r12d
201-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r15d
202-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r14d
203-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %ebx
204-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r11d
205-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r10d
206-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
207-
; CHECK-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
208-
; CHECK-NEXT: movq %rsi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
209-
; CHECK-NEXT: movq %rdx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
210-
; CHECK-NEXT: movq %rcx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
211-
; CHECK-NEXT: movq %r8, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
212-
; CHECK-NEXT: movq %r9, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
213-
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
214-
; CHECK-NEXT: movq %r10, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
215-
; CHECK-NEXT: movq %r11, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
216265
; CHECK-NEXT: callq _bar ## 160-byte Folded Reload
217266
; CHECK-NEXT: Ltmp9:
218267
; CHECK-NEXT: addq $168, %rsp
@@ -271,16 +320,34 @@ define void @test8(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %
271320
; CHECK-NEXT: .cfi_def_cfa_offset 48
272321
; CHECK-NEXT: pushq %rbx
273322
; CHECK-NEXT: .cfi_def_cfa_offset 56
274-
; CHECK-NEXT: subq $104, %rsp
275-
; CHECK-NEXT: .cfi_def_cfa_offset 160
323+
; CHECK-NEXT: subq $136, %rsp
324+
; CHECK-NEXT: .cfi_def_cfa_offset 192
276325
; CHECK-NEXT: .cfi_offset %rbx, -56
277326
; CHECK-NEXT: .cfi_offset %r12, -48
278327
; CHECK-NEXT: .cfi_offset %r13, -40
279328
; CHECK-NEXT: .cfi_offset %r14, -32
280329
; CHECK-NEXT: .cfi_offset %r15, -24
281330
; CHECK-NEXT: .cfi_offset %rbp, -16
282-
; CHECK-NEXT: movl %r9d, %r10d
283-
; CHECK-NEXT: movl %r8d, %r9d
331+
; CHECK-NEXT: movl %r9d, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
332+
; CHECK-NEXT: movl %r8d, (%rsp) ## 4-byte Spill
333+
; CHECK-NEXT: movl %ecx, %r12d
334+
; CHECK-NEXT: movl %edx, %r13d
335+
; CHECK-NEXT: movl %esi, %ebx
336+
; CHECK-NEXT: movl %edi, %ebp
337+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
338+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
339+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
340+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
341+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
342+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
343+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
344+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
345+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
346+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
347+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
348+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
349+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
350+
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
284351
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
285352
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
286353
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
@@ -299,27 +366,11 @@ define void @test8(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %
299366
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
300367
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
301368
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
302-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %ebp
303-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r13d
304-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r12d
305-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r15d
306369
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r14d
307-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %ebx
308-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r11d
309-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r8d
310-
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %eax
311-
; CHECK-NEXT: movb %dil, {{[-0-9]+}}(%r{{[sb]}}p) ## 1-byte Spill
312-
; CHECK-NEXT: movb %sil, {{[-0-9]+}}(%r{{[sb]}}p) ## 1-byte Spill
313-
; CHECK-NEXT: movb %dl, {{[-0-9]+}}(%r{{[sb]}}p) ## 1-byte Spill
314-
; CHECK-NEXT: movb %cl, (%rsp) ## 1-byte Spill
315-
; CHECK-NEXT: movw %r9w, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill
316-
; CHECK-NEXT: movw %r10w, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill
317-
; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
318-
; CHECK-NEXT: movq %r8, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
319-
; CHECK-NEXT: movq %r11, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
320-
; CHECK-NEXT: callq _bar ## 104-byte Folded Reload
370+
; CHECK-NEXT: movl {{[0-9]+}}(%rsp), %r15d
371+
; CHECK-NEXT: callq _bar ## 132-byte Folded Reload
321372
; CHECK-NEXT: Ltmp10:
322-
; CHECK-NEXT: addq $104, %rsp
373+
; CHECK-NEXT: addq $136, %rsp
323374
; CHECK-NEXT: popq %rbx
324375
; CHECK-NEXT: popq %r12
325376
; CHECK-NEXT: popq %r13
@@ -363,17 +414,41 @@ entry:
363414
define void @test9(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i, i32 %j, i32 %k, i32 %l, i32 %m, i32 %n, i32 %o, i32 %p, i32 %q, i32 %r, i32 %s, i32 %t, i32 %u, i32 %v, i32 %w, i32 %x, i32 %y, i32 %z) gc "statepoint-example" {
364415
; CHECK-LABEL: test9:
365416
; CHECK: ## %bb.0: ## %entry
366-
; CHECK-NEXT: subq $24, %rsp
417+
; CHECK-NEXT: pushq %rbp
418+
; CHECK-NEXT: .cfi_def_cfa_offset 16
419+
; CHECK-NEXT: pushq %r15
420+
; CHECK-NEXT: .cfi_def_cfa_offset 24
421+
; CHECK-NEXT: pushq %r14
367422
; CHECK-NEXT: .cfi_def_cfa_offset 32
368-
; CHECK-NEXT: movl %edi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
369-
; CHECK-NEXT: movl %esi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
370-
; CHECK-NEXT: movl %edx, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
371-
; CHECK-NEXT: movl %ecx, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
372-
; CHECK-NEXT: movl %r8d, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
373-
; CHECK-NEXT: movl %r9d, (%rsp) ## 4-byte Spill
374-
; CHECK-NEXT: callq _bar ## 24-byte Folded Reload
423+
; CHECK-NEXT: pushq %r13
424+
; CHECK-NEXT: .cfi_def_cfa_offset 40
425+
; CHECK-NEXT: pushq %r12
426+
; CHECK-NEXT: .cfi_def_cfa_offset 48
427+
; CHECK-NEXT: pushq %rbx
428+
; CHECK-NEXT: .cfi_def_cfa_offset 56
429+
; CHECK-NEXT: pushq %rax
430+
; CHECK-NEXT: .cfi_def_cfa_offset 64
431+
; CHECK-NEXT: .cfi_offset %rbx, -56
432+
; CHECK-NEXT: .cfi_offset %r12, -48
433+
; CHECK-NEXT: .cfi_offset %r13, -40
434+
; CHECK-NEXT: .cfi_offset %r14, -32
435+
; CHECK-NEXT: .cfi_offset %r15, -24
436+
; CHECK-NEXT: .cfi_offset %rbp, -16
437+
; CHECK-NEXT: movl %r9d, %r14d
438+
; CHECK-NEXT: movl %r8d, %r15d
439+
; CHECK-NEXT: movl %ecx, %r12d
440+
; CHECK-NEXT: movl %edx, %r13d
441+
; CHECK-NEXT: movl %esi, %ebx
442+
; CHECK-NEXT: movl %edi, %ebp
443+
; CHECK-NEXT: callq _bar
375444
; CHECK-NEXT: Ltmp11:
376-
; CHECK-NEXT: addq $24, %rsp
445+
; CHECK-NEXT: addq $8, %rsp
446+
; CHECK-NEXT: popq %rbx
447+
; CHECK-NEXT: popq %r12
448+
; CHECK-NEXT: popq %r13
449+
; CHECK-NEXT: popq %r14
450+
; CHECK-NEXT: popq %r15
451+
; CHECK-NEXT: popq %rbp
377452
; CHECK-NEXT: retq
378453

379454
entry:
@@ -624,13 +699,13 @@ entry:
624699
define void @addr_func() gc "statepoint-example" {
625700
; CHECK-LABEL: addr_func:
626701
; CHECK: ## %bb.0: ## %entry
627-
; CHECK-NEXT: pushq %rax
702+
; CHECK-NEXT: pushq %rbx
628703
; CHECK-NEXT: .cfi_def_cfa_offset 16
629-
; CHECK-NEXT: movq _bar@{{.*}}(%rip), %rax
630-
; CHECK-NEXT: movq %rax, (%rsp) ## 8-byte Spill
631-
; CHECK-NEXT: callq _bar ## 8-byte Folded Reload
704+
; CHECK-NEXT: .cfi_offset %rbx, -16
705+
; CHECK-NEXT: movq _bar@{{.*}}(%rip), %rbx
706+
; CHECK-NEXT: callq _bar
632707
; CHECK-NEXT: Ltmp15:
633-
; CHECK-NEXT: popq %rax
708+
; CHECK-NEXT: popq %rbx
634709
; CHECK-NEXT: retq
635710
entry:
636711
%statepoint_token1 = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @bar, i32 0, i32 0, i64 0, i64 0) ["deopt" (void ()* @bar, void ()* @bar, void ()* @bar)]
@@ -642,13 +717,13 @@ entry:
642717
define void @addr_global() gc "statepoint-example" {
643718
; CHECK-LABEL: addr_global:
644719
; CHECK: ## %bb.0: ## %entry
645-
; CHECK-NEXT: pushq %rax
720+
; CHECK-NEXT: pushq %rbx
646721
; CHECK-NEXT: .cfi_def_cfa_offset 16
647-
; CHECK-NEXT: movq _G@{{.*}}(%rip), %rax
648-
; CHECK-NEXT: movq %rax, (%rsp) ## 8-byte Spill
649-
; CHECK-NEXT: callq _bar ## 8-byte Folded Reload
722+
; CHECK-NEXT: .cfi_offset %rbx, -16
723+
; CHECK-NEXT: movq _G@{{.*}}(%rip), %rbx
724+
; CHECK-NEXT: callq _bar
650725
; CHECK-NEXT: Ltmp16:
651-
; CHECK-NEXT: popq %rax
726+
; CHECK-NEXT: popq %rbx
652727
; CHECK-NEXT: retq
653728
entry:
654729
%statepoint_token1 = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @bar, i32 0, i32 0, i64 0, i64 0) ["deopt" (i32* @G, i32* @G, i32* @G)]

0 commit comments

Comments
 (0)