llvm/test/CodeGen/AArch64/swifttail-call.ll

   1 ; RUN: llc -verify-machineinstrs < %s -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=SDAG,COMMON
   2 ; RUN: llc -global-isel -global-isel-abort=1 -verify-machineinstrs < %s -mtriple=aarch64-none-linux-gnu  | FileCheck %s --check-prefixes=GISEL,COMMON
   3
   4 declare swifttailcc void @callee_stack0()
   5 declare swifttailcc void @callee_stack8([8 x i64], i64)
   6 declare swifttailcc void @callee_stack16([8 x i64], i64, i64)
   7 declare extern_weak swifttailcc void @callee_weak()
   8
   9 define swifttailcc void @caller_to0_from0() nounwind {
  10 ; COMMON-LABEL: caller_to0_from0:
  11 ; COMMON-NEXT: // %bb.
  12
  13   musttail call swifttailcc void @callee_stack0()
  14   ret void
  15
  16 ; COMMON-NEXT: b callee_stack0
  17 }
  18
  19 define swifttailcc void @caller_to0_from8([8 x i64], i64) {
  20 ; COMMON-LABEL: caller_to0_from8:
  21
  22   musttail call swifttailcc void @callee_stack0()
  23   ret void
  24
  25 ; COMMON: add sp, sp, #16
  26 ; COMMON-NEXT: b callee_stack0
  27 }
  28
  29 define swifttailcc void @caller_to8_from0() {
  30 ; COMMON-LABEL: caller_to8_from0:
  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   musttail call swifttailcc void @callee_stack8([8 x i64] undef, i64 42)
  35   ret void
  36
  37 ; COMMON: str {{x[0-9]+}}, [sp, #-16]!
  38 ; COMMON-NEXT: b callee_stack8
  39 }
  40
  41 define swifttailcc void @caller_to8_from8([8 x i64], i64 %a) {
  42 ; COMMON-LABEL: caller_to8_from8:
  43 ; COMMON-NOT: sub sp,
  44
  45 ; Key point is that the "%a" should go where at SP on entry.
  46   musttail call swifttailcc void @callee_stack8([8 x i64] undef, i64 42)
  47   ret void
  48
  49 ; COMMON: str {{x[0-9]+}}, [sp]
  50 ; COMMON-NEXT: b callee_stack8
  51 }
  52
  53 define swifttailcc void @caller_to16_from8([8 x i64], i64 %a) {
  54 ; COMMON-LABEL: caller_to16_from8:
  55 ; COMMON-NOT: sub sp,
  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 swifttailcc.
  60   musttail call swifttailcc void @callee_stack16([8 x i64] undef, i64 42, i64 2)
  61
  62 ; COMMON: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp]
  63 ; COMMON-NEXT: b callee_stack16
  64   ret void
  65 }
  66
  67
  68 define swifttailcc void @caller_to8_from24([8 x i64], i64 %a, i64 %b, i64 %c) {
  69 ; COMMON-LABEL: caller_to8_from24:
  70 ; COMMON-NOT: sub sp,
  71
  72 ; Key point is that the "%a" should go where at #16 above SP on entry.
  73   musttail call swifttailcc void @callee_stack8([8 x i64] undef, i64 42)
  74   ret void
  75
  76 ; COMMON: str {{x[0-9]+}}, [sp, #16]!
  77 ; COMMON-NEXT: b callee_stack8
  78 }
  79
  80
  81 define swifttailcc void @caller_to16_from16([8 x i64], i64 %a, i64 %b) {
  82 ; COMMON-LABEL: caller_to16_from16:
  83 ; COMMON-NOT: sub sp,
  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   musttail call swifttailcc void @callee_stack16([8 x i64] undef, i64 %b, i64 %a)
  88   ret void
  89
  90 ; COMMON: ldp {{x[0-9]+}}, {{x[0-9]+}}, [sp]
  91 ; COMMON: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp]
  92 ; COMMON-NEXT: b callee_stack16
  93 }
  94
  95 define swifttailcc void @disable_tail_calls() nounwind "disable-tail-calls"="true" {
  96 ; COMMON-LABEL: disable_tail_calls:
  97 ; COMMON-NEXT: // %bb.
  98
  99   tail call swifttailcc void @callee_stack0()
 100   ret void
 101
 102 ; COMMON: bl callee_stack0
 103 ; COMMON: ret
 104 }
 105
 106 ; Weakly-referenced extern functions cannot be tail-called, as AAELF does
 107 ; not define the behaviour of branch instructions to undefined weak symbols.
 108 define swifttailcc void @caller_weak() {
 109 ; COMMON-LABEL: caller_weak:
 110 ; COMMON: bl callee_weak
 111   tail call void @callee_weak()
 112   ret void
 113 }
 114
 115 declare { [2 x float] } @get_vec2()
 116
 117 define { [3 x float] } @test_add_elem() {
 118 ; SDAG-LABEL: test_add_elem:
 119 ; SDAG: bl get_vec2
 120 ; SDAG: fmov s2, #1.0
 121 ; SDAG: ret
 122 ; GISEL-LABEL: test_add_elem:
 123 ; GISEL: str    x30, [sp, #-16]!
 124 ; GISEL: bl get_vec2
 125 ; GISEL: fmov   s2, #1.0
 126 ; GISEL: ldr    x30, [sp], #16
 127 ; GISEL: ret
 128
 129   %call = tail call { [2 x float] } @get_vec2()
 130   %arr = extractvalue { [2 x float] } %call, 0
 131   %arr.0 = extractvalue [2 x float] %arr, 0
 132   %arr.1 = extractvalue [2 x float] %arr, 1
 133
 134   %res.0 = insertvalue { [3 x float] } undef, float %arr.0, 0, 0
 135   %res.01 = insertvalue { [3 x float] } %res.0, float %arr.1, 0, 1
 136   %res.012 = insertvalue { [3 x float] } %res.01, float 1.000000e+00, 0, 2
 137   ret { [3 x float] } %res.012
 138 }
 139
 140 declare double @get_double()
 141 define { double, [2 x double] } @test_mismatched_insert() {
 142 ; COMMON-LABEL: test_mismatched_insert:
 143 ; COMMON: bl get_double
 144 ; COMMON: bl get_double
 145 ; COMMON: bl get_double
 146 ; COMMON: ret
 147
 148   %val0 = call double @get_double()
 149   %val1 = call double @get_double()
 150   %val2 = tail call double @get_double()
 151
 152   %res.0 = insertvalue { double, [2 x double] } undef, double %val0, 0
 153   %res.01 = insertvalue { double, [2 x double] } %res.0, double %val1, 1, 0
 154   %res.012 = insertvalue { double, [2 x double] } %res.01, double %val2, 1, 1
 155
 156   ret { double, [2 x double] } %res.012
 157 }
 158
 159 define void @fromC_totail() {
 160 ; COMMON-LABEL: fromC_totail:
 161 ; COMMON: sub sp, sp, #48
 162
 163 ; COMMON-NOT: sub sp,
 164 ; COMMON: mov w[[TMP:[0-9]+]], #42
 165 ; COMMON: str x[[TMP]], [sp]
 166 ; COMMON: bl callee_stack8
 167   ; We must reset the stack to where it was before the call by undoing its extra stack pop.
 168 ; COMMON: str x[[TMP]], [sp, #-16]!
 169 ; COMMON: bl callee_stack8
 170 ; COMMON: sub sp, sp, #16
 171
 172   call swifttailcc void @callee_stack8([8 x i64] undef, i64 42)
 173   call swifttailcc void @callee_stack8([8 x i64] undef, i64 42)
 174   ret void
 175 }
 176
 177 define void @fromC_totail_noreservedframe(i32 %len) {
 178 ; COMMON-LABEL: fromC_totail_noreservedframe:
 179 ; COMMON: stp x29, x30, [sp, #-48]!
 180
 181 ; COMMON: mov w[[TMP:[0-9]+]], #42
 182   ; Note stack is subtracted here to allocate space for arg
 183 ; COMMON: str x[[TMP]], [sp, #-16]!
 184 ; COMMON: bl callee_stack8
 185   ; And here.
 186 ; COMMON: str x[[TMP]], [sp, #-16]!
 187 ; COMMON: bl callee_stack8
 188   ; But not restored here because callee_stack8 did that for us.
 189 ; COMMON-NOT: sub sp,
 190
 191   ; Variable sized allocation prevents reserving frame at start of function so each call must allocate any stack space it needs.
 192   %var = alloca i32, i32 %len
 193
 194   call swifttailcc void @callee_stack8([8 x i64] undef, i64 42)
 195   call swifttailcc void @callee_stack8([8 x i64] undef, i64 42)
 196   ret void
 197 }
 198
 199 declare void @Ccallee_stack8([8 x i64], i64)
 200
 201 define swifttailcc void @fromtail_toC() {
 202 ; COMMON-LABEL: fromtail_toC:
 203 ; COMMON: sub sp, sp, #32
 204
 205 ; COMMON-NOT: sub sp,
 206 ; COMMON: mov w[[TMP:[0-9]+]], #42
 207 ; COMMON: str x[[TMP]], [sp]
 208 ; COMMON: bl Ccallee_stack8
 209   ; C callees will return with the stack exactly where we left it, so we mustn't try to fix anything.
 210 ; COMMON-NOT: add sp,
 211 ; COMMON-NOT: sub sp,
 212 ; COMMON: str x[[TMP]], [sp]{{$}}
 213 ; COMMON: bl Ccallee_stack8
 214 ; COMMON-NOT: sub sp,
 215
 216
 217   call void @Ccallee_stack8([8 x i64] undef, i64 42)
 218   call void @Ccallee_stack8([8 x i64] undef, i64 42)
 219   ret void
 220 }
 221
 222 declare swifttailcc i8* @SwiftSelf(i8 * swiftasync %context, i8* swiftself %closure)
 223 define swiftcc i8* @CallSwiftSelf(i8* swiftself %closure, i8* %context) {
 224 ; CHECK-LABEL: CallSwiftSelf:
 225 ; CHECK: stp x20
 226   ;call void asm "","~{r13}"() ; We get a push r13 but why not with the call
 227   ; below?
 228   %res = call swifttailcc i8* @SwiftSelf(i8 * swiftasync %context, i8* swiftself %closure)
 229   ret i8* %res
 230 }