test/CodeGen/ARM/GlobalISel/arm-legalize-fp.mir

   1 # RUN: llc -O0 -mtriple arm-linux-gnueabihf -mattr=+vfp2 -float-abi=hard -run-pass=legalizer %s -o - | FileCheck %s -check-prefix CHECK -check-prefix HARD
   2 # RUN: llc -O0 -mtriple arm-linux-gnueabi -mattr=+vfp2,+soft-float -float-abi=soft -run-pass=legalizer %s -o - | FileCheck %s -check-prefix CHECK -check-prefix SOFT -check-prefix SOFT-AEABI
   3 # RUN: llc -O0 -mtriple arm-linux-gnu -mattr=+soft-float -float-abi=soft -run-pass=legalizer %s -o - | FileCheck %s  -check-prefix CHECK -check-prefix SOFT -check-prefix SOFT-DEFAULT
   4 # RUN: llc -O0 -mtriple thumb-linux-gnueabihf -mattr=+v6t2,+vfp2 -float-abi=hard -run-pass=legalizer %s -o - | FileCheck %s -check-prefix CHECK -check-prefix HARD
   5 # RUN: llc -O0 -mtriple thumb-linux-gnueabi -mattr=+v6t2,+vfp2,+soft-float -float-abi=soft -run-pass=legalizer %s -o - | FileCheck %s -check-prefix CHECK -check-prefix SOFT -check-prefix SOFT-AEABI
   6 # RUN: llc -O0 -mtriple thumb-linux-gnu -mattr=+v6t2,+soft-float -float-abi=soft -run-pass=legalizer %s -o - | FileCheck %s  -check-prefix CHECK -check-prefix SOFT -check-prefix SOFT-DEFAULT
   7 --- |
   8   define void @test_frem_float() { ret void }
   9   define void @test_frem_double() { ret void }
  10
  11   define void @test_fpow_float() { ret void }
  12   define void @test_fpow_double() { ret void }
  13
  14   define void @test_fadd_float() { ret void }
  15   define void @test_fadd_double() { ret void }
  16
  17   define void @test_fsub_float() { ret void }
  18   define void @test_fsub_double() { ret void }
  19
  20   define void @test_fmul_float() { ret void }
  21   define void @test_fmul_double() { ret void }
  22
  23   define void @test_fdiv_float() { ret void }
  24   define void @test_fdiv_double() { ret void }
  25
  26   define void @test_fconstant_float() { ret void }
  27   define void @test_fconstant_double() { ret void }
  28
  29   define void @test_fneg_float() { ret void }
  30   define void @test_fneg_double() { ret void }
  31
  32   define void @test_fpext_float_to_double() { ret void }
  33   define void @test_fptrunc_double_to_float() { ret void }
  34
  35   define void @test_fptosi_float() { ret void }
  36   define void @test_fptosi_double() { ret void }
  37   define void @test_fptoui_float() { ret void }
  38   define void @test_fptoui_double() { ret void }
  39
  40   define void @test_sitofp_float() { ret void }
  41   define void @test_sitofp_double() { ret void }
  42   define void @test_uitofp_float() { ret void }
  43   define void @test_uitofp_double() { ret void }
  44
  45   define void @test_fcmp_true_s32() { ret void }
  46   define void @test_fcmp_false_s32() { ret void }
  47
  48   define void @test_fcmp_oeq_s32() { ret void }
  49   define void @test_fcmp_ogt_s32() { ret void }
  50   define void @test_fcmp_oge_s32() { ret void }
  51   define void @test_fcmp_olt_s32() { ret void }
  52   define void @test_fcmp_ole_s32() { ret void }
  53   define void @test_fcmp_ord_s32() { ret void }
  54   define void @test_fcmp_ugt_s32() { ret void }
  55   define void @test_fcmp_uge_s32() { ret void }
  56   define void @test_fcmp_ult_s32() { ret void }
  57   define void @test_fcmp_ule_s32() { ret void }
  58   define void @test_fcmp_une_s32() { ret void }
  59   define void @test_fcmp_uno_s32() { ret void }
  60
  61   define void @test_fcmp_one_s32() { ret void }
  62   define void @test_fcmp_ueq_s32() { ret void }
  63
  64   define void @test_fcmp_true_s64() { ret void }
  65   define void @test_fcmp_false_s64() { ret void }
  66
  67   define void @test_fcmp_oeq_s64() { ret void }
  68   define void @test_fcmp_ogt_s64() { ret void }
  69   define void @test_fcmp_oge_s64() { ret void }
  70   define void @test_fcmp_olt_s64() { ret void }
  71   define void @test_fcmp_ole_s64() { ret void }
  72   define void @test_fcmp_ord_s64() { ret void }
  73   define void @test_fcmp_ugt_s64() { ret void }
  74   define void @test_fcmp_uge_s64() { ret void }
  75   define void @test_fcmp_ult_s64() { ret void }
  76   define void @test_fcmp_ule_s64() { ret void }
  77   define void @test_fcmp_une_s64() { ret void }
  78   define void @test_fcmp_uno_s64() { ret void }
  79
  80   define void @test_fcmp_one_s64() { ret void }
  81   define void @test_fcmp_ueq_s64() { ret void }
  82 ...
  83 ---
  84 name:            test_frem_float
  85 # CHECK-LABEL: name: test_frem_float
  86 legalized:       false
  87 # CHECK: legalized: true
  88 regBankSelected: false
  89 selected:        false
  90 tracksRegLiveness: true
  91 registers:
  92   - { id: 0, class: _ }
  93   - { id: 1, class: _ }
  94   - { id: 2, class: _ }
  95 body:             |
  96   bb.0:
  97     liveins: $r0, $r1
  98
  99     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 100     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
 101     %0(s32) = COPY $r0
 102     %1(s32) = COPY $r1
 103     ; CHECK-NOT: G_FREM
 104     ; CHECK: ADJCALLSTACKDOWN
 105     ; SOFT-DAG: $r0 = COPY [[X]]
 106     ; SOFT-DAG: $r1 = COPY [[Y]]
 107     ; HARD-DAG: $s0 = COPY [[X]]
 108     ; HARD-DAG: $s1 = COPY [[Y]]
 109     ; SOFT: BL{{.*}} &fmodf, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 110     ; HARD: BL{{.*}} &fmodf, {{.*}}, implicit $s0, implicit $s1, implicit-def $s0
 111     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 112     ; HARD: [[R:%[0-9]+]]:_(s32) = COPY $s0
 113     ; CHECK: ADJCALLSTACKUP
 114     ; CHECK-NOT: G_FREM
 115     %2(s32) = G_FREM %0, %1
 116     ; CHECK: $r0 = COPY [[R]]
 117     $r0 = COPY %2(s32)
 118     BX_RET 14, $noreg, implicit $r0
 119 ...
 120 ---
 121 name:            test_frem_double
 122 # CHECK-LABEL: name: test_frem_double
 123 legalized:       false
 124 # CHECK: legalized: true
 125 regBankSelected: false
 126 selected:        false
 127 tracksRegLiveness: true
 128 registers:
 129   - { id: 0, class: _ }
 130   - { id: 1, class: _ }
 131   - { id: 2, class: _ }
 132   - { id: 3, class: _ }
 133   - { id: 4, class: _ }
 134   - { id: 5, class: _ }
 135   - { id: 6, class: _ }
 136   - { id: 7, class: _ }
 137   - { id: 8, class: _ }
 138 body:             |
 139   bb.0:
 140     liveins: $r0, $r1, $r2, $r3
 141
 142     ; The inputs may be in the wrong order (depending on the target's
 143     ; endianness), but that's orthogonal to what we're trying to test here.
 144     ; For soft float, we only need to check that the first value, received
 145     ; through R0-R1, ends up in R0-R1 or R1-R0, and the second value, received
 146     ; through R2-R3, ends up in R2-R3 or R3-R2, when passed to fmod.
 147     ; For hard float, the values need to end up in D0 and D1.
 148     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 149     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 150     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
 151     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
 152     %0(s32) = COPY $r0
 153     %1(s32) = COPY $r1
 154     %2(s32) = COPY $r2
 155     %3(s32) = COPY $r3
 156     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 157     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]]
 158     %4(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 159     %5(s64) = G_MERGE_VALUES %2(s32), %3(s32)
 160     ; CHECK-NOT: G_FREM
 161     ; CHECK: ADJCALLSTACKDOWN
 162     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X0]]
 163     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X1]]
 164     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y0]]
 165     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y1]]
 166     ; HARD-DAG: $d0 = COPY [[X]]
 167     ; HARD-DAG: $d1 = COPY [[Y]]
 168     ; SOFT: BL{{.*}} &fmod, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 169     ; HARD: BL{{.*}} &fmod, {{.*}}, implicit $d0, implicit $d1, implicit-def $d0
 170     ; CHECK: ADJCALLSTACKUP
 171     ; CHECK-NOT: G_FREM
 172     %6(s64) = G_FREM %4, %5
 173     %7(s32), %8(s32) = G_UNMERGE_VALUES %6(s64)
 174     $r0 = COPY %7(s32)
 175     $r1 = COPY %8(s32)
 176     BX_RET 14, $noreg, implicit $r0, implicit $r1
 177 ...
 178 ---
 179 name:            test_fpow_float
 180 # CHECK-LABEL: name: test_fpow_float
 181 legalized:       false
 182 # CHECK: legalized: true
 183 regBankSelected: false
 184 selected:        false
 185 tracksRegLiveness: true
 186 registers:
 187   - { id: 0, class: _ }
 188   - { id: 1, class: _ }
 189   - { id: 2, class: _ }
 190 body:             |
 191   bb.0:
 192     liveins: $r0, $r1
 193
 194     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 195     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
 196     %0(s32) = COPY $r0
 197     %1(s32) = COPY $r1
 198     ; CHECK-NOT: G_FPOW
 199     ; CHECK: ADJCALLSTACKDOWN
 200     ; SOFT-DAG: $r0 = COPY [[X]]
 201     ; SOFT-DAG: $r1 = COPY [[Y]]
 202     ; HARD-DAG: $s0 = COPY [[X]]
 203     ; HARD-DAG: $s1 = COPY [[Y]]
 204     ; SOFT: BL{{.*}} &powf, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 205     ; HARD: BL{{.*}} &powf, {{.*}}, implicit $s0, implicit $s1, implicit-def $s0
 206     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 207     ; HARD: [[R:%[0-9]+]]:_(s32) = COPY $s0
 208     ; CHECK: ADJCALLSTACKUP
 209     ; CHECK-NOT: G_FPOW
 210     %2(s32) = G_FPOW %0, %1
 211     ; CHECK: $r0 = COPY [[R]]
 212     $r0 = COPY %2(s32)
 213     BX_RET 14, $noreg, implicit $r0
 214 ...
 215 ---
 216 name:            test_fpow_double
 217 # CHECK-LABEL: name: test_fpow_double
 218 legalized:       false
 219 # CHECK: legalized: true
 220 regBankSelected: false
 221 selected:        false
 222 tracksRegLiveness: true
 223 registers:
 224   - { id: 0, class: _ }
 225   - { id: 1, class: _ }
 226   - { id: 2, class: _ }
 227   - { id: 3, class: _ }
 228   - { id: 4, class: _ }
 229   - { id: 5, class: _ }
 230   - { id: 6, class: _ }
 231   - { id: 7, class: _ }
 232   - { id: 8, class: _ }
 233 body:             |
 234   bb.0:
 235     liveins: $r0, $r1, $r2, $r3
 236
 237     ; The inputs may be in the wrong order (depending on the target's
 238     ; endianness), but that's orthogonal to what we're trying to test here.
 239     ; For soft float, we only need to check that the first value, received
 240     ; through R0-R1, ends up in R0-R1 or R1-R0, and the second value, received
 241     ; through R2-R3, ends up in R2-R3 or R3-R2, when passed to pow.
 242     ; For hard float, the values need to end up in D0 and D1.
 243     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 244     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 245     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
 246     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
 247     %0(s32) = COPY $r0
 248     %1(s32) = COPY $r1
 249     %2(s32) = COPY $r2
 250     %3(s32) = COPY $r3
 251     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 252     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]]
 253     %4(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 254     %5(s64) = G_MERGE_VALUES %2(s32), %3(s32)
 255     ; CHECK-NOT: G_FPOW
 256     ; CHECK: ADJCALLSTACKDOWN
 257     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X0]]
 258     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X1]]
 259     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y0]]
 260     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y1]]
 261     ; HARD-DAG: $d0 = COPY [[X]]
 262     ; HARD-DAG: $d1 = COPY [[Y]]
 263     ; SOFT: BL{{.*}} &pow, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 264     ; HARD: BL{{.*}} &pow, {{.*}}, implicit $d0, implicit $d1, implicit-def $d0
 265     ; CHECK: ADJCALLSTACKUP
 266     ; CHECK-NOT: G_FPOW
 267     %6(s64) = G_FPOW %4, %5
 268     %7(s32), %8(s32) = G_UNMERGE_VALUES %6(s64)
 269     $r0 = COPY %7(s32)
 270     $r1 = COPY %8(s32)
 271     BX_RET 14, $noreg, implicit $r0, implicit $r1
 272 ...
 273 ---
 274 name:            test_fadd_float
 275 # CHECK-LABEL: name: test_fadd_float
 276 legalized:       false
 277 # CHECK: legalized: true
 278 regBankSelected: false
 279 selected:        false
 280 tracksRegLiveness: true
 281 registers:
 282   - { id: 0, class: _ }
 283   - { id: 1, class: _ }
 284   - { id: 2, class: _ }
 285 body:             |
 286   bb.0:
 287     liveins: $r0, $r1
 288
 289     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 290     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
 291     %0(s32) = COPY $r0
 292     %1(s32) = COPY $r1
 293     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FADD [[X]], [[Y]]
 294     ; SOFT-NOT: G_FADD
 295     ; SOFT: ADJCALLSTACKDOWN
 296     ; SOFT-DAG: $r0 = COPY [[X]]
 297     ; SOFT-DAG: $r1 = COPY [[Y]]
 298     ; SOFT-AEABI: BL{{.*}} &__aeabi_fadd, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 299     ; SOFT-DEFAULT: BL{{.*}} &__addsf3, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 300     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 301     ; SOFT: ADJCALLSTACKUP
 302     ; SOFT-NOT: G_FADD
 303     %2(s32) = G_FADD %0, %1
 304     ; CHECK: $r0 = COPY [[R]]
 305     $r0 = COPY %2(s32)
 306     BX_RET 14, $noreg, implicit $r0
 307 ...
 308 ---
 309 name:            test_fadd_double
 310 # CHECK-LABEL: name: test_fadd_double
 311 legalized:       false
 312 # CHECK: legalized: true
 313 regBankSelected: false
 314 selected:        false
 315 tracksRegLiveness: true
 316 registers:
 317   - { id: 0, class: _ }
 318   - { id: 1, class: _ }
 319   - { id: 2, class: _ }
 320   - { id: 3, class: _ }
 321   - { id: 4, class: _ }
 322   - { id: 5, class: _ }
 323   - { id: 6, class: _ }
 324   - { id: 7, class: _ }
 325   - { id: 8, class: _ }
 326 body:             |
 327   bb.0:
 328     liveins: $r0, $r1, $r2, $r3
 329
 330     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 331     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 332     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
 333     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
 334     %0(s32) = COPY $r0
 335     %1(s32) = COPY $r1
 336     %2(s32) = COPY $r2
 337     %3(s32) = COPY $r3
 338     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 339     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]]
 340     %4(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 341     %5(s64) = G_MERGE_VALUES %2(s32), %3(s32)
 342     ; HARD: [[R:%[0-9]+]]:_(s64) = G_FADD [[X]], [[Y]]
 343     ; SOFT-NOT: G_FADD
 344     ; SOFT: ADJCALLSTACKDOWN
 345     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X0]]
 346     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X1]]
 347     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y0]]
 348     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y1]]
 349     ; SOFT-AEABI: BL{{.*}} &__aeabi_dadd, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 350     ; SOFT-DEFAULT: BL{{.*}} &__adddf3, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 351     ; SOFT: ADJCALLSTACKUP
 352     ; SOFT-NOT: G_FADD
 353     %6(s64) = G_FADD %4, %5
 354     ; HARD-DAG: G_UNMERGE_VALUES [[R]](s64)
 355     %7(s32),%8(s32) = G_UNMERGE_VALUES %6(s64)
 356     $r0 = COPY %7(s32)
 357     $r1 = COPY %8(s32)
 358     BX_RET 14, $noreg, implicit $r0, implicit $r1
 359 ...
 360 ---
 361 name:            test_fsub_float
 362 # CHECK-LABEL: name: test_fsub_float
 363 legalized:       false
 364 # CHECK: legalized: true
 365 regBankSelected: false
 366 selected:        false
 367 tracksRegLiveness: true
 368 registers:
 369   - { id: 0, class: _ }
 370   - { id: 1, class: _ }
 371   - { id: 2, class: _ }
 372 body:             |
 373   bb.0:
 374     liveins: $r0, $r1
 375
 376     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 377     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
 378     %0(s32) = COPY $r0
 379     %1(s32) = COPY $r1
 380     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FSUB [[X]], [[Y]]
 381     ; SOFT-NOT: G_FSUB
 382     ; SOFT: ADJCALLSTACKDOWN
 383     ; SOFT-DAG: $r0 = COPY [[X]]
 384     ; SOFT-DAG: $r1 = COPY [[Y]]
 385     ; SOFT-AEABI: BL{{.*}} &__aeabi_fsub, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 386     ; SOFT-DEFAULT: BL{{.*}} &__subsf3, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 387     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 388     ; SOFT: ADJCALLSTACKUP
 389     ; SOFT-NOT: G_FSUB
 390     %2(s32) = G_FSUB %0, %1
 391     ; CHECK: $r0 = COPY [[R]]
 392     $r0 = COPY %2(s32)
 393     BX_RET 14, $noreg, implicit $r0
 394 ...
 395 ---
 396 name:            test_fsub_double
 397 # CHECK-LABEL: name: test_fsub_double
 398 legalized:       false
 399 # CHECK: legalized: true
 400 regBankSelected: false
 401 selected:        false
 402 tracksRegLiveness: true
 403 registers:
 404   - { id: 0, class: _ }
 405   - { id: 1, class: _ }
 406   - { id: 2, class: _ }
 407   - { id: 3, class: _ }
 408   - { id: 4, class: _ }
 409   - { id: 5, class: _ }
 410   - { id: 6, class: _ }
 411   - { id: 7, class: _ }
 412   - { id: 8, class: _ }
 413 body:             |
 414   bb.0:
 415     liveins: $r0, $r1, $r2, $r3
 416
 417     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 418     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 419     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
 420     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
 421     %0(s32) = COPY $r0
 422     %1(s32) = COPY $r1
 423     %2(s32) = COPY $r2
 424     %3(s32) = COPY $r3
 425     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 426     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]]
 427     %4(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 428     %5(s64) = G_MERGE_VALUES %2(s32), %3(s32)
 429     ; HARD: [[R:%[0-9]+]]:_(s64) = G_FSUB [[X]], [[Y]]
 430     ; SOFT-NOT: G_FSUB
 431     ; SOFT: ADJCALLSTACKDOWN
 432     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X0]]
 433     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X1]]
 434     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y0]]
 435     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y1]]
 436     ; SOFT-AEABI: BL{{.*}} &__aeabi_dsub, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 437     ; SOFT-DEFAULT: BL{{.*}} &__subdf3, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 438     ; SOFT: ADJCALLSTACKUP
 439     ; SOFT-NOT: G_FSUB
 440     %6(s64) = G_FSUB %4, %5
 441     ; HARD-DAG: G_UNMERGE_VALUES [[R]](s64)
 442     %7(s32),%8(s32) = G_UNMERGE_VALUES %6(s64)
 443     $r0 = COPY %7(s32)
 444     $r1 = COPY %8(s32)
 445     BX_RET 14, $noreg, implicit $r0, implicit $r1
 446 ...
 447 ---
 448 name:            test_fmul_float
 449 # CHECK-LABEL: name: test_fmul_float
 450 legalized:       false
 451 # CHECK: legalized: true
 452 regBankSelected: false
 453 selected:        false
 454 tracksRegLiveness: true
 455 registers:
 456   - { id: 0, class: _ }
 457   - { id: 1, class: _ }
 458   - { id: 2, class: _ }
 459 body:             |
 460   bb.0:
 461     liveins: $r0, $r1
 462
 463     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 464     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
 465     %0(s32) = COPY $r0
 466     %1(s32) = COPY $r1
 467     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FMUL [[X]], [[Y]]
 468     ; SOFT-NOT: G_FMUL
 469     ; SOFT: ADJCALLSTACKDOWN
 470     ; SOFT-DAG: $r0 = COPY [[X]]
 471     ; SOFT-DAG: $r1 = COPY [[Y]]
 472     ; SOFT-AEABI: BL{{.*}} &__aeabi_fmul, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 473     ; SOFT-DEFAULT: BL{{.*}} &__mulsf3, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 474     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 475     ; SOFT: ADJCALLSTACKUP
 476     ; SOFT-NOT: G_FMUL
 477     %2(s32) = G_FMUL %0, %1
 478     ; CHECK: $r0 = COPY [[R]]
 479     $r0 = COPY %2(s32)
 480     BX_RET 14, $noreg, implicit $r0
 481 ...
 482 ---
 483 name:            test_fmul_double
 484 # CHECK-LABEL: name: test_fmul_double
 485 legalized:       false
 486 # CHECK: legalized: true
 487 regBankSelected: false
 488 selected:        false
 489 tracksRegLiveness: true
 490 registers:
 491   - { id: 0, class: _ }
 492   - { id: 1, class: _ }
 493   - { id: 2, class: _ }
 494   - { id: 3, class: _ }
 495   - { id: 4, class: _ }
 496   - { id: 5, class: _ }
 497   - { id: 6, class: _ }
 498   - { id: 7, class: _ }
 499   - { id: 8, class: _ }
 500 body:             |
 501   bb.0:
 502     liveins: $r0, $r1, $r2, $r3
 503
 504     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 505     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 506     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
 507     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
 508     %0(s32) = COPY $r0
 509     %1(s32) = COPY $r1
 510     %2(s32) = COPY $r2
 511     %3(s32) = COPY $r3
 512     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 513     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]]
 514     %4(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 515     %5(s64) = G_MERGE_VALUES %2(s32), %3(s32)
 516     ; HARD: [[R:%[0-9]+]]:_(s64) = G_FMUL [[X]], [[Y]]
 517     ; SOFT-NOT: G_FMUL
 518     ; SOFT: ADJCALLSTACKDOWN
 519     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X0]]
 520     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X1]]
 521     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y0]]
 522     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y1]]
 523     ; SOFT-AEABI: BL{{.*}} &__aeabi_dmul, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 524     ; SOFT-DEFAULT: BL{{.*}} &__muldf3, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 525     ; SOFT: ADJCALLSTACKUP
 526     ; SOFT-NOT: G_FMUL
 527     %6(s64) = G_FMUL %4, %5
 528     ; HARD-DAG: G_UNMERGE_VALUES [[R]](s64)
 529     %7(s32),%8(s32) = G_UNMERGE_VALUES %6(s64)
 530     $r0 = COPY %7(s32)
 531     $r1 = COPY %8(s32)
 532     BX_RET 14, $noreg, implicit $r0, implicit $r1
 533 ...
 534 ---
 535 name:            test_fdiv_float
 536 # CHECK-LABEL: name: test_fdiv_float
 537 legalized:       false
 538 # CHECK: legalized: true
 539 regBankSelected: false
 540 selected:        false
 541 tracksRegLiveness: true
 542 registers:
 543   - { id: 0, class: _ }
 544   - { id: 1, class: _ }
 545   - { id: 2, class: _ }
 546 body:             |
 547   bb.0:
 548     liveins: $r0, $r1
 549
 550     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 551     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
 552     %0(s32) = COPY $r0
 553     %1(s32) = COPY $r1
 554     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FDIV [[X]], [[Y]]
 555     ; SOFT-NOT: G_FDIV
 556     ; SOFT: ADJCALLSTACKDOWN
 557     ; SOFT-DAG: $r0 = COPY [[X]]
 558     ; SOFT-DAG: $r1 = COPY [[Y]]
 559     ; SOFT-AEABI: BL{{.*}} &__aeabi_fdiv, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 560     ; SOFT-DEFAULT: BL{{.*}} &__divsf3, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 561     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 562     ; SOFT: ADJCALLSTACKUP
 563     ; SOFT-NOT: G_FDIV
 564     %2(s32) = G_FDIV %0, %1
 565     ; CHECK: $r0 = COPY [[R]]
 566     $r0 = COPY %2(s32)
 567     BX_RET 14, $noreg, implicit $r0
 568 ...
 569 ---
 570 name:            test_fdiv_double
 571 # CHECK-LABEL: name: test_fdiv_double
 572 legalized:       false
 573 # CHECK: legalized: true
 574 regBankSelected: false
 575 selected:        false
 576 tracksRegLiveness: true
 577 registers:
 578   - { id: 0, class: _ }
 579   - { id: 1, class: _ }
 580   - { id: 2, class: _ }
 581   - { id: 3, class: _ }
 582   - { id: 4, class: _ }
 583   - { id: 5, class: _ }
 584   - { id: 6, class: _ }
 585   - { id: 7, class: _ }
 586   - { id: 8, class: _ }
 587 body:             |
 588   bb.0:
 589     liveins: $r0, $r1, $r2, $r3
 590
 591     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 592     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 593     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
 594     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
 595     %0(s32) = COPY $r0
 596     %1(s32) = COPY $r1
 597     %2(s32) = COPY $r2
 598     %3(s32) = COPY $r3
 599     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 600     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]]
 601     %4(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 602     %5(s64) = G_MERGE_VALUES %2(s32), %3(s32)
 603     ; HARD: [[R:%[0-9]+]]:_(s64) = G_FDIV [[X]], [[Y]]
 604     ; SOFT-NOT: G_FDIV
 605     ; SOFT: ADJCALLSTACKDOWN
 606     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X0]]
 607     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X1]]
 608     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y0]]
 609     ; SOFT-DAG: $r{{[2-3]}} = COPY [[Y1]]
 610     ; SOFT-AEABI: BL{{.*}} &__aeabi_ddiv, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 611     ; SOFT-DEFAULT: BL{{.*}} &__divdf3, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 612     ; SOFT: ADJCALLSTACKUP
 613     ; SOFT-NOT: G_FDIV
 614     %6(s64) = G_FDIV %4, %5
 615     ; HARD-DAG: G_UNMERGE_VALUES [[R]](s64)
 616     %7(s32),%8(s32) = G_UNMERGE_VALUES %6(s64)
 617     $r0 = COPY %7(s32)
 618     $r1 = COPY %8(s32)
 619     BX_RET 14, $noreg, implicit $r0, implicit $r1
 620 ...
 621 ---
 622 name:            test_fconstant_float
 623 # CHECK-LABEL: name: test_fconstant_float
 624 legalized:       false
 625 # CHECK: legalized: true
 626 regBankSelected: false
 627 selected:        false
 628 tracksRegLiveness: true
 629 registers:
 630   - { id: 0, class: _ }
 631 body:             |
 632   bb.0:
 633     liveins:
 634
 635     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.25
 636     ; SOFT-NOT: G_FCONSTANT
 637     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_CONSTANT i32 -1080033280
 638     ; SOFT-NOT: G_FCONSTANT
 639     %0(s32) = G_FCONSTANT float -1.25
 640     ; CHECK: $r0 = COPY [[R]]
 641     $r0 = COPY %0(s32)
 642     BX_RET 14, $noreg, implicit $r0
 643 ...
 644 ---
 645 name:            test_fconstant_double
 646 # CHECK-LABEL: name: test_fconstant_double
 647 legalized:       false
 648 # CHECK: legalized: true
 649 regBankSelected: false
 650 selected:        false
 651 tracksRegLiveness: true
 652 registers:
 653   - { id: 0, class: _ }
 654   - { id: 1, class: _ }
 655   - { id: 2, class: _ }
 656 body:             |
 657   bb.0:
 658     liveins:
 659
 660     ; HARD: [[R:%[0-9]+]]:_(s64) = G_FCONSTANT double -2.4
 661     ; SOFT-NOT: G_FCONSTANT
 662     ; SOFT-DAG: [[HI:%[0-9]+]]:_(s32) = G_CONSTANT i32 -1073532109
 663     ; SOFT-DAG: [[LO:%[0-9]+]]:_(s32) = G_CONSTANT i32 858993459
 664     ; SOFT-NOT: G_FCONSTANT
 665     %0(s64) = G_FCONSTANT double -2.4
 666     ; HARD-DAG: G_UNMERGE_VALUES [[R]](s64)
 667     ; SOFT-DAG: $r0 = COPY [[HI]]
 668     ; SOFT-DAG: $r1 = COPY [[LO]]
 669     %1(s32),%2(s32) = G_UNMERGE_VALUES %0(s64)
 670     $r0 = COPY %2(s32)
 671     $r1 = COPY %1(s32)
 672     BX_RET 14, $noreg, implicit $r0, implicit $r1
 673 ...
 674 ---
 675 name:            test_fneg_float
 676 # CHECK-LABEL: name: test_fneg_float
 677 legalized:       false
 678 # CHECK: legalized: true
 679 regBankSelected: false
 680 selected:        false
 681 tracksRegLiveness: true
 682 registers:
 683   - { id: 0, class: _ }
 684   - { id: 1, class: _ }
 685 body:             |
 686   bb.0:
 687     liveins: $r0
 688
 689     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 690     %0(s32) = COPY $r0
 691     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FNEG [[X]]
 692     ; SOFT-NOT: G_FNEG
 693     ; SOFT-DAG: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 -2147483648
 694     ; SOFT: ADJCALLSTACKDOWN
 695     ; SOFT-DAG: $r0 = COPY [[ZERO]]
 696     ; SOFT-DAG: $r1 = COPY [[X]]
 697     ; SOFT-AEABI: BL{{.*}} &__aeabi_fsub, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 698     ; SOFT-DEFAULT: BL{{.*}} &__subsf3, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 699     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 700     ; SOFT: ADJCALLSTACKUP
 701     ; SOFT-NOT: G_FNEG
 702     %1(s32) = G_FNEG %0
 703     ; CHECK: $r0 = COPY [[R]]
 704     $r0 = COPY %1(s32)
 705     BX_RET 14, $noreg, implicit $r0
 706 ...
 707 ---
 708 name:            test_fneg_double
 709 # CHECK-LABEL: name: test_fneg_double
 710 legalized:       false
 711 # CHECK: legalized: true
 712 regBankSelected: false
 713 selected:        false
 714 tracksRegLiveness: true
 715 registers:
 716   - { id: 0, class: _ }
 717   - { id: 1, class: _ }
 718   - { id: 2, class: _ }
 719   - { id: 3, class: _ }
 720   - { id: 4, class: _ }
 721   - { id: 5, class: _ }
 722 body:             |
 723   bb.0:
 724     liveins: $r0, $r1
 725
 726     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 727     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 728     %0(s32) = COPY $r0
 729     %1(s32) = COPY $r1
 730     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 731     %2(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 732     ; HARD: [[R:%[0-9]+]]:_(s64) = G_FNEG [[X]]
 733     ; SOFT-NOT: G_FNEG
 734     ; SOFT-DAG: [[NEGATIVE_ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 -2147483648
 735     ; SOFT-DAG: [[POSITIVE_ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 736     ; SOFT: ADJCALLSTACKDOWN
 737     ; SOFT-DAG: $r{{[0-1]}} = COPY [[NEGATIVE_ZERO]]
 738     ; SOFT-DAG: $r{{[0-1]}} = COPY [[POSITIVE_ZERO]]
 739     ; SOFT-DAG: $r{{[2-3]}} = COPY [[X0]]
 740     ; SOFT-DAG: $r{{[2-3]}} = COPY [[X1]]
 741     ; SOFT-AEABI: BL{{.*}} &__aeabi_dsub, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 742     ; SOFT-DEFAULT: BL{{.*}} &__subdf3, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0, implicit-def $r1
 743     ; SOFT: ADJCALLSTACKUP
 744     ; SOFT-NOT: G_FNEG
 745     %3(s64) = G_FNEG %2
 746     ; HARD-DAG: G_UNMERGE_VALUES [[R]](s64)
 747     %4(s32),%5(s32) = G_UNMERGE_VALUES %3(s64)
 748     $r0 = COPY %4(s32)
 749     $r1 = COPY %5(s32)
 750     BX_RET 14, $noreg, implicit $r0, implicit $r1
 751 ...
 752 ---
 753 name:            test_fpext_float_to_double
 754 # CHECK-LABEL: name: test_fpext_float_to_double
 755 legalized:       false
 756 # CHECK: legalized: true
 757 regBankSelected: false
 758 selected:        false
 759 tracksRegLiveness: true
 760 registers:
 761   - { id: 0, class: _ }
 762   - { id: 1, class: _ }
 763   - { id: 2, class: _ }
 764   - { id: 3, class: _ }
 765 body:             |
 766   bb.0:
 767     liveins: $r0
 768
 769     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 770     %0(s32) = COPY $r0
 771     ; HARD: [[R:%[0-9]+]]:_(s64) = G_FPEXT [[X]]
 772     ; SOFT-NOT: G_FPEXT
 773     ; SOFT: ADJCALLSTACKDOWN
 774     ; SOFT-DAG: $r0 = COPY [[X]]
 775     ; SOFT-AEABI: BL{{.*}} &__aeabi_f2d, {{.*}}, implicit $r0, implicit-def $r0, implicit-def $r1
 776     ; SOFT-DEFAULT: BL{{.*}} &__extendsfdf2, {{.*}}, implicit $r0, implicit-def $r0, implicit-def $r1
 777     ; SOFT: [[R0:%[0-9]+]]:_(s32) = COPY $r0
 778     ; SOFT: [[R1:%[0-9]+]]:_(s32) = COPY $r1
 779     ; SOFT: ADJCALLSTACKUP
 780     ; SOFT-NOT: G_FPEXT
 781     %1(s64) = G_FPEXT %0(s32)
 782     ; HARD: G_UNMERGE_VALUES [[R]](s64)
 783     ; SOFT-DAG: $r{{[0-1]}} = COPY [[R0]]
 784     ; SOFT-DAG: $r{{[0-1]}} = COPY [[R1]]
 785     %2(s32), %3(s32) = G_UNMERGE_VALUES %1(s64)
 786     $r0 = COPY %2(s32)
 787     $r1 = COPY %3(s32)
 788     BX_RET 14, $noreg, implicit $r0, implicit $r1
 789 ...
 790 ---
 791 name:            test_fptrunc_double_to_float
 792 # CHECK-LABEL: name: test_fptrunc_double_to_float
 793 legalized:       false
 794 # CHECK: legalized: true
 795 regBankSelected: false
 796 selected:        false
 797 tracksRegLiveness: true
 798 registers:
 799   - { id: 0, class: _ }
 800   - { id: 1, class: _ }
 801   - { id: 2, class: _ }
 802   - { id: 3, class: _ }
 803 body:             |
 804   bb.0:
 805     liveins: $r0, $r1
 806
 807     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 808     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 809     ; HARD: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 810     %0(s32) = COPY $r0
 811     %1(s32) = COPY $r1
 812     %2(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 813     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FPTRUNC [[X]]
 814     ; SOFT-NOT: G_FPTRUNC
 815     ; SOFT: ADJCALLSTACKDOWN
 816     ; SOFT-DAG: $r0 = COPY [[X0]]
 817     ; SOFT-DAG: $r1 = COPY [[X1]]
 818     ; SOFT-AEABI: BL{{.*}} &__aeabi_d2f, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 819     ; SOFT-DEFAULT: BL{{.*}} &__truncdfsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 820     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 821     ; SOFT: ADJCALLSTACKUP
 822     ; SOFT-NOT: G_FPTRUNC
 823     %3(s32) = G_FPTRUNC %2(s64)
 824     ; CHECK: $r0 = COPY [[R]]
 825     $r0 = COPY %3(s32)
 826     BX_RET 14, $noreg, implicit $r0
 827 ---
 828 ---
 829 name:            test_fptosi_float
 830 # CHECK-LABEL: name: test_fptosi_float
 831 legalized:       false
 832 # CHECK: legalized: true
 833 regBankSelected: false
 834 selected:        false
 835 tracksRegLiveness: true
 836 registers:
 837   - { id: 0, class: _ }
 838   - { id: 1, class: _ }
 839 body:             |
 840   bb.0:
 841     liveins: $r0
 842
 843     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 844     %0(s32) = COPY $r0
 845     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FPTOSI [[X]]
 846     ; SOFT-NOT: G_FPTOSI
 847     ; SOFT: ADJCALLSTACKDOWN
 848     ; SOFT-DAG: $r0 = COPY [[X]]
 849     ; SOFT-AEABI: BL{{.*}} &__aeabi_f2iz, {{.*}}, implicit $r0, implicit-def $r0
 850     ; SOFT-DEFAULT: BL{{.*}} &__fixsfsi, {{.*}}, implicit $r0, implicit-def $r0
 851     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 852     ; SOFT: ADJCALLSTACKUP
 853     ; SOFT-NOT: G_FPTOSI
 854     %1(s32) = G_FPTOSI %0(s32)
 855     ; CHECK: $r0 = COPY [[R]]
 856     $r0 = COPY %1(s32)
 857     BX_RET 14, $noreg, implicit $r0
 858 ...
 859 ---
 860 name:            test_fptosi_double
 861 # CHECK-LABEL: name: test_fptosi_double
 862 legalized:       false
 863 # CHECK: legalized: true
 864 regBankSelected: false
 865 selected:        false
 866 tracksRegLiveness: true
 867 registers:
 868   - { id: 0, class: _ }
 869   - { id: 1, class: _ }
 870   - { id: 2, class: _ }
 871   - { id: 3, class: _ }
 872 body:             |
 873   bb.0:
 874     liveins: $r0, $r1
 875
 876     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 877     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 878     %0(s32) = COPY $r0
 879     %1(s32) = COPY $r1
 880     ; HARD: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 881     %2(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 882     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FPTOSI [[X]]
 883     ; SOFT-NOT: G_FPTOSI
 884     ; SOFT: ADJCALLSTACKDOWN
 885     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X0]]
 886     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X1]]
 887     ; SOFT-AEABI: BL{{.*}} &__aeabi_d2iz, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 888     ; SOFT-DEFAULT: BL{{.*}} &__fixdfsi, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 889     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 890     ; SOFT: ADJCALLSTACKUP
 891     ; SOFT-NOT: G_FPTOSI
 892     %3(s32) = G_FPTOSI %2(s64)
 893     ; CHECK: $r0 = COPY [[R]](s32)
 894     $r0 = COPY %3(s32)
 895     BX_RET 14, $noreg, implicit $r0
 896 ...
 897 ---
 898 name:            test_fptoui_float
 899 # CHECK-LABEL: name: test_fptoui_float
 900 legalized:       false
 901 # CHECK: legalized: true
 902 regBankSelected: false
 903 selected:        false
 904 tracksRegLiveness: true
 905 registers:
 906   - { id: 0, class: _ }
 907   - { id: 1, class: _ }
 908 body:             |
 909   bb.0:
 910     liveins: $r0
 911
 912     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 913     %0(s32) = COPY $r0
 914     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FPTOUI [[X]]
 915     ; SOFT-NOT: G_FPTOUI
 916     ; SOFT: ADJCALLSTACKDOWN
 917     ; SOFT-DAG: $r0 = COPY [[X]]
 918     ; SOFT-AEABI: BL{{.*}} &__aeabi_f2uiz, {{.*}}, implicit $r0, implicit-def $r0
 919     ; SOFT-DEFAULT: BL{{.*}} &__fixunssfsi, {{.*}}, implicit $r0, implicit-def $r0
 920     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 921     ; SOFT: ADJCALLSTACKUP
 922     ; SOFT-NOT: G_FPTOUI
 923     %1(s32) = G_FPTOUI %0(s32)
 924     ; CHECK: $r0 = COPY [[R]]
 925     $r0 = COPY %1(s32)
 926     BX_RET 14, $noreg, implicit $r0
 927 ...
 928 ---
 929 name:            test_fptoui_double
 930 # CHECK-LABEL: name: test_fptoui_double
 931 legalized:       false
 932 # CHECK: legalized: true
 933 regBankSelected: false
 934 selected:        false
 935 tracksRegLiveness: true
 936 registers:
 937   - { id: 0, class: _ }
 938   - { id: 1, class: _ }
 939   - { id: 2, class: _ }
 940   - { id: 3, class: _ }
 941 body:             |
 942   bb.0:
 943     liveins: $r0, $r1
 944
 945     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
 946     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
 947     %0(s32) = COPY $r0
 948     %1(s32) = COPY $r1
 949     ; HARD: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]]
 950     %2(s64) = G_MERGE_VALUES %0(s32), %1(s32)
 951     ; HARD: [[R:%[0-9]+]]:_(s32) = G_FPTOUI [[X]]
 952     ; SOFT-NOT: G_FPTOUI
 953     ; SOFT: ADJCALLSTACKDOWN
 954     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X0]]
 955     ; SOFT-DAG: $r{{[0-1]}} = COPY [[X1]]
 956     ; SOFT-AEABI: BL{{.*}} &__aeabi_d2uiz, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 957     ; SOFT-DEFAULT: BL{{.*}} &__fixunsdfsi, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
 958     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 959     ; SOFT: ADJCALLSTACKUP
 960     ; SOFT-NOT: G_FPTOUI
 961     %3(s32) = G_FPTOUI %2(s64)
 962     ; CHECK: $r0 = COPY [[R]](s32)
 963     $r0 = COPY %3(s32)
 964     BX_RET 14, $noreg, implicit $r0
 965 ...
 966 ---
 967 name:            test_sitofp_float
 968 # CHECK-LABEL: name: test_sitofp_float
 969 legalized:       false
 970 # CHECK: legalized: true
 971 regBankSelected: false
 972 selected:        false
 973 tracksRegLiveness: true
 974 registers:
 975   - { id: 0, class: _ }
 976   - { id: 1, class: _ }
 977 body:             |
 978   bb.0:
 979     liveins: $r0
 980
 981     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
 982     %0(s32) = COPY $r0
 983     ; HARD: [[R:%[0-9]+]]:_(s32) = G_SITOFP [[X]]
 984     ; SOFT-NOT: G_SITOFP
 985     ; SOFT: ADJCALLSTACKDOWN
 986     ; SOFT-DAG: $r0 = COPY [[X]]
 987     ; SOFT-AEABI: BL{{.*}} &__aeabi_i2f, {{.*}}, implicit $r0, implicit-def $r0
 988     ; SOFT-DEFAULT: BL{{.*}} &__floatsisf, {{.*}}, implicit $r0, implicit-def $r0
 989     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
 990     ; SOFT: ADJCALLSTACKUP
 991     ; SOFT-NOT: G_SITOFP
 992     %1(s32) = G_SITOFP %0(s32)
 993     ; CHECK: $r0 = COPY [[R]]
 994     $r0 = COPY %1(s32)
 995     BX_RET 14, $noreg, implicit $r0
 996 ...
 997 ---
 998 name:            test_sitofp_double
 999 # CHECK-LABEL: name: test_sitofp_double
1000 legalized:       false
1001 # CHECK: legalized: true
1002 regBankSelected: false
1003 selected:        false
1004 tracksRegLiveness: true
1005 registers:
1006   - { id: 0, class: _ }
1007   - { id: 1, class: _ }
1008   - { id: 2, class: _ }
1009   - { id: 3, class: _ }
1010 body:             |
1011   bb.0:
1012     liveins: $r0
1013
1014     ; CHECK: [[X:%[0-9]+]]:_(s32) = COPY $r0
1015     %0(s32) = COPY $r0
1016     ; HARD: [[R:%[0-9]+]]:_(s64) = G_SITOFP [[X]]
1017     ; SOFT-NOT: G_SITOFP
1018     ; SOFT: ADJCALLSTACKDOWN
1019     ; SOFT: $r0 = COPY [[X]]
1020     ; SOFT-AEABI: BL{{.*}} &__aeabi_i2d, {{.*}}, implicit $r0, implicit-def $r0, implicit-def $r1
1021     ; SOFT-DEFAULT: BL{{.*}} &__floatsidf, {{.*}}, implicit $r0, implicit-def $r0, implicit-def $r1
1022     ; SOFT-DAG: [[R0:%[0-9]+]]:_(s32) = COPY $r0
1023     ; SOFT-DAG: [[R1:%[0-9]+]]:_(s32) = COPY $r1
1024     ; SOFT: ADJCALLSTACKUP
1025     ; SOFT-NOT: G_SITOFP
1026     %1(s64) = G_SITOFP %0(s32)
1027     ; HARD: [[R0:%[0-9]+]]:_(s32), [[R1:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[R]]
1028     %2(s32), %3(s32) = G_UNMERGE_VALUES %1(s64)
1029     ; CHECK-DAG: $r0 = COPY [[R0]](s32)
1030     ; CHECK-DAG: $r1 = COPY [[R1]](s32)
1031     $r0 = COPY %2(s32)
1032     $r1 = COPY %3(s32)
1033     BX_RET 14, $noreg, implicit $r0, implicit $r1
1034 ...
1035 ---
1036 name:            test_uitofp_float
1037 # CHECK-LABEL: name: test_uitofp_float
1038 legalized:       false
1039 # CHECK: legalized: true
1040 regBankSelected: false
1041 selected:        false
1042 tracksRegLiveness: true
1043 registers:
1044   - { id: 0, class: _ }
1045   - { id: 1, class: _ }
1046 body:             |
1047   bb.0:
1048     liveins: $r0
1049
1050     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1051     %0(s32) = COPY $r0
1052     ; HARD: [[R:%[0-9]+]]:_(s32) = G_UITOFP [[X]]
1053     ; SOFT-NOT: G_UITOFP
1054     ; SOFT: ADJCALLSTACKDOWN
1055     ; SOFT-DAG: $r0 = COPY [[X]]
1056     ; SOFT-AEABI: BL{{.*}} &__aeabi_ui2f, {{.*}}, implicit $r0, implicit-def $r0
1057     ; SOFT-DEFAULT: BL{{.*}} &__floatunsisf, {{.*}}, implicit $r0, implicit-def $r0
1058     ; SOFT: [[R:%[0-9]+]]:_(s32) = COPY $r0
1059     ; SOFT: ADJCALLSTACKUP
1060     ; SOFT-NOT: G_UITOFP
1061     %1(s32) = G_UITOFP %0(s32)
1062     ; CHECK: $r0 = COPY [[R]]
1063     $r0 = COPY %1(s32)
1064     BX_RET 14, $noreg, implicit $r0
1065 ...
1066 ---
1067 name:            test_uitofp_double
1068 # CHECK-LABEL: name: test_uitofp_double
1069 legalized:       false
1070 # CHECK: legalized: true
1071 regBankSelected: false
1072 selected:        false
1073 tracksRegLiveness: true
1074 registers:
1075   - { id: 0, class: _ }
1076   - { id: 1, class: _ }
1077   - { id: 2, class: _ }
1078   - { id: 3, class: _ }
1079 body:             |
1080   bb.0:
1081     liveins: $r0
1082
1083     ; CHECK: [[X:%[0-9]+]]:_(s32) = COPY $r0
1084     %0(s32) = COPY $r0
1085     ; HARD: [[R:%[0-9]+]]:_(s64) = G_UITOFP [[X]]
1086     ; SOFT-NOT: G_UITOFP
1087     ; SOFT: ADJCALLSTACKDOWN
1088     ; SOFT: $r0 = COPY [[X]]
1089     ; SOFT-AEABI: BL{{.*}} &__aeabi_ui2d, {{.*}}, implicit $r0, implicit-def $r0, implicit-def $r1
1090     ; SOFT-DEFAULT: BL{{.*}} &__floatunsidf, {{.*}}, implicit $r0, implicit-def $r0, implicit-def $r1
1091     ; SOFT-DAG: [[R0:%[0-9]+]]:_(s32) = COPY $r0
1092     ; SOFT-DAG: [[R1:%[0-9]+]]:_(s32) = COPY $r1
1093     ; SOFT: ADJCALLSTACKUP
1094     ; SOFT-NOT: G_UITOFP
1095     %1(s64) = G_UITOFP %0(s32)
1096     ; HARD: [[R0:%[0-9]+]]:_(s32), [[R1:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[R]]
1097     %2(s32), %3(s32) = G_UNMERGE_VALUES %1(s64)
1098     ; CHECK-DAG: $r0 = COPY [[R0]](s32)
1099     ; CHECK-DAG: $r1 = COPY [[R1]](s32)
1100     $r0 = COPY %2(s32)
1101     $r1 = COPY %3(s32)
1102     BX_RET 14, $noreg, implicit $r0, implicit $r1
1103 ...
1104 ...
1105 name:            test_fcmp_true_s32
1106 # CHECK-LABEL: name: test_fcmp_true_s32
1107 legalized:       false
1108 # CHECK: legalized: true
1109 regBankSelected: false
1110 selected:        false
1111 tracksRegLiveness: true
1112 registers:
1113   - { id: 0, class: _ }
1114   - { id: 1, class: _ }
1115   - { id: 2, class: _ }
1116   - { id: 3, class: _ }
1117 body:             |
1118   bb.0:
1119     liveins: $r0, $r1
1120
1121     %0(s32) = COPY $r0
1122     %1(s32) = COPY $r1
1123     %2(s1) = G_FCMP floatpred(true), %0(s32), %1
1124     %3(s32) = G_ZEXT %2(s1)
1125     $r0 = COPY %3(s32)
1126     BX_RET 14, $noreg, implicit $r0
1127     ; HARD-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1128     ; HARD-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1129     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(true), [[X]](s32), [[Y]]
1130     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1131     ; SOFT-NOT: G_FCMP
1132     ; For soft float we just need to return a '-1' constant, but the truncation
1133     ; to 1 bit is converted by the combiner to the following masking sequence.
1134     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_CONSTANT i32 -1
1135     ; SOFT: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1136     ; SOFT: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[R]](s32)
1137     ; SOFT: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1138     ; SOFT-NOT: G_FCMP
1139     ; CHECK: $r0 = COPY [[REXT]]
1140 ...
1141 ---
1142 name:            test_fcmp_false_s32
1143 # CHECK-LABEL: name: test_fcmp_false_s32
1144 legalized:       false
1145 # CHECK: legalized: true
1146 regBankSelected: false
1147 selected:        false
1148 tracksRegLiveness: true
1149 registers:
1150   - { id: 0, class: _ }
1151   - { id: 1, class: _ }
1152   - { id: 2, class: _ }
1153   - { id: 3, class: _ }
1154 body:             |
1155   bb.0:
1156     liveins: $r0, $r1
1157
1158     %0(s32) = COPY $r0
1159     %1(s32) = COPY $r1
1160     %2(s1) = G_FCMP floatpred(false), %0(s32), %1
1161     %3(s32) = G_ZEXT %2(s1)
1162     $r0 = COPY %3(s32)
1163     BX_RET 14, $noreg, implicit $r0
1164     ; HARD-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1165     ; HARD-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1166     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(false), [[X]](s32), [[Y]]
1167     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1168     ; SOFT-NOT: G_FCMP
1169     ; For soft float we just need to return a '0' constant, but the truncation
1170     ; to 1 bit is converted by the combiner to the following masking sequence.
1171     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1172     ; SOFT: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1173     ; SOFT: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[R]](s32)
1174     ; SOFT: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1175     ; SOFT-NOT: G_FCMP
1176     ; CHECK: $r0 = COPY [[REXT]]
1177 ...
1178 ---
1179 name:            test_fcmp_oeq_s32
1180 # CHECK-LABEL: name: test_fcmp_oeq_s32
1181 legalized:       false
1182 # CHECK: legalized: true
1183 regBankSelected: false
1184 selected:        false
1185 tracksRegLiveness: true
1186 registers:
1187   - { id: 0, class: _ }
1188   - { id: 1, class: _ }
1189   - { id: 2, class: _ }
1190   - { id: 3, class: _ }
1191 body:             |
1192   bb.0:
1193     liveins: $r0, $r1
1194
1195     %0(s32) = COPY $r0
1196     %1(s32) = COPY $r1
1197     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1198     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1199     %2(s1) = G_FCMP floatpred(oeq), %0(s32), %1
1200     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(oeq), [[X]](s32), [[Y]]
1201     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1202     ; SOFT-NOT: G_FCMP
1203     ; SOFT: ADJCALLSTACKDOWN
1204     ; SOFT-DAG: $r0 = COPY [[X]]
1205     ; SOFT-DAG: $r1 = COPY [[Y]]
1206     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpeq, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1207     ; SOFT-DEFAULT: BL{{.*}} &__eqsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1208     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1209     ; SOFT: ADJCALLSTACKUP
1210     ; For aeabi, we just need to truncate the result. The combiner changes the
1211     ; truncation into the following masking sequence.
1212     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1213     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
1214     ; SOFT-AEABI: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1215     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1216     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
1217     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1218     ; SOFT-NOT: G_FCMP
1219     %3(s32) = G_ZEXT %2(s1)
1220     $r0 = COPY %3(s32)
1221     ; CHECK: $r0 = COPY [[REXT]]
1222     BX_RET 14, $noreg, implicit $r0
1223 ...
1224 ---
1225 name:            test_fcmp_ogt_s32
1226 # CHECK-LABEL: name: test_fcmp_ogt_s32
1227 legalized:       false
1228 # CHECK: legalized: true
1229 regBankSelected: false
1230 selected:        false
1231 tracksRegLiveness: true
1232 registers:
1233   - { id: 0, class: _ }
1234   - { id: 1, class: _ }
1235   - { id: 2, class: _ }
1236   - { id: 3, class: _ }
1237 body:             |
1238   bb.0:
1239     liveins: $r0, $r1
1240
1241     %0(s32) = COPY $r0
1242     %1(s32) = COPY $r1
1243     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1244     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1245     %2(s1) = G_FCMP floatpred(ogt), %0(s32), %1
1246     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ogt), [[X]](s32), [[Y]]
1247     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1248     ; SOFT-NOT: G_FCMP
1249     ; SOFT: ADJCALLSTACKDOWN
1250     ; SOFT-DAG: $r0 = COPY [[X]]
1251     ; SOFT-DAG: $r1 = COPY [[Y]]
1252     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpgt, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1253     ; SOFT-DEFAULT: BL{{.*}} &__gtsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1254     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1255     ; SOFT: ADJCALLSTACKUP
1256     ; For aeabi, we just need to truncate the result. The combiner changes the
1257     ; truncation into the following masking sequence.
1258     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1259     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
1260     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1261     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1262     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[RET]](s32), [[ZERO]]
1263     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1264     ; SOFT-NOT: G_FCMP
1265     %3(s32) = G_ZEXT %2(s1)
1266     $r0 = COPY %3(s32)
1267     ; CHECK: $r0 = COPY [[REXT]]
1268     BX_RET 14, $noreg, implicit $r0
1269 ...
1270 ---
1271 name:            test_fcmp_oge_s32
1272 # CHECK-LABEL: name: test_fcmp_oge_s32
1273 legalized:       false
1274 # CHECK: legalized: true
1275 regBankSelected: false
1276 selected:        false
1277 tracksRegLiveness: true
1278 registers:
1279   - { id: 0, class: _ }
1280   - { id: 1, class: _ }
1281   - { id: 2, class: _ }
1282   - { id: 3, class: _ }
1283 body:             |
1284   bb.0:
1285     liveins: $r0, $r1
1286
1287     %0(s32) = COPY $r0
1288     %1(s32) = COPY $r1
1289     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1290     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1291     %2(s1) = G_FCMP floatpred(oge), %0(s32), %1
1292     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[X]](s32), [[Y]]
1293     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1294     ; SOFT-NOT: G_FCMP
1295     ; SOFT: ADJCALLSTACKDOWN
1296     ; SOFT-DAG: $r0 = COPY [[X]]
1297     ; SOFT-DAG: $r1 = COPY [[Y]]
1298     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpge, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1299     ; SOFT-DEFAULT: BL{{.*}} &__gesf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1300     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1301     ; SOFT: ADJCALLSTACKUP
1302     ; For aeabi, we just need to truncate the result. The combiner changes the
1303     ; truncation into the following masking sequence.
1304     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1305     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
1306     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1307     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1308     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sge), [[RET]](s32), [[ZERO]]
1309     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1310     ; SOFT-NOT: G_FCMP
1311     %3(s32) = G_ZEXT %2(s1)
1312     $r0 = COPY %3(s32)
1313     ; CHECK: $r0 = COPY [[REXT]]
1314     BX_RET 14, $noreg, implicit $r0
1315 ...
1316 ---
1317 name:            test_fcmp_olt_s32
1318 # CHECK-LABEL: name: test_fcmp_olt_s32
1319 legalized:       false
1320 # CHECK: legalized: true
1321 regBankSelected: false
1322 selected:        false
1323 tracksRegLiveness: true
1324 registers:
1325   - { id: 0, class: _ }
1326   - { id: 1, class: _ }
1327   - { id: 2, class: _ }
1328   - { id: 3, class: _ }
1329 body:             |
1330   bb.0:
1331     liveins: $r0, $r1
1332
1333     %0(s32) = COPY $r0
1334     %1(s32) = COPY $r1
1335     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1336     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1337     %2(s1) = G_FCMP floatpred(olt), %0(s32), %1
1338     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[X]](s32), [[Y]]
1339     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1340     ; SOFT-NOT: G_FCMP
1341     ; SOFT: ADJCALLSTACKDOWN
1342     ; SOFT-DAG: $r0 = COPY [[X]]
1343     ; SOFT-DAG: $r1 = COPY [[Y]]
1344     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmplt, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1345     ; SOFT-DEFAULT: BL{{.*}} &__ltsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1346     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1347     ; SOFT: ADJCALLSTACKUP
1348     ; For aeabi, we just need to truncate the result. The combiner changes the
1349     ; truncation into the following masking sequence.
1350     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1351     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
1352     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1353     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1354     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[RET]](s32), [[ZERO]]
1355     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1356     ; SOFT-NOT: G_FCMP
1357     %3(s32) = G_ZEXT %2(s1)
1358     $r0 = COPY %3(s32)
1359     ; CHECK: $r0 = COPY [[REXT]]
1360     BX_RET 14, $noreg, implicit $r0
1361 ...
1362 ---
1363 name:            test_fcmp_ole_s32
1364 # CHECK-LABEL: name: test_fcmp_ole_s32
1365 legalized:       false
1366 # CHECK: legalized: true
1367 regBankSelected: false
1368 selected:        false
1369 tracksRegLiveness: true
1370 registers:
1371   - { id: 0, class: _ }
1372   - { id: 1, class: _ }
1373   - { id: 2, class: _ }
1374   - { id: 3, class: _ }
1375 body:             |
1376   bb.0:
1377     liveins: $r0, $r1
1378
1379     %0(s32) = COPY $r0
1380     %1(s32) = COPY $r1
1381     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1382     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1383     %2(s1) = G_FCMP floatpred(ole), %0(s32), %1
1384     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ole), [[X]](s32), [[Y]]
1385     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1386     ; SOFT-NOT: G_FCMP
1387     ; SOFT: ADJCALLSTACKDOWN
1388     ; SOFT-DAG: $r0 = COPY [[X]]
1389     ; SOFT-DAG: $r1 = COPY [[Y]]
1390     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmple, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1391     ; SOFT-DEFAULT: BL{{.*}} &__lesf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1392     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1393     ; SOFT: ADJCALLSTACKUP
1394     ; For aeabi, we just need to truncate the result. The combiner changes the
1395     ; truncation into the following masking sequence.
1396     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1397     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
1398     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1399     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1400     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sle), [[RET]](s32), [[ZERO]]
1401     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1402     ; SOFT-NOT: G_FCMP
1403     %3(s32) = G_ZEXT %2(s1)
1404     $r0 = COPY %3(s32)
1405     ; CHECK: $r0 = COPY [[REXT]]
1406     BX_RET 14, $noreg, implicit $r0
1407 ...
1408 ---
1409 name:            test_fcmp_ord_s32
1410 # CHECK-LABEL: name: test_fcmp_ord_s32
1411 legalized:       false
1412 # CHECK: legalized: true
1413 regBankSelected: false
1414 selected:        false
1415 tracksRegLiveness: true
1416 registers:
1417   - { id: 0, class: _ }
1418   - { id: 1, class: _ }
1419   - { id: 2, class: _ }
1420   - { id: 3, class: _ }
1421 body:             |
1422   bb.0:
1423     liveins: $r0, $r1
1424
1425     %0(s32) = COPY $r0
1426     %1(s32) = COPY $r1
1427     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1428     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1429     %2(s1) = G_FCMP floatpred(ord), %0(s32), %1
1430     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ord), [[X]](s32), [[Y]]
1431     ; SOFT-NOT: G_FCMP
1432     ; SOFT: ADJCALLSTACKDOWN
1433     ; SOFT-DAG: $r0 = COPY [[X]]
1434     ; SOFT-DAG: $r1 = COPY [[Y]]
1435     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpun, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1436     ; SOFT-DEFAULT: BL{{.*}} &__unordsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1437     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1438     ; SOFT: ADJCALLSTACKUP
1439     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1440     ; SOFT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
1441     ; SOFT-NOT: G_FCMP
1442     %3(s32) = G_ZEXT %2(s1)
1443     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1444     $r0 = COPY %3(s32)
1445     ; CHECK: $r0 = COPY [[REXT]]
1446     BX_RET 14, $noreg, implicit $r0
1447 ...
1448 ---
1449 name:            test_fcmp_ugt_s32
1450 # CHECK-LABEL: name: test_fcmp_ugt_s32
1451 legalized:       false
1452 # CHECK: legalized: true
1453 regBankSelected: false
1454 selected:        false
1455 tracksRegLiveness: true
1456 registers:
1457   - { id: 0, class: _ }
1458   - { id: 1, class: _ }
1459   - { id: 2, class: _ }
1460   - { id: 3, class: _ }
1461 body:             |
1462   bb.0:
1463     liveins: $r0, $r1
1464
1465     %0(s32) = COPY $r0
1466     %1(s32) = COPY $r1
1467     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1468     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1469     %2(s1) = G_FCMP floatpred(ugt), %0(s32), %1
1470     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ugt), [[X]](s32), [[Y]]
1471     ; SOFT-NOT: G_FCMP
1472     ; SOFT: ADJCALLSTACKDOWN
1473     ; SOFT-DAG: $r0 = COPY [[X]]
1474     ; SOFT-DAG: $r1 = COPY [[Y]]
1475     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmple, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1476     ; SOFT-DEFAULT: BL{{.*}} &__lesf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1477     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1478     ; SOFT: ADJCALLSTACKUP
1479     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1480     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
1481     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[RET]](s32), [[ZERO]]
1482     ; SOFT-NOT: G_FCMP
1483     %3(s32) = G_ZEXT %2(s1)
1484     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1485     $r0 = COPY %3(s32)
1486     ; CHECK: $r0 = COPY [[REXT]]
1487     BX_RET 14, $noreg, implicit $r0
1488 ...
1489 ---
1490 name:            test_fcmp_uge_s32
1491 # CHECK-LABEL: name: test_fcmp_uge_s32
1492 legalized:       false
1493 # CHECK: legalized: true
1494 regBankSelected: false
1495 selected:        false
1496 tracksRegLiveness: true
1497 registers:
1498   - { id: 0, class: _ }
1499   - { id: 1, class: _ }
1500   - { id: 2, class: _ }
1501   - { id: 3, class: _ }
1502 body:             |
1503   bb.0:
1504     liveins: $r0, $r1
1505
1506     %0(s32) = COPY $r0
1507     %1(s32) = COPY $r1
1508     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1509     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1510     %2(s1) = G_FCMP floatpred(uge), %0(s32), %1
1511     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(uge), [[X]](s32), [[Y]]
1512     ; SOFT-NOT: G_FCMP
1513     ; SOFT: ADJCALLSTACKDOWN
1514     ; SOFT-DAG: $r0 = COPY [[X]]
1515     ; SOFT-DAG: $r1 = COPY [[Y]]
1516     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmplt, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1517     ; SOFT-DEFAULT: BL{{.*}} &__ltsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1518     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1519     ; SOFT: ADJCALLSTACKUP
1520     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1521     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
1522     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sge), [[RET]](s32), [[ZERO]]
1523     ; SOFT-NOT: G_FCMP
1524     %3(s32) = G_ZEXT %2(s1)
1525     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1526     $r0 = COPY %3(s32)
1527     ; CHECK: $r0 = COPY [[REXT]]
1528     BX_RET 14, $noreg, implicit $r0
1529 ...
1530 ---
1531 name:            test_fcmp_ult_s32
1532 # CHECK-LABEL: name: test_fcmp_ult_s32
1533 legalized:       false
1534 # CHECK: legalized: true
1535 regBankSelected: false
1536 selected:        false
1537 tracksRegLiveness: true
1538 registers:
1539   - { id: 0, class: _ }
1540   - { id: 1, class: _ }
1541   - { id: 2, class: _ }
1542   - { id: 3, class: _ }
1543 body:             |
1544   bb.0:
1545     liveins: $r0, $r1
1546
1547     %0(s32) = COPY $r0
1548     %1(s32) = COPY $r1
1549     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1550     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1551     %2(s1) = G_FCMP floatpred(ult), %0(s32), %1
1552     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ult), [[X]](s32), [[Y]]
1553     ; SOFT-NOT: G_FCMP
1554     ; SOFT: ADJCALLSTACKDOWN
1555     ; SOFT-DAG: $r0 = COPY [[X]]
1556     ; SOFT-DAG: $r1 = COPY [[Y]]
1557     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpge, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1558     ; SOFT-DEFAULT: BL{{.*}} &__gesf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1559     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1560     ; SOFT: ADJCALLSTACKUP
1561     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1562     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
1563     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[RET]](s32), [[ZERO]]
1564     ; SOFT-NOT: G_FCMP
1565     %3(s32) = G_ZEXT %2(s1)
1566     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1567     $r0 = COPY %3(s32)
1568     ; CHECK: $r0 = COPY [[REXT]]
1569     BX_RET 14, $noreg, implicit $r0
1570 ...
1571 ---
1572 name:            test_fcmp_ule_s32
1573 # CHECK-LABEL: name: test_fcmp_ule_s32
1574 legalized:       false
1575 # CHECK: legalized: true
1576 regBankSelected: false
1577 selected:        false
1578 tracksRegLiveness: true
1579 registers:
1580   - { id: 0, class: _ }
1581   - { id: 1, class: _ }
1582   - { id: 2, class: _ }
1583   - { id: 3, class: _ }
1584 body:             |
1585   bb.0:
1586     liveins: $r0, $r1
1587
1588     %0(s32) = COPY $r0
1589     %1(s32) = COPY $r1
1590     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1591     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1592     %2(s1) = G_FCMP floatpred(ule), %0(s32), %1
1593     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ule), [[X]](s32), [[Y]]
1594     ; SOFT-NOT: G_FCMP
1595     ; SOFT: ADJCALLSTACKDOWN
1596     ; SOFT-DAG: $r0 = COPY [[X]]
1597     ; SOFT-DAG: $r1 = COPY [[Y]]
1598     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpgt, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1599     ; SOFT-DEFAULT: BL{{.*}} &__gtsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1600     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1601     ; SOFT: ADJCALLSTACKUP
1602     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1603     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
1604     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sle), [[RET]](s32), [[ZERO]]
1605     ; SOFT-NOT: G_FCMP
1606     %3(s32) = G_ZEXT %2(s1)
1607     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1608     $r0 = COPY %3(s32)
1609     ; CHECK: $r0 = COPY [[REXT]]
1610     BX_RET 14, $noreg, implicit $r0
1611 ...
1612 ---
1613 name:            test_fcmp_une_s32
1614 # CHECK-LABEL: name: test_fcmp_une_s32
1615 legalized:       false
1616 # CHECK: legalized: true
1617 regBankSelected: false
1618 selected:        false
1619 tracksRegLiveness: true
1620 registers:
1621   - { id: 0, class: _ }
1622   - { id: 1, class: _ }
1623   - { id: 2, class: _ }
1624   - { id: 3, class: _ }
1625 body:             |
1626   bb.0:
1627     liveins: $r0, $r1
1628
1629     %0(s32) = COPY $r0
1630     %1(s32) = COPY $r1
1631     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1632     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1633     %2(s1) = G_FCMP floatpred(une), %0(s32), %1
1634     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(une), [[X]](s32), [[Y]]
1635     ; SOFT-NOT: G_FCMP
1636     ; SOFT: ADJCALLSTACKDOWN
1637     ; SOFT-DAG: $r0 = COPY [[X]]
1638     ; SOFT-DAG: $r1 = COPY [[Y]]
1639     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpeq, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1640     ; SOFT-DEFAULT: BL{{.*}} &__nesf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1641     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1642     ; SOFT: ADJCALLSTACKUP
1643     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1644     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
1645     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[RET]](s32), [[ZERO]]
1646     ; SOFT-NOT: G_FCMP
1647     %3(s32) = G_ZEXT %2(s1)
1648     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1649     $r0 = COPY %3(s32)
1650     ; CHECK: $r0 = COPY [[REXT]]
1651     BX_RET 14, $noreg, implicit $r0
1652 ...
1653 ---
1654 name:            test_fcmp_uno_s32
1655 # CHECK-LABEL: name: test_fcmp_uno_s32
1656 legalized:       false
1657 # CHECK: legalized: true
1658 regBankSelected: false
1659 selected:        false
1660 tracksRegLiveness: true
1661 registers:
1662   - { id: 0, class: _ }
1663   - { id: 1, class: _ }
1664   - { id: 2, class: _ }
1665   - { id: 3, class: _ }
1666 body:             |
1667   bb.0:
1668     liveins: $r0, $r1
1669
1670     %0(s32) = COPY $r0
1671     %1(s32) = COPY $r1
1672     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1673     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1674     %2(s1) = G_FCMP floatpred(uno), %0(s32), %1
1675     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(uno), [[X]](s32), [[Y]]
1676     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1677     ; SOFT-NOT: G_FCMP
1678     ; SOFT: ADJCALLSTACKDOWN
1679     ; SOFT-DAG: $r0 = COPY [[X]]
1680     ; SOFT-DAG: $r1 = COPY [[Y]]
1681     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpun, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1682     ; SOFT-DEFAULT: BL{{.*}} &__unordsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1683     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1684     ; SOFT: ADJCALLSTACKUP
1685     ; For aeabi, we just need to truncate the result. The combiner changes the
1686     ; truncation into the following masking sequence.
1687     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1688     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
1689     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1690     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1691     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[RET]](s32), [[ZERO]]
1692     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1693     ; SOFT-NOT: G_FCMP
1694     %3(s32) = G_ZEXT %2(s1)
1695     $r0 = COPY %3(s32)
1696     ; CHECK: $r0 = COPY [[REXT]]
1697     BX_RET 14, $noreg, implicit $r0
1698 ...
1699 ---
1700 name:            test_fcmp_one_s32
1701 # CHECK-LABEL: name: test_fcmp_one_s32
1702 legalized:       false
1703 # CHECK: legalized: true
1704 regBankSelected: false
1705 selected:        false
1706 tracksRegLiveness: true
1707 registers:
1708   - { id: 0, class: _ }
1709   - { id: 1, class: _ }
1710   - { id: 2, class: _ }
1711   - { id: 3, class: _ }
1712 body:             |
1713   bb.0:
1714     liveins: $r0, $r1
1715
1716     %0(s32) = COPY $r0
1717     %1(s32) = COPY $r1
1718     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1719     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1720     %2(s1) = G_FCMP floatpred(one), %0(s32), %1
1721     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[X]](s32), [[Y]]
1722     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1723     ; SOFT-NOT: G_FCMP
1724     ; SOFT: ADJCALLSTACKDOWN
1725     ; SOFT-DAG: $r0 = COPY [[X]]
1726     ; SOFT-DAG: $r1 = COPY [[Y]]
1727     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpgt, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1728     ; SOFT-DEFAULT: BL{{.*}} &__gtsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1729     ; SOFT: [[RET1:%[0-9]+]]:_(s32) = COPY $r0
1730     ; SOFT: ADJCALLSTACKUP
1731     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1732     ; SOFT-DEFAULT: [[R1:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[RET1]](s32), [[ZERO]]
1733     ; SOFT-NOT: G_FCMP
1734     ; SOFT: ADJCALLSTACKDOWN
1735     ; SOFT-DAG: $r0 = COPY [[X]]
1736     ; SOFT-DAG: $r1 = COPY [[Y]]
1737     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmplt, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1738     ; SOFT-DEFAULT: BL{{.*}} &__ltsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1739     ; SOFT: [[RET2:%[0-9]+]]:_(s32) = COPY $r0
1740     ; SOFT: ADJCALLSTACKUP
1741     ; SOFT-DEFAULT: [[ZERO2:%[0-9]+]]:_(s32) = COPY [[ZERO]]
1742     ; SOFT-DEFAULT: [[R2:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[RET2]](s32), [[ZERO2]]
1743     ; SOFT-AEABI: [[R1EXT:%[0-9]+]]:_(s32) = COPY [[RET1]]
1744     ; SOFT-AEABI: [[R2EXT:%[0-9]+]]:_(s32) = COPY [[RET2]]
1745     ; SOFT-DEFAULT: [[R1EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[R1]]
1746     ; SOFT-DEFAULT: [[R2EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[R2]]
1747     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_OR [[R1EXT]], [[R2EXT]]
1748     ; The result of the G_OR needs to be truncated, and the combiner turns the
1749     ; truncation into the following masking sequence.
1750     ; SOFT: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1751     ; SOFT: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[R]]
1752     ; SOFT: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1753     ; SOFT-NOT: G_FCMP
1754     %3(s32) = G_ZEXT %2(s1)
1755     $r0 = COPY %3(s32)
1756     ; CHECK: $r0 = COPY [[REXT]]
1757     BX_RET 14, $noreg, implicit $r0
1758 ...
1759 ---
1760 name:            test_fcmp_ueq_s32
1761 # CHECK-LABEL: name: test_fcmp_ueq_s32
1762 legalized:       false
1763 # CHECK: legalized: true
1764 regBankSelected: false
1765 selected:        false
1766 tracksRegLiveness: true
1767 registers:
1768   - { id: 0, class: _ }
1769   - { id: 1, class: _ }
1770   - { id: 2, class: _ }
1771   - { id: 3, class: _ }
1772 body:             |
1773   bb.0:
1774     liveins: $r0, $r1
1775
1776     %0(s32) = COPY $r0
1777     %1(s32) = COPY $r1
1778     ; CHECK-DAG: [[X:%[0-9]+]]:_(s32) = COPY $r0
1779     ; CHECK-DAG: [[Y:%[0-9]+]]:_(s32) = COPY $r1
1780     %2(s1) = G_FCMP floatpred(ueq), %0(s32), %1
1781     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ueq), [[X]](s32), [[Y]]
1782     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1783     ; SOFT-NOT: G_FCMP
1784     ; SOFT: ADJCALLSTACKDOWN
1785     ; SOFT-DAG: $r0 = COPY [[X]]
1786     ; SOFT-DAG: $r1 = COPY [[Y]]
1787     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpeq, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1788     ; SOFT-DEFAULT: BL{{.*}} &__eqsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1789     ; SOFT: [[RET1:%[0-9]+]]:_(s32) = COPY $r0
1790     ; SOFT: ADJCALLSTACKUP
1791     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1792     ; SOFT-DEFAULT: [[R1:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET1]](s32), [[ZERO]]
1793     ; SOFT-NOT: G_FCMP
1794     ; SOFT: ADJCALLSTACKDOWN
1795     ; SOFT-DAG: $r0 = COPY [[X]]
1796     ; SOFT-DAG: $r1 = COPY [[Y]]
1797     ; SOFT-AEABI: BL{{.*}} &__aeabi_fcmpun, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1798     ; SOFT-DEFAULT: BL{{.*}} &__unordsf2, {{.*}}, implicit $r0, implicit $r1, implicit-def $r0
1799     ; SOFT: [[RET2:%[0-9]+]]:_(s32) = COPY $r0
1800     ; SOFT: ADJCALLSTACKUP
1801     ; SOFT-DEFAULT: [[ZERO2:%[0-9]+]]:_(s32) = COPY [[ZERO]]
1802     ; SOFT-DEFAULT: [[R2:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[RET2]](s32), [[ZERO2]]
1803     ; SOFT-AEABI: [[R1EXT:%[0-9]+]]:_(s32) = COPY [[RET1]]
1804     ; SOFT-AEABI: [[R2EXT:%[0-9]+]]:_(s32) = COPY [[RET2]]
1805     ; SOFT-DEFAULT: [[R1EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[R1]]
1806     ; SOFT-DEFAULT: [[R2EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[R2]]
1807     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_OR [[R1EXT]], [[R2EXT]]
1808     ; The result of the G_OR needs to be truncated, and the combiner turns the
1809     ; truncation into the following masking sequence.
1810     ; SOFT: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1811     ; SOFT: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[R]]
1812     ; SOFT: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1813     ; SOFT-NOT: G_FCMP
1814     %3(s32) = G_ZEXT %2(s1)
1815     $r0 = COPY %3(s32)
1816     ; CHECK: $r0 = COPY [[REXT]]
1817     BX_RET 14, $noreg, implicit $r0
1818 ...
1819 ---
1820 name:            test_fcmp_true_s64
1821 # CHECK-LABEL: name: test_fcmp_true_s64
1822 legalized:       false
1823 # CHECK: legalized: true
1824 regBankSelected: false
1825 selected:        false
1826 tracksRegLiveness: true
1827 registers:
1828   - { id: 0, class: _ }
1829   - { id: 1, class: _ }
1830   - { id: 2, class: _ }
1831   - { id: 3, class: _ }
1832   - { id: 4, class: _ }
1833   - { id: 5, class: _ }
1834   - { id: 6, class: _ }
1835   - { id: 7, class: _ }
1836 body:             |
1837   bb.0:
1838     liveins: $r0, $r1, $r2, $r3
1839
1840     %0(s32) = COPY $r0
1841     %1(s32) = COPY $r1
1842     %2(s32) = COPY $r2
1843     %3(s32) = COPY $r3
1844     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
1845     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
1846     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
1847     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
1848     %4(s64) = G_MERGE_VALUES %0(s32), %1
1849     %5(s64) = G_MERGE_VALUES %2(s32), %3
1850     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
1851     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
1852     %6(s1) = G_FCMP floatpred(true), %4(s64), %5
1853     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(true), [[X]](s64), [[Y]]
1854     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1855     ; SOFT-NOT: G_FCMP
1856     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_CONSTANT i32 -1
1857     ; The result needs to be truncated, and the combiner turns the truncation
1858     ; into the following masking sequence.
1859     ; SOFT: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1860     ; SOFT: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[R]]
1861     ; SOFT: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1862     ; SOFT-NOT: G_FCMP
1863     %7(s32) = G_ZEXT %6(s1)
1864     $r0 = COPY %7(s32)
1865     ; CHECK: $r0 = COPY [[REXT]]
1866     BX_RET 14, $noreg, implicit $r0
1867 ...
1868 ---
1869 name:            test_fcmp_false_s64
1870 # CHECK-LABEL: name: test_fcmp_false_s64
1871 legalized:       false
1872 # CHECK: legalized: true
1873 regBankSelected: false
1874 selected:        false
1875 tracksRegLiveness: true
1876 registers:
1877   - { id: 0, class: _ }
1878   - { id: 1, class: _ }
1879   - { id: 2, class: _ }
1880   - { id: 3, class: _ }
1881   - { id: 4, class: _ }
1882   - { id: 5, class: _ }
1883   - { id: 6, class: _ }
1884   - { id: 7, class: _ }
1885 body:             |
1886   bb.0:
1887     liveins: $r0, $r1, $r2, $r3
1888
1889     %0(s32) = COPY $r0
1890     %1(s32) = COPY $r1
1891     %2(s32) = COPY $r2
1892     %3(s32) = COPY $r3
1893     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
1894     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
1895     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
1896     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
1897     %4(s64) = G_MERGE_VALUES %0(s32), %1
1898     %5(s64) = G_MERGE_VALUES %2(s32), %3
1899     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
1900     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
1901     %6(s1) = G_FCMP floatpred(false), %4(s64), %5
1902     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(false), [[X]](s64), [[Y]]
1903     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1904     ; SOFT-NOT: G_FCMP
1905     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1906     ; The result needs to be truncated, and the combiner turns the truncation
1907     ; into the following masking sequence.
1908     ; SOFT: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1909     ; SOFT: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[R]]
1910     ; SOFT: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1911     ; SOFT-NOT: G_FCMP
1912     ; SOFT-NOT: G_FCMP
1913     %7(s32) = G_ZEXT %6(s1)
1914     $r0 = COPY %7(s32)
1915     ; CHECK: $r0 = COPY [[REXT]]
1916     BX_RET 14, $noreg, implicit $r0
1917 ...
1918 ---
1919 name:            test_fcmp_oeq_s64
1920 # CHECK-LABEL: name: test_fcmp_oeq_s64
1921 legalized:       false
1922 # CHECK: legalized: true
1923 regBankSelected: false
1924 selected:        false
1925 tracksRegLiveness: true
1926 registers:
1927   - { id: 0, class: _ }
1928   - { id: 1, class: _ }
1929   - { id: 2, class: _ }
1930   - { id: 3, class: _ }
1931   - { id: 4, class: _ }
1932   - { id: 5, class: _ }
1933   - { id: 6, class: _ }
1934   - { id: 7, class: _ }
1935 body:             |
1936   bb.0:
1937     liveins: $r0, $r1, $r2, $r3
1938
1939     %0(s32) = COPY $r0
1940     %1(s32) = COPY $r1
1941     %2(s32) = COPY $r2
1942     %3(s32) = COPY $r3
1943     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
1944     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
1945     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
1946     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
1947     %4(s64) = G_MERGE_VALUES %0(s32), %1
1948     %5(s64) = G_MERGE_VALUES %2(s32), %3
1949     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
1950     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
1951     %6(s1) = G_FCMP floatpred(oeq), %4(s64), %5
1952     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(oeq), [[X]](s64), [[Y]]
1953     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1954     ; SOFT-NOT: G_FCMP
1955     ; SOFT: ADJCALLSTACKDOWN
1956     ; SOFT-DAG: $r0 = COPY [[X0]]
1957     ; SOFT-DAG: $r1 = COPY [[X1]]
1958     ; SOFT-DAG: $r2 = COPY [[Y0]]
1959     ; SOFT-DAG: $r3 = COPY [[Y1]]
1960     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpeq, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
1961     ; SOFT-DEFAULT: BL{{.*}} &__eqdf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
1962     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
1963     ; SOFT: ADJCALLSTACKUP
1964     ; For aeabi, we just need to truncate the result. The combiner changes the
1965     ; truncation into the following masking sequence.
1966     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1967     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
1968     ; SOFT-AEABI: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
1969     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1970     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
1971     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
1972     ; SOFT-NOT: G_FCMP
1973     %7(s32) = G_ZEXT %6(s1)
1974     $r0 = COPY %7(s32)
1975     ; CHECK: $r0 = COPY [[REXT]]
1976     BX_RET 14, $noreg, implicit $r0
1977 ...
1978 ---
1979 name:            test_fcmp_ogt_s64
1980 # CHECK-LABEL: name: test_fcmp_ogt_s64
1981 legalized:       false
1982 # CHECK: legalized: true
1983 regBankSelected: false
1984 selected:        false
1985 tracksRegLiveness: true
1986 registers:
1987   - { id: 0, class: _ }
1988   - { id: 1, class: _ }
1989   - { id: 2, class: _ }
1990   - { id: 3, class: _ }
1991   - { id: 4, class: _ }
1992   - { id: 5, class: _ }
1993   - { id: 6, class: _ }
1994   - { id: 7, class: _ }
1995 body:             |
1996   bb.0:
1997     liveins: $r0, $r1, $r2, $r3
1998
1999     %0(s32) = COPY $r0
2000     %1(s32) = COPY $r1
2001     %2(s32) = COPY $r2
2002     %3(s32) = COPY $r3
2003     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2004     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2005     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2006     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2007     %4(s64) = G_MERGE_VALUES %0(s32), %1
2008     %5(s64) = G_MERGE_VALUES %2(s32), %3
2009     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2010     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2011     %6(s1) = G_FCMP floatpred(ogt), %4(s64), %5
2012     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ogt), [[X]](s64), [[Y]]
2013     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2014     ; SOFT-NOT: G_FCMP
2015     ; SOFT: ADJCALLSTACKDOWN
2016     ; SOFT-DAG: $r0 = COPY [[X0]]
2017     ; SOFT-DAG: $r1 = COPY [[X1]]
2018     ; SOFT-DAG: $r2 = COPY [[Y0]]
2019     ; SOFT-DAG: $r3 = COPY [[Y1]]
2020     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpgt, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2021     ; SOFT-DEFAULT: BL{{.*}} &__gtdf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2022     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2023     ; SOFT: ADJCALLSTACKUP
2024     ; For aeabi, we just need to truncate the result. The combiner changes the
2025     ; truncation into the following masking sequence.
2026     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
2027     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
2028     ; SOFT-AEABI: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
2029     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2030     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[RET]](s32), [[ZERO]]
2031     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2032     ; SOFT-NOT: G_FCMP
2033     %7(s32) = G_ZEXT %6(s1)
2034     $r0 = COPY %7(s32)
2035     ; CHECK: $r0 = COPY [[REXT]]
2036     BX_RET 14, $noreg, implicit $r0
2037 ...
2038 ---
2039 name:            test_fcmp_oge_s64
2040 # CHECK-LABEL: name: test_fcmp_oge_s64
2041 legalized:       false
2042 # CHECK: legalized: true
2043 regBankSelected: false
2044 selected:        false
2045 tracksRegLiveness: true
2046 registers:
2047   - { id: 0, class: _ }
2048   - { id: 1, class: _ }
2049   - { id: 2, class: _ }
2050   - { id: 3, class: _ }
2051   - { id: 4, class: _ }
2052   - { id: 5, class: _ }
2053   - { id: 6, class: _ }
2054   - { id: 7, class: _ }
2055 body:             |
2056   bb.0:
2057     liveins: $r0, $r1, $r2, $r3
2058
2059     %0(s32) = COPY $r0
2060     %1(s32) = COPY $r1
2061     %2(s32) = COPY $r2
2062     %3(s32) = COPY $r3
2063     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2064     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2065     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2066     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2067     %4(s64) = G_MERGE_VALUES %0(s32), %1
2068     %5(s64) = G_MERGE_VALUES %2(s32), %3
2069     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2070     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2071     %6(s1) = G_FCMP floatpred(oge), %4(s64), %5
2072     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[X]](s64), [[Y]]
2073     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2074     ; SOFT-NOT: G_FCMP
2075     ; SOFT: ADJCALLSTACKDOWN
2076     ; SOFT-DAG: $r0 = COPY [[X0]]
2077     ; SOFT-DAG: $r1 = COPY [[X1]]
2078     ; SOFT-DAG: $r2 = COPY [[Y0]]
2079     ; SOFT-DAG: $r3 = COPY [[Y1]]
2080     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpge, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2081     ; SOFT-DEFAULT: BL{{.*}} &__gedf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2082     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2083     ; SOFT: ADJCALLSTACKUP
2084     ; For aeabi, we just need to truncate the result. The combiner changes the
2085     ; truncation into the following masking sequence.
2086     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
2087     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
2088     ; SOFT-AEABI: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
2089     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2090     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sge), [[RET]](s32), [[ZERO]]
2091     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2092     ; SOFT-NOT: G_FCMP
2093     %7(s32) = G_ZEXT %6(s1)
2094     $r0 = COPY %7(s32)
2095     ; CHECK: $r0 = COPY [[REXT]]
2096     BX_RET 14, $noreg, implicit $r0
2097 ...
2098 ---
2099 name:            test_fcmp_olt_s64
2100 # CHECK-LABEL: name: test_fcmp_olt_s64
2101 legalized:       false
2102 # CHECK: legalized: true
2103 regBankSelected: false
2104 selected:        false
2105 tracksRegLiveness: true
2106 registers:
2107   - { id: 0, class: _ }
2108   - { id: 1, class: _ }
2109   - { id: 2, class: _ }
2110   - { id: 3, class: _ }
2111   - { id: 4, class: _ }
2112   - { id: 5, class: _ }
2113   - { id: 6, class: _ }
2114   - { id: 7, class: _ }
2115 body:             |
2116   bb.0:
2117     liveins: $r0, $r1, $r2, $r3
2118
2119     %0(s32) = COPY $r0
2120     %1(s32) = COPY $r1
2121     %2(s32) = COPY $r2
2122     %3(s32) = COPY $r3
2123     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2124     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2125     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2126     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2127     %4(s64) = G_MERGE_VALUES %0(s32), %1
2128     %5(s64) = G_MERGE_VALUES %2(s32), %3
2129     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2130     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2131     %6(s1) = G_FCMP floatpred(olt), %4(s64), %5
2132     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[X]](s64), [[Y]]
2133     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2134     ; SOFT-NOT: G_FCMP
2135     ; SOFT: ADJCALLSTACKDOWN
2136     ; SOFT-DAG: $r0 = COPY [[X0]]
2137     ; SOFT-DAG: $r1 = COPY [[X1]]
2138     ; SOFT-DAG: $r2 = COPY [[Y0]]
2139     ; SOFT-DAG: $r3 = COPY [[Y1]]
2140     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmplt, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2141     ; SOFT-DEFAULT: BL{{.*}} &__ltdf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2142     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2143     ; SOFT: ADJCALLSTACKUP
2144     ; For aeabi, we just need to truncate the result. The combiner changes the
2145     ; truncation into the following masking sequence.
2146     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
2147     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
2148     ; SOFT-AEABI: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
2149     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2150     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[RET]](s32), [[ZERO]]
2151     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2152     ; SOFT-NOT: G_FCMP
2153     %7(s32) = G_ZEXT %6(s1)
2154     $r0 = COPY %7(s32)
2155     ; CHECK: $r0 = COPY [[REXT]]
2156     BX_RET 14, $noreg, implicit $r0
2157 ...
2158 ---
2159 name:            test_fcmp_ole_s64
2160 # CHECK-LABEL: name: test_fcmp_ole_s64
2161 legalized:       false
2162 # CHECK: legalized: true
2163 regBankSelected: false
2164 selected:        false
2165 tracksRegLiveness: true
2166 registers:
2167   - { id: 0, class: _ }
2168   - { id: 1, class: _ }
2169   - { id: 2, class: _ }
2170   - { id: 3, class: _ }
2171   - { id: 4, class: _ }
2172   - { id: 5, class: _ }
2173   - { id: 6, class: _ }
2174   - { id: 7, class: _ }
2175 body:             |
2176   bb.0:
2177     liveins: $r0, $r1, $r2, $r3
2178
2179     %0(s32) = COPY $r0
2180     %1(s32) = COPY $r1
2181     %2(s32) = COPY $r2
2182     %3(s32) = COPY $r3
2183     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2184     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2185     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2186     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2187     %4(s64) = G_MERGE_VALUES %0(s32), %1
2188     %5(s64) = G_MERGE_VALUES %2(s32), %3
2189     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2190     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2191     %6(s1) = G_FCMP floatpred(ole), %4(s64), %5
2192     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ole), [[X]](s64), [[Y]]
2193     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2194     ; SOFT-NOT: G_FCMP
2195     ; SOFT: ADJCALLSTACKDOWN
2196     ; SOFT-DAG: $r0 = COPY [[X0]]
2197     ; SOFT-DAG: $r1 = COPY [[X1]]
2198     ; SOFT-DAG: $r2 = COPY [[Y0]]
2199     ; SOFT-DAG: $r3 = COPY [[Y1]]
2200     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmple, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2201     ; SOFT-DEFAULT: BL{{.*}} &__ledf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2202     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2203     ; SOFT: ADJCALLSTACKUP
2204     ; For aeabi, we just need to truncate the result. The combiner changes the
2205     ; truncation into the following masking sequence.
2206     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
2207     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
2208     ; SOFT-AEABI: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
2209     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2210     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sle), [[RET]](s32), [[ZERO]]
2211     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2212     ; SOFT-NOT: G_FCMP
2213     %7(s32) = G_ZEXT %6(s1)
2214     $r0 = COPY %7(s32)
2215     ; CHECK: $r0 = COPY [[REXT]]
2216     BX_RET 14, $noreg, implicit $r0
2217 ...
2218 ---
2219 name:            test_fcmp_ord_s64
2220 # CHECK-LABEL: name: test_fcmp_ord_s64
2221 legalized:       false
2222 # CHECK: legalized: true
2223 regBankSelected: false
2224 selected:        false
2225 tracksRegLiveness: true
2226 registers:
2227   - { id: 0, class: _ }
2228   - { id: 1, class: _ }
2229   - { id: 2, class: _ }
2230   - { id: 3, class: _ }
2231   - { id: 4, class: _ }
2232   - { id: 5, class: _ }
2233   - { id: 6, class: _ }
2234   - { id: 7, class: _ }
2235 body:             |
2236   bb.0:
2237     liveins: $r0, $r1, $r2, $r3
2238
2239     %0(s32) = COPY $r0
2240     %1(s32) = COPY $r1
2241     %2(s32) = COPY $r2
2242     %3(s32) = COPY $r3
2243     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2244     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2245     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2246     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2247     %4(s64) = G_MERGE_VALUES %0(s32), %1
2248     %5(s64) = G_MERGE_VALUES %2(s32), %3
2249     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2250     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2251     %6(s1) = G_FCMP floatpred(ord), %4(s64), %5
2252     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ord), [[X]](s64), [[Y]]
2253     ; SOFT-NOT: G_FCMP
2254     ; SOFT: ADJCALLSTACKDOWN
2255     ; SOFT-DAG: $r0 = COPY [[X0]]
2256     ; SOFT-DAG: $r1 = COPY [[X1]]
2257     ; SOFT-DAG: $r2 = COPY [[Y0]]
2258     ; SOFT-DAG: $r3 = COPY [[Y1]]
2259     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpun, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2260     ; SOFT-DEFAULT: BL{{.*}} &__unorddf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2261     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2262     ; SOFT: ADJCALLSTACKUP
2263     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2264     ; SOFT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
2265     ; SOFT-NOT: G_FCMP
2266     %7(s32) = G_ZEXT %6(s1)
2267     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2268     $r0 = COPY %7(s32)
2269     ; CHECK: $r0 = COPY [[REXT]]
2270     BX_RET 14, $noreg, implicit $r0
2271 ...
2272 ---
2273 name:            test_fcmp_ugt_s64
2274 # CHECK-LABEL: name: test_fcmp_ugt_s64
2275 legalized:       false
2276 # CHECK: legalized: true
2277 regBankSelected: false
2278 selected:        false
2279 tracksRegLiveness: true
2280 registers:
2281   - { id: 0, class: _ }
2282   - { id: 1, class: _ }
2283   - { id: 2, class: _ }
2284   - { id: 3, class: _ }
2285   - { id: 4, class: _ }
2286   - { id: 5, class: _ }
2287   - { id: 6, class: _ }
2288   - { id: 7, class: _ }
2289 body:             |
2290   bb.0:
2291     liveins: $r0, $r1, $r2, $r3
2292
2293     %0(s32) = COPY $r0
2294     %1(s32) = COPY $r1
2295     %2(s32) = COPY $r2
2296     %3(s32) = COPY $r3
2297     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2298     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2299     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2300     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2301     %4(s64) = G_MERGE_VALUES %0(s32), %1
2302     %5(s64) = G_MERGE_VALUES %2(s32), %3
2303     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2304     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2305     %6(s1) = G_FCMP floatpred(ugt), %4(s64), %5
2306     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ugt), [[X]](s64), [[Y]]
2307     ; SOFT-NOT: G_FCMP
2308     ; SOFT: ADJCALLSTACKDOWN
2309     ; SOFT-DAG: $r0 = COPY [[X0]]
2310     ; SOFT-DAG: $r1 = COPY [[X1]]
2311     ; SOFT-DAG: $r2 = COPY [[Y0]]
2312     ; SOFT-DAG: $r3 = COPY [[Y1]]
2313     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmple, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2314     ; SOFT-DEFAULT: BL{{.*}} &__ledf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2315     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2316     ; SOFT: ADJCALLSTACKUP
2317     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2318     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
2319     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[RET]](s32), [[ZERO]]
2320     ; SOFT-NOT: G_FCMP
2321     %7(s32) = G_ZEXT %6(s1)
2322     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2323     $r0 = COPY %7(s32)
2324     ; CHECK: $r0 = COPY [[REXT]]
2325     BX_RET 14, $noreg, implicit $r0
2326 ...
2327 ---
2328 name:            test_fcmp_uge_s64
2329 # CHECK-LABEL: name: test_fcmp_uge_s64
2330 legalized:       false
2331 # CHECK: legalized: true
2332 regBankSelected: false
2333 selected:        false
2334 tracksRegLiveness: true
2335 registers:
2336   - { id: 0, class: _ }
2337   - { id: 1, class: _ }
2338   - { id: 2, class: _ }
2339   - { id: 3, class: _ }
2340   - { id: 4, class: _ }
2341   - { id: 5, class: _ }
2342   - { id: 6, class: _ }
2343   - { id: 7, class: _ }
2344 body:             |
2345   bb.0:
2346     liveins: $r0, $r1, $r2, $r3
2347
2348     %0(s32) = COPY $r0
2349     %1(s32) = COPY $r1
2350     %2(s32) = COPY $r2
2351     %3(s32) = COPY $r3
2352     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2353     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2354     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2355     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2356     %4(s64) = G_MERGE_VALUES %0(s32), %1
2357     %5(s64) = G_MERGE_VALUES %2(s32), %3
2358     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2359     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2360     %6(s1) = G_FCMP floatpred(uge), %4(s64), %5
2361     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(uge), [[X]](s64), [[Y]]
2362     ; SOFT-NOT: G_FCMP
2363     ; SOFT: ADJCALLSTACKDOWN
2364     ; SOFT-DAG: $r0 = COPY [[X0]]
2365     ; SOFT-DAG: $r1 = COPY [[X1]]
2366     ; SOFT-DAG: $r2 = COPY [[Y0]]
2367     ; SOFT-DAG: $r3 = COPY [[Y1]]
2368     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmplt, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2369     ; SOFT-DEFAULT: BL{{.*}} &__ltdf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2370     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2371     ; SOFT: ADJCALLSTACKUP
2372     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2373     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
2374     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sge), [[RET]](s32), [[ZERO]]
2375     ; SOFT-NOT: G_FCMP
2376     %7(s32) = G_ZEXT %6(s1)
2377     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2378     $r0 = COPY %7(s32)
2379     ; CHECK: $r0 = COPY [[REXT]]
2380     BX_RET 14, $noreg, implicit $r0
2381 ...
2382 ---
2383 name:            test_fcmp_ult_s64
2384 # CHECK-LABEL: name: test_fcmp_ult_s64
2385 legalized:       false
2386 # CHECK: legalized: true
2387 regBankSelected: false
2388 selected:        false
2389 tracksRegLiveness: true
2390 registers:
2391   - { id: 0, class: _ }
2392   - { id: 1, class: _ }
2393   - { id: 2, class: _ }
2394   - { id: 3, class: _ }
2395   - { id: 4, class: _ }
2396   - { id: 5, class: _ }
2397   - { id: 6, class: _ }
2398   - { id: 7, class: _ }
2399 body:             |
2400   bb.0:
2401     liveins: $r0, $r1, $r2, $r3
2402
2403     %0(s32) = COPY $r0
2404     %1(s32) = COPY $r1
2405     %2(s32) = COPY $r2
2406     %3(s32) = COPY $r3
2407     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2408     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2409     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2410     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2411     %4(s64) = G_MERGE_VALUES %0(s32), %1
2412     %5(s64) = G_MERGE_VALUES %2(s32), %3
2413     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2414     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2415     %6(s1) = G_FCMP floatpred(ult), %4(s64), %5
2416     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ult), [[X]](s64), [[Y]]
2417     ; SOFT-NOT: G_FCMP
2418     ; SOFT: ADJCALLSTACKDOWN
2419     ; SOFT-DAG: $r0 = COPY [[X0]]
2420     ; SOFT-DAG: $r1 = COPY [[X1]]
2421     ; SOFT-DAG: $r2 = COPY [[Y0]]
2422     ; SOFT-DAG: $r3 = COPY [[Y1]]
2423     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpge, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2424     ; SOFT-DEFAULT: BL{{.*}} &__gedf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2425     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2426     ; SOFT: ADJCALLSTACKUP
2427     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2428     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
2429     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[RET]](s32), [[ZERO]]
2430     ; SOFT-NOT: G_FCMP
2431     %7(s32) = G_ZEXT %6(s1)
2432     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2433     $r0 = COPY %7(s32)
2434     ; CHECK: $r0 = COPY [[REXT]]
2435     BX_RET 14, $noreg, implicit $r0
2436 ...
2437 ---
2438 name:            test_fcmp_ule_s64
2439 # CHECK-LABEL: name: test_fcmp_ule_s64
2440 legalized:       false
2441 # CHECK: legalized: true
2442 regBankSelected: false
2443 selected:        false
2444 tracksRegLiveness: true
2445 registers:
2446   - { id: 0, class: _ }
2447   - { id: 1, class: _ }
2448   - { id: 2, class: _ }
2449   - { id: 3, class: _ }
2450   - { id: 4, class: _ }
2451   - { id: 5, class: _ }
2452   - { id: 6, class: _ }
2453   - { id: 7, class: _ }
2454 body:             |
2455   bb.0:
2456     liveins: $r0, $r1, $r2, $r3
2457
2458     %0(s32) = COPY $r0
2459     %1(s32) = COPY $r1
2460     %2(s32) = COPY $r2
2461     %3(s32) = COPY $r3
2462     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2463     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2464     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2465     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2466     %4(s64) = G_MERGE_VALUES %0(s32), %1
2467     %5(s64) = G_MERGE_VALUES %2(s32), %3
2468     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2469     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2470     %6(s1) = G_FCMP floatpred(ule), %4(s64), %5
2471     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ule), [[X]](s64), [[Y]]
2472     ; SOFT-NOT: G_FCMP
2473     ; SOFT: ADJCALLSTACKDOWN
2474     ; SOFT-DAG: $r0 = COPY [[X0]]
2475     ; SOFT-DAG: $r1 = COPY [[X1]]
2476     ; SOFT-DAG: $r2 = COPY [[Y0]]
2477     ; SOFT-DAG: $r3 = COPY [[Y1]]
2478     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpgt, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2479     ; SOFT-DEFAULT: BL{{.*}} &__gtdf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2480     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2481     ; SOFT: ADJCALLSTACKUP
2482     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2483     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
2484     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(sle), [[RET]](s32), [[ZERO]]
2485     ; SOFT-NOT: G_FCMP
2486     %7(s32) = G_ZEXT %6(s1)
2487     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2488     $r0 = COPY %7(s32)
2489     ; CHECK: $r0 = COPY [[REXT]]
2490     BX_RET 14, $noreg, implicit $r0
2491 ...
2492 ---
2493 name:            test_fcmp_une_s64
2494 # CHECK-LABEL: name: test_fcmp_une_s64
2495 legalized:       false
2496 # CHECK: legalized: true
2497 regBankSelected: false
2498 selected:        false
2499 tracksRegLiveness: true
2500 registers:
2501   - { id: 0, class: _ }
2502   - { id: 1, class: _ }
2503   - { id: 2, class: _ }
2504   - { id: 3, class: _ }
2505   - { id: 4, class: _ }
2506   - { id: 5, class: _ }
2507   - { id: 6, class: _ }
2508   - { id: 7, class: _ }
2509 body:             |
2510   bb.0:
2511     liveins: $r0, $r1, $r2, $r3
2512
2513     %0(s32) = COPY $r0
2514     %1(s32) = COPY $r1
2515     %2(s32) = COPY $r2
2516     %3(s32) = COPY $r3
2517     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2518     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2519     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2520     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2521     %4(s64) = G_MERGE_VALUES %0(s32), %1
2522     %5(s64) = G_MERGE_VALUES %2(s32), %3
2523     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2524     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2525     %6(s1) = G_FCMP floatpred(une), %4(s64), %5
2526     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(une), [[X]](s64), [[Y]]
2527     ; SOFT-NOT: G_FCMP
2528     ; SOFT: ADJCALLSTACKDOWN
2529     ; SOFT-DAG: $r0 = COPY [[X0]]
2530     ; SOFT-DAG: $r1 = COPY [[X1]]
2531     ; SOFT-DAG: $r2 = COPY [[Y0]]
2532     ; SOFT-DAG: $r3 = COPY [[Y1]]
2533     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpeq, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2534     ; SOFT-DEFAULT: BL{{.*}} &__nedf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2535     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2536     ; SOFT: ADJCALLSTACKUP
2537     ; SOFT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2538     ; SOFT-AEABI: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET]](s32), [[ZERO]]
2539     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[RET]](s32), [[ZERO]]
2540     ; SOFT-NOT: G_FCMP
2541     %7(s32) = G_ZEXT %6(s1)
2542     ; CHECK: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2543     $r0 = COPY %7(s32)
2544     ; CHECK: $r0 = COPY [[REXT]]
2545     BX_RET 14, $noreg, implicit $r0
2546 ...
2547 ---
2548 name:            test_fcmp_uno_s64
2549 # CHECK-LABEL: name: test_fcmp_uno_s64
2550 legalized:       false
2551 # CHECK: legalized: true
2552 regBankSelected: false
2553 selected:        false
2554 tracksRegLiveness: true
2555 registers:
2556   - { id: 0, class: _ }
2557   - { id: 1, class: _ }
2558   - { id: 2, class: _ }
2559   - { id: 3, class: _ }
2560   - { id: 4, class: _ }
2561   - { id: 5, class: _ }
2562   - { id: 6, class: _ }
2563   - { id: 7, class: _ }
2564 body:             |
2565   bb.0:
2566     liveins: $r0, $r1, $r2, $r3
2567
2568     %0(s32) = COPY $r0
2569     %1(s32) = COPY $r1
2570     %2(s32) = COPY $r2
2571     %3(s32) = COPY $r3
2572     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2573     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2574     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2575     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2576     %4(s64) = G_MERGE_VALUES %0(s32), %1
2577     %5(s64) = G_MERGE_VALUES %2(s32), %3
2578     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2579     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2580     %6(s1) = G_FCMP floatpred(uno), %4(s64), %5
2581     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(uno), [[X]](s64), [[Y]]
2582     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2583     ; SOFT-NOT: G_FCMP
2584     ; SOFT: ADJCALLSTACKDOWN
2585     ; SOFT-DAG: $r0 = COPY [[X0]]
2586     ; SOFT-DAG: $r1 = COPY [[X1]]
2587     ; SOFT-DAG: $r2 = COPY [[Y0]]
2588     ; SOFT-DAG: $r3 = COPY [[Y1]]
2589     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpun, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2590     ; SOFT-DEFAULT: BL{{.*}} &__unorddf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2591     ; SOFT: [[RET:%[0-9]+]]:_(s32) = COPY $r0
2592     ; SOFT: ADJCALLSTACKUP
2593     ; For aeabi, we just need to truncate the result. The combiner changes the
2594     ; truncation into the following masking sequence.
2595     ; SOFT-AEABI: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
2596     ; SOFT-AEABI: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[RET]](s32)
2597     ; SOFT-AEABI: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
2598     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2599     ; SOFT-DEFAULT: [[R:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[RET]](s32), [[ZERO]]
2600     ; SOFT-DEFAULT: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2601     ; SOFT-NOT: G_FCMP
2602     %7(s32) = G_ZEXT %6(s1)
2603     $r0 = COPY %7(s32)
2604     ; CHECK: $r0 = COPY [[REXT]]
2605     BX_RET 14, $noreg, implicit $r0
2606 ...
2607 ---
2608 name:            test_fcmp_one_s64
2609 # CHECK-LABEL: name: test_fcmp_one_s64
2610 legalized:       false
2611 # CHECK: legalized: true
2612 regBankSelected: false
2613 selected:        false
2614 tracksRegLiveness: true
2615 registers:
2616   - { id: 0, class: _ }
2617   - { id: 1, class: _ }
2618   - { id: 2, class: _ }
2619   - { id: 3, class: _ }
2620   - { id: 4, class: _ }
2621   - { id: 5, class: _ }
2622   - { id: 6, class: _ }
2623   - { id: 7, class: _ }
2624 body:             |
2625   bb.0:
2626     liveins: $r0, $r1, $r2, $r3
2627
2628     %0(s32) = COPY $r0
2629     %1(s32) = COPY $r1
2630     %2(s32) = COPY $r2
2631     %3(s32) = COPY $r3
2632     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2633     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2634     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2635     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2636     %4(s64) = G_MERGE_VALUES %0(s32), %1
2637     %5(s64) = G_MERGE_VALUES %2(s32), %3
2638     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2639     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2640     %6(s1) = G_FCMP floatpred(one), %4(s64), %5
2641     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[X]](s64), [[Y]]
2642     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2643     ; SOFT-NOT: G_FCMP
2644     ; SOFT: ADJCALLSTACKDOWN
2645     ; SOFT-DAG: $r0 = COPY [[X0]]
2646     ; SOFT-DAG: $r1 = COPY [[X1]]
2647     ; SOFT-DAG: $r2 = COPY [[Y0]]
2648     ; SOFT-DAG: $r3 = COPY [[Y1]]
2649     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpgt, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2650     ; SOFT-DEFAULT: BL{{.*}} &__gtdf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2651     ; SOFT: [[RET1:%[0-9]+]]:_(s32) = COPY $r0
2652     ; SOFT: ADJCALLSTACKUP
2653     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2654     ; SOFT-DEFAULT: [[R1:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[RET1]](s32), [[ZERO]]
2655     ; SOFT-NOT: G_FCMP
2656     ; SOFT: ADJCALLSTACKDOWN
2657     ; SOFT-DAG: $r0 = COPY [[X0]]
2658     ; SOFT-DAG: $r1 = COPY [[X1]]
2659     ; SOFT-DAG: $r2 = COPY [[Y0]]
2660     ; SOFT-DAG: $r3 = COPY [[Y1]]
2661     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmplt, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2662     ; SOFT-DEFAULT: BL{{.*}} &__ltdf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2663     ; SOFT: [[RET2:%[0-9]+]]:_(s32) = COPY $r0
2664     ; SOFT: ADJCALLSTACKUP
2665     ; SOFT-DEFAULT: [[ZERO2:%[0-9]+]]:_(s32) = COPY [[ZERO]]
2666     ; SOFT-DEFAULT: [[R2:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[RET2]](s32), [[ZERO2]]
2667     ; SOFT-AEABI: [[R1EXT:%[0-9]+]]:_(s32) = COPY [[RET1]]
2668     ; SOFT-AEABI: [[R2EXT:%[0-9]+]]:_(s32) = COPY [[RET2]]
2669     ; SOFT-DEFAULT: [[R1EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[R1]]
2670     ; SOFT-DEFAULT: [[R2EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[R2]]
2671     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_OR [[R1EXT]], [[R2EXT]]
2672     ; The result of the G_OR needs to be truncated, and the combiner turns the
2673     ; truncation into the following masking sequence.
2674     ; SOFT: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
2675     ; SOFT: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[R]]
2676     ; SOFT: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
2677     ; SOFT-NOT: G_FCMP
2678     %7(s32) = G_ZEXT %6(s1)
2679     $r0 = COPY %7(s32)
2680     ; CHECK: $r0 = COPY [[REXT]]
2681     BX_RET 14, $noreg, implicit $r0
2682 ...
2683 ---
2684 name:            test_fcmp_ueq_s64
2685 # CHECK-LABEL: name: test_fcmp_ueq_s64
2686 legalized:       false
2687 # CHECK: legalized: true
2688 regBankSelected: false
2689 selected:        false
2690 tracksRegLiveness: true
2691 registers:
2692   - { id: 0, class: _ }
2693   - { id: 1, class: _ }
2694   - { id: 2, class: _ }
2695   - { id: 3, class: _ }
2696   - { id: 4, class: _ }
2697   - { id: 5, class: _ }
2698   - { id: 6, class: _ }
2699   - { id: 7, class: _ }
2700 body:             |
2701   bb.0:
2702     liveins: $r0, $r1, $r2, $r3
2703
2704     %0(s32) = COPY $r0
2705     %1(s32) = COPY $r1
2706     %2(s32) = COPY $r2
2707     %3(s32) = COPY $r3
2708     ; CHECK-DAG: [[X0:%[0-9]+]]:_(s32) = COPY $r0
2709     ; CHECK-DAG: [[X1:%[0-9]+]]:_(s32) = COPY $r1
2710     ; CHECK-DAG: [[Y0:%[0-9]+]]:_(s32) = COPY $r2
2711     ; CHECK-DAG: [[Y1:%[0-9]+]]:_(s32) = COPY $r3
2712     %4(s64) = G_MERGE_VALUES %0(s32), %1
2713     %5(s64) = G_MERGE_VALUES %2(s32), %3
2714     ; HARD-DAG: [[X:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[X0]](s32), [[X1]](s32)
2715     ; HARD-DAG: [[Y:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[Y0]](s32), [[Y1]](s32)
2716     %6(s1) = G_FCMP floatpred(ueq), %4(s64), %5
2717     ; HARD: [[R:%[0-9]+]]:_(s1) = G_FCMP floatpred(ueq), [[X]](s64), [[Y]]
2718     ; HARD: [[REXT:%[0-9]+]]:_(s32) = G_ZEXT [[R]](s1)
2719     ; SOFT-NOT: G_FCMP
2720     ; SOFT: ADJCALLSTACKDOWN
2721     ; SOFT-DAG: $r0 = COPY [[X0]]
2722     ; SOFT-DAG: $r1 = COPY [[X1]]
2723     ; SOFT-DAG: $r2 = COPY [[Y0]]
2724     ; SOFT-DAG: $r3 = COPY [[Y1]]
2725     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpeq, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2726     ; SOFT-DEFAULT: BL{{.*}} &__eqdf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2727     ; SOFT: [[RET1:%[0-9]+]]:_(s32) = COPY $r0
2728     ; SOFT: ADJCALLSTACKUP
2729     ; SOFT-DEFAULT: [[ZERO:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
2730     ; SOFT-DEFAULT: [[R1:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[RET1]](s32), [[ZERO]]
2731     ; SOFT-NOT: G_FCMP
2732     ; SOFT: ADJCALLSTACKDOWN
2733     ; SOFT-DAG: $r0 = COPY [[X0]]
2734     ; SOFT-DAG: $r1 = COPY [[X1]]
2735     ; SOFT-DAG: $r2 = COPY [[Y0]]
2736     ; SOFT-DAG: $r3 = COPY [[Y1]]
2737     ; SOFT-AEABI: BL{{.*}} &__aeabi_dcmpun, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2738     ; SOFT-DEFAULT: BL{{.*}} &__unorddf2, {{.*}}, implicit $r0, implicit $r1, implicit $r2, implicit $r3, implicit-def $r0
2739     ; SOFT: [[RET2:%[0-9]+]]:_(s32) = COPY $r0
2740     ; SOFT: ADJCALLSTACKUP
2741     ; SOFT-DEFAULT: [[ZERO2:%[0-9]+]]:_(s32) = COPY [[ZERO]]
2742     ; SOFT-DEFAULT: [[R2:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[RET2]](s32), [[ZERO2]]
2743     ; SOFT-AEABI: [[R1EXT:%[0-9]+]]:_(s32) = COPY [[RET1]]
2744     ; SOFT-AEABI: [[R2EXT:%[0-9]+]]:_(s32) = COPY [[RET2]]
2745     ; SOFT-DEFAULT: [[R1EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[R1]]
2746     ; SOFT-DEFAULT: [[R2EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[R2]]
2747     ; SOFT: [[R:%[0-9]+]]:_(s32) = G_OR [[R1EXT]], [[R2EXT]]
2748     ; The result of the G_OR needs to be truncated, and the combiner turns the
2749     ; truncation into the following masking sequence.
2750     ; SOFT: [[MASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
2751     ; SOFT: [[RCOPY:%[0-9]+]]:_(s32) = COPY [[R]]
2752     ; SOFT: [[REXT:%[0-9]+]]:_(s32) = G_AND [[RCOPY]], [[MASK]]
2753     ; SOFT-NOT: G_FCMP
2754     %7(s32) = G_ZEXT %6(s1)
2755     $r0 = COPY %7(s32)
2756     ; CHECK: $r0 = COPY [[REXT]]
2757     BX_RET 14, $noreg, implicit $r0
2758 ...