test/CodeGen/AArch64/tail-call.ll

   1 ; RUN: llc -verify-machineinstrs < %s -mtriple=aarch64-none-linux-gnu -tailcallopt | FileCheck %s
   2
   3 declare fastcc void @callee_stack0()
   4 declare fastcc void @callee_stack8([8 x i32], i64)
   5 declare fastcc void @callee_stack16([8 x i32], i64, i64)
   6 declare extern_weak fastcc void @callee_weak()
   7
   8 define 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
  18 define 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
  28 define 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
  41 define 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
  53 define 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
  69 define 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
  82 define 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.
 100 define fastcc void @caller_weak() {
 101 ; CHECK-LABEL: caller_weak:
 102 ; CHECK: bl callee_weak
 103   tail call void @callee_weak()
 104   ret void
 105 }