| ; RUN: llc -verify-machineinstrs < %s -mtriple=thumbv7k-apple-watchos | FileCheck %s |
| |
| declare swifttailcc void @callee_stack0() |
| declare swifttailcc void @callee_stack4([4 x i32], i32) |
| declare swifttailcc void @callee_stack20([4 x i32], [5 x i32]) |
| declare extern_weak swifttailcc void @callee_weak() |
| |
| define swifttailcc void @caller_to0_from0() nounwind { |
| ; CHECK-LABEL: _caller_to0_from0: |
| |
| tail call swifttailcc void @callee_stack0() |
| ret void |
| ; CHECK-NOT: add |
| ; CHECK-NOT: sub |
| ; CHECK: b.w _callee_stack0 |
| } |
| |
| define swifttailcc void @caller_to0_from4([4 x i32], i32) { |
| ; CHECK-LABEL: _caller_to0_from4: |
| |
| tail call swifttailcc void @callee_stack0() |
| ret void |
| |
| ; CHECK: add sp, #16 |
| ; CHECK-NEXT: b.w _callee_stack0 |
| } |
| |
| define swifttailcc void @caller_to4_from0() { |
| ; Key point is that the "42" should go #16 below incoming stack |
| ; pointer (we didn't have arg space to reuse). |
| tail call swifttailcc void @callee_stack4([4 x i32] undef, i32 42) |
| ret void |
| |
| ; CHECK-LABEL: _caller_to4_from0: |
| ; CHECK: sub sp, #16 |
| ; CHECK: movs [[TMP:r[0-9]+]], #42 |
| ; CHECK: str [[TMP]], [sp] |
| ; CHECK-NOT: add sp |
| ; CHECK: b.w _callee_stack4 |
| |
| } |
| |
| define swifttailcc void @caller_to4_from4([4 x i32], i32 %a) { |
| ; CHECK-LABEL: _caller_to4_from4: |
| ; CHECK-NOT: sub sp |
| ; Key point is that the "%a" should go where at SP on entry. |
| tail call swifttailcc void @callee_stack4([4 x i32] undef, i32 42) |
| ret void |
| |
| ; CHECK: str {{r[0-9]+}}, [sp] |
| ; CHECK-NOT: add sp |
| ; CHECK-NEXT: b.w _callee_stack4 |
| } |
| |
| define swifttailcc void @caller_to20_from4([4 x i32], i32 %a) { |
| ; CHECK-LABEL: _caller_to20_from4: |
| ; CHECK: sub sp, #16 |
| |
| ; Important point is that the call reuses the "dead" argument space |
| ; above %a on the stack. If it tries to go below incoming-SP then the |
| ; _callee will not deallocate the space, even in swifttailcc. |
| tail call swifttailcc void @callee_stack20([4 x i32] undef, [5 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5]) |
| |
| ; CHECK: str {{.*}}, [sp] |
| ; CHECK: str {{.*}}, [sp, #4] |
| ; CHECK: str {{.*}}, [sp, #8] |
| ; CHECK: str {{.*}}, [sp, #12] |
| ; CHECK: str {{.*}}, [sp, #16] |
| ; CHECK-NOT: add sp |
| ; CHECK-NOT: sub sp |
| ; CHECK: b.w _callee_stack20 |
| ret void |
| } |
| |
| |
| define swifttailcc void @caller_to4_from24([4 x i32], i64 %a, i64 %b, i64 %c) { |
| ; CHECK-LABEL: _caller_to4_from24: |
| |
| |
| ; Key point is that the "%a" should go where at #16 above SP on entry. |
| tail call swifttailcc void @callee_stack4([4 x i32] undef, i32 42) |
| ret void |
| |
| ; CHECK: str {{.*}}, [sp, #16] |
| ; CHECK: add sp, #16 |
| ; CHECK-NEXT: b.w _callee_stack4 |
| } |
| |
| |
| define swifttailcc void @caller_to20_from20([4 x i32], [5 x i32] %a) { |
| ; CHECK-LABEL: _caller_to20_from20: |
| ; CHECK-NOT: add sp, |
| ; CHECK-NOT: sub sp, |
| |
| ; Here we want to make sure that both loads happen before the stores: |
| ; otherwise either %a or %b.w will be wrongly clobbered. |
| tail call swifttailcc void @callee_stack20([4 x i32] undef, [5 x i32] %a) |
| ret void |
| |
| ; If these ever get interleaved make sure aliasing slots don't clobber each |
| ; other. |
| ; CHECK: ldrd {{.*}}, {{.*}}, [sp, #12] |
| ; CHECK: ldm.w sp, |
| ; CHECK: stm.w |
| ; CHECK: strd |
| ; CHECK-NEXT: b.w _callee_stack20 |
| } |
| |
| define swifttailcc void @disable_tail_calls() nounwind "disable-tail-calls"="true" { |
| ; CHECK-LABEL: disable_tail_calls: |
| |
| tail call swifttailcc void @callee_stack0() |
| ret void |
| |
| ; CHECK: bl _callee_stack0 |
| ; CHECK: ret |
| } |
| |
| define swifttailcc void @normal_ret_with_stack([4 x i32], i32 %a) { |
| ; CHECK: _normal_ret_with_stack: |
| ; CHECK: add sp, #16 |
| ; CHECK: bx lr |
| ret void |
| } |
| |
| declare { [2 x float] } @get_vec2() |
| |
| define void @fromC_totail() { |
| ; COMMON-LABEL: fromC_totail: |
| ; COMMON: puch {r4, lr} |
| ; COMMON: sub sp, #8 |
| |
| ; COMMON-NOT: sub sp, |
| ; COMMON: movs [[TMP:r[0-9]+]], #42 |
| ; COMMON: str [[TMP]], [sp] |
| ; COMMON: bl _callee_stack4 |
| ; We must reset the stack to where it was before the call by undoing its extra stack pop. |
| ; COMMON: sub sp, #16 |
| ; COMMON: str [[TMP]], [sp] |
| ; COMMON: bl callee_stack4 |
| ; COMMON: sub sp, #16 |
| |
| call swifttailcc void @callee_stack4([4 x i32] undef, i32 42) |
| call swifttailcc void @callee_stack4([4 x i32] undef, i32 42) |
| ret void |
| } |
| |
| define void @fromC_totail_noreservedframe(i32 %len) { |
| ; COMMON-LABEL: fromC_totail_noreservedframe: |
| ; COMMON: sub.w sp, sp, r{{.*}} |
| |
| ; COMMON: movs [[TMP:r[0-9]+]], #42 |
| ; Note stack is subtracted here to allocate space for arg |
| ; COMMON: sub.w sp, #16 |
| ; COMMON: str [[TMP]], [sp] |
| ; COMMON: bl _callee_stack4 |
| ; And here. |
| ; COMMON: sub sp, #16 |
| ; COMMON: str [[TMP]], [sp] |
| ; COMMON: bl _callee_stack4 |
| ; But not restored here because callee_stack8 did that for us. |
| ; COMMON-NOT: sub sp, |
| |
| ; Variable sized allocation prevents reserving frame at start of function so each call must allocate any stack space it needs. |
| %var = alloca i32, i32 %len |
| |
| call swifttailcc void @callee_stack4([4 x i32] undef, i32 42) |
| call swifttailcc void @callee_stack4([4 x i32] undef, i32 42) |
| ret void |
| } |
| |
| declare void @Ccallee_stack4([4 x i32], i32) |
| |
| define swifttailcc void @fromtail_toC() { |
| ; COMMON-LABEL: fromtail_toC: |
| ; COMMON: push {r4, lr} |
| ; COMMON: sub sp, #8 |
| |
| ; COMMON-NOT: sub sp, |
| ; COMMON: movs [[TMP:r[0-9]+]], #42 |
| ; COMMON: str [[TMP]], [sp] |
| ; COMMON: bl _Ccallee_stack4 |
| ; C callees will return with the stack exactly where we left it, so we mustn't try to fix anything. |
| ; COMMON-NOT: add sp, |
| ; COMMON-NOT: sub sp, |
| ; COMMON: str [[TMP]], [sp]{{$}} |
| ; COMMON: bl _Ccallee_stack4 |
| ; COMMON-NOT: sub sp, |
| |
| call void @Ccallee_stack4([4 x i32] undef, i32 42) |
| call void @Ccallee_stack4([4 x i32] undef, i32 42) |
| ret void |
| } |
| |
| declare swifttailcc ptr @SwiftSelf(ptr swiftasync %context, ptr swiftself %closure) |
| define swiftcc ptr @CallSwiftSelf(ptr swiftself %closure, ptr %context) { |
| ; CHECK-LABEL: CallSwiftSelf: |
| ; CHECK: push{{.*}}r10 |
| %res = call swifttailcc ptr @SwiftSelf(ptr swiftasync %context, ptr swiftself %closure) |
| ret ptr %res |
| } |