test/CodeGen/X86/swift-return.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -verify-machineinstrs < %s -mtriple=x86_64-unknown-unknown | FileCheck %s
   3 ; RUN: llc -verify-machineinstrs < %s -mtriple=x86_64-unknown-unknown -O0 | FileCheck --check-prefix=CHECK-O0 %s
   4
   5 @var = global i32 0
   6
   7 ; Test how llvm handles return type of {i16, i8}. The return value will be
   8 ; passed in %eax and %dl.
   9 define i16 @test(i32 %key) {
  10 ; CHECK-LABEL: test:
  11 ; CHECK:       # %bb.0: # %entry
  12 ; CHECK-NEXT:    pushq %rax
  13 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
  14 ; CHECK-NEXT:    movl %edi, {{[0-9]+}}(%rsp)
  15 ; CHECK-NEXT:    callq gen
  16 ; CHECK-NEXT:    # kill: def $ax killed $ax def $eax
  17 ; CHECK-NEXT:    movsbl %dl, %ecx
  18 ; CHECK-NEXT:    addl %ecx, %eax
  19 ; CHECK-NEXT:    # kill: def $ax killed $ax killed $eax
  20 ; CHECK-NEXT:    popq %rcx
  21 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
  22 ; CHECK-NEXT:    retq
  23 ;
  24 ; CHECK-O0-LABEL: test:
  25 ; CHECK-O0:       # %bb.0: # %entry
  26 ; CHECK-O0-NEXT:    pushq %rax
  27 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 16
  28 ; CHECK-O0-NEXT:    movl %edi, {{[0-9]+}}(%rsp)
  29 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%rsp), %edi
  30 ; CHECK-O0-NEXT:    callq gen
  31 ; CHECK-O0-NEXT:    movswl %ax, %ecx
  32 ; CHECK-O0-NEXT:    movsbl %dl, %esi
  33 ; CHECK-O0-NEXT:    addl %esi, %ecx
  34 ; CHECK-O0-NEXT:    # kill: def $cx killed $cx killed $ecx
  35 ; CHECK-O0-NEXT:    movw %cx, %ax
  36 ; CHECK-O0-NEXT:    popq %rcx
  37 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
  38 ; CHECK-O0-NEXT:    retq
  39 entry:
  40   %key.addr = alloca i32, align 4
  41   store i32 %key, i32* %key.addr, align 4
  42   %0 = load i32, i32* %key.addr, align 4
  43   %call = call swiftcc { i16, i8 } @gen(i32 %0)
  44   %v3 = extractvalue { i16, i8 } %call, 0
  45   %v1 = sext i16 %v3 to i32
  46   %v5 = extractvalue { i16, i8 } %call, 1
  47   %v2 = sext i8 %v5 to i32
  48   %add = add nsw i32 %v1, %v2
  49   %conv = trunc i32 %add to i16
  50   ret i16 %conv
  51 }
  52
  53 declare swiftcc { i16, i8 } @gen(i32)
  54
  55 ; If we can't pass every return value in register, we will pass everything
  56 ; in memroy. The caller provides space for the return value and passes
  57 ; the address in %rax. The first input argument will be in %rdi.
  58 define i32 @test2(i32 %key) #0 {
  59 ; CHECK-LABEL: test2:
  60 ; CHECK:       # %bb.0: # %entry
  61 ; CHECK-NEXT:    subq $24, %rsp
  62 ; CHECK-NEXT:    .cfi_def_cfa_offset 32
  63 ; CHECK-NEXT:    movl %edi, {{[0-9]+}}(%rsp)
  64 ; CHECK-NEXT:    movq %rsp, %rax
  65 ; CHECK-NEXT:    callq gen2
  66 ; CHECK-NEXT:    movl (%rsp), %eax
  67 ; CHECK-NEXT:    addl {{[0-9]+}}(%rsp), %eax
  68 ; CHECK-NEXT:    addl {{[0-9]+}}(%rsp), %eax
  69 ; CHECK-NEXT:    addl {{[0-9]+}}(%rsp), %eax
  70 ; CHECK-NEXT:    addl {{[0-9]+}}(%rsp), %eax
  71 ; CHECK-NEXT:    addq $24, %rsp
  72 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
  73 ; CHECK-NEXT:    retq
  74 ;
  75 ; CHECK-O0-LABEL: test2:
  76 ; CHECK-O0:       # %bb.0: # %entry
  77 ; CHECK-O0-NEXT:    subq $24, %rsp
  78 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 32
  79 ; CHECK-O0-NEXT:    movl %edi, {{[0-9]+}}(%rsp)
  80 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%rsp), %edi
  81 ; CHECK-O0-NEXT:    movq %rsp, %rax
  82 ; CHECK-O0-NEXT:    callq gen2
  83 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%rsp), %ecx
  84 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%rsp), %edx
  85 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%rsp), %esi
  86 ; CHECK-O0-NEXT:    movl (%rsp), %edi
  87 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%rsp), %r8d
  88 ; CHECK-O0-NEXT:    addl %r8d, %edi
  89 ; CHECK-O0-NEXT:    addl %esi, %edi
  90 ; CHECK-O0-NEXT:    addl %edx, %edi
  91 ; CHECK-O0-NEXT:    addl %ecx, %edi
  92 ; CHECK-O0-NEXT:    movl %edi, %eax
  93 ; CHECK-O0-NEXT:    addq $24, %rsp
  94 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
  95 ; CHECK-O0-NEXT:    retq
  96 entry:
  97   %key.addr = alloca i32, align 4
  98   store i32 %key, i32* %key.addr, align 4
  99   %0 = load i32, i32* %key.addr, align 4
 100   %call = call swiftcc { i32, i32, i32, i32, i32 } @gen2(i32 %0)
 101
 102   %v3 = extractvalue { i32, i32, i32, i32, i32 } %call, 0
 103   %v5 = extractvalue { i32, i32, i32, i32, i32 } %call, 1
 104   %v6 = extractvalue { i32, i32, i32, i32, i32 } %call, 2
 105   %v7 = extractvalue { i32, i32, i32, i32, i32 } %call, 3
 106   %v8 = extractvalue { i32, i32, i32, i32, i32 } %call, 4
 107
 108   %add = add nsw i32 %v3, %v5
 109   %add1 = add nsw i32 %add, %v6
 110   %add2 = add nsw i32 %add1, %v7
 111   %add3 = add nsw i32 %add2, %v8
 112   ret i32 %add3
 113 }
 114
 115 ; The address of the return value is passed in %rax.
 116 ; On return, we don't keep the address in %rax.
 117 define swiftcc { i32, i32, i32, i32, i32 } @gen2(i32 %key) {
 118 ; CHECK-LABEL: gen2:
 119 ; CHECK:       # %bb.0:
 120 ; CHECK-NEXT:    movl %edi, 16(%rax)
 121 ; CHECK-NEXT:    movl %edi, 12(%rax)
 122 ; CHECK-NEXT:    movl %edi, 8(%rax)
 123 ; CHECK-NEXT:    movl %edi, 4(%rax)
 124 ; CHECK-NEXT:    movl %edi, (%rax)
 125 ; CHECK-NEXT:    retq
 126 ;
 127 ; CHECK-O0-LABEL: gen2:
 128 ; CHECK-O0:       # %bb.0:
 129 ; CHECK-O0-NEXT:    movl %edi, 16(%rax)
 130 ; CHECK-O0-NEXT:    movl %edi, 12(%rax)
 131 ; CHECK-O0-NEXT:    movl %edi, 8(%rax)
 132 ; CHECK-O0-NEXT:    movl %edi, 4(%rax)
 133 ; CHECK-O0-NEXT:    movl %edi, (%rax)
 134 ; CHECK-O0-NEXT:    retq
 135   %Y = insertvalue { i32, i32, i32, i32, i32 } undef, i32 %key, 0
 136   %Z = insertvalue { i32, i32, i32, i32, i32 } %Y, i32 %key, 1
 137   %Z2 = insertvalue { i32, i32, i32, i32, i32 } %Z, i32 %key, 2
 138   %Z3 = insertvalue { i32, i32, i32, i32, i32 } %Z2, i32 %key, 3
 139   %Z4 = insertvalue { i32, i32, i32, i32, i32 } %Z3, i32 %key, 4
 140   ret { i32, i32, i32, i32, i32 } %Z4
 141 }
 142
 143 ; The return value {i32, i32, i32, i32} will be returned via registers %eax,
 144 ; %edx, %ecx, %r8d.
 145 define i32 @test3(i32 %key) #0 {
 146 ; CHECK-LABEL: test3:
 147 ; CHECK:       # %bb.0: # %entry
 148 ; CHECK-NEXT:    pushq %rax
 149 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 150 ; CHECK-NEXT:    movl %edi, {{[0-9]+}}(%rsp)
 151 ; CHECK-NEXT:    callq gen3
 152 ; CHECK-NEXT:    addl %edx, %eax
 153 ; CHECK-NEXT:    addl %ecx, %eax
 154 ; CHECK-NEXT:    addl %r8d, %eax
 155 ; CHECK-NEXT:    popq %rcx
 156 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 157 ; CHECK-NEXT:    retq
 158 ;
 159 ; CHECK-O0-LABEL: test3:
 160 ; CHECK-O0:       # %bb.0: # %entry
 161 ; CHECK-O0-NEXT:    pushq %rax
 162 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 16
 163 ; CHECK-O0-NEXT:    movl %edi, {{[0-9]+}}(%rsp)
 164 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%rsp), %edi
 165 ; CHECK-O0-NEXT:    callq gen3
 166 ; CHECK-O0-NEXT:    addl %edx, %eax
 167 ; CHECK-O0-NEXT:    addl %ecx, %eax
 168 ; CHECK-O0-NEXT:    addl %r8d, %eax
 169 ; CHECK-O0-NEXT:    popq %rcx
 170 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
 171 ; CHECK-O0-NEXT:    retq
 172 entry:
 173   %key.addr = alloca i32, align 4
 174   store i32 %key, i32* %key.addr, align 4
 175   %0 = load i32, i32* %key.addr, align 4
 176   %call = call swiftcc { i32, i32, i32, i32 } @gen3(i32 %0)
 177
 178   %v3 = extractvalue { i32, i32, i32, i32 } %call, 0
 179   %v5 = extractvalue { i32, i32, i32, i32 } %call, 1
 180   %v6 = extractvalue { i32, i32, i32, i32 } %call, 2
 181   %v7 = extractvalue { i32, i32, i32, i32 } %call, 3
 182
 183   %add = add nsw i32 %v3, %v5
 184   %add1 = add nsw i32 %add, %v6
 185   %add2 = add nsw i32 %add1, %v7
 186   ret i32 %add2
 187 }
 188
 189 declare swiftcc { i32, i32, i32, i32 } @gen3(i32 %key)
 190
 191 ; The return value {float, float, float, float} will be returned via registers
 192 ; %xmm0, %xmm1, %xmm2, %xmm3.
 193 define float @test4(float %key) #0 {
 194 ; CHECK-LABEL: test4:
 195 ; CHECK:       # %bb.0: # %entry
 196 ; CHECK-NEXT:    pushq %rax
 197 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 198 ; CHECK-NEXT:    movss %xmm0, {{[0-9]+}}(%rsp)
 199 ; CHECK-NEXT:    callq gen4
 200 ; CHECK-NEXT:    addss %xmm1, %xmm0
 201 ; CHECK-NEXT:    addss %xmm2, %xmm0
 202 ; CHECK-NEXT:    addss %xmm3, %xmm0
 203 ; CHECK-NEXT:    popq %rax
 204 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 205 ; CHECK-NEXT:    retq
 206 ;
 207 ; CHECK-O0-LABEL: test4:
 208 ; CHECK-O0:       # %bb.0: # %entry
 209 ; CHECK-O0-NEXT:    pushq %rax
 210 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 16
 211 ; CHECK-O0-NEXT:    movss %xmm0, {{[0-9]+}}(%rsp)
 212 ; CHECK-O0-NEXT:    movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
 213 ; CHECK-O0-NEXT:    callq gen4
 214 ; CHECK-O0-NEXT:    addss %xmm1, %xmm0
 215 ; CHECK-O0-NEXT:    addss %xmm2, %xmm0
 216 ; CHECK-O0-NEXT:    addss %xmm3, %xmm0
 217 ; CHECK-O0-NEXT:    popq %rax
 218 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
 219 ; CHECK-O0-NEXT:    retq
 220 entry:
 221   %key.addr = alloca float, align 4
 222   store float %key, float* %key.addr, align 4
 223   %0 = load float, float* %key.addr, align 4
 224   %call = call swiftcc { float, float, float, float } @gen4(float %0)
 225
 226   %v3 = extractvalue { float, float, float, float } %call, 0
 227   %v5 = extractvalue { float, float, float, float } %call, 1
 228   %v6 = extractvalue { float, float, float, float } %call, 2
 229   %v7 = extractvalue { float, float, float, float } %call, 3
 230
 231   %add = fadd float %v3, %v5
 232   %add1 = fadd float %add, %v6
 233   %add2 = fadd float %add1, %v7
 234   ret float %add2
 235 }
 236
 237 declare swiftcc { float, float, float, float } @gen4(float %key)
 238
 239 define void @consume_i1_ret() {
 240 ; CHECK-LABEL: consume_i1_ret:
 241 ; CHECK:       # %bb.0:
 242 ; CHECK-NEXT:    pushq %rax
 243 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 244 ; CHECK-NEXT:    callq produce_i1_ret
 245 ; CHECK-NEXT:    movzbl %al, %eax
 246 ; CHECK-NEXT:    andl $1, %eax
 247 ; CHECK-NEXT:    movl %eax, {{.*}}(%rip)
 248 ; CHECK-NEXT:    movzbl %dl, %eax
 249 ; CHECK-NEXT:    andl $1, %eax
 250 ; CHECK-NEXT:    movl %eax, {{.*}}(%rip)
 251 ; CHECK-NEXT:    movzbl %cl, %eax
 252 ; CHECK-NEXT:    andl $1, %eax
 253 ; CHECK-NEXT:    movl %eax, {{.*}}(%rip)
 254 ; CHECK-NEXT:    movzbl %r8b, %eax
 255 ; CHECK-NEXT:    andl $1, %eax
 256 ; CHECK-NEXT:    movl %eax, {{.*}}(%rip)
 257 ; CHECK-NEXT:    popq %rax
 258 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 259 ; CHECK-NEXT:    retq
 260 ;
 261 ; CHECK-O0-LABEL: consume_i1_ret:
 262 ; CHECK-O0:       # %bb.0:
 263 ; CHECK-O0-NEXT:    pushq %rax
 264 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 16
 265 ; CHECK-O0-NEXT:    callq produce_i1_ret
 266 ; CHECK-O0-NEXT:    andb $1, %al
 267 ; CHECK-O0-NEXT:    movzbl %al, %esi
 268 ; CHECK-O0-NEXT:    movl %esi, var
 269 ; CHECK-O0-NEXT:    andb $1, %dl
 270 ; CHECK-O0-NEXT:    movzbl %dl, %esi
 271 ; CHECK-O0-NEXT:    movl %esi, var
 272 ; CHECK-O0-NEXT:    andb $1, %cl
 273 ; CHECK-O0-NEXT:    movzbl %cl, %esi
 274 ; CHECK-O0-NEXT:    movl %esi, var
 275 ; CHECK-O0-NEXT:    andb $1, %r8b
 276 ; CHECK-O0-NEXT:    movzbl %r8b, %esi
 277 ; CHECK-O0-NEXT:    movl %esi, var
 278 ; CHECK-O0-NEXT:    popq %rax
 279 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
 280 ; CHECK-O0-NEXT:    retq
 281   %call = call swiftcc { i1, i1, i1, i1 } @produce_i1_ret()
 282   %v3 = extractvalue { i1, i1, i1, i1 } %call, 0
 283   %v5 = extractvalue { i1, i1, i1, i1 } %call, 1
 284   %v6 = extractvalue { i1, i1, i1, i1 } %call, 2
 285   %v7 = extractvalue { i1, i1, i1, i1 } %call, 3
 286   %val = zext i1 %v3 to i32
 287   store volatile i32 %val, i32* @var
 288   %val2 = zext i1 %v5 to i32
 289   store volatile i32 %val2, i32* @var
 290   %val3 = zext i1 %v6 to i32
 291   store volatile i32 %val3, i32* @var
 292   %val4 = zext i1 %v7 to i32
 293   store i32 %val4, i32* @var
 294   ret void
 295 }
 296
 297 declare swiftcc { i1, i1, i1, i1 } @produce_i1_ret()
 298
 299 define swiftcc void @foo(i64* sret %agg.result, i64 %val) {
 300 ; CHECK-LABEL: foo:
 301 ; CHECK:       # %bb.0:
 302 ; CHECK-NEXT:    movq %rdi, (%rax)
 303 ; CHECK-NEXT:    retq
 304 ;
 305 ; CHECK-O0-LABEL: foo:
 306 ; CHECK-O0:       # %bb.0:
 307 ; CHECK-O0-NEXT:    movq %rdi, (%rax)
 308 ; CHECK-O0-NEXT:    retq
 309   store i64 %val, i64* %agg.result
 310   ret void
 311 }
 312
 313 define swiftcc double @test5() #0 {
 314 ; CHECK-LABEL: test5:
 315 ; CHECK:       # %bb.0: # %entry
 316 ; CHECK-NEXT:    pushq %rax
 317 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 318 ; CHECK-NEXT:    callq gen5
 319 ; CHECK-NEXT:    addsd %xmm1, %xmm0
 320 ; CHECK-NEXT:    addsd %xmm2, %xmm0
 321 ; CHECK-NEXT:    addsd %xmm3, %xmm0
 322 ; CHECK-NEXT:    popq %rax
 323 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 324 ; CHECK-NEXT:    retq
 325 ;
 326 ; CHECK-O0-LABEL: test5:
 327 ; CHECK-O0:       # %bb.0: # %entry
 328 ; CHECK-O0-NEXT:    pushq %rax
 329 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 16
 330 ; CHECK-O0-NEXT:    callq gen5
 331 ; CHECK-O0-NEXT:    addsd %xmm1, %xmm0
 332 ; CHECK-O0-NEXT:    addsd %xmm2, %xmm0
 333 ; CHECK-O0-NEXT:    addsd %xmm3, %xmm0
 334 ; CHECK-O0-NEXT:    popq %rax
 335 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
 336 ; CHECK-O0-NEXT:    retq
 337 entry:
 338   %call = call swiftcc { double, double, double, double } @gen5()
 339
 340   %v3 = extractvalue { double, double, double, double } %call, 0
 341   %v5 = extractvalue { double, double, double, double } %call, 1
 342   %v6 = extractvalue { double, double, double, double } %call, 2
 343   %v7 = extractvalue { double, double, double, double } %call, 3
 344
 345   %add = fadd double %v3, %v5
 346   %add1 = fadd double %add, %v6
 347   %add2 = fadd double %add1, %v7
 348   ret double %add2
 349 }
 350
 351 declare swiftcc { double, double, double, double } @gen5()
 352
 353
 354 define swiftcc { double, i64 } @test6() #0 {
 355 ; CHECK-LABEL: test6:
 356 ; CHECK:       # %bb.0: # %entry
 357 ; CHECK-NEXT:    pushq %rax
 358 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 359 ; CHECK-NEXT:    callq gen6
 360 ; CHECK-NEXT:    addsd %xmm1, %xmm0
 361 ; CHECK-NEXT:    addsd %xmm2, %xmm0
 362 ; CHECK-NEXT:    addsd %xmm3, %xmm0
 363 ; CHECK-NEXT:    addq %rdx, %rax
 364 ; CHECK-NEXT:    addq %rcx, %rax
 365 ; CHECK-NEXT:    addq %r8, %rax
 366 ; CHECK-NEXT:    popq %rcx
 367 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 368 ; CHECK-NEXT:    retq
 369 ;
 370 ; CHECK-O0-LABEL: test6:
 371 ; CHECK-O0:       # %bb.0: # %entry
 372 ; CHECK-O0-NEXT:    pushq %rax
 373 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 16
 374 ; CHECK-O0-NEXT:    callq gen6
 375 ; CHECK-O0-NEXT:    addsd %xmm1, %xmm0
 376 ; CHECK-O0-NEXT:    addsd %xmm2, %xmm0
 377 ; CHECK-O0-NEXT:    addsd %xmm3, %xmm0
 378 ; CHECK-O0-NEXT:    addq %rdx, %rax
 379 ; CHECK-O0-NEXT:    addq %rcx, %rax
 380 ; CHECK-O0-NEXT:    addq %r8, %rax
 381 ; CHECK-O0-NEXT:    popq %rcx
 382 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
 383 ; CHECK-O0-NEXT:    retq
 384 entry:
 385   %call = call swiftcc { double, double, double, double, i64, i64, i64, i64 } @gen6()
 386
 387   %v3 = extractvalue { double, double, double, double, i64, i64, i64, i64 } %call, 0
 388   %v5 = extractvalue { double, double, double, double, i64, i64, i64, i64 } %call, 1
 389   %v6 = extractvalue { double, double, double, double, i64, i64, i64, i64 } %call, 2
 390   %v7 = extractvalue { double, double, double, double, i64, i64, i64, i64 } %call, 3
 391   %v3.i = extractvalue { double, double, double, double, i64, i64, i64, i64 } %call, 4
 392   %v5.i = extractvalue { double, double, double, double, i64, i64, i64, i64 } %call, 5
 393   %v6.i = extractvalue { double, double, double, double, i64, i64, i64, i64 } %call, 6
 394   %v7.i = extractvalue { double, double, double, double, i64, i64, i64, i64 } %call, 7
 395
 396   %add = fadd double %v3, %v5
 397   %add1 = fadd double %add, %v6
 398   %add2 = fadd double %add1, %v7
 399
 400   %add.i = add nsw i64 %v3.i, %v5.i
 401   %add1.i = add nsw i64 %add.i, %v6.i
 402   %add2.i = add nsw i64 %add1.i, %v7.i
 403
 404   %Y = insertvalue { double, i64 } undef, double %add2, 0
 405   %Z = insertvalue { double, i64 } %Y, i64 %add2.i, 1
 406   ret { double, i64} %Z
 407 }
 408
 409 declare swiftcc { double, double, double, double, i64, i64, i64, i64 } @gen6()
 410
 411 define swiftcc { i32, i32, i32, i32 } @gen7(i32 %key) {
 412 ; CHECK-LABEL: gen7:
 413 ; CHECK:       # %bb.0:
 414 ; CHECK-NEXT:    movl %edi, %eax
 415 ; CHECK-NEXT:    movl %edi, %edx
 416 ; CHECK-NEXT:    movl %edi, %ecx
 417 ; CHECK-NEXT:    movl %edi, %r8d
 418 ; CHECK-NEXT:    retq
 419 ;
 420 ; CHECK-O0-LABEL: gen7:
 421 ; CHECK-O0:       # %bb.0:
 422 ; CHECK-O0-NEXT:    movl %edi, %eax
 423 ; CHECK-O0-NEXT:    movl %edi, %edx
 424 ; CHECK-O0-NEXT:    movl %edi, %ecx
 425 ; CHECK-O0-NEXT:    movl %edi, %r8d
 426 ; CHECK-O0-NEXT:    retq
 427   %v0 = insertvalue { i32, i32, i32, i32 } undef, i32 %key, 0
 428   %v1 = insertvalue { i32, i32, i32, i32 } %v0, i32 %key, 1
 429   %v2 = insertvalue { i32, i32, i32, i32 } %v1, i32 %key, 2
 430   %v3 = insertvalue { i32, i32, i32, i32 } %v2, i32 %key, 3
 431   ret { i32, i32, i32, i32 } %v3
 432 }
 433
 434 define swiftcc { i64, i64, i64, i64 } @gen8(i64 %key) {
 435 ; CHECK-LABEL: gen8:
 436 ; CHECK:       # %bb.0:
 437 ; CHECK-NEXT:    movq %rdi, %rax
 438 ; CHECK-NEXT:    movq %rdi, %rdx
 439 ; CHECK-NEXT:    movq %rdi, %rcx
 440 ; CHECK-NEXT:    movq %rdi, %r8
 441 ; CHECK-NEXT:    retq
 442 ;
 443 ; CHECK-O0-LABEL: gen8:
 444 ; CHECK-O0:       # %bb.0:
 445 ; CHECK-O0-NEXT:    movq %rdi, %rax
 446 ; CHECK-O0-NEXT:    movq %rdi, %rdx
 447 ; CHECK-O0-NEXT:    movq %rdi, %rcx
 448 ; CHECK-O0-NEXT:    movq %rdi, %r8
 449 ; CHECK-O0-NEXT:    retq
 450   %v0 = insertvalue { i64, i64, i64, i64 } undef, i64 %key, 0
 451   %v1 = insertvalue { i64, i64, i64, i64 } %v0, i64 %key, 1
 452   %v2 = insertvalue { i64, i64, i64, i64 } %v1, i64 %key, 2
 453   %v3 = insertvalue { i64, i64, i64, i64 } %v2, i64 %key, 3
 454   ret { i64, i64, i64, i64 } %v3
 455 }
 456
 457 define swiftcc { i8, i8, i8, i8 } @gen9(i8 %key) {
 458 ; CHECK-LABEL: gen9:
 459 ; CHECK:       # %bb.0:
 460 ; CHECK-NEXT:    movl %edi, %eax
 461 ; CHECK-NEXT:    movl %eax, %edx
 462 ; CHECK-NEXT:    movl %eax, %ecx
 463 ; CHECK-NEXT:    movl %eax, %r8d
 464 ; CHECK-NEXT:    retq
 465 ;
 466 ; CHECK-O0-LABEL: gen9:
 467 ; CHECK-O0:       # %bb.0:
 468 ; CHECK-O0-NEXT:    # kill: def $dil killed $dil killed $edi
 469 ; CHECK-O0-NEXT:    movb %dil, %al
 470 ; CHECK-O0-NEXT:    movb %dil, %dl
 471 ; CHECK-O0-NEXT:    movb %dil, %cl
 472 ; CHECK-O0-NEXT:    movb %dil, %r8b
 473 ; CHECK-O0-NEXT:    retq
 474   %v0 = insertvalue { i8, i8, i8, i8 } undef, i8 %key, 0
 475   %v1 = insertvalue { i8, i8, i8, i8 } %v0, i8 %key, 1
 476   %v2 = insertvalue { i8, i8, i8, i8 } %v1, i8 %key, 2
 477   %v3 = insertvalue { i8, i8, i8, i8 } %v2, i8 %key, 3
 478   ret { i8, i8, i8, i8 } %v3
 479 }
 480 define swiftcc { double, double, double, double, i64, i64, i64, i64 } @gen10(double %keyd, i64 %keyi) {
 481 ; CHECK-LABEL: gen10:
 482 ; CHECK:       # %bb.0:
 483 ; CHECK-NEXT:    movq %rdi, %rax
 484 ; CHECK-NEXT:    movaps %xmm0, %xmm1
 485 ; CHECK-NEXT:    movaps %xmm0, %xmm2
 486 ; CHECK-NEXT:    movaps %xmm0, %xmm3
 487 ; CHECK-NEXT:    movq %rdi, %rdx
 488 ; CHECK-NEXT:    movq %rdi, %rcx
 489 ; CHECK-NEXT:    movq %rdi, %r8
 490 ; CHECK-NEXT:    retq
 491 ;
 492 ; CHECK-O0-LABEL: gen10:
 493 ; CHECK-O0:       # %bb.0:
 494 ; CHECK-O0-NEXT:    movsd %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
 495 ; CHECK-O0-NEXT:    movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
 496 ; CHECK-O0-NEXT:    # xmm1 = mem[0],zero
 497 ; CHECK-O0-NEXT:    movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm2 # 8-byte Reload
 498 ; CHECK-O0-NEXT:    # xmm2 = mem[0],zero
 499 ; CHECK-O0-NEXT:    movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm3 # 8-byte Reload
 500 ; CHECK-O0-NEXT:    # xmm3 = mem[0],zero
 501 ; CHECK-O0-NEXT:    movq %rdi, %rax
 502 ; CHECK-O0-NEXT:    movq %rdi, %rdx
 503 ; CHECK-O0-NEXT:    movq %rdi, %rcx
 504 ; CHECK-O0-NEXT:    movq %rdi, %r8
 505 ; CHECK-O0-NEXT:    retq
 506   %v0 = insertvalue { double, double, double, double, i64, i64, i64, i64 } undef, double %keyd, 0
 507   %v1 = insertvalue { double, double, double, double, i64, i64, i64, i64 } %v0, double %keyd, 1
 508   %v2 = insertvalue { double, double, double, double, i64, i64, i64, i64 } %v1, double %keyd, 2
 509   %v3 = insertvalue { double, double, double, double, i64, i64, i64, i64 } %v2, double %keyd, 3
 510   %v4 = insertvalue { double, double, double, double, i64, i64, i64, i64 } %v3, i64 %keyi, 4
 511   %v5 = insertvalue { double, double, double, double, i64, i64, i64, i64 } %v4, i64 %keyi, 5
 512   %v6 = insertvalue { double, double, double, double, i64, i64, i64, i64 } %v5, i64 %keyi, 6
 513   %v7 = insertvalue { double, double, double, double, i64, i64, i64, i64 } %v6, i64 %keyi, 7
 514   ret { double, double, double, double, i64, i64, i64, i64 } %v7
 515 }
 516
 517
 518 define swiftcc <4 x float> @test11() #0 {
 519 ; CHECK-LABEL: test11:
 520 ; CHECK:       # %bb.0: # %entry
 521 ; CHECK-NEXT:    pushq %rax
 522 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 523 ; CHECK-NEXT:    callq gen11
 524 ; CHECK-NEXT:    addps %xmm1, %xmm0
 525 ; CHECK-NEXT:    addps %xmm2, %xmm0
 526 ; CHECK-NEXT:    addps %xmm3, %xmm0
 527 ; CHECK-NEXT:    popq %rax
 528 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 529 ; CHECK-NEXT:    retq
 530 ;
 531 ; CHECK-O0-LABEL: test11:
 532 ; CHECK-O0:       # %bb.0: # %entry
 533 ; CHECK-O0-NEXT:    pushq %rax
 534 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 16
 535 ; CHECK-O0-NEXT:    callq gen11
 536 ; CHECK-O0-NEXT:    addps %xmm1, %xmm0
 537 ; CHECK-O0-NEXT:    addps %xmm2, %xmm0
 538 ; CHECK-O0-NEXT:    addps %xmm3, %xmm0
 539 ; CHECK-O0-NEXT:    popq %rax
 540 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
 541 ; CHECK-O0-NEXT:    retq
 542 entry:
 543   %call = call swiftcc { <4 x float>, <4 x float>, <4 x float>, <4 x float> } @gen11()
 544
 545   %v3 = extractvalue { <4 x float>, <4 x float>, <4 x float>, <4 x float> } %call, 0
 546   %v5 = extractvalue { <4 x float>, <4 x float>, <4 x float>, <4 x float> } %call, 1
 547   %v6 = extractvalue { <4 x float>, <4 x float>, <4 x float>, <4 x float> } %call, 2
 548   %v7 = extractvalue { <4 x float>, <4 x float>, <4 x float>, <4 x float> } %call, 3
 549
 550   %add = fadd <4 x float> %v3, %v5
 551   %add1 = fadd <4 x float> %add, %v6
 552   %add2 = fadd <4 x float> %add1, %v7
 553   ret <4 x float> %add2
 554 }
 555
 556 declare swiftcc { <4 x float>, <4 x float>, <4 x float>, <4 x float> } @gen11()
 557
 558 define swiftcc { <4 x float>, float } @test12() #0 {
 559 ; CHECK-LABEL: test12:
 560 ; CHECK:       # %bb.0: # %entry
 561 ; CHECK-NEXT:    pushq %rax
 562 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 563 ; CHECK-NEXT:    callq gen12
 564 ; CHECK-NEXT:    addps %xmm1, %xmm0
 565 ; CHECK-NEXT:    addps %xmm2, %xmm0
 566 ; CHECK-NEXT:    movaps %xmm3, %xmm1
 567 ; CHECK-NEXT:    popq %rax
 568 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 569 ; CHECK-NEXT:    retq
 570 ;
 571 ; CHECK-O0-LABEL: test12:
 572 ; CHECK-O0:       # %bb.0: # %entry
 573 ; CHECK-O0-NEXT:    pushq %rax
 574 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 16
 575 ; CHECK-O0-NEXT:    callq gen12
 576 ; CHECK-O0-NEXT:    addps %xmm1, %xmm0
 577 ; CHECK-O0-NEXT:    addps %xmm2, %xmm0
 578 ; CHECK-O0-NEXT:    movaps %xmm3, %xmm1
 579 ; CHECK-O0-NEXT:    popq %rax
 580 ; CHECK-O0-NEXT:    .cfi_def_cfa_offset 8
 581 ; CHECK-O0-NEXT:    retq
 582 entry:
 583   %call = call swiftcc { <4 x float>, <4 x float>, <4 x float>, float } @gen12()
 584
 585   %v3 = extractvalue { <4 x float>, <4 x float>, <4 x float>, float } %call, 0
 586   %v5 = extractvalue { <4 x float>, <4 x float>, <4 x float>, float } %call, 1
 587   %v6 = extractvalue { <4 x float>, <4 x float>, <4 x float>, float } %call, 2
 588   %v8 = extractvalue { <4 x float>, <4 x float>, <4 x float>, float } %call, 3
 589
 590   %add = fadd <4 x float> %v3, %v5
 591   %add1 = fadd <4 x float> %add, %v6
 592   %res.0 = insertvalue { <4 x float>, float } undef, <4 x float> %add1, 0
 593   %res = insertvalue { <4 x float>, float } %res.0, float %v8, 1
 594   ret { <4 x float>, float } %res
 595 }
 596
 597 declare swiftcc { <4 x float>, <4 x float>, <4 x float>, float } @gen12()