test/CodeGen/Mips/mips64-f128.ll

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