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: b callee_stack16 64 ret void 65} 66 67 68define fastcc void @caller_to8_from24([8 x i32], i64 %a, i64 %b, i64 %c) { 69; CHECK-LABEL: caller_to8_from24: 70; CHECK: sub sp, sp, #16 71 72; Key point is that the "%a" should go where at #16 above SP on entry. 73 tail call fastcc void @callee_stack8([8 x i32] undef, i64 42) 74 ret void 75 76; CHECK: str {{x[0-9]+}}, [sp, #32]! 77; CHECK-NEXT: b callee_stack8 78} 79 80 81define fastcc void @caller_to16_from16([8 x i32], i64 %a, i64 %b) { 82; CHECK-LABEL: caller_to16_from16: 83; CHECK: sub sp, sp, #16 84 85; Here we want to make sure that both loads happen before the stores: 86; otherwise either %a or %b will be wrongly clobbered. 87 tail call fastcc void @callee_stack16([8 x i32] undef, i64 %b, i64 %a) 88 ret void 89 90; CHECK: ldp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16] 91; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16]! 92; CHECK-NEXT: b callee_stack16 93} 94 95 96; Weakly-referenced extern functions cannot be tail-called, as AAELF does 97; not define the behaviour of branch instructions to undefined weak symbols. 98define fastcc void @caller_weak() { 99; CHECK-LABEL: caller_weak: 100; CHECK: bl callee_weak 101 tail call void @callee_weak() 102 ret void 103} 104 105declare { [2 x float] } @get_vec2() 106 107define { [3 x float] } @test_add_elem() { 108; CHECK-LABEL: test_add_elem: 109; CHECK: bl get_vec2 110; CHECK: fmov s2, #1.0 111; CHECK: ret 112 113 %call = tail call { [2 x float] } @get_vec2() 114 %arr = extractvalue { [2 x float] } %call, 0 115 %arr.0 = extractvalue [2 x float] %arr, 0 116 %arr.1 = extractvalue [2 x float] %arr, 1 117 118 %res.0 = insertvalue { [3 x float] } undef, float %arr.0, 0, 0 119 %res.01 = insertvalue { [3 x float] } %res.0, float %arr.1, 0, 1 120 %res.012 = insertvalue { [3 x float] } %res.01, float 1.000000e+00, 0, 2 121 ret { [3 x float] } %res.012 122} 123 124declare double @get_double() 125define { double, [2 x double] } @test_mismatched_insert() { 126; CHECK-LABEL: test_mismatched_insert: 127; CHECK: bl get_double 128; CHECK: bl get_double 129; CHECK: bl get_double 130; CHECK: ret 131 132 %val0 = call double @get_double() 133 %val1 = call double @get_double() 134 %val2 = tail call double @get_double() 135 136 %res.0 = insertvalue { double, [2 x double] } undef, double %val0, 0 137 %res.01 = insertvalue { double, [2 x double] } %res.0, double %val1, 1, 0 138 %res.012 = insertvalue { double, [2 x double] } %res.01, double %val2, 1, 1 139 140 ret { double, [2 x double] } %res.012 141} 142