test/CodeGen/Mips/mips64-f128.ll

   1 ; RUN: llc -mtriple=mips64el-unknown-unknown -mcpu=mips4 -soft-float -O1 \
   2 ; RUN:     -disable-mips-delay-filler < %s | FileCheck %s
   3 ; RUN: llc -mtriple=mips64el-unknown-unknown -mcpu=mips64 -soft-float -O1 \
   4 ; RUN:     -disable-mips-delay-filler < %s | FileCheck %s
   5
   6 @gld0 = external global fp128
   7 @gld1 = external global fp128
   8 @gld2 = external global fp128
   9 @gf1 = external global float
  10 @gd1 = external global double
  11
  12 ; CHECK-LABEL: addLD:
  13 ; CHECK: ld $25, %call16(__addtf3)
  14
  15 define fp128 @addLD() {
  16 entry:
  17   %0 = load fp128* @gld0, align 16
  18   %1 = load fp128* @gld1, align 16
  19   %add = fadd fp128 %0, %1
  20   ret fp128 %add
  21 }
  22
  23 ; CHECK-LABEL: subLD:
  24 ; CHECK: ld $25, %call16(__subtf3)
  25
  26 define fp128 @subLD() {
  27 entry:
  28   %0 = load fp128* @gld0, align 16
  29   %1 = load fp128* @gld1, align 16
  30   %sub = fsub fp128 %0, %1
  31   ret fp128 %sub
  32 }
  33
  34 ; CHECK-LABEL: mulLD:
  35 ; CHECK: ld $25, %call16(__multf3)
  36
  37 define fp128 @mulLD() {
  38 entry:
  39   %0 = load fp128* @gld0, align 16
  40   %1 = load fp128* @gld1, align 16
  41   %mul = fmul fp128 %0, %1
  42   ret fp128 %mul
  43 }
  44
  45 ; CHECK-LABEL: divLD:
  46 ; CHECK: ld $25, %call16(__divtf3)
  47
  48 define fp128 @divLD() {
  49 entry:
  50   %0 = load fp128* @gld0, align 16
  51   %1 = load fp128* @gld1, align 16
  52   %div = fdiv fp128 %0, %1
  53   ret fp128 %div
  54 }
  55
  56 ; CHECK-LABEL: conv_LD_char:
  57 ; CHECK: ld $25, %call16(__floatsitf)
  58
  59 define fp128 @conv_LD_char(i8 signext %a) {
  60 entry:
  61   %conv = sitofp i8 %a to fp128
  62   ret fp128 %conv
  63 }
  64
  65 ; CHECK-LABEL: conv_LD_short:
  66 ; CHECK: ld $25, %call16(__floatsitf)
  67
  68 define fp128 @conv_LD_short(i16 signext %a) {
  69 entry:
  70   %conv = sitofp i16 %a to fp128
  71   ret fp128 %conv
  72 }
  73
  74 ; CHECK-LABEL: conv_LD_int:
  75 ; CHECK: ld $25, %call16(__floatsitf)
  76
  77 define fp128 @conv_LD_int(i32 %a) {
  78 entry:
  79   %conv = sitofp i32 %a to fp128
  80   ret fp128 %conv
  81 }
  82
  83 ; CHECK-LABEL: conv_LD_LL:
  84 ; CHECK: ld $25, %call16(__floatditf)
  85
  86 define fp128 @conv_LD_LL(i64 %a) {
  87 entry:
  88   %conv = sitofp i64 %a to fp128
  89   ret fp128 %conv
  90 }
  91
  92 ; CHECK-LABEL: conv_LD_UChar:
  93 ; CHECK: ld $25, %call16(__floatunsitf)
  94
  95 define fp128 @conv_LD_UChar(i8 zeroext %a) {
  96 entry:
  97   %conv = uitofp i8 %a to fp128
  98   ret fp128 %conv
  99 }
 100
 101 ; CHECK-LABEL: conv_LD_UShort:
 102 ; CHECK: ld $25, %call16(__floatunsitf)
 103
 104 define fp128 @conv_LD_UShort(i16 zeroext %a) {
 105 entry:
 106   %conv = uitofp i16 %a to fp128
 107   ret fp128 %conv
 108 }
 109
 110 ; CHECK-LABEL: conv_LD_UInt:
 111 ; CHECK: ld $25, %call16(__floatunsitf)
 112
 113 define fp128 @conv_LD_UInt(i32 %a) {
 114 entry:
 115   %conv = uitofp i32 %a to fp128
 116   ret fp128 %conv
 117 }
 118
 119 ; CHECK-LABEL: conv_LD_ULL:
 120 ; CHECK: ld $25, %call16(__floatunditf)
 121
 122 define fp128 @conv_LD_ULL(i64 %a) {
 123 entry:
 124   %conv = uitofp i64 %a to fp128
 125   ret fp128 %conv
 126 }
 127
 128 ; CHECK-LABEL: conv_char_LD:
 129 ; CHECK: ld $25, %call16(__fixtfsi)
 130
 131 define signext i8 @conv_char_LD(fp128 %a) {
 132 entry:
 133   %conv = fptosi fp128 %a to i8
 134   ret i8 %conv
 135 }
 136
 137 ; CHECK-LABEL: conv_short_LD:
 138 ; CHECK: ld $25, %call16(__fixtfsi)
 139
 140 define signext i16 @conv_short_LD(fp128 %a) {
 141 entry:
 142   %conv = fptosi fp128 %a to i16
 143   ret i16 %conv
 144 }
 145
 146 ; CHECK-LABEL: conv_int_LD:
 147 ; CHECK: ld $25, %call16(__fixtfsi)
 148
 149 define i32 @conv_int_LD(fp128 %a) {
 150 entry:
 151   %conv = fptosi fp128 %a to i32
 152   ret i32 %conv
 153 }
 154
 155 ; CHECK-LABEL: conv_LL_LD:
 156 ; CHECK: ld $25, %call16(__fixtfdi)
 157
 158 define i64 @conv_LL_LD(fp128 %a) {
 159 entry:
 160   %conv = fptosi fp128 %a to i64
 161   ret i64 %conv
 162 }
 163
 164 ; CHECK-LABEL: conv_UChar_LD:
 165 ; CHECK: ld $25, %call16(__fixtfsi)
 166
 167 define zeroext i8 @conv_UChar_LD(fp128 %a) {
 168 entry:
 169   %conv = fptoui fp128 %a to i8
 170   ret i8 %conv
 171 }
 172
 173 ; CHECK-LABEL: conv_UShort_LD:
 174 ; CHECK: ld $25, %call16(__fixtfsi)
 175
 176 define zeroext i16 @conv_UShort_LD(fp128 %a) {
 177 entry:
 178   %conv = fptoui fp128 %a to i16
 179   ret i16 %conv
 180 }
 181
 182 ; CHECK-LABEL: conv_UInt_LD:
 183 ; CHECK: ld $25, %call16(__fixunstfsi)
 184
 185 define i32 @conv_UInt_LD(fp128 %a) {
 186 entry:
 187   %conv = fptoui fp128 %a to i32
 188   ret i32 %conv
 189 }
 190
 191 ; CHECK-LABEL: conv_ULL_LD:
 192 ; CHECK: ld $25, %call16(__fixunstfdi)
 193
 194 define i64 @conv_ULL_LD(fp128 %a) {
 195 entry:
 196   %conv = fptoui fp128 %a to i64
 197   ret i64 %conv
 198 }
 199
 200 ; CHECK-LABEL: conv_LD_float:
 201 ; CHECK: ld $25, %call16(__extendsftf2)
 202
 203 define fp128 @conv_LD_float(float %a) {
 204 entry:
 205   %conv = fpext float %a to fp128
 206   ret fp128 %conv
 207 }
 208
 209 ; CHECK-LABEL: conv_LD_double:
 210 ; CHECK: ld $25, %call16(__extenddftf2)
 211
 212 define fp128 @conv_LD_double(double %a) {
 213 entry:
 214   %conv = fpext double %a to fp128
 215   ret fp128 %conv
 216 }
 217
 218 ; CHECK-LABEL: conv_float_LD:
 219 ; CHECK: ld $25, %call16(__trunctfsf2)
 220
 221 define float @conv_float_LD(fp128 %a) {
 222 entry:
 223   %conv = fptrunc fp128 %a to float
 224   ret float %conv
 225 }
 226
 227 ; CHECK-LABEL: conv_double_LD:
 228 ; CHECK: ld $25, %call16(__trunctfdf2)
 229
 230 define double @conv_double_LD(fp128 %a) {
 231 entry:
 232   %conv = fptrunc fp128 %a to double
 233   ret double %conv
 234 }
 235
 236 ; CHECK-LABEL:             libcall1_fabsl:
 237 ; CHECK-DAG: ld      $[[R0:[0-9]+]], 8($[[R4:[0-9]+]])
 238 ; CHECK-DAG: daddiu  $[[R1:[0-9]+]], $zero, 1
 239 ; CHECK-DAG: dsll    $[[R2:[0-9]+]], $[[R1]], 63
 240 ; CHECK-DAG: daddiu  $[[R3:[0-9]+]], $[[R2]], -1
 241 ; CHECK-DAG: and     $4, $[[R0]], $[[R3]]
 242 ; CHECK-DAG: ld      $2, 0($[[R4]])
 243
 244 define fp128 @libcall1_fabsl() {
 245 entry:
 246   %0 = load fp128* @gld0, align 16
 247   %call = tail call fp128 @fabsl(fp128 %0) nounwind readnone
 248   ret fp128 %call
 249 }
 250
 251 declare fp128 @fabsl(fp128) #1
 252
 253 ; CHECK-LABEL: libcall1_ceill:
 254 ; CHECK: ld $25, %call16(ceill)
 255
 256 define fp128 @libcall1_ceill() {
 257 entry:
 258   %0 = load fp128* @gld0, align 16
 259   %call = tail call fp128 @ceill(fp128 %0) nounwind readnone
 260   ret fp128 %call
 261 }
 262
 263 declare fp128 @ceill(fp128) #1
 264
 265 ; CHECK-LABEL: libcall1_sinl:
 266 ; CHECK: ld $25, %call16(sinl)
 267
 268 define fp128 @libcall1_sinl() {
 269 entry:
 270   %0 = load fp128* @gld0, align 16
 271   %call = tail call fp128 @sinl(fp128 %0) nounwind
 272   ret fp128 %call
 273 }
 274
 275 declare fp128 @sinl(fp128) #2
 276
 277 ; CHECK-LABEL: libcall1_cosl:
 278 ; CHECK: ld $25, %call16(cosl)
 279
 280 define fp128 @libcall1_cosl() {
 281 entry:
 282   %0 = load fp128* @gld0, align 16
 283   %call = tail call fp128 @cosl(fp128 %0) nounwind
 284   ret fp128 %call
 285 }
 286
 287 declare fp128 @cosl(fp128) #2
 288
 289 ; CHECK-LABEL: libcall1_expl:
 290 ; CHECK: ld $25, %call16(expl)
 291
 292 define fp128 @libcall1_expl() {
 293 entry:
 294   %0 = load fp128* @gld0, align 16
 295   %call = tail call fp128 @expl(fp128 %0) nounwind
 296   ret fp128 %call
 297 }
 298
 299 declare fp128 @expl(fp128) #2
 300
 301 ; CHECK-LABEL: libcall1_exp2l:
 302 ; CHECK: ld $25, %call16(exp2l)
 303
 304 define fp128 @libcall1_exp2l() {
 305 entry:
 306   %0 = load fp128* @gld0, align 16
 307   %call = tail call fp128 @exp2l(fp128 %0) nounwind
 308   ret fp128 %call
 309 }
 310
 311 declare fp128 @exp2l(fp128) #2
 312
 313 ; CHECK-LABEL: libcall1_logl:
 314 ; CHECK: ld $25, %call16(logl)
 315
 316 define fp128 @libcall1_logl() {
 317 entry:
 318   %0 = load fp128* @gld0, align 16
 319   %call = tail call fp128 @logl(fp128 %0) nounwind
 320   ret fp128 %call
 321 }
 322
 323 declare fp128 @logl(fp128) #2
 324
 325 ; CHECK-LABEL: libcall1_log2l:
 326 ; CHECK: ld $25, %call16(log2l)
 327
 328 define fp128 @libcall1_log2l() {
 329 entry:
 330   %0 = load fp128* @gld0, align 16
 331   %call = tail call fp128 @log2l(fp128 %0) nounwind
 332   ret fp128 %call
 333 }
 334
 335 declare fp128 @log2l(fp128) #2
 336
 337 ; CHECK-LABEL: libcall1_log10l:
 338 ; CHECK: ld $25, %call16(log10l)
 339
 340 define fp128 @libcall1_log10l() {
 341 entry:
 342   %0 = load fp128* @gld0, align 16
 343   %call = tail call fp128 @log10l(fp128 %0) nounwind
 344   ret fp128 %call
 345 }
 346
 347 declare fp128 @log10l(fp128) #2
 348
 349 ; CHECK-LABEL: libcall1_nearbyintl:
 350 ; CHECK: ld $25, %call16(nearbyintl)
 351
 352 define fp128 @libcall1_nearbyintl() {
 353 entry:
 354   %0 = load fp128* @gld0, align 16
 355   %call = tail call fp128 @nearbyintl(fp128 %0) nounwind readnone
 356   ret fp128 %call
 357 }
 358
 359 declare fp128 @nearbyintl(fp128) #1
 360
 361 ; CHECK-LABEL: libcall1_floorl:
 362 ; CHECK: ld $25, %call16(floorl)
 363
 364 define fp128 @libcall1_floorl() {
 365 entry:
 366   %0 = load fp128* @gld0, align 16
 367   %call = tail call fp128 @floorl(fp128 %0) nounwind readnone
 368   ret fp128 %call
 369 }
 370
 371 declare fp128 @floorl(fp128) #1
 372
 373 ; CHECK-LABEL: libcall1_sqrtl:
 374 ; CHECK: ld $25, %call16(sqrtl)
 375
 376 define fp128 @libcall1_sqrtl() {
 377 entry:
 378   %0 = load fp128* @gld0, align 16
 379   %call = tail call fp128 @sqrtl(fp128 %0) nounwind
 380   ret fp128 %call
 381 }
 382
 383 declare fp128 @sqrtl(fp128) #2
 384
 385 ; CHECK-LABEL: libcall1_rintl:
 386 ; CHECK: ld $25, %call16(rintl)
 387
 388 define fp128 @libcall1_rintl() {
 389 entry:
 390   %0 = load fp128* @gld0, align 16
 391   %call = tail call fp128 @rintl(fp128 %0) nounwind readnone
 392   ret fp128 %call
 393 }
 394
 395 declare fp128 @rintl(fp128) #1
 396
 397 ; CHECK-LABEL: libcall_powil:
 398 ; CHECK: ld $25, %call16(__powitf2)
 399
 400 define fp128 @libcall_powil(fp128 %a, i32 %b) {
 401 entry:
 402   %0 = tail call fp128 @llvm.powi.f128(fp128 %a, i32 %b)
 403   ret fp128 %0
 404 }
 405
 406 declare fp128 @llvm.powi.f128(fp128, i32) #3
 407
 408 ; CHECK-LABEL:     libcall2_copysignl:
 409 ; CHECK-DAG: daddiu $[[R2:[0-9]+]], $zero, 1
 410 ; CHECK-DAG: dsll   $[[R3:[0-9]+]], $[[R2]], 63
 411 ; CHECK-DAG: ld     $[[R0:[0-9]+]], %got_disp(gld1)
 412 ; CHECK-DAG: ld     $[[R1:[0-9]+]], 8($[[R0]])
 413 ; CHECK-DAG: and    $[[R4:[0-9]+]], $[[R1]], $[[R3]]
 414 ; CHECK-DAG: ld     $[[R5:[0-9]+]], %got_disp(gld0)
 415 ; CHECK-DAG: ld     $[[R6:[0-9]+]], 8($[[R5]])
 416 ; CHECK-DAG: daddiu $[[R7:[0-9]+]], $[[R3]], -1
 417 ; CHECK-DAG: and    $[[R8:[0-9]+]], $[[R6]], $[[R7]]
 418 ; CHECK-DAG: or     $4, $[[R8]], $[[R4]]
 419 ; CHECK-DAG: ld     $2, 0($[[R5]])
 420
 421 define fp128 @libcall2_copysignl() {
 422 entry:
 423   %0 = load fp128* @gld0, align 16
 424   %1 = load fp128* @gld1, align 16
 425   %call = tail call fp128 @copysignl(fp128 %0, fp128 %1) nounwind readnone
 426   ret fp128 %call
 427 }
 428
 429 declare fp128 @copysignl(fp128, fp128) #1
 430
 431 ; CHECK-LABEL: libcall2_powl:
 432 ; CHECK: ld $25, %call16(powl)
 433
 434 define fp128 @libcall2_powl() {
 435 entry:
 436   %0 = load fp128* @gld0, align 16
 437   %1 = load fp128* @gld1, align 16
 438   %call = tail call fp128 @powl(fp128 %0, fp128 %1) nounwind
 439   ret fp128 %call
 440 }
 441
 442 declare fp128 @powl(fp128, fp128) #2
 443
 444 ; CHECK-LABEL: libcall2_fmodl:
 445 ; CHECK: ld $25, %call16(fmodl)
 446
 447 define fp128 @libcall2_fmodl() {
 448 entry:
 449   %0 = load fp128* @gld0, align 16
 450   %1 = load fp128* @gld1, align 16
 451   %call = tail call fp128 @fmodl(fp128 %0, fp128 %1) nounwind
 452   ret fp128 %call
 453 }
 454
 455 declare fp128 @fmodl(fp128, fp128) #2
 456
 457 ; CHECK-LABEL: libcall3_fmal:
 458 ; CHECK: ld $25, %call16(fmal)
 459
 460 define fp128 @libcall3_fmal() {
 461 entry:
 462   %0 = load fp128* @gld0, align 16
 463   %1 = load fp128* @gld2, align 16
 464   %2 = load fp128* @gld1, align 16
 465   %3 = tail call fp128 @llvm.fma.f128(fp128 %0, fp128 %2, fp128 %1)
 466   ret fp128 %3
 467 }
 468
 469 declare fp128 @llvm.fma.f128(fp128, fp128, fp128) #4
 470
 471 ; CHECK-LABEL: cmp_lt:
 472 ; CHECK: ld $25, %call16(__lttf2)
 473
 474 define i32 @cmp_lt(fp128 %a, fp128 %b) {
 475 entry:
 476   %cmp = fcmp olt fp128 %a, %b
 477   %conv = zext i1 %cmp to i32
 478   ret i32 %conv
 479 }
 480
 481 ; CHECK-LABEL: cmp_le:
 482 ; CHECK: ld $25, %call16(__letf2)
 483
 484 define i32 @cmp_le(fp128 %a, fp128 %b) {
 485 entry:
 486   %cmp = fcmp ole fp128 %a, %b
 487   %conv = zext i1 %cmp to i32
 488   ret i32 %conv
 489 }
 490
 491 ; CHECK-LABEL: cmp_gt:
 492 ; CHECK: ld $25, %call16(__gttf2)
 493
 494 define i32 @cmp_gt(fp128 %a, fp128 %b) {
 495 entry:
 496   %cmp = fcmp ogt fp128 %a, %b
 497   %conv = zext i1 %cmp to i32
 498   ret i32 %conv
 499 }
 500
 501 ; CHECK-LABEL: cmp_ge:
 502 ; CHECK: ld $25, %call16(__getf2)
 503
 504 define i32 @cmp_ge(fp128 %a, fp128 %b) {
 505 entry:
 506   %cmp = fcmp oge fp128 %a, %b
 507   %conv = zext i1 %cmp to i32
 508   ret i32 %conv
 509 }
 510
 511 ; CHECK-LABEL: cmp_eq:
 512 ; CHECK: ld $25, %call16(__eqtf2)
 513
 514 define i32 @cmp_eq(fp128 %a, fp128 %b) {
 515 entry:
 516   %cmp = fcmp oeq fp128 %a, %b
 517   %conv = zext i1 %cmp to i32
 518   ret i32 %conv
 519 }
 520
 521 ; CHECK-LABEL: cmp_ne:
 522 ; CHECK: ld $25, %call16(__netf2)
 523
 524 define i32 @cmp_ne(fp128 %a, fp128 %b) {
 525 entry:
 526   %cmp = fcmp une fp128 %a, %b
 527   %conv = zext i1 %cmp to i32
 528   ret i32 %conv
 529 }
 530
 531 ; CHECK-LABEL: load_LD_LD:
 532 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
 533 ; CHECK: ld $2, 0($[[R0]])
 534 ; CHECK: ld $4, 8($[[R0]])
 535
 536 define fp128 @load_LD_LD() {
 537 entry:
 538   %0 = load fp128* @gld1, align 16
 539   ret fp128 %0
 540 }
 541
 542 ; CHECK-LABEL: load_LD_float:
 543 ; CHECK: ld   $[[R0:[0-9]+]], %got_disp(gf1)
 544 ; CHECK: lw   $4, 0($[[R0]])
 545 ; CHECK: ld   $25, %call16(__extendsftf2)
 546 ; CHECK: jalr $25
 547
 548 define fp128 @load_LD_float() {
 549 entry:
 550   %0 = load float* @gf1, align 4
 551   %conv = fpext float %0 to fp128
 552   ret fp128 %conv
 553 }
 554
 555 ; CHECK-LABEL: load_LD_double:
 556 ; CHECK: ld   $[[R0:[0-9]+]], %got_disp(gd1)
 557 ; CHECK: ld   $4, 0($[[R0]])
 558 ; CHECK: ld   $25, %call16(__extenddftf2)
 559 ; CHECK: jalr $25
 560
 561 define fp128 @load_LD_double() {
 562 entry:
 563   %0 = load double* @gd1, align 8
 564   %conv = fpext double %0 to fp128
 565   ret fp128 %conv
 566 }
 567
 568 ; CHECK-LABEL: store_LD_LD:
 569 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
 570 ; CHECK: ld $[[R1:[0-9]+]], 0($[[R0]])
 571 ; CHECK: ld $[[R2:[0-9]+]], 8($[[R0]])
 572 ; CHECK: ld $[[R3:[0-9]+]], %got_disp(gld0)
 573 ; CHECK: sd $[[R2]], 8($[[R3]])
 574 ; CHECK: sd $[[R1]], 0($[[R3]])
 575
 576 define void @store_LD_LD() {
 577 entry:
 578   %0 = load fp128* @gld1, align 16
 579   store fp128 %0, fp128* @gld0, align 16
 580   ret void
 581 }
 582
 583 ; CHECK-LABEL: store_LD_float:
 584 ; CHECK: ld   $[[R0:[0-9]+]], %got_disp(gld1)
 585 ; CHECK: ld   $4, 0($[[R0]])
 586 ; CHECK: ld   $5, 8($[[R0]])
 587 ; CHECK: ld   $25, %call16(__trunctfsf2)
 588 ; CHECK: jalr $25
 589 ; CHECK: ld   $[[R1:[0-9]+]], %got_disp(gf1)
 590 ; CHECK: sw   $2, 0($[[R1]])
 591
 592 define void @store_LD_float() {
 593 entry:
 594   %0 = load fp128* @gld1, align 16
 595   %conv = fptrunc fp128 %0 to float
 596   store float %conv, float* @gf1, align 4
 597   ret void
 598 }
 599
 600 ; CHECK-LABEL: store_LD_double:
 601 ; CHECK: ld   $[[R0:[0-9]+]], %got_disp(gld1)
 602 ; CHECK: ld   $4, 0($[[R0]])
 603 ; CHECK: ld   $5, 8($[[R0]])
 604 ; CHECK: ld   $25, %call16(__trunctfdf2)
 605 ; CHECK: jalr $25
 606 ; CHECK: ld   $[[R1:[0-9]+]], %got_disp(gd1)
 607 ; CHECK: sd   $2, 0($[[R1]])
 608
 609 define void @store_LD_double() {
 610 entry:
 611   %0 = load fp128* @gld1, align 16
 612   %conv = fptrunc fp128 %0 to double
 613   store double %conv, double* @gd1, align 8
 614   ret void
 615 }
 616
 617 ; CHECK-LABEL: select_LD:
 618 ; CHECK: movn $8, $6, $4
 619 ; CHECK: movn $9, $7, $4
 620 ; CHECK: move $2, $8
 621 ; CHECK: move $4, $9
 622
 623 define fp128 @select_LD(i32 %a, i64, fp128 %b, fp128 %c) {
 624 entry:
 625   %tobool = icmp ne i32 %a, 0
 626   %cond = select i1 %tobool, fp128 %b, fp128 %c
 627   ret fp128 %cond
 628 }
 629
 630 ; CHECK-LABEL: selectCC_LD:
 631 ; CHECK: move $[[R0:[0-9]+]], $11
 632 ; CHECK: move $[[R1:[0-9]+]], $10
 633 ; CHECK: move $[[R2:[0-9]+]], $9
 634 ; CHECK: move $[[R3:[0-9]+]], $8
 635 ; CHECK: ld   $25, %call16(__gttf2)($gp)
 636 ; CHECK: jalr $25
 637 ; CHECK: slti $1, $2, 1
 638 ; CHECK: movz $[[R1]], $[[R3]], $1
 639 ; CHECK: movz $[[R0]], $[[R2]], $1
 640 ; CHECK: move $2, $[[R1]]
 641 ; CHECK: move $4, $[[R0]]
 642
 643 define fp128 @selectCC_LD(fp128 %a, fp128 %b, fp128 %c, fp128 %d) {
 644 entry:
 645   %cmp = fcmp ogt fp128 %a, %b
 646   %cond = select i1 %cmp, fp128 %c, fp128 %d
 647   ret fp128 %cond
 648 }