1; RUN: llc -verify-machineinstrs < %s -mtriple=aarch64-none-linux-gnu -tailcallopt | FileCheck %s 2 3declare fastcc void @callee_stack0() 4declare fastcc void @callee_stack8([8 x i32], i64) 5declare fastcc void @callee_stack16([8 x i32], i64, i64) 6declare extern_weak fastcc void @callee_weak() 7 8define fastcc void @caller_to0_from0() nounwind { 9; CHECK-LABEL: caller_to0_from0: 10; CHECK-NEXT: // BB 11 12 tail call fastcc void @callee_stack0() 13 ret void 14 15; CHECK-NEXT: b callee_stack0 16} 17 18define fastcc void @caller_to0_from8([8 x i32], i64) { 19; CHECK-LABEL: caller_to0_from8: 20 21 tail call fastcc void @callee_stack0() 22 ret void 23 24; CHECK: add sp, sp, #16 25; CHECK-NEXT: b callee_stack0 26} 27 28define fastcc void @caller_to8_from0() { 29; CHECK-LABEL: caller_to8_from0: 30; CHECK: sub sp, sp, #32 31 32; Key point is that the "42" should go #16 below incoming stack 33; pointer (we didn't have arg space to reuse). 34 tail call fastcc void @callee_stack8([8 x i32] undef, i64 42) 35 ret void 36 37; CHECK: str {{x[0-9]+}}, [sp, #16]! 38; CHECK-NEXT: b callee_stack8 39} 40 41define fastcc void @caller_to8_from8([8 x i32], i64 %a) { 42; CHECK-LABEL: caller_to8_from8: 43; CHECK: sub sp, sp, #16 44 45; Key point is that the "%a" should go where at SP on entry. 46 tail call fastcc void @callee_stack8([8 x i32] undef, i64 42) 47 ret void 48 49; CHECK: str {{x[0-9]+}}, [sp, #16]! 50; CHECK-NEXT: b callee_stack8 51} 52 53define fastcc void @caller_to16_from8([8 x i32], i64 %a) { 54; CHECK-LABEL: caller_to16_from8: 55; CHECK: sub sp, sp, #16 56 57; Important point is that the call reuses the "dead" argument space 58; above %a on the stack. If it tries to go below incoming-SP then the 59; callee will not deallocate the space, even in fastcc. 60 tail call fastcc void @callee_stack16([8 x i32] undef, i64 42, i64 2) 61 62; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16] 63; CHECK-NEXT: add sp, sp, #16 64; CHECK-NEXT: b callee_stack16 65 ret void 66} 67 68 69define fastcc void @caller_to8_from24([8 x i32], i64 %a, i64 %b, i64 %c) { 70; CHECK-LABEL: caller_to8_from24: 71; CHECK: sub sp, sp, #16 72 73; Key point is that the "%a" should go where at #16 above SP on entry. 74 tail call fastcc void @callee_stack8([8 x i32] undef, i64 42) 75 ret void 76 77; CHECK: str {{x[0-9]+}}, [sp, #32]! 78; CHECK-NEXT: b callee_stack8 79} 80 81 82define fastcc void @caller_to16_from16([8 x i32], i64 %a, i64 %b) { 83; CHECK-LABEL: caller_to16_from16: 84; CHECK: sub sp, sp, #16 85 86; Here we want to make sure that both loads happen before the stores: 87; otherwise either %a or %b will be wrongly clobbered. 88 tail call fastcc void @callee_stack16([8 x i32] undef, i64 %b, i64 %a) 89 ret void 90 91; CHECK: ldp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16] 92; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16] 93; CHECK-NEXT: add sp, sp, #16 94; CHECK-NEXT: b callee_stack16 95} 96 97 98; Weakly-referenced extern functions cannot be tail-called, as AAELF does 99; not define the behaviour of branch instructions to undefined weak symbols. 100define fastcc void @caller_weak() { 101; CHECK-LABEL: caller_weak: 102; CHECK: bl callee_weak 103 tail call void @callee_weak() 104 ret void 105} 106