test/CodeGen/AArch64/GlobalISel/swifterror.ll

   1 ; RUN: llc -verify-machineinstrs -frame-pointer=all -global-isel < %s -mtriple=aarch64-apple-ios -disable-post-ra | FileCheck %s
   2
   3 declare i8* @malloc(i64)
   4 declare void @free(i8*)
   5 %swift_error = type {i64, i8}
   6
   7 ; This tests the basic usage of a swifterror parameter. "foo" is the function
   8 ; that takes a swifterror parameter and "caller" is the caller of "foo".
   9 define float @foo(%swift_error** swifterror %error_ptr_ref) {
  10 ; CHECK-LABEL: foo:
  11 ; CHECK: mov [[ID:w[0-9]+]], #1
  12 ; CHECK: mov w0, #16
  13 ; CHECK: malloc
  14 ; CHECK: strb [[ID]], [x0, #8]
  15 ; CHECK: mov x21, x0
  16 ; CHECK-NOT: x21
  17
  18 entry:
  19   %call = call i8* @malloc(i64 16)
  20   %call.0 = bitcast i8* %call to %swift_error*
  21   store %swift_error* %call.0, %swift_error** %error_ptr_ref
  22   %tmp = getelementptr inbounds i8, i8* %call, i64 8
  23   store i8 1, i8* %tmp
  24   ret float 1.0
  25 }
  26
  27 ; "caller" calls "foo" that takes a swifterror parameter.
  28 define float @caller(i8* %error_ref) {
  29 ; CHECK-LABEL: caller:
  30 ; CHECK: mov [[ID:x[0-9]+]], x0
  31 ; CHECK: bl {{.*}}foo
  32 ; CHECK: mov x0, x21
  33 ; CHECK: cbnz x21
  34 ; Access part of the error object and save it to error_ref
  35 ; CHECK: ldrb [[CODE:w[0-9]+]], [x0, #8]
  36 ; CHECK: strb [[CODE]], [{{.*}}[[ID]]]
  37 ; CHECK: bl {{.*}}free
  38
  39 entry:
  40   %error_ptr_ref = alloca swifterror %swift_error*
  41   store %swift_error* null, %swift_error** %error_ptr_ref
  42   %call = call float @foo(%swift_error** swifterror %error_ptr_ref)
  43   %error_from_foo = load %swift_error*, %swift_error** %error_ptr_ref
  44   %had_error_from_foo = icmp ne %swift_error* %error_from_foo, null
  45   %tmp = bitcast %swift_error* %error_from_foo to i8*
  46   br i1 %had_error_from_foo, label %handler, label %cont
  47 cont:
  48   %v1 = getelementptr inbounds %swift_error, %swift_error* %error_from_foo, i64 0, i32 1
  49   %t = load i8, i8* %v1
  50   store i8 %t, i8* %error_ref
  51   br label %handler
  52 handler:
  53   call void @free(i8* %tmp)
  54   ret float 1.0
  55 }
  56
  57 ; "caller2" is the caller of "foo", it calls "foo" inside a loop.
  58 define float @caller2(i8* %error_ref) {
  59 ; CHECK-LABEL: caller2:
  60 ; CHECK: mov [[ID:x[0-9]+]], x0
  61 ; CHECK: fmov [[CMP:s[0-9]+]], #1.0
  62 ; CHECK: mov x21, xzr
  63 ; CHECK: bl {{.*}}foo
  64 ; CHECK: cbnz x21
  65 ; CHECK: fcmp s0, [[CMP]]
  66 ; CHECK: b.le
  67 ; Access part of the error object and save it to error_ref
  68 ; CHECK: ldrb [[CODE:w[0-9]+]], [x21, #8]
  69 ; CHECK: strb [[CODE]], [{{.*}}[[ID]]]
  70 ; CHECK: mov x0, x21
  71 ; CHECK: bl {{.*}}free
  72
  73 entry:
  74   %error_ptr_ref = alloca swifterror %swift_error*
  75   br label %bb_loop
  76 bb_loop:
  77   store %swift_error* null, %swift_error** %error_ptr_ref
  78   %call = call float @foo(%swift_error** swifterror %error_ptr_ref)
  79   %error_from_foo = load %swift_error*, %swift_error** %error_ptr_ref
  80   %had_error_from_foo = icmp ne %swift_error* %error_from_foo, null
  81   %tmp = bitcast %swift_error* %error_from_foo to i8*
  82   br i1 %had_error_from_foo, label %handler, label %cont
  83 cont:
  84   %cmp = fcmp ogt float %call, 1.000000e+00
  85   br i1 %cmp, label %bb_end, label %bb_loop
  86 bb_end:
  87   %v1 = getelementptr inbounds %swift_error, %swift_error* %error_from_foo, i64 0, i32 1
  88   %t = load i8, i8* %v1
  89   store i8 %t, i8* %error_ref
  90   br label %handler
  91 handler:
  92   call void @free(i8* %tmp)
  93   ret float 1.0
  94 }
  95
  96 ; "foo_if" is a function that takes a swifterror parameter, it sets swifterror
  97 ; under a certain condition.
  98 define float @foo_if(%swift_error** swifterror %error_ptr_ref, i32 %cc) {
  99 ; CHECK-LABEL: foo_if:
 100 ; CHECK: cbz w0
 101 ; CHECK: mov w0, #16
 102 ; CHECK: malloc
 103 ; CHECK: mov [[ID:w[0-9]+]], #1
 104 ; CHECK: strb [[ID]], [x0, #8]
 105 ; CHECK: mov x21, x0
 106 ; CHECK-NOT: x21
 107 ; CHECK: ret
 108
 109 entry:
 110   %cond = icmp ne i32 %cc, 0
 111   br i1 %cond, label %gen_error, label %normal
 112
 113 gen_error:
 114   %call = call i8* @malloc(i64 16)
 115   %call.0 = bitcast i8* %call to %swift_error*
 116   store %swift_error* %call.0, %swift_error** %error_ptr_ref
 117   %tmp = getelementptr inbounds i8, i8* %call, i64 8
 118   store i8 1, i8* %tmp
 119   ret float 1.0
 120
 121 normal:
 122   ret float 0.0
 123 }
 124
 125 ; "foo_loop" is a function that takes a swifterror parameter, it sets swifterror
 126 ; under a certain condition inside a loop.
 127 define float @foo_loop(%swift_error** swifterror %error_ptr_ref, i32 %cc, float %cc2) {
 128 ; CHECK-LABEL: foo_loop:
 129 ; CHECK: cbz
 130 ; CHECK: mov w0, #16
 131 ; CHECK: malloc
 132 ; CHECK: mov x21, x0
 133 ; CHECK: strb w{{.*}}, [x0, #8]
 134 ; CHECK: fcmp
 135 ; CHECK: b.le
 136 ; CHECK: ret
 137
 138 entry:
 139   br label %bb_loop
 140
 141 bb_loop:
 142   %cond = icmp ne i32 %cc, 0
 143   br i1 %cond, label %gen_error, label %bb_cont
 144
 145 gen_error:
 146   %call = call i8* @malloc(i64 16)
 147   %call.0 = bitcast i8* %call to %swift_error*
 148   store %swift_error* %call.0, %swift_error** %error_ptr_ref
 149   %tmp = getelementptr inbounds i8, i8* %call, i64 8
 150   store i8 1, i8* %tmp
 151   br label %bb_cont
 152
 153 bb_cont:
 154   %cmp = fcmp ogt float %cc2, 1.000000e+00
 155   br i1 %cmp, label %bb_end, label %bb_loop
 156 bb_end:
 157   ret float 0.0
 158 }
 159
 160 %struct.S = type { i32, i32, i32, i32, i32, i32 }
 161
 162 ; "foo_sret" is a function that takes a swifterror parameter, it also has a sret
 163 ; parameter.
 164 define void @foo_sret(%struct.S* sret %agg.result, i32 %val1, %swift_error** swifterror %error_ptr_ref) {
 165 ; CHECK-LABEL: foo_sret:
 166 ; CHECK: mov [[SRET:x[0-9]+]], x8
 167 ; CHECK: mov [[ID:w[0-9]+]], #1
 168 ; CHECK: mov w0, #16
 169 ; CHECK: malloc
 170 ; CHECK: strb [[ID]], [x0, #8]
 171 ; CHECK: str w{{.*}}, [{{.*}}[[SRET]], #4]
 172 ; CHECK: mov x21, x0
 173 ; CHECK-NOT: x21
 174
 175 entry:
 176   %call = call i8* @malloc(i64 16)
 177   %call.0 = bitcast i8* %call to %swift_error*
 178   store %swift_error* %call.0, %swift_error** %error_ptr_ref
 179   %tmp = getelementptr inbounds i8, i8* %call, i64 8
 180   store i8 1, i8* %tmp
 181   %v2 = getelementptr inbounds %struct.S, %struct.S* %agg.result, i32 0, i32 1
 182   store i32 %val1, i32* %v2
 183   ret void
 184 }
 185
 186 ; "caller3" calls "foo_sret" that takes a swifterror parameter.
 187 define float @caller3(i8* %error_ref) {
 188 ; CHECK-LABEL: caller3:
 189 ; CHECK: mov [[ID:x[0-9]+]], x0
 190 ; CHECK: mov [[ZERO:x[0-9]+]], xzr
 191 ; CHECK: bl {{.*}}foo_sret
 192 ; CHECK: mov x0, x21
 193 ; CHECK: cbnz x21
 194 ; Access part of the error object and save it to error_ref
 195 ; CHECK: ldrb [[CODE:w[0-9]+]], [x0, #8]
 196 ; CHECK: strb [[CODE]], [{{.*}}[[ID]]]
 197 ; CHECK: bl {{.*}}free
 198
 199 entry:
 200   %s = alloca %struct.S, align 8
 201   %error_ptr_ref = alloca swifterror %swift_error*
 202   store %swift_error* null, %swift_error** %error_ptr_ref
 203   call void @foo_sret(%struct.S* sret %s, i32 1, %swift_error** swifterror %error_ptr_ref)
 204   %error_from_foo = load %swift_error*, %swift_error** %error_ptr_ref
 205   %had_error_from_foo = icmp ne %swift_error* %error_from_foo, null
 206   %tmp = bitcast %swift_error* %error_from_foo to i8*
 207   br i1 %had_error_from_foo, label %handler, label %cont
 208 cont:
 209   %v1 = getelementptr inbounds %swift_error, %swift_error* %error_from_foo, i64 0, i32 1
 210   %t = load i8, i8* %v1
 211   store i8 %t, i8* %error_ref
 212   br label %handler
 213 handler:
 214   call void @free(i8* %tmp)
 215   ret float 1.0
 216 }
 217
 218 ; "foo_vararg" is a function that takes a swifterror parameter, it also has
 219 ; variable number of arguments.
 220 declare void @llvm.va_start(i8*) nounwind
 221 define float @foo_vararg(%swift_error** swifterror %error_ptr_ref, ...) {
 222 ; CHECK-LABEL: foo_vararg:
 223 ; CHECK-DAG: mov [[ID:w[0-9]+]], #1
 224 ; CHECK: mov w0, #16
 225 ; CHECK: malloc
 226 ; CHECK-DAG: strb [[ID]], [x0, #8]
 227
 228 ; First vararg
 229 ; CHECK: ldr {{w[0-9]+}}, [x[[ARG1:[0-9]+]]], #8
 230 ; Second vararg
 231 ; CHECK: ldr {{w[0-9]+}}, [x[[ARG1]]], #8
 232 ; Third vararg
 233 ; CHECK: ldr {{w[0-9]+}}, [x[[ARG1]]], #8
 234
 235 ; CHECK: mov x21, x0
 236 ; CHECK-NOT: x21
 237 entry:
 238   %call = call i8* @malloc(i64 16)
 239   %call.0 = bitcast i8* %call to %swift_error*
 240   store %swift_error* %call.0, %swift_error** %error_ptr_ref
 241   %tmp = getelementptr inbounds i8, i8* %call, i64 8
 242   store i8 1, i8* %tmp
 243
 244   %args = alloca i8*, align 8
 245   %a10 = alloca i32, align 4
 246   %a11 = alloca i32, align 4
 247   %a12 = alloca i32, align 4
 248   %v10 = bitcast i8** %args to i8*
 249   call void @llvm.va_start(i8* %v10)
 250   %v11 = va_arg i8** %args, i32
 251   store i32 %v11, i32* %a10, align 4
 252   %v12 = va_arg i8** %args, i32
 253   store i32 %v12, i32* %a11, align 4
 254   %v13 = va_arg i8** %args, i32
 255   store i32 %v13, i32* %a12, align 4
 256
 257   ret float 1.0
 258 }
 259
 260 ; "caller4" calls "foo_vararg" that takes a swifterror parameter.
 261 define float @caller4(i8* %error_ref) {
 262 ; CHECK-LABEL: caller4:
 263
 264 ; CHECK: mov [[ID:x[0-9]+]], x0
 265 ; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp]
 266 ; CHECK: str {{x[0-9]+}}, [sp, #16]
 267 ; CHECK: mov x21, xzr
 268
 269 ; CHECK: bl {{.*}}foo_vararg
 270 ; CHECK: mov x0, x21
 271 ; CHECK: cbnz x21
 272 ; Access part of the error object and save it to error_ref
 273 ; CHECK: ldrb [[CODE:w[0-9]+]], [x0, #8]
 274 ; CHECK: strb [[CODE]], [{{.*}}[[ID]]]
 275 ; CHECK: bl {{.*}}free
 276 entry:
 277   %error_ptr_ref = alloca swifterror %swift_error*
 278   store %swift_error* null, %swift_error** %error_ptr_ref
 279
 280   %a10 = alloca i32, align 4
 281   %a11 = alloca i32, align 4
 282   %a12 = alloca i32, align 4
 283   store i32 10, i32* %a10, align 4
 284   store i32 11, i32* %a11, align 4
 285   store i32 12, i32* %a12, align 4
 286   %v10 = load i32, i32* %a10, align 4
 287   %v11 = load i32, i32* %a11, align 4
 288   %v12 = load i32, i32* %a12, align 4
 289
 290   %call = call float (%swift_error**, ...) @foo_vararg(%swift_error** swifterror %error_ptr_ref, i32 %v10, i32 %v11, i32 %v12)
 291   %error_from_foo = load %swift_error*, %swift_error** %error_ptr_ref
 292   %had_error_from_foo = icmp ne %swift_error* %error_from_foo, null
 293   %tmp = bitcast %swift_error* %error_from_foo to i8*
 294   br i1 %had_error_from_foo, label %handler, label %cont
 295
 296 cont:
 297   %v1 = getelementptr inbounds %swift_error, %swift_error* %error_from_foo, i64 0, i32 1
 298   %t = load i8, i8* %v1
 299   store i8 %t, i8* %error_ref
 300   br label %handler
 301 handler:
 302   call void @free(i8* %tmp)
 303   ret float 1.0
 304 }
 305
 306 ; Check that we don't blow up on tail calling swifterror argument functions.
 307 define float @tailcallswifterror(%swift_error** swifterror %error_ptr_ref) {
 308 entry:
 309   %0 = tail call float @tailcallswifterror(%swift_error** swifterror %error_ptr_ref)
 310   ret float %0
 311 }
 312 define swiftcc float @tailcallswifterror_swiftcc(%swift_error** swifterror %error_ptr_ref) {
 313 entry:
 314   %0 = tail call swiftcc float @tailcallswifterror_swiftcc(%swift_error** swifterror %error_ptr_ref)
 315   ret float %0
 316 }
 317
 318 ; CHECK-LABEL: params_in_reg
 319 ; Save callee saved registers and swifterror since it will be clobbered by the first call to params_in_reg2.
 320 ; CHECK:  stp     x28, x0, [sp
 321 ; CHECK:  stp     x27, x26, [sp
 322 ; CHECK:  stp     x25, x24, [sp
 323 ; CHECK:  stp     x23, x22, [sp
 324 ; CHECK:  stp     x20, x19, [sp
 325 ; CHECK:  stp     x29, x30, [sp
 326 ; Store argument registers.
 327 ; CHECK:  mov      x20, x1
 328 ; CHECK:  mov      x22, x2
 329 ; CHECK:  mov      x23, x3
 330 ; CHECK:  mov      x24, x4
 331 ; CHECK:  mov      x25, x5
 332 ; CHECK:  mov      x26, x6
 333 ; CHECK:  mov      x27, x7
 334 ; CHECK:  mov      x28, x21
 335 ; Setup call.
 336 ; CHECK:  mov     w0, #1
 337 ; CHECK:  mov     w1, #2
 338 ; CHECK:  mov     w2, #3
 339 ; CHECK:  mov     w3, #4
 340 ; CHECK:  mov     w4, #5
 341 ; CHECK:  mov     w5, #6
 342 ; CHECK:  mov     w6, #7
 343 ; CHECK:  mov     w7, #8
 344 ; CHECK:  str     xzr, [sp]
 345 ; CHECK:  mov      x21, xzr
 346 ; CHECK:  bl      _params_in_reg2
 347 ; Restore original arguments for next call.
 348 ; CHECK:  ldr      x0, [sp
 349 ; CHECK:  mov      x1, x20
 350 ; CHECK:  mov      x2, x22
 351 ; CHECK:  mov      x3, x23
 352 ; CHECK:  mov      x4, x24
 353 ; CHECK:  mov      x5, x25
 354 ; CHECK:  mov      x6, x26
 355 ; CHECK:  mov      x7, x27
 356 ; Restore original swiftself argument and swifterror %err.
 357 ; CHECK:  mov      x21, x28
 358 ; CHECK:  bl      _params_in_reg2
 359 ; Restore calle save registers but don't clober swifterror x21.
 360 ; CHECK-NOT: x21
 361 ; CHECK:  ldp     x29, x30, [sp
 362 ; CHECK-NOT: x21
 363 ; CHECK:  ldp     x20, x19, [sp
 364 ; CHECK-NOT: x21
 365 ; CHECK:  ldp     x23, x22, [sp
 366 ; CHECK-NOT: x21
 367 ; CHECK:  ldp     x25, x24, [sp
 368 ; CHECK-NOT: x21
 369 ; CHECK:  ldp     x27, x26, [sp
 370 ; CHECK-NOT: x21
 371 ; CHECK:  ldr     x28, [sp
 372 ; CHECK-NOT: x21
 373 ; CHECK:  ret
 374 define swiftcc void @params_in_reg(i64, i64, i64, i64, i64, i64, i64, i64, i8*, %swift_error** nocapture swifterror %err) {
 375   %error_ptr_ref = alloca swifterror %swift_error*, align 8
 376   store %swift_error* null, %swift_error** %error_ptr_ref
 377   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i8*  null, %swift_error** nocapture swifterror %error_ptr_ref)
 378   call swiftcc void @params_in_reg2(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, i8*  %8, %swift_error** nocapture swifterror %err)
 379   ret void
 380 }
 381 declare swiftcc void @params_in_reg2(i64, i64, i64, i64, i64, i64, i64, i64, i8* , %swift_error** nocapture swifterror %err)
 382
 383 ; CHECK-LABEL: params_and_return_in_reg
 384 ; Store callee saved registers.
 385 ; CHECK:  stp     x28, x0, [sp, #16
 386 ; CHECK:  stp     x27, x26, [sp
 387 ; CHECK:  stp     x25, x24, [sp
 388 ; CHECK:  stp     x23, x22, [sp
 389 ; CHECK:  stp     x20, x19, [sp
 390 ; CHECK:  stp     x29, x30, [sp
 391 ; Save original arguments.
 392 ; CHECK:  mov      x20, x1
 393 ; CHECK:  mov      x22, x2
 394 ; CHECK:  mov      x23, x3
 395 ; CHECK:  mov      x24, x4
 396 ; CHECK:  mov      x25, x5
 397 ; CHECK:  mov      x26, x6
 398 ; CHECK:  mov      x27, x7
 399 ; CHECK:  mov      x28, x21
 400 ; Setup call arguments.
 401 ; CHECK:  mov     w0, #1
 402 ; CHECK:  mov     w1, #2
 403 ; CHECK:  mov     w2, #3
 404 ; CHECK:  mov     w3, #4
 405 ; CHECK:  mov     w4, #5
 406 ; CHECK:  mov     w5, #6
 407 ; CHECK:  mov     w6, #7
 408 ; CHECK:  mov     w7, #8
 409 ; CHECK:  mov      x21, xzr
 410 ; CHECK:  bl      _params_in_reg2
 411 ; Store swifterror %error_ptr_ref.
 412 ; CHECK:  stp     {{x[0-9]+}}, x21, [sp]
 413 ; Setup call arguments from original arguments.
 414 ; CHECK:  ldr      x0, [sp, #24
 415 ; CHECK:  mov      x1, x20
 416 ; CHECK:  mov      x2, x22
 417 ; CHECK:  mov      x3, x23
 418 ; CHECK:  mov      x4, x24
 419 ; CHECK:  mov      x5, x25
 420 ; CHECK:  mov      x6, x26
 421 ; CHECK:  mov      x7, x27
 422 ; CHECK:  mov      x21, x28
 423 ; CHECK:  bl      _params_and_return_in_reg2
 424 ; Store return values.
 425 ; CHECK:  mov      x20, x0
 426 ; CHECK:  mov      x22, x1
 427 ; CHECK:  mov      x23, x2
 428 ; CHECK:  mov      x24, x3
 429 ; CHECK:  mov      x25, x4
 430 ; CHECK:  mov      x26, x5
 431 ; CHECK:  mov      x27, x6
 432 ; CHECK:  mov      x28, x7
 433 ; Save swifterror %err.
 434 ; CHECK:  mov      x19, x21
 435 ; Setup call.
 436 ; CHECK:  mov     w0, #1
 437 ; CHECK:  mov     w1, #2
 438 ; CHECK:  mov     w2, #3
 439 ; CHECK:  mov     w3, #4
 440 ; CHECK:  mov     w4, #5
 441 ; CHECK:  mov     w5, #6
 442 ; CHECK:  mov     w6, #7
 443 ; CHECK:  mov     w7, #8
 444 ; ... setup call with swiferror %error_ptr_ref.
 445 ; CHECK:  ldr     x21, [sp, #8]
 446 ; CHECK:  bl      _params_in_reg2
 447 ; Restore return values for return from this function.
 448 ; CHECK:  mov      x0, x20
 449 ; CHECK:  mov      x1, x22
 450 ; CHECK:  mov      x2, x23
 451 ; CHECK:  mov      x3, x24
 452 ; CHECK:  mov      x4, x25
 453 ; CHECK:  mov      x5, x26
 454 ; CHECK:  mov      x6, x27
 455 ; CHECK:  mov      x7, x28
 456 ; CHECK:  mov      x21, x19
 457 ; Restore callee save registers.
 458 ; CHECK:  ldp     x29, x30, [sp
 459 ; CHECK:  ldp     x20, x19, [sp
 460 ; CHECK:  ldp     x23, x22, [sp
 461 ; CHECK:  ldp     x25, x24, [sp
 462 ; CHECK:  ldp     x27, x26, [sp
 463 ; CHECK:  ldr     x28, [sp
 464 ; CHECK:  ret
 465 define swiftcc { i64, i64, i64, i64, i64, i64, i64, i64 } @params_and_return_in_reg(i64, i64, i64, i64, i64, i64, i64, i64, i8* , %swift_error** nocapture swifterror %err) {
 466   %error_ptr_ref = alloca swifterror %swift_error*, align 8
 467   store %swift_error* null, %swift_error** %error_ptr_ref
 468   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i8*  null, %swift_error** nocapture swifterror %error_ptr_ref)
 469   %val = call swiftcc  { i64, i64, i64, i64, i64, i64, i64, i64 } @params_and_return_in_reg2(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, i8*  %8, %swift_error** nocapture swifterror %err)
 470   call swiftcc void @params_in_reg2(i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i8*  null, %swift_error** nocapture swifterror %error_ptr_ref)
 471   ret { i64, i64, i64, i64, i64, i64, i64, i64 } %val
 472 }
 473
 474 declare swiftcc { i64, i64, i64, i64, i64, i64, i64, i64 } @params_and_return_in_reg2(i64, i64, i64, i64, i64, i64, i64, i64, i8* , %swift_error** nocapture swifterror %err)
 475
 476 declare void @acallee(i8*)
 477
 478 ; Make sure we don't tail call if the caller returns a swifterror value. We
 479 ; would have to move into the swifterror register before the tail call.
 480 ; CHECK: tailcall_from_swifterror:
 481 ; CHECK-NOT: b _acallee
 482 ; CHECK: bl _acallee
 483
 484 define swiftcc void @tailcall_from_swifterror(%swift_error** swifterror %error_ptr_ref) {
 485 entry:
 486   tail call void @acallee(i8* null)
 487   ret void
 488 }
 489
 490 ; CHECK: tailcall_from_swifterror2
 491 ; CHECK-NOT: b _simple_fn
 492 ; CHECK: bl _simple_fn
 493 declare void @simple_fn()
 494 define swiftcc void @tailcall_from_swifterror2(%swift_error** swifterror %error_ptr_ref) {
 495   tail call void @simple_fn()
 496   ret void
 497 }
 498
 499 declare swiftcc void @foo2(%swift_error** swifterror)
 500 ; CHECK-LABEL: testAssign
 501 ; CHECK: mov      x21, xzr
 502 ; CHECK: bl      _foo2
 503 ; CHECK: mov      x0, x21
 504
 505 define swiftcc %swift_error* @testAssign(i8* %error_ref) {
 506 entry:
 507   %error_ptr = alloca swifterror %swift_error*
 508   store %swift_error* null, %swift_error** %error_ptr
 509   call swiftcc void @foo2(%swift_error** swifterror %error_ptr)
 510   br label %a
 511
 512 a:
 513   %error = load %swift_error*, %swift_error** %error_ptr
 514   ret %swift_error* %error
 515 }