llvm/test/CodeGen/AArch64/arm64-fp128.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=arm64-linux-gnu -verify-machineinstrs < %s | FileCheck %s --check-prefixes=CHECK,CHECK-SD
   3 ; RUN: llc -mtriple=arm64-linux-gnu -verify-machineinstrs -global-isel -global-isel-abort=2 < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-GI
   4
   5 ; CHECK-GI:       warning: Instruction selection used fallback path for test_neg_sub
   6
   7 define fp128 @test_add(fp128 %lhs, fp128 %rhs) {
   8 ; CHECK-LABEL: test_add:
   9 ; CHECK:       // %bb.0:
  10 ; CHECK-NEXT:    b __addtf3
  11   %val = fadd fp128 %lhs, %rhs
  12   ret fp128 %val
  13 }
  14
  15 define fp128 @test_sub(fp128 %lhs, fp128 %rhs) {
  16 ; CHECK-LABEL: test_sub:
  17 ; CHECK:       // %bb.0:
  18 ; CHECK-NEXT:    b __subtf3
  19   %val = fsub fp128 %lhs, %rhs
  20   ret fp128 %val
  21 }
  22
  23 define fp128 @test_mul(fp128 %lhs, fp128 %rhs) {
  24 ; CHECK-LABEL: test_mul:
  25 ; CHECK:       // %bb.0:
  26 ; CHECK-NEXT:    b __multf3
  27   %val = fmul fp128 %lhs, %rhs
  28   ret fp128 %val
  29 }
  30
  31 define fp128 @test_div(fp128 %lhs, fp128 %rhs) {
  32 ; CHECK-LABEL: test_div:
  33 ; CHECK:       // %bb.0:
  34 ; CHECK-NEXT:    b __divtf3
  35   %val = fdiv fp128 %lhs, %rhs
  36   ret fp128 %val
  37 }
  38
  39 define i32 @test_fptosi_32(fp128 %val) {
  40 ; CHECK-SD-LABEL: test_fptosi_32:
  41 ; CHECK-SD:       // %bb.0:
  42 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
  43 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
  44 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
  45 ; CHECK-SD-NEXT:    bl __fixtfsi
  46 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
  47 ; CHECK-SD-NEXT:    ret
  48 ;
  49 ; CHECK-GI-LABEL: test_fptosi_32:
  50 ; CHECK-GI:       // %bb.0:
  51 ; CHECK-GI-NEXT:    b __fixtfsi
  52   %val32 = fptosi fp128 %val to i32
  53   ret i32 %val32
  54 }
  55
  56 define i64 @test_fptosi_64(fp128 %val) {
  57 ; CHECK-SD-LABEL: test_fptosi_64:
  58 ; CHECK-SD:       // %bb.0:
  59 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
  60 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
  61 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
  62 ; CHECK-SD-NEXT:    bl __fixtfdi
  63 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
  64 ; CHECK-SD-NEXT:    ret
  65 ;
  66 ; CHECK-GI-LABEL: test_fptosi_64:
  67 ; CHECK-GI:       // %bb.0:
  68 ; CHECK-GI-NEXT:    b __fixtfdi
  69   %val64 = fptosi fp128 %val to i64
  70   ret i64 %val64
  71 }
  72
  73 define i32 @test_fptoui_32(fp128 %val) {
  74 ; CHECK-SD-LABEL: test_fptoui_32:
  75 ; CHECK-SD:       // %bb.0:
  76 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
  77 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
  78 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
  79 ; CHECK-SD-NEXT:    bl __fixunstfsi
  80 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
  81 ; CHECK-SD-NEXT:    ret
  82 ;
  83 ; CHECK-GI-LABEL: test_fptoui_32:
  84 ; CHECK-GI:       // %bb.0:
  85 ; CHECK-GI-NEXT:    b __fixunstfsi
  86   %val32 = fptoui fp128 %val to i32
  87   ret i32 %val32
  88 }
  89
  90 define i64 @test_fptoui_64(fp128 %val) {
  91 ; CHECK-SD-LABEL: test_fptoui_64:
  92 ; CHECK-SD:       // %bb.0:
  93 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
  94 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
  95 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
  96 ; CHECK-SD-NEXT:    bl __fixunstfdi
  97 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
  98 ; CHECK-SD-NEXT:    ret
  99 ;
 100 ; CHECK-GI-LABEL: test_fptoui_64:
 101 ; CHECK-GI:       // %bb.0:
 102 ; CHECK-GI-NEXT:    b __fixunstfdi
 103   %val64 = fptoui fp128 %val to i64
 104   ret i64 %val64
 105 }
 106
 107 define fp128 @test_sitofp_32(i32 %src32) {
 108 ; CHECK-SD-LABEL: test_sitofp_32:
 109 ; CHECK-SD:       // %bb.0:
 110 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 111 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 112 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 113 ; CHECK-SD-NEXT:    bl __floatsitf
 114 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 115 ; CHECK-SD-NEXT:    ret
 116 ;
 117 ; CHECK-GI-LABEL: test_sitofp_32:
 118 ; CHECK-GI:       // %bb.0:
 119 ; CHECK-GI-NEXT:    b __floatsitf
 120   %val32 = sitofp i32 %src32 to fp128
 121   ret fp128 %val32
 122 }
 123
 124 define fp128 @test_sitofp_64(i64 %src64) {
 125 ; CHECK-SD-LABEL: test_sitofp_64:
 126 ; CHECK-SD:       // %bb.0:
 127 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 128 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 129 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 130 ; CHECK-SD-NEXT:    bl __floatditf
 131 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 132 ; CHECK-SD-NEXT:    ret
 133 ;
 134 ; CHECK-GI-LABEL: test_sitofp_64:
 135 ; CHECK-GI:       // %bb.0:
 136 ; CHECK-GI-NEXT:    b __floatditf
 137   %val64 = sitofp i64 %src64 to fp128
 138   ret fp128 %val64
 139 }
 140
 141 define fp128 @test_uitofp_32(i32 %src32) {
 142 ; CHECK-SD-LABEL: test_uitofp_32:
 143 ; CHECK-SD:       // %bb.0:
 144 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 145 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 146 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 147 ; CHECK-SD-NEXT:    bl __floatunsitf
 148 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 149 ; CHECK-SD-NEXT:    ret
 150 ;
 151 ; CHECK-GI-LABEL: test_uitofp_32:
 152 ; CHECK-GI:       // %bb.0:
 153 ; CHECK-GI-NEXT:    b __floatunsitf
 154   %val32 = uitofp i32 %src32 to fp128
 155   ret fp128 %val32
 156 }
 157
 158 define fp128 @test_uitofp_64(i64 %src64) {
 159 ; CHECK-SD-LABEL: test_uitofp_64:
 160 ; CHECK-SD:       // %bb.0:
 161 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 162 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 163 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 164 ; CHECK-SD-NEXT:    bl __floatunditf
 165 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 166 ; CHECK-SD-NEXT:    ret
 167 ;
 168 ; CHECK-GI-LABEL: test_uitofp_64:
 169 ; CHECK-GI:       // %bb.0:
 170 ; CHECK-GI-NEXT:    b __floatunditf
 171   %val64 = uitofp i64 %src64 to fp128
 172   ret fp128 %val64
 173 }
 174
 175 ; Technically, everything after the call to __letf2 is redundant, but we'll let
 176 ; LLVM have its fun for now.
 177 define i1 @test_setcc1(fp128 %lhs, fp128 %rhs) {
 178 ; CHECK-LABEL: test_setcc1:
 179 ; CHECK:       // %bb.0:
 180 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 181 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 182 ; CHECK-NEXT:    .cfi_offset w30, -16
 183 ; CHECK-NEXT:    bl __letf2
 184 ; CHECK-NEXT:    cmp w0, #0
 185 ; CHECK-NEXT:    cset w0, le
 186 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 187 ; CHECK-NEXT:    ret
 188   %val = fcmp ole fp128 %lhs, %rhs
 189   ret i1 %val
 190 }
 191
 192 define i1 @test_setcc2(fp128 %lhs, fp128 %rhs) {
 193 ; CHECK-LABEL: test_setcc2:
 194 ; CHECK:       // %bb.0:
 195 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 196 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 197 ; CHECK-NEXT:    .cfi_offset w30, -16
 198 ; CHECK-NEXT:    bl __letf2
 199 ; CHECK-NEXT:    cmp w0, #0
 200 ; CHECK-NEXT:    cset w0, gt
 201 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 202 ; CHECK-NEXT:    ret
 203   %val = fcmp ugt fp128 %lhs, %rhs
 204   ret i1 %val
 205 }
 206
 207 define i1 @test_setcc3(fp128 %lhs, fp128 %rhs) {
 208 ; CHECK-SD-LABEL: test_setcc3:
 209 ; CHECK-SD:       // %bb.0:
 210 ; CHECK-SD-NEXT:    sub sp, sp, #48
 211 ; CHECK-SD-NEXT:    stp x30, x19, [sp, #32] // 16-byte Folded Spill
 212 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 213 ; CHECK-SD-NEXT:    .cfi_offset w19, -8
 214 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 215 ; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
 216 ; CHECK-SD-NEXT:    bl __eqtf2
 217 ; CHECK-SD-NEXT:    ldp q0, q1, [sp] // 32-byte Folded Reload
 218 ; CHECK-SD-NEXT:    mov w19, w0
 219 ; CHECK-SD-NEXT:    bl __unordtf2
 220 ; CHECK-SD-NEXT:    cmp w0, #0
 221 ; CHECK-SD-NEXT:    ccmp w19, #0, #4, eq
 222 ; CHECK-SD-NEXT:    ldp x30, x19, [sp, #32] // 16-byte Folded Reload
 223 ; CHECK-SD-NEXT:    cset w0, eq
 224 ; CHECK-SD-NEXT:    add sp, sp, #48
 225 ; CHECK-SD-NEXT:    ret
 226 ;
 227 ; CHECK-GI-LABEL: test_setcc3:
 228 ; CHECK-GI:       // %bb.0:
 229 ; CHECK-GI-NEXT:    sub sp, sp, #48
 230 ; CHECK-GI-NEXT:    stp x30, x19, [sp, #32] // 16-byte Folded Spill
 231 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 48
 232 ; CHECK-GI-NEXT:    .cfi_offset w19, -8
 233 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 234 ; CHECK-GI-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
 235 ; CHECK-GI-NEXT:    bl __eqtf2
 236 ; CHECK-GI-NEXT:    ldp q1, q0, [sp] // 32-byte Folded Reload
 237 ; CHECK-GI-NEXT:    cmp w0, #0
 238 ; CHECK-GI-NEXT:    cset w19, eq
 239 ; CHECK-GI-NEXT:    bl __unordtf2
 240 ; CHECK-GI-NEXT:    cmp w0, #0
 241 ; CHECK-GI-NEXT:    cset w8, ne
 242 ; CHECK-GI-NEXT:    orr w0, w19, w8
 243 ; CHECK-GI-NEXT:    ldp x30, x19, [sp, #32] // 16-byte Folded Reload
 244 ; CHECK-GI-NEXT:    add sp, sp, #48
 245 ; CHECK-GI-NEXT:    ret
 246   %val = fcmp ueq fp128 %lhs, %rhs
 247   ret i1 %val
 248 }
 249
 250 ; olt == !uge, which LLVM optimizes this to.
 251 define i32 @test_br_cc(fp128 %lhs, fp128 %rhs) {
 252 ; CHECK-SD-LABEL: test_br_cc:
 253 ; CHECK-SD:       // %bb.0: // %common.ret
 254 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 255 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 256 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 257 ; CHECK-SD-NEXT:    bl __lttf2
 258 ; CHECK-SD-NEXT:    mov w8, #29 // =0x1d
 259 ; CHECK-SD-NEXT:    cmp w0, #0
 260 ; CHECK-SD-NEXT:    mov w9, #42 // =0x2a
 261 ; CHECK-SD-NEXT:    csel w0, w9, w8, lt
 262 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 263 ; CHECK-SD-NEXT:    ret
 264 ;
 265 ; CHECK-GI-LABEL: test_br_cc:
 266 ; CHECK-GI:       // %bb.0: // %common.ret
 267 ; CHECK-GI-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 268 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 16
 269 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 270 ; CHECK-GI-NEXT:    bl __lttf2
 271 ; CHECK-GI-NEXT:    mov w8, #29 // =0x1d
 272 ; CHECK-GI-NEXT:    mov w9, #42 // =0x2a
 273 ; CHECK-GI-NEXT:    cmp w0, #0
 274 ; CHECK-GI-NEXT:    csel w0, w9, w8, lt
 275 ; CHECK-GI-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 276 ; CHECK-GI-NEXT:    ret
 277   %cond = fcmp olt fp128 %lhs, %rhs
 278   br i1 %cond, label %iftrue, label %iffalse
 279
 280 iftrue:
 281   ret i32 42
 282 iffalse:
 283   ret i32 29
 284 }
 285
 286 define fp128 @test_select(i1 %cond, fp128 %lhs, fp128 %rhs) {
 287 ; CHECK-SD-LABEL: test_select:
 288 ; CHECK-SD:       // %bb.0:
 289 ; CHECK-SD-NEXT:    tst w0, #0x1
 290 ; CHECK-SD-NEXT:    b.eq .LBB16_2
 291 ; CHECK-SD-NEXT:  // %bb.1:
 292 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 293 ; CHECK-SD-NEXT:  .LBB16_2:
 294 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
 295 ; CHECK-SD-NEXT:    ret
 296 ;
 297 ; CHECK-GI-LABEL: test_select:
 298 ; CHECK-GI:       // %bb.0:
 299 ; CHECK-GI-NEXT:    and w8, w0, #0x1
 300 ; CHECK-GI-NEXT:    mov d2, v0.d[1]
 301 ; CHECK-GI-NEXT:    mov d3, v1.d[1]
 302 ; CHECK-GI-NEXT:    tst w8, #0x1
 303 ; CHECK-GI-NEXT:    fcsel d0, d0, d1, ne
 304 ; CHECK-GI-NEXT:    fcsel d1, d2, d3, ne
 305 ; CHECK-GI-NEXT:    fmov x8, d0
 306 ; CHECK-GI-NEXT:    mov v0.d[0], x8
 307 ; CHECK-GI-NEXT:    fmov x8, d1
 308 ; CHECK-GI-NEXT:    mov v0.d[1], x8
 309 ; CHECK-GI-NEXT:    ret
 310   %val = select i1 %cond, fp128 %lhs, fp128 %rhs
 311   ret fp128 %val
 312 }
 313
 314 define half @test_round_f16(fp128 %val) {
 315 ; CHECK-SD-LABEL: test_round_f16:
 316 ; CHECK-SD:       // %bb.0:
 317 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 318 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 319 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 320 ; CHECK-SD-NEXT:    bl __trunctfhf2
 321 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 322 ; CHECK-SD-NEXT:    ret
 323 ;
 324 ; CHECK-GI-LABEL: test_round_f16:
 325 ; CHECK-GI:       // %bb.0:
 326 ; CHECK-GI-NEXT:    b __trunctfhf2
 327   %dst = fptrunc fp128 %val to half
 328   ret half %dst
 329 }
 330
 331 define float @test_round_f32(fp128 %val) {
 332 ; CHECK-SD-LABEL: test_round_f32:
 333 ; CHECK-SD:       // %bb.0:
 334 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 335 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 336 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 337 ; CHECK-SD-NEXT:    bl __trunctfsf2
 338 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 339 ; CHECK-SD-NEXT:    ret
 340 ;
 341 ; CHECK-GI-LABEL: test_round_f32:
 342 ; CHECK-GI:       // %bb.0:
 343 ; CHECK-GI-NEXT:    b __trunctfsf2
 344   %dst = fptrunc fp128 %val to float
 345   ret float %dst
 346 }
 347
 348 define double @test_round_f64(fp128 %val) {
 349 ; CHECK-SD-LABEL: test_round_f64:
 350 ; CHECK-SD:       // %bb.0:
 351 ; CHECK-SD-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 352 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 353 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 354 ; CHECK-SD-NEXT:    bl __trunctfdf2
 355 ; CHECK-SD-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 356 ; CHECK-SD-NEXT:    ret
 357 ;
 358 ; CHECK-GI-LABEL: test_round_f64:
 359 ; CHECK-GI:       // %bb.0:
 360 ; CHECK-GI-NEXT:    b __trunctfdf2
 361   %dst = fptrunc fp128 %val to double
 362   ret double %dst
 363 }
 364
 365 define fp128 @test_extend_f16(half %val) {
 366 ; CHECK-LABEL: test_extend_f16:
 367 ; CHECK:       // %bb.0:
 368 ; CHECK-NEXT:    b __extendhftf2
 369   %dst = fpext half %val to fp128
 370   ret fp128 %dst
 371 }
 372
 373 define fp128 @test_extend_f32(float %val) {
 374 ; CHECK-LABEL: test_extend_f32:
 375 ; CHECK:       // %bb.0:
 376 ; CHECK-NEXT:    b __extendsftf2
 377   %dst = fpext float %val to fp128
 378   ret fp128 %dst
 379 }
 380
 381 define fp128 @test_extend_f64(double %val) {
 382 ; CHECK-LABEL: test_extend_f64:
 383 ; CHECK:       // %bb.0:
 384 ; CHECK-NEXT:    b __extenddftf2
 385   %dst = fpext double %val to fp128
 386   ret fp128 %dst
 387 }
 388
 389 ;; We convert this to fneg, and target-independent code expands it with
 390 ;; integer operations.
 391 define fp128 @test_neg_sub(fp128 %in) {
 392 ; CHECK-LABEL: test_neg_sub:
 393 ; CHECK:       // %bb.0:
 394 ; CHECK-NEXT:    str q0, [sp, #-16]!
 395 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
 396 ; CHECK-NEXT:    ldrb w8, [sp, #15]
 397 ; CHECK-NEXT:    eor w8, w8, #0x80
 398 ; CHECK-NEXT:    strb w8, [sp, #15]
 399 ; CHECK-NEXT:    ldr q0, [sp], #16
 400 ; CHECK-NEXT:    ret
 401   %ret = fsub fp128 0xL00000000000000008000000000000000, %in
 402   ret fp128 %ret
 403 }
 404
 405 define fp128 @test_neg(fp128 %in) {
 406 ; CHECK-SD-LABEL: test_neg:
 407 ; CHECK-SD:       // %bb.0:
 408 ; CHECK-SD-NEXT:    str q0, [sp, #-16]!
 409 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 16
 410 ; CHECK-SD-NEXT:    ldrb w8, [sp, #15]
 411 ; CHECK-SD-NEXT:    eor w8, w8, #0x80
 412 ; CHECK-SD-NEXT:    strb w8, [sp, #15]
 413 ; CHECK-SD-NEXT:    ldr q0, [sp], #16
 414 ; CHECK-SD-NEXT:    ret
 415 ;
 416 ; CHECK-GI-LABEL: test_neg:
 417 ; CHECK-GI:       // %bb.0:
 418 ; CHECK-GI-NEXT:    mov x8, v0.d[1]
 419 ; CHECK-GI-NEXT:    mov v0.d[0], v0.d[0]
 420 ; CHECK-GI-NEXT:    eor x8, x8, #0x8000000000000000
 421 ; CHECK-GI-NEXT:    mov v0.d[1], x8
 422 ; CHECK-GI-NEXT:    ret
 423   %ret = fneg fp128 %in
 424   ret fp128 %ret
 425 }
 426
 427
 428
 429 define <2 x fp128> @vec_add(<2 x fp128> %lhs, <2 x fp128> %rhs) {
 430 ; CHECK-SD-LABEL: vec_add:
 431 ; CHECK-SD:       // %bb.0:
 432 ; CHECK-SD-NEXT:    sub sp, sp, #64
 433 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 434 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
 435 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 436 ; CHECK-SD-NEXT:    stp q1, q3, [sp, #16] // 32-byte Folded Spill
 437 ; CHECK-SD-NEXT:    mov v1.16b, v2.16b
 438 ; CHECK-SD-NEXT:    bl __addtf3
 439 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 440 ; CHECK-SD-NEXT:    ldp q0, q1, [sp, #16] // 32-byte Folded Reload
 441 ; CHECK-SD-NEXT:    bl __addtf3
 442 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 443 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 444 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 445 ; CHECK-SD-NEXT:    add sp, sp, #64
 446 ; CHECK-SD-NEXT:    ret
 447 ;
 448 ; CHECK-GI-LABEL: vec_add:
 449 ; CHECK-GI:       // %bb.0:
 450 ; CHECK-GI-NEXT:    sub sp, sp, #64
 451 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 452 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
 453 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 454 ; CHECK-GI-NEXT:    stp q3, q1, [sp, #16] // 32-byte Folded Spill
 455 ; CHECK-GI-NEXT:    mov v1.16b, v2.16b
 456 ; CHECK-GI-NEXT:    bl __addtf3
 457 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 458 ; CHECK-GI-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
 459 ; CHECK-GI-NEXT:    bl __addtf3
 460 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
 461 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 462 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 463 ; CHECK-GI-NEXT:    add sp, sp, #64
 464 ; CHECK-GI-NEXT:    ret
 465   %val = fadd <2 x fp128> %lhs, %rhs
 466   ret <2 x fp128> %val
 467 }
 468
 469 define <2 x fp128> @vec_sub(<2 x fp128> %lhs, <2 x fp128> %rhs) {
 470 ; CHECK-SD-LABEL: vec_sub:
 471 ; CHECK-SD:       // %bb.0:
 472 ; CHECK-SD-NEXT:    sub sp, sp, #64
 473 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 474 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
 475 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 476 ; CHECK-SD-NEXT:    stp q1, q3, [sp, #16] // 32-byte Folded Spill
 477 ; CHECK-SD-NEXT:    mov v1.16b, v2.16b
 478 ; CHECK-SD-NEXT:    bl __subtf3
 479 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 480 ; CHECK-SD-NEXT:    ldp q0, q1, [sp, #16] // 32-byte Folded Reload
 481 ; CHECK-SD-NEXT:    bl __subtf3
 482 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 483 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 484 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 485 ; CHECK-SD-NEXT:    add sp, sp, #64
 486 ; CHECK-SD-NEXT:    ret
 487 ;
 488 ; CHECK-GI-LABEL: vec_sub:
 489 ; CHECK-GI:       // %bb.0:
 490 ; CHECK-GI-NEXT:    sub sp, sp, #64
 491 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 492 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
 493 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 494 ; CHECK-GI-NEXT:    stp q3, q1, [sp, #16] // 32-byte Folded Spill
 495 ; CHECK-GI-NEXT:    mov v1.16b, v2.16b
 496 ; CHECK-GI-NEXT:    bl __subtf3
 497 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 498 ; CHECK-GI-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
 499 ; CHECK-GI-NEXT:    bl __subtf3
 500 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
 501 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 502 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 503 ; CHECK-GI-NEXT:    add sp, sp, #64
 504 ; CHECK-GI-NEXT:    ret
 505   %val = fsub <2 x fp128> %lhs, %rhs
 506   ret <2 x fp128> %val
 507 }
 508
 509 define <2 x fp128> @vec_mul(<2 x fp128> %lhs, <2 x fp128> %rhs) {
 510 ; CHECK-SD-LABEL: vec_mul:
 511 ; CHECK-SD:       // %bb.0:
 512 ; CHECK-SD-NEXT:    sub sp, sp, #64
 513 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 514 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
 515 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 516 ; CHECK-SD-NEXT:    stp q1, q3, [sp, #16] // 32-byte Folded Spill
 517 ; CHECK-SD-NEXT:    mov v1.16b, v2.16b
 518 ; CHECK-SD-NEXT:    bl __multf3
 519 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 520 ; CHECK-SD-NEXT:    ldp q0, q1, [sp, #16] // 32-byte Folded Reload
 521 ; CHECK-SD-NEXT:    bl __multf3
 522 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 523 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 524 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 525 ; CHECK-SD-NEXT:    add sp, sp, #64
 526 ; CHECK-SD-NEXT:    ret
 527 ;
 528 ; CHECK-GI-LABEL: vec_mul:
 529 ; CHECK-GI:       // %bb.0:
 530 ; CHECK-GI-NEXT:    sub sp, sp, #64
 531 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 532 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
 533 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 534 ; CHECK-GI-NEXT:    stp q3, q1, [sp, #16] // 32-byte Folded Spill
 535 ; CHECK-GI-NEXT:    mov v1.16b, v2.16b
 536 ; CHECK-GI-NEXT:    bl __multf3
 537 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 538 ; CHECK-GI-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
 539 ; CHECK-GI-NEXT:    bl __multf3
 540 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
 541 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 542 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 543 ; CHECK-GI-NEXT:    add sp, sp, #64
 544 ; CHECK-GI-NEXT:    ret
 545   %val = fmul <2 x fp128> %lhs, %rhs
 546   ret <2 x fp128> %val
 547 }
 548
 549 define <2 x fp128> @vec_div(<2 x fp128> %lhs, <2 x fp128> %rhs) {
 550 ; CHECK-SD-LABEL: vec_div:
 551 ; CHECK-SD:       // %bb.0:
 552 ; CHECK-SD-NEXT:    sub sp, sp, #64
 553 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 554 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
 555 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 556 ; CHECK-SD-NEXT:    stp q1, q3, [sp, #16] // 32-byte Folded Spill
 557 ; CHECK-SD-NEXT:    mov v1.16b, v2.16b
 558 ; CHECK-SD-NEXT:    bl __divtf3
 559 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 560 ; CHECK-SD-NEXT:    ldp q0, q1, [sp, #16] // 32-byte Folded Reload
 561 ; CHECK-SD-NEXT:    bl __divtf3
 562 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 563 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 564 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 565 ; CHECK-SD-NEXT:    add sp, sp, #64
 566 ; CHECK-SD-NEXT:    ret
 567 ;
 568 ; CHECK-GI-LABEL: vec_div:
 569 ; CHECK-GI:       // %bb.0:
 570 ; CHECK-GI-NEXT:    sub sp, sp, #64
 571 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 572 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
 573 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 574 ; CHECK-GI-NEXT:    stp q3, q1, [sp, #16] // 32-byte Folded Spill
 575 ; CHECK-GI-NEXT:    mov v1.16b, v2.16b
 576 ; CHECK-GI-NEXT:    bl __divtf3
 577 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 578 ; CHECK-GI-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
 579 ; CHECK-GI-NEXT:    bl __divtf3
 580 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
 581 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 582 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 583 ; CHECK-GI-NEXT:    add sp, sp, #64
 584 ; CHECK-GI-NEXT:    ret
 585   %val = fdiv <2 x fp128> %lhs, %rhs
 586   ret <2 x fp128> %val
 587 }
 588
 589 define <2 x i32> @vec_fptosi_32(<2 x fp128> %val) {
 590 ; CHECK-SD-LABEL: vec_fptosi_32:
 591 ; CHECK-SD:       // %bb.0:
 592 ; CHECK-SD-NEXT:    sub sp, sp, #48
 593 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 594 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 595 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 596 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 597 ; CHECK-SD-NEXT:    bl __fixtfsi
 598 ; CHECK-SD-NEXT:    fmov s0, w0
 599 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 600 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 601 ; CHECK-SD-NEXT:    bl __fixtfsi
 602 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 603 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 604 ; CHECK-SD-NEXT:    mov v0.s[1], w0
 605 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
 606 ; CHECK-SD-NEXT:    add sp, sp, #48
 607 ; CHECK-SD-NEXT:    ret
 608 ;
 609 ; CHECK-GI-LABEL: vec_fptosi_32:
 610 ; CHECK-GI:       // %bb.0:
 611 ; CHECK-GI-NEXT:    sub sp, sp, #32
 612 ; CHECK-GI-NEXT:    stp x30, x19, [sp, #16] // 16-byte Folded Spill
 613 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 614 ; CHECK-GI-NEXT:    .cfi_offset w19, -8
 615 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 616 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
 617 ; CHECK-GI-NEXT:    bl __fixtfsi
 618 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 619 ; CHECK-GI-NEXT:    mov w19, w0
 620 ; CHECK-GI-NEXT:    bl __fixtfsi
 621 ; CHECK-GI-NEXT:    mov v0.s[0], w19
 622 ; CHECK-GI-NEXT:    ldp x30, x19, [sp, #16] // 16-byte Folded Reload
 623 ; CHECK-GI-NEXT:    mov v0.s[1], w0
 624 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
 625 ; CHECK-GI-NEXT:    add sp, sp, #32
 626 ; CHECK-GI-NEXT:    ret
 627   %val32 = fptosi <2 x fp128> %val to <2 x i32>
 628   ret <2 x i32> %val32
 629 }
 630
 631 define <2 x i64> @vec_fptosi_64(<2 x fp128> %val) {
 632 ; CHECK-SD-LABEL: vec_fptosi_64:
 633 ; CHECK-SD:       // %bb.0:
 634 ; CHECK-SD-NEXT:    sub sp, sp, #48
 635 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 636 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 637 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 638 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 639 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
 640 ; CHECK-SD-NEXT:    bl __fixtfdi
 641 ; CHECK-SD-NEXT:    fmov d0, x0
 642 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 643 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 644 ; CHECK-SD-NEXT:    bl __fixtfdi
 645 ; CHECK-SD-NEXT:    fmov d0, x0
 646 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 647 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 648 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
 649 ; CHECK-SD-NEXT:    add sp, sp, #48
 650 ; CHECK-SD-NEXT:    ret
 651 ;
 652 ; CHECK-GI-LABEL: vec_fptosi_64:
 653 ; CHECK-GI:       // %bb.0:
 654 ; CHECK-GI-NEXT:    sub sp, sp, #32
 655 ; CHECK-GI-NEXT:    stp x30, x19, [sp, #16] // 16-byte Folded Spill
 656 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 657 ; CHECK-GI-NEXT:    .cfi_offset w19, -8
 658 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 659 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
 660 ; CHECK-GI-NEXT:    bl __fixtfdi
 661 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 662 ; CHECK-GI-NEXT:    mov x19, x0
 663 ; CHECK-GI-NEXT:    bl __fixtfdi
 664 ; CHECK-GI-NEXT:    mov v0.d[0], x19
 665 ; CHECK-GI-NEXT:    ldp x30, x19, [sp, #16] // 16-byte Folded Reload
 666 ; CHECK-GI-NEXT:    mov v0.d[1], x0
 667 ; CHECK-GI-NEXT:    add sp, sp, #32
 668 ; CHECK-GI-NEXT:    ret
 669   %val64 = fptosi <2 x fp128> %val to <2 x i64>
 670   ret <2 x i64> %val64
 671 }
 672
 673 define <2 x i32> @vec_fptoui_32(<2 x fp128> %val) {
 674 ; CHECK-SD-LABEL: vec_fptoui_32:
 675 ; CHECK-SD:       // %bb.0:
 676 ; CHECK-SD-NEXT:    sub sp, sp, #48
 677 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 678 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 679 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 680 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 681 ; CHECK-SD-NEXT:    bl __fixunstfsi
 682 ; CHECK-SD-NEXT:    fmov s0, w0
 683 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 684 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 685 ; CHECK-SD-NEXT:    bl __fixunstfsi
 686 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 687 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 688 ; CHECK-SD-NEXT:    mov v0.s[1], w0
 689 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
 690 ; CHECK-SD-NEXT:    add sp, sp, #48
 691 ; CHECK-SD-NEXT:    ret
 692 ;
 693 ; CHECK-GI-LABEL: vec_fptoui_32:
 694 ; CHECK-GI:       // %bb.0:
 695 ; CHECK-GI-NEXT:    sub sp, sp, #32
 696 ; CHECK-GI-NEXT:    stp x30, x19, [sp, #16] // 16-byte Folded Spill
 697 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 698 ; CHECK-GI-NEXT:    .cfi_offset w19, -8
 699 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 700 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
 701 ; CHECK-GI-NEXT:    bl __fixunstfsi
 702 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 703 ; CHECK-GI-NEXT:    mov w19, w0
 704 ; CHECK-GI-NEXT:    bl __fixunstfsi
 705 ; CHECK-GI-NEXT:    mov v0.s[0], w19
 706 ; CHECK-GI-NEXT:    ldp x30, x19, [sp, #16] // 16-byte Folded Reload
 707 ; CHECK-GI-NEXT:    mov v0.s[1], w0
 708 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
 709 ; CHECK-GI-NEXT:    add sp, sp, #32
 710 ; CHECK-GI-NEXT:    ret
 711   %val32 = fptoui <2 x fp128> %val to <2 x i32>
 712   ret <2 x i32> %val32
 713 }
 714
 715 define <2 x i64> @vec_fptoui_64(<2 x fp128> %val) {
 716 ; CHECK-SD-LABEL: vec_fptoui_64:
 717 ; CHECK-SD:       // %bb.0:
 718 ; CHECK-SD-NEXT:    sub sp, sp, #48
 719 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 720 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 721 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 722 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 723 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
 724 ; CHECK-SD-NEXT:    bl __fixunstfdi
 725 ; CHECK-SD-NEXT:    fmov d0, x0
 726 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 727 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 728 ; CHECK-SD-NEXT:    bl __fixunstfdi
 729 ; CHECK-SD-NEXT:    fmov d0, x0
 730 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 731 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 732 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
 733 ; CHECK-SD-NEXT:    add sp, sp, #48
 734 ; CHECK-SD-NEXT:    ret
 735 ;
 736 ; CHECK-GI-LABEL: vec_fptoui_64:
 737 ; CHECK-GI:       // %bb.0:
 738 ; CHECK-GI-NEXT:    sub sp, sp, #32
 739 ; CHECK-GI-NEXT:    stp x30, x19, [sp, #16] // 16-byte Folded Spill
 740 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 741 ; CHECK-GI-NEXT:    .cfi_offset w19, -8
 742 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 743 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
 744 ; CHECK-GI-NEXT:    bl __fixunstfdi
 745 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 746 ; CHECK-GI-NEXT:    mov x19, x0
 747 ; CHECK-GI-NEXT:    bl __fixunstfdi
 748 ; CHECK-GI-NEXT:    mov v0.d[0], x19
 749 ; CHECK-GI-NEXT:    ldp x30, x19, [sp, #16] // 16-byte Folded Reload
 750 ; CHECK-GI-NEXT:    mov v0.d[1], x0
 751 ; CHECK-GI-NEXT:    add sp, sp, #32
 752 ; CHECK-GI-NEXT:    ret
 753   %val64 = fptoui <2 x fp128> %val to <2 x i64>
 754   ret <2 x i64> %val64
 755 }
 756
 757 define <2 x fp128> @vec_sitofp_32(<2 x i32> %src32) {
 758 ; CHECK-SD-LABEL: vec_sitofp_32:
 759 ; CHECK-SD:       // %bb.0:
 760 ; CHECK-SD-NEXT:    sub sp, sp, #32
 761 ; CHECK-SD-NEXT:    str x30, [sp, #16] // 8-byte Folded Spill
 762 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
 763 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 764 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
 765 ; CHECK-SD-NEXT:    fmov w0, s0
 766 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 767 ; CHECK-SD-NEXT:    bl __floatsitf
 768 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 769 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 770 ; CHECK-SD-NEXT:    mov w0, v1.s[1]
 771 ; CHECK-SD-NEXT:    bl __floatsitf
 772 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 773 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 774 ; CHECK-SD-NEXT:    ldr x30, [sp, #16] // 8-byte Folded Reload
 775 ; CHECK-SD-NEXT:    add sp, sp, #32
 776 ; CHECK-SD-NEXT:    ret
 777 ;
 778 ; CHECK-GI-LABEL: vec_sitofp_32:
 779 ; CHECK-GI:       // %bb.0:
 780 ; CHECK-GI-NEXT:    sub sp, sp, #32
 781 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
 782 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
 783 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 784 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 785 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 786 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
 787 ; CHECK-GI-NEXT:    fmov w0, s0
 788 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
 789 ; CHECK-GI-NEXT:    bl __floatsitf
 790 ; CHECK-GI-NEXT:    fmov w0, s8
 791 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 792 ; CHECK-GI-NEXT:    bl __floatsitf
 793 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
 794 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 795 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
 796 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
 797 ; CHECK-GI-NEXT:    add sp, sp, #32
 798 ; CHECK-GI-NEXT:    ret
 799   %val32 = sitofp <2 x i32> %src32 to <2 x fp128>
 800   ret <2 x fp128> %val32
 801 }
 802
 803 define <2 x fp128> @vec_sitofp_64(<2 x i64> %src64) {
 804 ; CHECK-SD-LABEL: vec_sitofp_64:
 805 ; CHECK-SD:       // %bb.0:
 806 ; CHECK-SD-NEXT:    sub sp, sp, #48
 807 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 808 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 809 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 810 ; CHECK-SD-NEXT:    fmov x0, d0
 811 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 812 ; CHECK-SD-NEXT:    bl __floatditf
 813 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 814 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 815 ; CHECK-SD-NEXT:    mov x0, v0.d[1]
 816 ; CHECK-SD-NEXT:    bl __floatditf
 817 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 818 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 819 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 820 ; CHECK-SD-NEXT:    add sp, sp, #48
 821 ; CHECK-SD-NEXT:    ret
 822 ;
 823 ; CHECK-GI-LABEL: vec_sitofp_64:
 824 ; CHECK-GI:       // %bb.0:
 825 ; CHECK-GI-NEXT:    sub sp, sp, #32
 826 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
 827 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
 828 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 829 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 830 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 831 ; CHECK-GI-NEXT:    fmov x0, d0
 832 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
 833 ; CHECK-GI-NEXT:    bl __floatditf
 834 ; CHECK-GI-NEXT:    fmov x0, d8
 835 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 836 ; CHECK-GI-NEXT:    bl __floatditf
 837 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
 838 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 839 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
 840 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
 841 ; CHECK-GI-NEXT:    add sp, sp, #32
 842 ; CHECK-GI-NEXT:    ret
 843   %val64 = sitofp <2 x i64> %src64 to <2 x fp128>
 844   ret <2 x fp128> %val64
 845 }
 846
 847 define <2 x fp128> @vec_uitofp_32(<2 x i32> %src32) {
 848 ; CHECK-SD-LABEL: vec_uitofp_32:
 849 ; CHECK-SD:       // %bb.0:
 850 ; CHECK-SD-NEXT:    sub sp, sp, #32
 851 ; CHECK-SD-NEXT:    str x30, [sp, #16] // 8-byte Folded Spill
 852 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
 853 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 854 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
 855 ; CHECK-SD-NEXT:    fmov w0, s0
 856 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 857 ; CHECK-SD-NEXT:    bl __floatunsitf
 858 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 859 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 860 ; CHECK-SD-NEXT:    mov w0, v1.s[1]
 861 ; CHECK-SD-NEXT:    bl __floatunsitf
 862 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 863 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 864 ; CHECK-SD-NEXT:    ldr x30, [sp, #16] // 8-byte Folded Reload
 865 ; CHECK-SD-NEXT:    add sp, sp, #32
 866 ; CHECK-SD-NEXT:    ret
 867 ;
 868 ; CHECK-GI-LABEL: vec_uitofp_32:
 869 ; CHECK-GI:       // %bb.0:
 870 ; CHECK-GI-NEXT:    sub sp, sp, #32
 871 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
 872 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
 873 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 874 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 875 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 876 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
 877 ; CHECK-GI-NEXT:    fmov w0, s0
 878 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
 879 ; CHECK-GI-NEXT:    bl __floatunsitf
 880 ; CHECK-GI-NEXT:    fmov w0, s8
 881 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 882 ; CHECK-GI-NEXT:    bl __floatunsitf
 883 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
 884 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 885 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
 886 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
 887 ; CHECK-GI-NEXT:    add sp, sp, #32
 888 ; CHECK-GI-NEXT:    ret
 889   %val32 = uitofp <2 x i32> %src32 to <2 x fp128>
 890   ret <2 x fp128> %val32
 891 }
 892
 893 define <2 x fp128> @vec_uitofp_64(<2 x i64> %src64) {
 894 ; CHECK-SD-LABEL: vec_uitofp_64:
 895 ; CHECK-SD:       // %bb.0:
 896 ; CHECK-SD-NEXT:    sub sp, sp, #48
 897 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 898 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 899 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 900 ; CHECK-SD-NEXT:    fmov x0, d0
 901 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 902 ; CHECK-SD-NEXT:    bl __floatunditf
 903 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 904 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 905 ; CHECK-SD-NEXT:    mov x0, v0.d[1]
 906 ; CHECK-SD-NEXT:    bl __floatunditf
 907 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
 908 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 909 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 910 ; CHECK-SD-NEXT:    add sp, sp, #48
 911 ; CHECK-SD-NEXT:    ret
 912 ;
 913 ; CHECK-GI-LABEL: vec_uitofp_64:
 914 ; CHECK-GI:       // %bb.0:
 915 ; CHECK-GI-NEXT:    sub sp, sp, #32
 916 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
 917 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
 918 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 919 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 920 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 921 ; CHECK-GI-NEXT:    fmov x0, d0
 922 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
 923 ; CHECK-GI-NEXT:    bl __floatunditf
 924 ; CHECK-GI-NEXT:    fmov x0, d8
 925 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 926 ; CHECK-GI-NEXT:    bl __floatunditf
 927 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
 928 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 929 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
 930 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
 931 ; CHECK-GI-NEXT:    add sp, sp, #32
 932 ; CHECK-GI-NEXT:    ret
 933   %val64 = uitofp <2 x i64> %src64 to <2 x fp128>
 934   ret <2 x fp128> %val64
 935 }
 936
 937 define <2 x i1> @vec_setcc1(<2 x fp128> %lhs, <2 x fp128> %rhs) {
 938 ; CHECK-SD-LABEL: vec_setcc1:
 939 ; CHECK-SD:       // %bb.0:
 940 ; CHECK-SD-NEXT:    sub sp, sp, #48
 941 ; CHECK-SD-NEXT:    str d8, [sp, #32] // 8-byte Folded Spill
 942 ; CHECK-SD-NEXT:    str x30, [sp, #40] // 8-byte Folded Spill
 943 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 944 ; CHECK-SD-NEXT:    .cfi_offset w30, -8
 945 ; CHECK-SD-NEXT:    .cfi_offset b8, -16
 946 ; CHECK-SD-NEXT:    stp q0, q2, [sp] // 32-byte Folded Spill
 947 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
 948 ; CHECK-SD-NEXT:    mov v1.16b, v3.16b
 949 ; CHECK-SD-NEXT:    bl __letf2
 950 ; CHECK-SD-NEXT:    cmp w0, #0
 951 ; CHECK-SD-NEXT:    ldp q0, q1, [sp] // 32-byte Folded Reload
 952 ; CHECK-SD-NEXT:    cset w8, le
 953 ; CHECK-SD-NEXT:    sbfx x8, x8, #0, #1
 954 ; CHECK-SD-NEXT:    fmov d8, x8
 955 ; CHECK-SD-NEXT:    bl __letf2
 956 ; CHECK-SD-NEXT:    cmp w0, #0
 957 ; CHECK-SD-NEXT:    ldr x30, [sp, #40] // 8-byte Folded Reload
 958 ; CHECK-SD-NEXT:    cset w8, le
 959 ; CHECK-SD-NEXT:    sbfx x8, x8, #0, #1
 960 ; CHECK-SD-NEXT:    fmov d0, x8
 961 ; CHECK-SD-NEXT:    zip1 v0.2s, v0.2s, v8.2s
 962 ; CHECK-SD-NEXT:    ldr d8, [sp, #32] // 8-byte Folded Reload
 963 ; CHECK-SD-NEXT:    add sp, sp, #48
 964 ; CHECK-SD-NEXT:    ret
 965 ;
 966 ; CHECK-GI-LABEL: vec_setcc1:
 967 ; CHECK-GI:       // %bb.0:
 968 ; CHECK-GI-NEXT:    sub sp, sp, #48
 969 ; CHECK-GI-NEXT:    stp x30, x19, [sp, #32] // 16-byte Folded Spill
 970 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 48
 971 ; CHECK-GI-NEXT:    .cfi_offset w19, -8
 972 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 973 ; CHECK-GI-NEXT:    stp q3, q1, [sp] // 32-byte Folded Spill
 974 ; CHECK-GI-NEXT:    mov v1.16b, v2.16b
 975 ; CHECK-GI-NEXT:    bl __letf2
 976 ; CHECK-GI-NEXT:    ldp q1, q0, [sp] // 32-byte Folded Reload
 977 ; CHECK-GI-NEXT:    cmp w0, #0
 978 ; CHECK-GI-NEXT:    cset w19, le
 979 ; CHECK-GI-NEXT:    bl __letf2
 980 ; CHECK-GI-NEXT:    mov v0.s[0], w19
 981 ; CHECK-GI-NEXT:    cmp w0, #0
 982 ; CHECK-GI-NEXT:    cset w8, le
 983 ; CHECK-GI-NEXT:    ldp x30, x19, [sp, #32] // 16-byte Folded Reload
 984 ; CHECK-GI-NEXT:    mov v0.s[1], w8
 985 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
 986 ; CHECK-GI-NEXT:    add sp, sp, #48
 987 ; CHECK-GI-NEXT:    ret
 988   %val = fcmp ole <2 x fp128> %lhs, %rhs
 989   ret <2 x i1> %val
 990 }
 991
 992 define <2 x i1> @vec_setcc2(<2 x fp128> %lhs, <2 x fp128> %rhs) {
 993 ; CHECK-SD-LABEL: vec_setcc2:
 994 ; CHECK-SD:       // %bb.0:
 995 ; CHECK-SD-NEXT:    sub sp, sp, #48
 996 ; CHECK-SD-NEXT:    str d8, [sp, #32] // 8-byte Folded Spill
 997 ; CHECK-SD-NEXT:    str x30, [sp, #40] // 8-byte Folded Spill
 998 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 999 ; CHECK-SD-NEXT:    .cfi_offset w30, -8
1000 ; CHECK-SD-NEXT:    .cfi_offset b8, -16
1001 ; CHECK-SD-NEXT:    stp q0, q2, [sp] // 32-byte Folded Spill
1002 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1003 ; CHECK-SD-NEXT:    mov v1.16b, v3.16b
1004 ; CHECK-SD-NEXT:    bl __letf2
1005 ; CHECK-SD-NEXT:    cmp w0, #0
1006 ; CHECK-SD-NEXT:    ldp q0, q1, [sp] // 32-byte Folded Reload
1007 ; CHECK-SD-NEXT:    cset w8, gt
1008 ; CHECK-SD-NEXT:    sbfx x8, x8, #0, #1
1009 ; CHECK-SD-NEXT:    fmov d8, x8
1010 ; CHECK-SD-NEXT:    bl __letf2
1011 ; CHECK-SD-NEXT:    cmp w0, #0
1012 ; CHECK-SD-NEXT:    ldr x30, [sp, #40] // 8-byte Folded Reload
1013 ; CHECK-SD-NEXT:    cset w8, gt
1014 ; CHECK-SD-NEXT:    sbfx x8, x8, #0, #1
1015 ; CHECK-SD-NEXT:    fmov d0, x8
1016 ; CHECK-SD-NEXT:    zip1 v0.2s, v0.2s, v8.2s
1017 ; CHECK-SD-NEXT:    ldr d8, [sp, #32] // 8-byte Folded Reload
1018 ; CHECK-SD-NEXT:    add sp, sp, #48
1019 ; CHECK-SD-NEXT:    ret
1020 ;
1021 ; CHECK-GI-LABEL: vec_setcc2:
1022 ; CHECK-GI:       // %bb.0:
1023 ; CHECK-GI-NEXT:    sub sp, sp, #48
1024 ; CHECK-GI-NEXT:    stp x30, x19, [sp, #32] // 16-byte Folded Spill
1025 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 48
1026 ; CHECK-GI-NEXT:    .cfi_offset w19, -8
1027 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1028 ; CHECK-GI-NEXT:    stp q3, q1, [sp] // 32-byte Folded Spill
1029 ; CHECK-GI-NEXT:    mov v1.16b, v2.16b
1030 ; CHECK-GI-NEXT:    bl __letf2
1031 ; CHECK-GI-NEXT:    ldp q1, q0, [sp] // 32-byte Folded Reload
1032 ; CHECK-GI-NEXT:    cmp w0, #0
1033 ; CHECK-GI-NEXT:    cset w19, gt
1034 ; CHECK-GI-NEXT:    bl __letf2
1035 ; CHECK-GI-NEXT:    mov v0.s[0], w19
1036 ; CHECK-GI-NEXT:    cmp w0, #0
1037 ; CHECK-GI-NEXT:    cset w8, gt
1038 ; CHECK-GI-NEXT:    ldp x30, x19, [sp, #32] // 16-byte Folded Reload
1039 ; CHECK-GI-NEXT:    mov v0.s[1], w8
1040 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1041 ; CHECK-GI-NEXT:    add sp, sp, #48
1042 ; CHECK-GI-NEXT:    ret
1043   %val = fcmp ugt <2 x fp128> %lhs, %rhs
1044   ret <2 x i1> %val
1045 }
1046
1047 define <2 x i1> @vec_setcc3(<2 x fp128> %lhs, <2 x fp128> %rhs) {
1048 ; CHECK-SD-LABEL: vec_setcc3:
1049 ; CHECK-SD:       // %bb.0:
1050 ; CHECK-SD-NEXT:    sub sp, sp, #96
1051 ; CHECK-SD-NEXT:    str d8, [sp, #64] // 8-byte Folded Spill
1052 ; CHECK-SD-NEXT:    stp x30, x19, [sp, #80] // 16-byte Folded Spill
1053 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 96
1054 ; CHECK-SD-NEXT:    .cfi_offset w19, -8
1055 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1056 ; CHECK-SD-NEXT:    .cfi_offset b8, -32
1057 ; CHECK-SD-NEXT:    stp q1, q3, [sp] // 32-byte Folded Spill
1058 ; CHECK-SD-NEXT:    stp q0, q2, [sp, #32] // 32-byte Folded Spill
1059 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1060 ; CHECK-SD-NEXT:    mov v1.16b, v3.16b
1061 ; CHECK-SD-NEXT:    bl __eqtf2
1062 ; CHECK-SD-NEXT:    ldp q0, q1, [sp] // 32-byte Folded Reload
1063 ; CHECK-SD-NEXT:    mov w19, w0
1064 ; CHECK-SD-NEXT:    bl __unordtf2
1065 ; CHECK-SD-NEXT:    cmp w0, #0
1066 ; CHECK-SD-NEXT:    ldp q0, q1, [sp, #32] // 32-byte Folded Reload
1067 ; CHECK-SD-NEXT:    ccmp w19, #0, #4, eq
1068 ; CHECK-SD-NEXT:    cset w8, eq
1069 ; CHECK-SD-NEXT:    sbfx x8, x8, #0, #1
1070 ; CHECK-SD-NEXT:    fmov d8, x8
1071 ; CHECK-SD-NEXT:    bl __eqtf2
1072 ; CHECK-SD-NEXT:    ldp q0, q1, [sp, #32] // 32-byte Folded Reload
1073 ; CHECK-SD-NEXT:    mov w19, w0
1074 ; CHECK-SD-NEXT:    bl __unordtf2
1075 ; CHECK-SD-NEXT:    cmp w0, #0
1076 ; CHECK-SD-NEXT:    ccmp w19, #0, #4, eq
1077 ; CHECK-SD-NEXT:    ldp x30, x19, [sp, #80] // 16-byte Folded Reload
1078 ; CHECK-SD-NEXT:    cset w8, eq
1079 ; CHECK-SD-NEXT:    sbfx x8, x8, #0, #1
1080 ; CHECK-SD-NEXT:    fmov d0, x8
1081 ; CHECK-SD-NEXT:    zip1 v0.2s, v0.2s, v8.2s
1082 ; CHECK-SD-NEXT:    ldr d8, [sp, #64] // 8-byte Folded Reload
1083 ; CHECK-SD-NEXT:    add sp, sp, #96
1084 ; CHECK-SD-NEXT:    ret
1085 ;
1086 ; CHECK-GI-LABEL: vec_setcc3:
1087 ; CHECK-GI:       // %bb.0:
1088 ; CHECK-GI-NEXT:    sub sp, sp, #96
1089 ; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
1090 ; CHECK-GI-NEXT:    stp x20, x19, [sp, #80] // 16-byte Folded Spill
1091 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 96
1092 ; CHECK-GI-NEXT:    .cfi_offset w19, -8
1093 ; CHECK-GI-NEXT:    .cfi_offset w20, -16
1094 ; CHECK-GI-NEXT:    .cfi_offset w30, -32
1095 ; CHECK-GI-NEXT:    stp q2, q0, [sp] // 32-byte Folded Spill
1096 ; CHECK-GI-NEXT:    stp q3, q1, [sp, #32] // 32-byte Folded Spill
1097 ; CHECK-GI-NEXT:    mov v1.16b, v2.16b
1098 ; CHECK-GI-NEXT:    bl __eqtf2
1099 ; CHECK-GI-NEXT:    ldp q1, q0, [sp] // 32-byte Folded Reload
1100 ; CHECK-GI-NEXT:    cmp w0, #0
1101 ; CHECK-GI-NEXT:    cset w19, eq
1102 ; CHECK-GI-NEXT:    bl __unordtf2
1103 ; CHECK-GI-NEXT:    ldp q1, q0, [sp, #32] // 32-byte Folded Reload
1104 ; CHECK-GI-NEXT:    cmp w0, #0
1105 ; CHECK-GI-NEXT:    cset w8, ne
1106 ; CHECK-GI-NEXT:    orr w19, w19, w8
1107 ; CHECK-GI-NEXT:    bl __eqtf2
1108 ; CHECK-GI-NEXT:    ldp q1, q0, [sp, #32] // 32-byte Folded Reload
1109 ; CHECK-GI-NEXT:    cmp w0, #0
1110 ; CHECK-GI-NEXT:    cset w20, eq
1111 ; CHECK-GI-NEXT:    bl __unordtf2
1112 ; CHECK-GI-NEXT:    mov v0.s[0], w19
1113 ; CHECK-GI-NEXT:    cmp w0, #0
1114 ; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
1115 ; CHECK-GI-NEXT:    cset w8, ne
1116 ; CHECK-GI-NEXT:    orr w8, w20, w8
1117 ; CHECK-GI-NEXT:    ldp x20, x19, [sp, #80] // 16-byte Folded Reload
1118 ; CHECK-GI-NEXT:    mov v0.s[1], w8
1119 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1120 ; CHECK-GI-NEXT:    add sp, sp, #96
1121 ; CHECK-GI-NEXT:    ret
1122   %val = fcmp ueq <2 x fp128> %lhs, %rhs
1123   ret <2 x i1> %val
1124 }
1125
1126 define <2 x fp128> @vec_select(<2 x i1> %cond, <2 x fp128> %lhs, <2 x fp128> %rhs) {
1127 ; CHECK-SD-LABEL: vec_select:
1128 ; CHECK-SD:       // %bb.0:
1129 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1130 ; CHECK-SD-NEXT:    fmov w8, s0
1131 ; CHECK-SD-NEXT:    tst w8, #0x1
1132 ; CHECK-SD-NEXT:    b.eq .LBB40_2
1133 ; CHECK-SD-NEXT:  // %bb.1:
1134 ; CHECK-SD-NEXT:    mov v3.16b, v1.16b
1135 ; CHECK-SD-NEXT:  .LBB40_2:
1136 ; CHECK-SD-NEXT:    mov w8, v0.s[1]
1137 ; CHECK-SD-NEXT:    tst w8, #0x1
1138 ; CHECK-SD-NEXT:    b.eq .LBB40_4
1139 ; CHECK-SD-NEXT:  // %bb.3:
1140 ; CHECK-SD-NEXT:    mov v4.16b, v2.16b
1141 ; CHECK-SD-NEXT:  .LBB40_4:
1142 ; CHECK-SD-NEXT:    mov v0.16b, v3.16b
1143 ; CHECK-SD-NEXT:    mov v1.16b, v4.16b
1144 ; CHECK-SD-NEXT:    ret
1145 ;
1146 ; CHECK-GI-LABEL: vec_select:
1147 ; CHECK-GI:       // %bb.0:
1148 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1149 ; CHECK-GI-NEXT:    mov w8, v0.s[1]
1150 ; CHECK-GI-NEXT:    fmov w9, s0
1151 ; CHECK-GI-NEXT:    mov d5, v1.d[1]
1152 ; CHECK-GI-NEXT:    mov d6, v3.d[1]
1153 ; CHECK-GI-NEXT:    and w9, w9, #0x1
1154 ; CHECK-GI-NEXT:    tst w9, #0x1
1155 ; CHECK-GI-NEXT:    and w8, w8, #0x1
1156 ; CHECK-GI-NEXT:    fcsel d0, d1, d3, ne
1157 ; CHECK-GI-NEXT:    fcsel d3, d5, d6, ne
1158 ; CHECK-GI-NEXT:    tst w8, #0x1
1159 ; CHECK-GI-NEXT:    mov d1, v2.d[1]
1160 ; CHECK-GI-NEXT:    mov d5, v4.d[1]
1161 ; CHECK-GI-NEXT:    fcsel d2, d2, d4, ne
1162 ; CHECK-GI-NEXT:    fmov x8, d0
1163 ; CHECK-GI-NEXT:    fmov x9, d2
1164 ; CHECK-GI-NEXT:    fcsel d2, d1, d5, ne
1165 ; CHECK-GI-NEXT:    mov v0.d[0], x8
1166 ; CHECK-GI-NEXT:    fmov x8, d3
1167 ; CHECK-GI-NEXT:    mov v1.d[0], x9
1168 ; CHECK-GI-NEXT:    fmov x9, d2
1169 ; CHECK-GI-NEXT:    mov v0.d[1], x8
1170 ; CHECK-GI-NEXT:    mov v1.d[1], x9
1171 ; CHECK-GI-NEXT:    ret
1172   %val = select <2 x i1> %cond, <2 x fp128> %lhs, <2 x fp128> %rhs
1173   ret <2 x fp128> %val
1174 }
1175
1176 define <2 x half> @vec_round_f16(<2 x fp128> %val) {
1177 ; CHECK-SD-LABEL: vec_round_f16:
1178 ; CHECK-SD:       // %bb.0:
1179 ; CHECK-SD-NEXT:    sub sp, sp, #48
1180 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1181 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1182 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1183 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1184 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1185 ; CHECK-SD-NEXT:    bl __trunctfhf2
1186 ; CHECK-SD-NEXT:    // kill: def $h0 killed $h0 def $q0
1187 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1188 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1189 ; CHECK-SD-NEXT:    bl __trunctfhf2
1190 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1191 ; CHECK-SD-NEXT:    // kill: def $h0 killed $h0 def $q0
1192 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1193 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
1194 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1195 ; CHECK-SD-NEXT:    add sp, sp, #48
1196 ; CHECK-SD-NEXT:    ret
1197 ;
1198 ; CHECK-GI-LABEL: vec_round_f16:
1199 ; CHECK-GI:       // %bb.0:
1200 ; CHECK-GI-NEXT:    sub sp, sp, #64
1201 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1202 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
1203 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1204 ; CHECK-GI-NEXT:    mov v2.d[0], x8
1205 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
1206 ; CHECK-GI-NEXT:    mov v2.d[1], x8
1207 ; CHECK-GI-NEXT:    str q2, [sp, #32] // 16-byte Folded Spill
1208 ; CHECK-GI-NEXT:    bl __trunctfhf2
1209 ; CHECK-GI-NEXT:    // kill: def $h0 killed $h0 def $q0
1210 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1211 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1212 ; CHECK-GI-NEXT:    bl __trunctfhf2
1213 ; CHECK-GI-NEXT:    // kill: def $h0 killed $h0 def $q0
1214 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1215 ; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1216 ; CHECK-GI-NEXT:    bl __trunctfhf2
1217 ; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1218 ; CHECK-GI-NEXT:    bl __trunctfhf2
1219 ; CHECK-GI-NEXT:    ldp q1, q0, [sp] // 32-byte Folded Reload
1220 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1221 ; CHECK-GI-NEXT:    mov v0.h[1], v1.h[0]
1222 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1223 ; CHECK-GI-NEXT:    add sp, sp, #64
1224 ; CHECK-GI-NEXT:    ret
1225   %dst = fptrunc <2 x fp128> %val to <2 x half>
1226   ret <2 x half> %dst
1227 }
1228
1229 define <2 x float> @vec_round_f32(<2 x fp128> %val) {
1230 ; CHECK-SD-LABEL: vec_round_f32:
1231 ; CHECK-SD:       // %bb.0:
1232 ; CHECK-SD-NEXT:    sub sp, sp, #48
1233 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1234 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1235 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1236 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1237 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1238 ; CHECK-SD-NEXT:    bl __trunctfsf2
1239 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1240 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1241 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1242 ; CHECK-SD-NEXT:    bl __trunctfsf2
1243 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1244 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1245 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1246 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1247 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1248 ; CHECK-SD-NEXT:    add sp, sp, #48
1249 ; CHECK-SD-NEXT:    ret
1250 ;
1251 ; CHECK-GI-LABEL: vec_round_f32:
1252 ; CHECK-GI:       // %bb.0:
1253 ; CHECK-GI-NEXT:    sub sp, sp, #48
1254 ; CHECK-GI-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1255 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 48
1256 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1257 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
1258 ; CHECK-GI-NEXT:    bl __trunctfsf2
1259 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1260 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1261 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1262 ; CHECK-GI-NEXT:    bl __trunctfsf2
1263 ; CHECK-GI-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1264 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1265 ; CHECK-GI-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1266 ; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
1267 ; CHECK-GI-NEXT:    fmov d0, d1
1268 ; CHECK-GI-NEXT:    add sp, sp, #48
1269 ; CHECK-GI-NEXT:    ret
1270   %dst = fptrunc <2 x fp128> %val to <2 x float>
1271   ret <2 x float> %dst
1272 }
1273
1274 define <2 x double> @vec_round_f64(<2 x fp128> %val) {
1275 ; CHECK-SD-LABEL: vec_round_f64:
1276 ; CHECK-SD:       // %bb.0:
1277 ; CHECK-SD-NEXT:    sub sp, sp, #48
1278 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1279 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1280 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1281 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1282 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1283 ; CHECK-SD-NEXT:    bl __trunctfdf2
1284 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1285 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1286 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1287 ; CHECK-SD-NEXT:    bl __trunctfdf2
1288 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1289 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1290 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1291 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
1292 ; CHECK-SD-NEXT:    add sp, sp, #48
1293 ; CHECK-SD-NEXT:    ret
1294 ;
1295 ; CHECK-GI-LABEL: vec_round_f64:
1296 ; CHECK-GI:       // %bb.0:
1297 ; CHECK-GI-NEXT:    sub sp, sp, #48
1298 ; CHECK-GI-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1299 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 48
1300 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1301 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
1302 ; CHECK-GI-NEXT:    bl __trunctfdf2
1303 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1304 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1305 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1306 ; CHECK-GI-NEXT:    bl __trunctfdf2
1307 ; CHECK-GI-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1308 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1309 ; CHECK-GI-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1310 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
1311 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
1312 ; CHECK-GI-NEXT:    add sp, sp, #48
1313 ; CHECK-GI-NEXT:    ret
1314   %dst = fptrunc <2 x fp128> %val to <2 x double>
1315   ret <2 x double> %dst
1316 }
1317
1318 define <2 x fp128> @vec_extend_f16(<2 x half> %val) {
1319 ; CHECK-SD-LABEL: vec_extend_f16:
1320 ; CHECK-SD:       // %bb.0:
1321 ; CHECK-SD-NEXT:    sub sp, sp, #32
1322 ; CHECK-SD-NEXT:    str x30, [sp, #16] // 8-byte Folded Spill
1323 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
1324 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1325 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1326 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1327 ; CHECK-SD-NEXT:    // kill: def $h0 killed $h0 killed $q0
1328 ; CHECK-SD-NEXT:    bl __extendhftf2
1329 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1330 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1331 ; CHECK-SD-NEXT:    mov h1, v1.h[1]
1332 ; CHECK-SD-NEXT:    fmov s0, s1
1333 ; CHECK-SD-NEXT:    bl __extendhftf2
1334 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
1335 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1336 ; CHECK-SD-NEXT:    ldr x30, [sp, #16] // 8-byte Folded Reload
1337 ; CHECK-SD-NEXT:    add sp, sp, #32
1338 ; CHECK-SD-NEXT:    ret
1339 ;
1340 ; CHECK-GI-LABEL: vec_extend_f16:
1341 ; CHECK-GI:       // %bb.0:
1342 ; CHECK-GI-NEXT:    sub sp, sp, #32
1343 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
1344 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1345 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1346 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
1347 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
1348 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1349 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
1350 ; CHECK-GI-NEXT:    // kill: def $h0 killed $h0 killed $q0
1351 ; CHECK-GI-NEXT:    bl __extendhftf2
1352 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1353 ; CHECK-GI-NEXT:    fmov s0, s8
1354 ; CHECK-GI-NEXT:    bl __extendhftf2
1355 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
1356 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1357 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1358 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
1359 ; CHECK-GI-NEXT:    add sp, sp, #32
1360 ; CHECK-GI-NEXT:    ret
1361   %dst = fpext <2 x half> %val to <2 x fp128>
1362   ret <2 x fp128> %dst
1363 }
1364
1365 define <2 x fp128> @vec_extend_f32(<2 x float> %val) {
1366 ; CHECK-SD-LABEL: vec_extend_f32:
1367 ; CHECK-SD:       // %bb.0:
1368 ; CHECK-SD-NEXT:    sub sp, sp, #32
1369 ; CHECK-SD-NEXT:    str x30, [sp, #16] // 8-byte Folded Spill
1370 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
1371 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1372 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1373 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1374 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1375 ; CHECK-SD-NEXT:    bl __extendsftf2
1376 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1377 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1378 ; CHECK-SD-NEXT:    mov s1, v1.s[1]
1379 ; CHECK-SD-NEXT:    fmov s0, s1
1380 ; CHECK-SD-NEXT:    bl __extendsftf2
1381 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
1382 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1383 ; CHECK-SD-NEXT:    ldr x30, [sp, #16] // 8-byte Folded Reload
1384 ; CHECK-SD-NEXT:    add sp, sp, #32
1385 ; CHECK-SD-NEXT:    ret
1386 ;
1387 ; CHECK-GI-LABEL: vec_extend_f32:
1388 ; CHECK-GI:       // %bb.0:
1389 ; CHECK-GI-NEXT:    sub sp, sp, #32
1390 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
1391 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1392 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1393 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
1394 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
1395 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1396 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
1397 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1398 ; CHECK-GI-NEXT:    bl __extendsftf2
1399 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1400 ; CHECK-GI-NEXT:    fmov s0, s8
1401 ; CHECK-GI-NEXT:    bl __extendsftf2
1402 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
1403 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1404 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1405 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
1406 ; CHECK-GI-NEXT:    add sp, sp, #32
1407 ; CHECK-GI-NEXT:    ret
1408   %dst = fpext <2 x float> %val to <2 x fp128>
1409   ret <2 x fp128> %dst
1410 }
1411
1412 define <2 x fp128> @vec_extend_f64(<2 x double> %val) {
1413 ; CHECK-SD-LABEL: vec_extend_f64:
1414 ; CHECK-SD:       // %bb.0:
1415 ; CHECK-SD-NEXT:    sub sp, sp, #48
1416 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1417 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1418 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1419 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1420 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1421 ; CHECK-SD-NEXT:    bl __extenddftf2
1422 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1423 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1424 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
1425 ; CHECK-SD-NEXT:    bl __extenddftf2
1426 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
1427 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1428 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1429 ; CHECK-SD-NEXT:    add sp, sp, #48
1430 ; CHECK-SD-NEXT:    ret
1431 ;
1432 ; CHECK-GI-LABEL: vec_extend_f64:
1433 ; CHECK-GI:       // %bb.0:
1434 ; CHECK-GI-NEXT:    sub sp, sp, #32
1435 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
1436 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1437 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1438 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
1439 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
1440 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
1441 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1442 ; CHECK-GI-NEXT:    bl __extenddftf2
1443 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1444 ; CHECK-GI-NEXT:    fmov d0, d8
1445 ; CHECK-GI-NEXT:    bl __extenddftf2
1446 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
1447 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1448 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1449 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
1450 ; CHECK-GI-NEXT:    add sp, sp, #32
1451 ; CHECK-GI-NEXT:    ret
1452   %dst = fpext <2 x double> %val to <2 x fp128>
1453   ret <2 x fp128> %dst
1454 }
1455
1456 define <2 x fp128> @vec_neg_sub(<2 x fp128> %in) {
1457 ; CHECK-SD-LABEL: vec_neg_sub:
1458 ; CHECK-SD:       // %bb.0:
1459 ; CHECK-SD-NEXT:    sub sp, sp, #64
1460 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1461 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
1462 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1463 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1464 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
1465 ; CHECK-SD-NEXT:    adrp x8, .LCPI47_0
1466 ; CHECK-SD-NEXT:    ldr q0, [x8, :lo12:.LCPI47_0]
1467 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1468 ; CHECK-SD-NEXT:    bl __subtf3
1469 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1470 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1471 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1472 ; CHECK-SD-NEXT:    bl __subtf3
1473 ; CHECK-SD-NEXT:    mov v1.16b, v0.16b
1474 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1475 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1476 ; CHECK-SD-NEXT:    add sp, sp, #64
1477 ; CHECK-SD-NEXT:    ret
1478 ;
1479 ; CHECK-GI-LABEL: vec_neg_sub:
1480 ; CHECK-GI:       // %bb.0:
1481 ; CHECK-GI-NEXT:    sub sp, sp, #64
1482 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1483 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
1484 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1485 ; CHECK-GI-NEXT:    mov v2.16b, v0.16b
1486 ; CHECK-GI-NEXT:    adrp x8, .LCPI47_0
1487 ; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1488 ; CHECK-GI-NEXT:    ldr q0, [x8, :lo12:.LCPI47_0]
1489 ; CHECK-GI-NEXT:    mov v1.16b, v2.16b
1490 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1491 ; CHECK-GI-NEXT:    bl __subtf3
1492 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1493 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1494 ; CHECK-GI-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1495 ; CHECK-GI-NEXT:    bl __subtf3
1496 ; CHECK-GI-NEXT:    mov v1.16b, v0.16b
1497 ; CHECK-GI-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1498 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1499 ; CHECK-GI-NEXT:    add sp, sp, #64
1500 ; CHECK-GI-NEXT:    ret
1501   %ret = fsub <2 x fp128> zeroinitializer, %in
1502   ret <2 x fp128> %ret
1503 }
1504
1505 define <2 x fp128> @vec_neg(<2 x fp128> %in) {
1506 ; CHECK-SD-LABEL: vec_neg:
1507 ; CHECK-SD:       // %bb.0:
1508 ; CHECK-SD-NEXT:    stp q0, q1, [sp, #-32]!
1509 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
1510 ; CHECK-SD-NEXT:    ldrb w8, [sp, #15]
1511 ; CHECK-SD-NEXT:    eor w8, w8, #0x80
1512 ; CHECK-SD-NEXT:    strb w8, [sp, #15]
1513 ; CHECK-SD-NEXT:    ldrb w8, [sp, #31]
1514 ; CHECK-SD-NEXT:    eor w8, w8, #0x80
1515 ; CHECK-SD-NEXT:    strb w8, [sp, #31]
1516 ; CHECK-SD-NEXT:    ldp q0, q1, [sp], #32
1517 ; CHECK-SD-NEXT:    ret
1518 ;
1519 ; CHECK-GI-LABEL: vec_neg:
1520 ; CHECK-GI:       // %bb.0:
1521 ; CHECK-GI-NEXT:    mov x8, v0.d[1]
1522 ; CHECK-GI-NEXT:    mov x9, v1.d[1]
1523 ; CHECK-GI-NEXT:    mov v0.d[0], v0.d[0]
1524 ; CHECK-GI-NEXT:    mov v1.d[0], v1.d[0]
1525 ; CHECK-GI-NEXT:    eor x8, x8, #0x8000000000000000
1526 ; CHECK-GI-NEXT:    eor x9, x9, #0x8000000000000000
1527 ; CHECK-GI-NEXT:    mov v0.d[1], x8
1528 ; CHECK-GI-NEXT:    mov v1.d[1], x9
1529 ; CHECK-GI-NEXT:    ret
1530   %ret = fneg <2 x fp128> %in
1531   ret <2 x fp128> %ret
1532 }