test/CodeGen/AArch64/tail-call.ll

   1 ; RUN: llc -verify-machineinstrs < %s -mtriple=aarch64-none-linux-gnu -tailcallopt | FileCheck %s --check-prefixes=SDAG,COMMON
   2 ; RUN: llc -global-isel -global-isel-abort=1 -verify-machineinstrs < %s -mtriple=aarch64-none-linux-gnu -tailcallopt | FileCheck %s --check-prefixes=GISEL,COMMON
   3
   4 declare fastcc void @callee_stack0()
   5 declare fastcc void @callee_stack8([8 x i64], i64)
   6 declare fastcc void @callee_stack16([8 x i64], i64, i64)
   7 declare extern_weak fastcc void @callee_weak()
   8
   9 define fastcc void @caller_to0_from0() nounwind {
  10 ; COMMON-LABEL: caller_to0_from0:
  11 ; COMMON-NEXT: // %bb.
  12
  13   tail call fastcc void @callee_stack0()
  14   ret void
  15
  16 ; COMMON-NEXT: b callee_stack0
  17 }
  18
  19 define fastcc void @caller_to0_from8([8 x i64], i64) {
  20 ; COMMON-LABEL: caller_to0_from8:
  21
  22   tail call fastcc void @callee_stack0()
  23   ret void
  24
  25 ; COMMON: add sp, sp, #16
  26 ; COMMON-NEXT: b callee_stack0
  27 }
  28
  29 define fastcc void @caller_to8_from0() {
  30 ; COMMON-LABEL: caller_to8_from0:
  31 ; COMMON: sub sp, sp, #32
  32
  33 ; Key point is that the "42" should go #16 below incoming stack
  34 ; pointer (we didn't have arg space to reuse).
  35   tail call fastcc void @callee_stack8([8 x i64] undef, i64 42)
  36   ret void
  37
  38 ; COMMON: str {{x[0-9]+}}, [sp, #16]!
  39 ; COMMON-NEXT: b callee_stack8
  40 }
  41
  42 define fastcc void @caller_to8_from8([8 x i64], i64 %a) {
  43 ; COMMON-LABEL: caller_to8_from8:
  44 ; COMMON: sub sp, sp, #16
  45
  46 ; Key point is that the "%a" should go where at SP on entry.
  47   tail call fastcc void @callee_stack8([8 x i64] undef, i64 42)
  48   ret void
  49
  50 ; COMMON: str {{x[0-9]+}}, [sp, #16]!
  51 ; COMMON-NEXT: b callee_stack8
  52 }
  53
  54 define fastcc void @caller_to16_from8([8 x i64], i64 %a) {
  55 ; COMMON-LABEL: caller_to16_from8:
  56 ; COMMON: sub sp, sp, #16
  57
  58 ; Important point is that the call reuses the "dead" argument space
  59 ; above %a on the stack. If it tries to go below incoming-SP then the
  60 ; callee will not deallocate the space, even in fastcc.
  61   tail call fastcc void @callee_stack16([8 x i64] undef, i64 42, i64 2)
  62
  63 ; COMMON: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16]!
  64 ; COMMON-NEXT: b callee_stack16
  65   ret void
  66 }
  67
  68
  69 define fastcc void @caller_to8_from24([8 x i64], i64 %a, i64 %b, i64 %c) {
  70 ; COMMON-LABEL: caller_to8_from24:
  71 ; COMMON: 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 i64] undef, i64 42)
  75   ret void
  76
  77 ; COMMON: str {{x[0-9]+}}, [sp, #32]!
  78 ; COMMON-NEXT: b callee_stack8
  79 }
  80
  81
  82 define fastcc void @caller_to16_from16([8 x i64], i64 %a, i64 %b) {
  83 ; COMMON-LABEL: caller_to16_from16:
  84 ; COMMON: 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 i64] undef, i64 %b, i64 %a)
  89   ret void
  90
  91 ; COMMON: ldp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16]
  92 ; COMMON: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16]!
  93 ; COMMON-NEXT: b callee_stack16
  94 }
  95
  96
  97 ; Weakly-referenced extern functions cannot be tail-called, as AAELF does
  98 ; not define the behaviour of branch instructions to undefined weak symbols.
  99 define fastcc void @caller_weak() {
 100 ; COMMON-LABEL: caller_weak:
 101 ; COMMON: bl callee_weak
 102   tail call void @callee_weak()
 103   ret void
 104 }
 105
 106 declare { [2 x float] } @get_vec2()
 107
 108 define { [3 x float] } @test_add_elem() {
 109 ; SDAG-LABEL: test_add_elem:
 110 ; SDAG: bl get_vec2
 111 ; SDAG: fmov s2, #1.0
 112 ; SDAG: ret
 113 ; GISEL-LABEL: test_add_elem:
 114 ; GISEL: fmov   s8, #1.00000000
 115 ; GISEL: bl get_vec2
 116 ; GISEL: ldr    x30, [sp, #8]
 117 ; GISEL: mov    v2.16b, v8.16b
 118 ; GISEL: ldr    d8, [sp], #16
 119 ; GISEL: ret
 120
 121   %call = tail call { [2 x float] } @get_vec2()
 122   %arr = extractvalue { [2 x float] } %call, 0
 123   %arr.0 = extractvalue [2 x float] %arr, 0
 124   %arr.1 = extractvalue [2 x float] %arr, 1
 125
 126   %res.0 = insertvalue { [3 x float] } undef, float %arr.0, 0, 0
 127   %res.01 = insertvalue { [3 x float] } %res.0, float %arr.1, 0, 1
 128   %res.012 = insertvalue { [3 x float] } %res.01, float 1.000000e+00, 0, 2
 129   ret { [3 x float] } %res.012
 130 }
 131
 132 declare double @get_double()
 133 define { double, [2 x double] } @test_mismatched_insert() {
 134 ; COMMON-LABEL: test_mismatched_insert:
 135 ; COMMON: bl get_double
 136 ; COMMON: bl get_double
 137 ; COMMON: bl get_double
 138 ; COMMON: ret
 139
 140   %val0 = call double @get_double()
 141   %val1 = call double @get_double()
 142   %val2 = tail call double @get_double()
 143
 144   %res.0 = insertvalue { double, [2 x double] } undef, double %val0, 0
 145   %res.01 = insertvalue { double, [2 x double] } %res.0, double %val1, 1, 0
 146   %res.012 = insertvalue { double, [2 x double] } %res.01, double %val2, 1, 1
 147
 148   ret { double, [2 x double] } %res.012
 149 }