test/CodeGen/ARM/swifterror.ll

   1 ; RUN: llc -verify-machineinstrs < %s -mtriple=armv7-apple-ios | FileCheck --check-prefix=CHECK-APPLE --check-prefix=CHECK-ARMV7 %s
   2 ; RUN: llc -verify-machineinstrs -O0 < %s -mtriple=armv7-apple-ios | FileCheck --check-prefix=CHECK-O0 %s
   3 ; RUN: llc -verify-machineinstrs < %s -mtriple=armv7-linux-androideabi | FileCheck --check-prefix=CHECK-ANDROID %s
   4
   5 declare i8* @malloc(i64)
   6 declare void @free(i8*)
   7 %swift_error = type { i64, i8 }
   8 %struct.S = type { i32, i32, i32, i32, i32, i32 }
   9
  10 ; This tests the basic usage of a swifterror parameter. "foo" is the function
  11 ; that takes a swifterror parameter and "caller" is the caller of "foo".
  12 define float @foo(%swift_error** swifterror %error_ptr_ref) {
  13 ; CHECK-APPLE-LABEL: foo:
  14 ; CHECK-APPLE: mov r0, #16
  15 ; CHECK-APPLE: malloc
  16 ; CHECK-APPLE-DAG: mov [[ID:r[0-9]+]], #1
  17 ; CHECK-APPLE-DAG: mov r8, r{{.*}}
  18 ; CHECK-APPLE-DAG: strb [[ID]], [r{{.*}}, #8]
  19
  20 ; CHECK-O0-LABEL: foo:
  21 ; CHECK-O0: mov r{{.*}}, #16
  22 ; CHECK-O0: malloc
  23 ; CHECK-O0: mov [[ID2:r[0-9]+]], r0
  24 ; CHECK-O0: mov [[ID:r[0-9]+]], #1
  25 ; CHECK-O0: strb [[ID]], [r0, #8]
  26 ; CHECK-O0: mov r8, [[ID2]]
  27 entry:
  28   %call = call i8* @malloc(i64 16)
  29   %call.0 = bitcast i8* %call to %swift_error*
  30   store %swift_error* %call.0, %swift_error** %error_ptr_ref
  31   %tmp = getelementptr inbounds i8, i8* %call, i64 8
  32   store i8 1, i8* %tmp
  33   ret float 1.0
  34 }
  35
  36 ; "caller" calls "foo" that takes a swifterror parameter.
  37 define float @caller(i8* %error_ref) {
  38 ; CHECK-APPLE-LABEL: caller:
  39 ; CHECK-APPLE-DAG: mov [[ID:r[0-9]+]], r0
  40 ; CHECK-APPLE-DAG: mov r8, #0
  41 ; CHECK-APPLE: bl {{.*}}foo
  42 ; CHECK-APPLE: cmp r8, #0
  43 ; Access part of the error object and save it to error_ref
  44 ; CHECK-APPLE: ldrbeq [[CODE:r[0-9]+]], [r8, #8]
  45 ; CHECK-APPLE: strbeq [[CODE]], [{{.*}}[[ID]]]
  46 ; CHECK-APPLE: mov r0, r8
  47 ; CHECK-APPLE: bl {{.*}}free
  48
  49 ; CHECK-O0-LABEL: caller:
  50 ; spill r0
  51 ; CHECK-O0-DAG: mov r8, #0
  52 ; CHECK-O0-DAG: str r0, [sp, [[SLOT:#[0-9]+]]
  53 ; CHECK-O0: bl {{.*}}foo
  54 ; CHECK-O0: mov [[TMP:r[0-9]+]], r8
  55 ; CHECK-O0: str [[TMP]], [sp]
  56 ; CHECK-O0: bne
  57 ; CHECK-O0: ldrb [[CODE:r[0-9]+]], [r0, #8]
  58 ; CHECK-O0: ldr     [[ID:r[0-9]+]], [sp, [[SLOT]]]
  59 ; CHECK-O0: strb [[CODE]], [{{.*}}[[ID]]]
  60 ; reload r0
  61 ; CHECK-O0: ldr r0, [sp]
  62 ; CHECK-O0: free
  63 entry:
  64   %error_ptr_ref = alloca swifterror %swift_error*
  65   store %swift_error* null, %swift_error** %error_ptr_ref
  66   %call = call float @foo(%swift_error** swifterror %error_ptr_ref)
  67   %error_from_foo = load %swift_error*, %swift_error** %error_ptr_ref
  68   %had_error_from_foo = icmp ne %swift_error* %error_from_foo, null
  69   %tmp = bitcast %swift_error* %error_from_foo to i8*
  70   br i1 %had_error_from_foo, label %handler, label %cont
  71 cont:
  72   %v1 = getelementptr inbounds %swift_error, %swift_error* %error_from_foo, i64 0, i32 1
  73   %t = load i8, i8* %v1
  74   store i8 %t, i8* %error_ref
  75   br label %handler
  76 handler:
  77   call void @free(i8* %tmp)
  78   ret float 1.0
  79 }
  80
  81 ; "caller2" is the caller of "foo", it calls "foo" inside a loop.
  82 define float @caller2(i8* %error_ref) {
  83 ; CHECK-APPLE-LABEL: caller2:
  84 ; CHECK-APPLE-DAG: mov [[ID:r[0-9]+]], r0
  85 ; CHECK-APPLE-DAG: mov r8, #0
  86 ; CHECK-APPLE: bl {{.*}}foo
  87 ; CHECK-APPLE: cmp r8, #0
  88 ; CHECK-APPLE: bne
  89 ; Access part of the error object and save it to error_ref
  90 ; CHECK-APPLE: ldrb [[CODE:r[0-9]+]], [r8, #8]
  91 ; CHECK-APPLE: strb [[CODE]], [{{.*}}[[ID]]]
  92 ; CHECK-APPLE: mov r0, r8
  93 ; CHECK-APPLE: bl {{.*}}free
  94
  95 ; CHECK-O0-LABEL: caller2:
  96 ; spill r0
  97 ; CHECK-O0-DAG: str r0,
  98 ; CHECK-O0-DAG: mov r8, #0
  99 ; CHECK-O0: bl {{.*}}foo
 100 ; CHECK-O0: mov r{{.*}}, r8
 101 ; CHECK-O0: str r0, [sp]
 102 ; CHECK-O0: bne
 103 ; CHECK-O0: ble
 104 ; CHECK-O0: ldrb [[CODE:r[0-9]+]], [r0, #8]
 105 ; reload r0
 106 ; CHECK-O0: ldr [[ID:r[0-9]+]],
 107 ; CHECK-O0: strb [[CODE]], [{{.*}}[[ID]]]
 108 ; CHECK-O0: ldr r0, [sp]
 109 ; CHECK-O0: free
 110 entry:
 111   %error_ptr_ref = alloca swifterror %swift_error*
 112   br label %bb_loop
 113 bb_loop:
 114   store %swift_error* null, %swift_error** %error_ptr_ref
 115   %call = call float @foo(%swift_error** swifterror %error_ptr_ref)
 116   %error_from_foo = load %swift_error*, %swift_error** %error_ptr_ref
 117   %had_error_from_foo = icmp ne %swift_error* %error_from_foo, null
 118   %tmp = bitcast %swift_error* %error_from_foo to i8*
 119   br i1 %had_error_from_foo, label %handler, label %cont
 120 cont:
 121   %cmp = fcmp ogt float %call, 1.000000e+00
 122   br i1 %cmp, label %bb_end, label %bb_loop
 123 bb_end:
 124   %v1 = getelementptr inbounds %swift_error, %swift_error* %error_from_foo, i64 0, i32 1
 125   %t = load i8, i8* %v1
 126   store i8 %t, i8* %error_ref
 127   br label %handler
 128 handler:
 129   call void @free(i8* %tmp)
 130   ret float 1.0
 131 }
 132
 133 ; "foo_if" is a function that takes a swifterror parameter, it sets swifterror
 134 ; under a certain condition.
 135 define float @foo_if(%swift_error** swifterror %error_ptr_ref, i32 %cc) {
 136 ; CHECK-APPLE-LABEL: foo_if:
 137 ; CHECK-APPLE: cmp r0, #0
 138 ; CHECK-APPLE: eq
 139 ; CHECK-APPLE: mov r0, #16
 140 ; CHECK-APPLE: malloc
 141 ; CHECK-APPLE: mov [[ID:r[0-9]+]], #1
 142 ; CHECK-APPLE-DAG: mov r8, r{{.*}}
 143 ; CHECK-APPLE-DAG: strb [[ID]], [r{{.*}}, #8]
 144
 145 ; CHECK-O0-LABEL: foo_if:
 146 ; CHECK-O0: cmp r0, #0
 147 ; spill to stack
 148 ; CHECK-O0: str r8
 149 ; CHECK-O0: beq
 150 ; CHECK-O0: mov r0, #16
 151 ; CHECK-O0: malloc
 152 ; CHECK-O0: mov [[ID:r[0-9]+]], r0
 153 ; CHECK-O0: mov [[ID2:[a-z0-9]+]], #1
 154 ; CHECK-O0: strb [[ID2]], [r0, #8]
 155 ; CHECK-O0: mov r8, [[ID]]
 156 ; reload from stack
 157 ; CHECK-O0: ldr r8
 158 entry:
 159   %cond = icmp ne i32 %cc, 0
 160   br i1 %cond, label %gen_error, label %normal
 161
 162 gen_error:
 163   %call = call i8* @malloc(i64 16)
 164   %call.0 = bitcast i8* %call to %swift_error*
 165   store %swift_error* %call.0, %swift_error** %error_ptr_ref
 166   %tmp = getelementptr inbounds i8, i8* %call, i64 8
 167   store i8 1, i8* %tmp
 168   ret float 1.0
 169
 170 normal:
 171   ret float 0.0
 172 }
 173
 174 ; "foo_loop" is a function that takes a swifterror parameter, it sets swifterror
 175 ; under a certain condition inside a loop.
 176 define float @foo_loop(%swift_error** swifterror %error_ptr_ref, i32 %cc, float %cc2) {
 177 ; CHECK-APPLE-LABEL: foo_loop:
 178 ; CHECK-APPLE: mov [[CODE:r[0-9]+]], r0
 179 ; swifterror is kept in a register
 180 ; CHECK-APPLE: mov [[ID:r[0-9]+]], r8
 181 ; CHECK-APPLE: cmp [[CODE]], #0
 182 ; CHECK-APPLE: beq
 183 ; CHECK-APPLE: mov r0, #16
 184 ; CHECK-APPLE: malloc
 185 ; CHECK-APPLE: strb r{{.*}}, [{{.*}}[[ID]], #8]
 186 ; CHECK-APPLE: ble
 187 ; CHECK-APPLE: mov r8, [[ID]]
 188
 189 ; CHECK-O0-LABEL: foo_loop:
 190 ; CHECK-O0: mov r{{.*}}, r8
 191 ; CHECK-O0: cmp r{{.*}}, #0
 192 ; CHECK-O0: beq
 193 ; CHECK-O0-DAG: movw r{{.*}}, #1
 194 ; CHECK-O0-DAG: mov r{{.*}}, #16
 195 ; CHECK-O0: malloc
 196 ; CHECK-O0-DAG: mov [[ID:r[0-9]+]], r0
 197 ; CHECK-O0-DAG: ldr [[ID2:r[0-9]+]], [sp{{.*}}]
 198 ; CHECK-O0: strb [[ID2]], [{{.*}}[[ID]], #8]
 199 ; spill r0
 200 ; CHECK-O0: str r0, [sp{{.*}}]
 201 ; CHECK-O0: vcmpe
 202 ; CHECK-O0: ble
 203 ; reload from stack
 204 ; CHECK-O0: ldr r8
 205 entry:
 206   br label %bb_loop
 207
 208 bb_loop:
 209   %cond = icmp ne i32 %cc, 0
 210   br i1 %cond, label %gen_error, label %bb_cont
 211
 212 gen_error:
 213   %call = call i8* @malloc(i64 16)
 214   %call.0 = bitcast i8* %call to %swift_error*
 215   store %swift_error* %call.0, %swift_error** %error_ptr_ref
 216   %tmp = getelementptr inbounds i8, i8* %call, i64 8
 217   store i8 1, i8* %tmp
 218   br label %bb_cont
 219
 220 bb_cont:
 221   %cmp = fcmp ogt float %cc2, 1.000000e+00
 222   br i1 %cmp, label %bb_end, label %bb_loop
 223 bb_end:
 224   ret float 0.0
 225 }
 226
 227 ; "foo_sret" is a function that takes a swifterror parameter, it also has a sret
 228 ; parameter.
 229 define void @foo_sret(%struct.S* sret %agg.result, i32 %val1, %swift_error** swifterror %error_ptr_ref) {
 230 ; CHECK-APPLE-LABEL: foo_sret:
 231 ; CHECK-APPLE: mov [[SRET:r[0-9]+]], r0
 232 ; CHECK-APPLE: mov r0, #16
 233 ; CHECK-APPLE: malloc
 234 ; CHECK-APPLE: mov [[REG:r[0-9]+]], #1
 235 ; CHECK-APPLE-DAG: mov r8, r0
 236 ; CHECK-APPLE-DAG: strb [[REG]], [r0, #8]
 237 ; CHECK-APPLE-DAG: str r{{.*}}, [{{.*}}[[SRET]], #4]
 238
 239 ; CHECK-O0-LABEL: foo_sret:
 240 ; CHECK-O0: mov r{{.*}}, #16
 241 ; spill to stack: sret and val1
 242 ; CHECK-O0-DAG: str r0
 243 ; CHECK-O0-DAG: str r1
 244 ; CHECK-O0: malloc
 245 ; CHECK-O0: mov [[ID:r[0-9]+]], #1
 246 ; CHECK-O0: strb [[ID]], [r0, #8]
 247 ; reload from stack: sret and val1
 248 ; CHECK-O0: ldr
 249 ; CHECK-O0: ldr
 250 ; CHECK-O0: str r{{.*}}, [{{.*}}, #4]
 251 ; CHECK-O0: mov r8
 252 entry:
 253   %call = call i8* @malloc(i64 16)
 254   %call.0 = bitcast i8* %call to %swift_error*
 255   store %swift_error* %call.0, %swift_error** %error_ptr_ref
 256   %tmp = getelementptr inbounds i8, i8* %call, i64 8
 257   store i8 1, i8* %tmp
 258   %v2 = getelementptr inbounds %struct.S, %struct.S* %agg.result, i32 0, i32 1
 259   store i32 %val1, i32* %v2
 260   ret void
 261 }
 262
 263 ; "caller3" calls "foo_sret" that takes a swifterror parameter.
 264 define float @caller3(i8* %error_ref) {
 265 ; CHECK-APPLE-LABEL: caller3:
 266 ; CHECK-APPLE: mov [[ID:r[0-9]+]], r0
 267 ; CHECK-APPLE: mov r8, #0
 268 ; CHECK-APPLE: bl {{.*}}foo_sret
 269 ; CHECK-APPLE: cmp r8, #0
 270 ; Access part of the error object and save it to error_ref
 271 ; CHECK-APPLE: ldrbeq [[CODE:r[0-9]+]], [r8, #8]
 272 ; CHECK-APPLE: strbeq [[CODE]], [{{.*}}[[ID]]]
 273 ; CHECK-APPLE: mov r0, r8
 274 ; CHECK-APPLE: bl {{.*}}free
 275
 276 ; CHECK-O0-LABEL: caller3:
 277 ; CHECK-O0-DAG: mov r8, #0
 278 ; CHECK-O0-DAG: mov r0
 279 ; CHECK-O0-DAG: mov r1
 280 ; CHECK-O0: bl {{.*}}foo_sret
 281 ; CHECK-O0: mov [[ID2:r[0-9]+]], r8
 282 ; CHECK-O0: cmp r8
 283 ; CHECK-O0: str [[ID2]], [sp[[SLOT:.*]]]
 284 ; CHECK-O0: bne
 285 ; Access part of the error object and save it to error_ref
 286 ; CHECK-O0: ldrb [[CODE:r[0-9]+]]
 287 ; CHECK-O0: ldr [[ID:r[0-9]+]]
 288 ; CHECK-O0: strb [[CODE]], [{{.*}}[[ID]]]
 289 ; CHECK-O0: ldr r0, [sp[[SLOT]]
 290 ; CHECK-O0: bl {{.*}}free
 291 entry:
 292   %s = alloca %struct.S, align 8
 293   %error_ptr_ref = alloca swifterror %swift_error*
 294   store %swift_error* null, %swift_error** %error_ptr_ref
 295   call void @foo_sret(%struct.S* sret %s, i32 1, %swift_error** swifterror %error_ptr_ref)
 296   %error_from_foo = load %swift_error*, %swift_error** %error_ptr_ref
 297   %had_error_from_foo = icmp ne %swift_error* %error_from_foo, null
 298   %tmp = bitcast %swift_error* %error_from_foo to i8*
 299   br i1 %had_error_from_foo, label %handler, label %cont
 300 cont:
 301   %v1 = getelementptr inbounds %swift_error, %swift_error* %error_from_foo, i64 0, i32 1
 302   %t = load i8, i8* %v1
 303   store i8 %t, i8* %error_ref
 304   br label %handler
 305 handler:
 306   call void @free(i8* %tmp)
 307   ret float 1.0
 308 }
 309
 310 ; "foo_vararg" is a function that takes a swifterror parameter, it also has
 311 ; variable number of arguments.
 312 declare void @llvm.va_start(i8*) nounwind
 313 define float @foo_vararg(%swift_error** swifterror %error_ptr_ref, ...) {
 314 ; CHECK-APPLE-LABEL: foo_vararg:
 315 ; CHECK-APPLE: mov r0, #16
 316 ; CHECK-APPLE: malloc
 317 ; CHECK-APPLE: mov [[REG:r[0-9]+]], r0
 318 ; CHECK-APPLE: mov [[ID:r[0-9]+]], #1
 319 ; CHECK-APPLE-DAG: strb [[ID]], [{{.*}}[[REG]], #8]
 320 ; CHECK-APPLE-DAG: mov r8, [[REG]]
 321
 322 entry:
 323   %call = call i8* @malloc(i64 16)
 324   %call.0 = bitcast i8* %call to %swift_error*
 325   store %swift_error* %call.0, %swift_error** %error_ptr_ref
 326   %tmp = getelementptr inbounds i8, i8* %call, i64 8
 327   store i8 1, i8* %tmp
 328
 329   %args = alloca i8*, align 8
 330   %a10 = alloca i32, align 4
 331   %a11 = alloca i32, align 4
 332   %a12 = alloca i32, align 4
 333   %v10 = bitcast i8** %args to i8*
 334   call void @llvm.va_start(i8* %v10)
 335   %v11 = va_arg i8** %args, i32
 336   store i32 %v11, i32* %a10, align 4
 337   %v12 = va_arg i8** %args, i32
 338   store i32 %v12, i32* %a11, align 4
 339   %v13 = va_arg i8** %args, i32
 340   store i32 %v13, i32* %a12, align 4
 341
 342   ret float 1.0
 343 }
 344
 345 ; "caller4" calls "foo_vararg" that takes a swifterror parameter.
 346 define float @caller4(i8* %error_ref) {
 347 ; CHECK-APPLE-LABEL: caller4:
 348 ; CHECK-APPLE: mov [[ID:r[0-9]+]], r0
 349 ; CHECK-APPLE: mov r8, #0
 350 ; CHECK-APPLE: bl {{.*}}foo_vararg
 351 ; CHECK-APPLE: cmp r8, #0
 352 ; Access part of the error object and save it to error_ref
 353 ; CHECK-APPLE: ldrbeq [[CODE:r[0-9]+]], [r8, #8]
 354 ; CHECK-APPLE: strbeq [[CODE]], [{{.*}}[[ID]]]
 355 ; CHECK-APPLE: mov r0, r8
 356 ; CHECK-APPLE: bl {{.*}}free
 357 entry:
 358   %error_ptr_ref = alloca swifterror %swift_error*
 359   store %swift_error* null, %swift_error** %error_ptr_ref
 360
 361   %a10 = alloca i32, align 4
 362   %a11 = alloca i32, align 4
 363   %a12 = alloca i32, align 4
 364   store i32 10, i32* %a10, align 4
 365   store i32 11, i32* %a11, align 4
 366   store i32 12, i32* %a12, align 4
 367   %v10 = load i32, i32* %a10, align 4
 368   %v11 = load i32, i32* %a11, align 4
 369   %v12 = load i32, i32* %a12, align 4
 370
 371   %call = call float (%swift_error**, ...) @foo_vararg(%swift_error** swifterror %error_ptr_ref, i32 %v10, i32 %v11, i32 %v12)
 372   %error_from_foo = load %swift_error*, %swift_error** %error_ptr_ref
 373   %had_error_from_foo = icmp ne %swift_error* %error_from_foo, null
 374   %tmp = bitcast %swift_error* %error_from_foo to i8*
 375   br i1 %had_error_from_foo, label %handler, label %cont
 376
 377 cont:
 378   %v1 = getelementptr inbounds %swift_error, %swift_error* %error_from_foo, i64 0, i32 1
 379   %t = load i8, i8* %v1
 380   store i8 %t, i8* %error_ref
 381   br label %handler
 382 handler:
 383   call void @free(i8* %tmp)
 384   ret float 1.0
 385 }
 386
 387 ; Check that we don't blow up on tail calling swifterror argument functions.
 388 define float @tailcallswifterror(%swift_error** swifterror %error_ptr_ref) {
 389 entry:
 390   %0 = tail call float @tailcallswifterror(%swift_error** swifterror %error_ptr_ref)
 391   ret float %0
 392 }
 393 define swiftcc float @tailcallswifterror_swiftcc(%swift_error** swifterror %error_ptr_ref) {
 394 entry:
 395   %0 = tail call swiftcc float @tailcallswifterror_swiftcc(%swift_error** swifterror %error_ptr_ref)
 396   ret float %0
 397 }
 398
 399 ; CHECK-APPLE-LABEL: swifterror_clobber
 400 ; CHECK-APPLE: mov [[REG:r[0-9]+]], r8
 401 ; CHECK-APPLE: nop
 402 ; CHECK-APPLE: mov r8, [[REG]]
 403 define swiftcc void @swifterror_clobber(%swift_error** nocapture swifterror %err) {
 404   call void asm sideeffect "nop", "~{r8}"()
 405   ret void
 406 }
 407
 408 ; CHECK-APPLE-LABEL: swifterror_reg_clobber
 409 ; CHECK-APPLE: push {{.*}}r8
 410 ; CHECK-APPLE: nop
 411 ; CHECK-APPLE: pop  {{.*}}r8
 412 define swiftcc void @swifterror_reg_clobber(%swift_error** nocapture %err) {
 413   call void asm sideeffect "nop", "~{r8}"()
 414   ret void
 415 }
 416
 417 ; CHECK-ARMV7-LABEL: _params_in_reg
 418 ; Store callee saved registers excluding swifterror.
 419 ; CHECK-ARMV7:  push   {r4, r5, r6, r7, r10, r11, lr}
 420 ; Store swiftself (r10) and swifterror (r8).
 421 ; CHECK-ARMV7-DAG:  str     r8, [s[[STK1:.*]]]
 422 ; CHECK-ARMV7-DAG:  str     r10, [s[[STK2:.*]]]
 423 ; Store arguments.
 424 ; CHECK-ARMV7-DAG:  mov     r6, r3
 425 ; CHECK-ARMV7-DAG:  mov     r4, r2
 426 ; CHECK-ARMV7-DAG:  mov     r11, r1
 427 ; CHECK-ARMV7-DAG:  mov     r5, r0
 428 ; Setup call.
 429 ; CHECK-ARMV7:  mov     r0, #1
 430 ; CHECK-ARMV7:  mov     r1, #2
 431 ; CHECK-ARMV7:  mov     r2, #3
 432 ; CHECK-ARMV7:  mov     r3, #4
 433 ; CHECK-ARMV7:  mov     r10, #0
 434 ; CHECK-ARMV7:  mov     r8, #0
 435 ; CHECK-ARMV7:  bl      _params_in_reg2
 436 ; Restore original arguments.
 437 ; CHECK-ARMV7-DAG:  ldr     r10, [s[[STK2]]]
 438 ; CHECK-ARMV7-DAG:  ldr     r8, [s[[STK1]]]
 439 ; CHECK-ARMV7-DAG:  mov     r0, r5
 440 ; CHECK-ARMV7-DAG:  mov     r1, r11
 441 ; CHECK-ARMV7-DAG:  mov     r2, r4
 442 ; CHECK-ARMV7-DAG:  mov     r3, r6
 443 ; CHECK-ARMV7:  bl      _params_in_reg2
 444 ; CHECK-ARMV7:  pop     {r4, r5, r6, r7, r10, r11, pc}
 445 define swiftcc void @params_in_reg(i32, i32, i32, i32, i8* swiftself, %swift_error** nocapture swifterror %err) {
 446   %error_ptr_ref = alloca swifterror %swift_error*, align 8
 447   store %swift_error* null, %swift_error** %error_ptr_ref
 448   call swiftcc void @params_in_reg2(i32 1, i32 2, i32 3, i32 4, i8* swiftself null, %swift_error** nocapture swifterror %error_ptr_ref)
 449   call swiftcc void @params_in_reg2(i32 %0, i32 %1, i32 %2, i32 %3, i8* swiftself %4, %swift_error** nocapture swifterror %err)
 450   ret void
 451 }
 452 declare swiftcc void @params_in_reg2(i32, i32, i32, i32, i8* swiftself, %swift_error** nocapture swifterror %err)
 453
 454 ; CHECK-ARMV7-LABEL: params_and_return_in_reg
 455 ; CHECK-ARMV7:  push    {r4, r5, r6, r7, r10, r11, lr}
 456 ; Store swifterror and swiftself
 457 ; CHECK-ARMV7:  mov     r6, r8
 458 ; CHECK-ARMV7:  str     r10, [s[[STK1:.*]]]
 459 ; Store arguments.
 460 ; CHECK-ARMV7:  str     r3, [s[[STK2:.*]]]
 461 ; CHECK-ARMV7:  mov     r4, r2
 462 ; CHECK-ARMV7:  mov     r11, r1
 463 ; CHECK-ARMV7:  mov     r5, r0
 464 ; Setup call.
 465 ; CHECK-ARMV7:  mov     r0, #1
 466 ; CHECK-ARMV7:  mov     r1, #2
 467 ; CHECK-ARMV7:  mov     r2, #3
 468 ; CHECK-ARMV7:  mov     r3, #4
 469 ; CHECK-ARMV7:  mov     r10, #0
 470 ; CHECK-ARMV7:  mov     r8, #0
 471 ; CHECK-ARMV7:  bl      _params_in_reg2
 472 ; Restore original arguments.
 473 ; CHECK-ARMV7-DAG:  ldr     r3, [s[[STK2]]]
 474 ; CHECK-ARMV7-DAG:  ldr     r10, [s[[STK1]]]
 475 ; Store %error_ptr_ref;
 476 ; CHECK-ARMV7-DAG:  str     r8, [s[[STK3:.*]]]
 477 ; Restore original arguments.
 478 ; CHECK-ARMV7-DAG:  mov     r0, r5
 479 ; CHECK-ARMV7-DAG:  mov     r1, r11
 480 ; CHECK-ARMV7-DAG:  mov     r2, r4
 481 ; CHECK-ARMV7-DAG:  mov     r8, r6
 482 ; CHECK-ARMV7:  bl      _params_and_return_in_reg2
 483 ; Store swifterror return %err;
 484 ; CHECK-ARMV7-DAG:  str     r8, [s[[STK1]]]
 485 ; Load swifterror value %error_ptr_ref.
 486 ; CHECK-ARMV7-DAG:  ldr     r8, [s[[STK3]]]
 487 ; Save return values.
 488 ; CHECK-ARMV7-DAG:  mov     r4, r0
 489 ; CHECK-ARMV7-DAG:  mov     r5, r1
 490 ; CHECK-ARMV7-DAG:  mov     r6, r2
 491 ; CHECK-ARMV7-DAG:  mov     r11, r3
 492 ; Setup call.
 493 ; CHECK-ARMV7:  mov     r0, #1
 494 ; CHECK-ARMV7:  mov     r1, #2
 495 ; CHECK-ARMV7:  mov     r2, #3
 496 ; CHECK-ARMV7:  mov     r3, #4
 497 ; CHECK-ARMV7:  mov     r10, #0
 498 ; CHECK-ARMV7:  bl      _params_in_reg2
 499 ; Load swifterror %err;
 500 ; CHECK-ARMV7-DAG:  ldr     r8, [s[[STK1]]]
 501 ; Restore return values for returning.
 502 ; CHECK-ARMV7-DAG:  mov     r0, r4
 503 ; CHECK-ARMV7-DAG:  mov     r1, r5
 504 ; CHECK-ARMV7-DAG:  mov     r2, r6
 505 ; CHECK-ARMV7-DAG:  mov     r3, r11
 506 ; CHECK-ARMV7:  pop     {r4, r5, r6, r7, r10, r11, pc}
 507
 508 ; CHECK-ANDROID-LABEL: params_and_return_in_reg
 509 ; CHECK-ANDROID:  push  {r4, r5, r6, r7, r10, r11, lr}
 510 ; CHECK-ANDROID:  sub   sp, sp, #12
 511 ; CHECK-ANDROID:  mov   r5, r8
 512 ; CHECK-ANDROID:  str   r10, [sp, #4]           @ 4-byte Spill
 513 ; CHECK-ANDROID:  mov   r6, r3
 514 ; CHECK-ANDROID:  mov   r7, r2
 515 ; CHECK-ANDROID:  mov   r4, r1
 516 ; CHECK-ANDROID:  mov   r11, r0
 517 ; CHECK-ANDROID:  mov   r0, #1
 518 ; CHECK-ANDROID:  mov   r1, #2
 519 ; CHECK-ANDROID:  mov   r2, #3
 520 ; CHECK-ANDROID:  mov   r3, #4
 521 ; CHECK-ANDROID:  mov   r10, #0
 522 ; CHECK-ANDROID:  mov   r8, #0
 523 ; CHECK-ANDROID:  bl    params_in_reg2
 524 ; CHECK-ANDROID:  ldr   r10, [sp, #4]           @ 4-byte Reload
 525 ; CHECK-ANDROID:  mov   r0, r11
 526 ; CHECK-ANDROID:  str   r8, [sp]                @ 4-byte Spill
 527 ; CHECK-ANDROID:  mov   r1, r4
 528 ; CHECK-ANDROID:  mov   r2, r7
 529 ; CHECK-ANDROID:  mov   r3, r6
 530 ; CHECK-ANDROID:  mov   r8, r5
 531 ; CHECK-ANDROID:  bl    params_and_return_in_reg2
 532 ; CHECK-ANDROID:  mov   r11, r8
 533 ; CHECK-ANDROID:  ldr   r8, [sp]                @ 4-byte Reload
 534 ; CHECK-ANDROID:  mov   r4, r0
 535 ; CHECK-ANDROID:  mov   r6, r1
 536 ; CHECK-ANDROID:  mov   r7, r2
 537 ; CHECK-ANDROID:  mov   r5, r3
 538 ; CHECK-ANDROID:  mov   r0, #1
 539 ; CHECK-ANDROID:  mov   r1, #2
 540 ; CHECK-ANDROID:  mov   r2, #3
 541 ; CHECK-ANDROID:  mov   r3, #4
 542 ; CHECK-ANDROID:  mov   r10, #0
 543 ; CHECK-ANDROID:  bl    params_in_reg2
 544 ; CHECK-ANDROID:  mov   r0, r4
 545 ; CHECK-ANDROID:  mov   r1, r6
 546 ; CHECK-ANDROID:  mov   r2, r7
 547 ; CHECK-ANDROID:  mov   r3, r5
 548 ; CHECK-ANDROID:  mov   r8, r11
 549 ; CHECK-ANDROID:  add   sp, sp, #12
 550 ; CHECK-ANDROID:  pop   {r4, r5, r6, r7, r10, r11, pc}
 551
 552 define swiftcc { i32, i32, i32, i32} @params_and_return_in_reg(i32, i32, i32, i32, i8* swiftself, %swift_error** nocapture swifterror %err) {
 553   %error_ptr_ref = alloca swifterror %swift_error*, align 8
 554   store %swift_error* null, %swift_error** %error_ptr_ref
 555   call swiftcc void @params_in_reg2(i32 1, i32 2, i32 3, i32 4, i8* swiftself null, %swift_error** nocapture swifterror %error_ptr_ref)
 556   %val = call swiftcc  { i32, i32, i32, i32 } @params_and_return_in_reg2(i32 %0, i32 %1, i32 %2, i32 %3, i8* swiftself %4, %swift_error** nocapture swifterror %err)
 557   call swiftcc void @params_in_reg2(i32 1, i32 2, i32 3, i32 4, i8* swiftself null, %swift_error** nocapture swifterror %error_ptr_ref)
 558   ret { i32, i32, i32, i32 }%val
 559 }
 560
 561 declare swiftcc { i32, i32, i32, i32 } @params_and_return_in_reg2(i32, i32, i32, i32, i8* swiftself, %swift_error** nocapture swifterror %err)
 562
 563
 564 declare void @acallee(i8*)
 565
 566 ; Make sure we don't tail call if the caller returns a swifterror value. We
 567 ; would have to move into the swifterror register before the tail call.
 568 ; CHECK-APPLE: tailcall_from_swifterror:
 569 ; CHECK-APPLE-NOT: b _acallee
 570 ; CHECK-APPLE: bl _acallee
 571 ; CHECK-ANDROID: tailcall_from_swifterror:
 572 ; CHECK-ANDROID-NOT: b acallee
 573 ; CHECK-ANDROID: bl acallee
 574
 575 define swiftcc void @tailcall_from_swifterror(%swift_error** swifterror %error_ptr_ref) {
 576 entry:
 577   tail call void @acallee(i8* null)
 578   ret void
 579 }
 580
 581
 582 declare swiftcc void @foo2(%swift_error** swifterror)
 583
 584 ; Make sure we properly assign registers during fast-isel.
 585 ; CHECK-O0-LABEL: testAssign
 586 ; CHECK-O0: mov     r8, #0
 587 ; CHECK-O0: bl      _foo2
 588 ; CHECK-O0: str     r8, [s[[STK:p.*]]]
 589 ; CHECK-O0: ldr     r0, [s[[STK]]]
 590 ; CHECK-O0: pop
 591
 592 ; CHECK-APPLE-LABEL: testAssign
 593 ; CHECK-APPLE:  mov     r8, #0
 594 ; CHECK-APPLE:  bl      _foo2
 595 ; CHECK-APPLE:  mov     r0, r8
 596
 597 ; CHECK-ANDROID-LABEL: testAssign
 598 ; CHECK-ANDROID:  mov     r8, #0
 599 ; CHECK-ANDROID:  bl      foo2
 600 ; CHECK-ANDROID:  mov     r0, r8
 601
 602 define swiftcc %swift_error* @testAssign(i8* %error_ref) {
 603 entry:
 604   %error_ptr = alloca swifterror %swift_error*
 605   store %swift_error* null, %swift_error** %error_ptr
 606   call swiftcc void @foo2(%swift_error** swifterror %error_ptr)
 607   br label %a
 608
 609 a:
 610   %error = load %swift_error*, %swift_error** %error_ptr
 611   ret %swift_error* %error
 612 }