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: b callee_stack16
  64   ret void
  65 }
  66
  67
  68 define 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
  81 define 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.
  98 define 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
 105 declare { [2 x float] } @get_vec2()
 106
 107 define { [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
 124 declare double @get_double()
 125 define { 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 }