llvm/test/CodeGen/AArch64/GlobalISel/postlegalizer-lowering-adjust-icmp-imm.mir

   1 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
   2 # RUN: llc -mtriple=aarch64 -run-pass=aarch64-postlegalizer-lowering -verify-machineinstrs %s -o - | FileCheck %s --check-prefix=LOWER
   3 # RUN: llc -mtriple=aarch64 -global-isel -start-before=aarch64-postlegalizer-lowering -stop-after=instruction-select -verify-machineinstrs %s -o - | FileCheck %s --check-prefix=SELECT
   4
   5 # Verify that we will adjust the constant + predicate of a compare when it will
   6 # allow us to fold an immediate into a compare.
   7 ...
   8 ---
   9 name:            slt_to_sle_s32
  10 legalized:       true
  11 tracksRegLiveness: true
  12 body:             |
  13   bb.0:
  14     liveins: $w0
  15
  16     ; x slt c => x sle c - 1
  17     ;
  18     ; log_2(4096) == 12, so we can represent this as a 12 bit value with a
  19     ; left shift.
  20
  21     ; LOWER-LABEL: name: slt_to_sle_s32
  22     ; LOWER: liveins: $w0
  23     ; LOWER-NEXT: {{  $}}
  24     ; LOWER-NEXT: %reg:_(s32) = COPY $w0
  25     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4096
  26     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %reg(s32), [[C]]
  27     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
  28     ; LOWER-NEXT: RET_ReallyLR implicit $w0
  29     ; SELECT-LABEL: name: slt_to_sle_s32
  30     ; SELECT: liveins: $w0
  31     ; SELECT-NEXT: {{  $}}
  32     ; SELECT-NEXT: %reg:gpr32sp = COPY $w0
  33     ; SELECT-NEXT: [[SUBSWri:%[0-9]+]]:gpr32 = SUBSWri %reg, 1, 12, implicit-def $nzcv
  34     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
  35     ; SELECT-NEXT: $w0 = COPY %cmp
  36     ; SELECT-NEXT: RET_ReallyLR implicit $w0
  37     %reg:_(s32) = COPY $w0
  38     %cst:_(s32) = G_CONSTANT i32 4097
  39     %cmp:_(s32) = G_ICMP intpred(slt), %reg(s32), %cst
  40     $w0 = COPY %cmp(s32)
  41     RET_ReallyLR implicit $w0
  42
  43 ...
  44 ---
  45 name:            slt_to_sle_s64
  46 legalized:       true
  47 tracksRegLiveness: true
  48 body:             |
  49   bb.0:
  50     liveins: $x0
  51
  52     ; x slt c => x sle c - 1
  53     ;
  54     ; log_2(4096) == 12, so we can represent this as a 12 bit value with a
  55     ; left shift.
  56
  57     ; LOWER-LABEL: name: slt_to_sle_s64
  58     ; LOWER: liveins: $x0
  59     ; LOWER-NEXT: {{  $}}
  60     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
  61     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4096
  62     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %reg(s64), [[C]]
  63     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
  64     ; LOWER-NEXT: RET_ReallyLR implicit $w0
  65     ; SELECT-LABEL: name: slt_to_sle_s64
  66     ; SELECT: liveins: $x0
  67     ; SELECT-NEXT: {{  $}}
  68     ; SELECT-NEXT: %reg:gpr64sp = COPY $x0
  69     ; SELECT-NEXT: [[SUBSXri:%[0-9]+]]:gpr64 = SUBSXri %reg, 1, 12, implicit-def $nzcv
  70     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
  71     ; SELECT-NEXT: $w0 = COPY %cmp
  72     ; SELECT-NEXT: RET_ReallyLR implicit $w0
  73     %reg:_(s64) = COPY $x0
  74     %cst:_(s64) = G_CONSTANT i64 4097
  75     %cmp:_(s32) = G_ICMP intpred(slt), %reg(s64), %cst
  76     $w0 = COPY %cmp(s32)
  77     RET_ReallyLR implicit $w0
  78
  79 ...
  80 ---
  81 name:            sge_to_sgt_s32
  82 legalized:       true
  83 tracksRegLiveness: true
  84 body:             |
  85   bb.0:
  86     liveins: $w0
  87
  88     ; x sge c => x sgt c - 1
  89     ;
  90     ; log_2(4096) == 12, so we can represent this as a 12 bit value with a
  91     ; left shift.
  92
  93     ; LOWER-LABEL: name: sge_to_sgt_s32
  94     ; LOWER: liveins: $w0
  95     ; LOWER-NEXT: {{  $}}
  96     ; LOWER-NEXT: %reg:_(s32) = COPY $w0
  97     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4096
  98     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sgt), %reg(s32), [[C]]
  99     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 100     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 101     ; SELECT-LABEL: name: sge_to_sgt_s32
 102     ; SELECT: liveins: $w0
 103     ; SELECT-NEXT: {{  $}}
 104     ; SELECT-NEXT: %reg:gpr32sp = COPY $w0
 105     ; SELECT-NEXT: [[SUBSWri:%[0-9]+]]:gpr32 = SUBSWri %reg, 1, 12, implicit-def $nzcv
 106     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 13, implicit $nzcv
 107     ; SELECT-NEXT: $w0 = COPY %cmp
 108     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 109     %reg:_(s32) = COPY $w0
 110     %cst:_(s32) = G_CONSTANT i32 4097
 111     %cmp:_(s32) = G_ICMP intpred(sge), %reg(s32), %cst
 112     $w0 = COPY %cmp(s32)
 113     RET_ReallyLR implicit $w0
 114
 115 ...
 116 ---
 117 name:            sge_to_sgt_s64
 118 legalized:       true
 119 tracksRegLiveness: true
 120 body:             |
 121   bb.0:
 122     liveins: $x0
 123
 124     ; x sge c => x sgt c - 1
 125     ;
 126     ; log_2(4096) == 12, so we can represent this as a 12 bit value with a
 127     ; left shift.
 128
 129     ; LOWER-LABEL: name: sge_to_sgt_s64
 130     ; LOWER: liveins: $x0
 131     ; LOWER-NEXT: {{  $}}
 132     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 133     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4096
 134     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sgt), %reg(s64), [[C]]
 135     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 136     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 137     ; SELECT-LABEL: name: sge_to_sgt_s64
 138     ; SELECT: liveins: $x0
 139     ; SELECT-NEXT: {{  $}}
 140     ; SELECT-NEXT: %reg:gpr64sp = COPY $x0
 141     ; SELECT-NEXT: [[SUBSXri:%[0-9]+]]:gpr64 = SUBSXri %reg, 1, 12, implicit-def $nzcv
 142     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 13, implicit $nzcv
 143     ; SELECT-NEXT: $w0 = COPY %cmp
 144     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 145     %reg:_(s64) = COPY $x0
 146     %cst:_(s64) = G_CONSTANT i64 4097
 147     %cmp:_(s32) = G_ICMP intpred(sge), %reg(s64), %cst
 148     $w0 = COPY %cmp(s32)
 149     RET_ReallyLR implicit $w0
 150
 151 ...
 152 ---
 153 name:            ult_to_ule_s32
 154 legalized:       true
 155 tracksRegLiveness: true
 156 body:             |
 157   bb.0:
 158     liveins: $w0
 159
 160     ; x ult c => x ule c - 1
 161     ;
 162     ; log_2(4096) == 12, so we can represent this as a 12 bit value with a
 163     ; left shift.
 164
 165     ; LOWER-LABEL: name: ult_to_ule_s32
 166     ; LOWER: liveins: $w0
 167     ; LOWER-NEXT: {{  $}}
 168     ; LOWER-NEXT: %reg:_(s32) = COPY $w0
 169     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4096
 170     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(ule), %reg(s32), [[C]]
 171     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 172     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 173     ; SELECT-LABEL: name: ult_to_ule_s32
 174     ; SELECT: liveins: $w0
 175     ; SELECT-NEXT: {{  $}}
 176     ; SELECT-NEXT: %reg:gpr32sp = COPY $w0
 177     ; SELECT-NEXT: [[SUBSWri:%[0-9]+]]:gpr32 = SUBSWri %reg, 1, 12, implicit-def $nzcv
 178     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 8, implicit $nzcv
 179     ; SELECT-NEXT: $w0 = COPY %cmp
 180     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 181     %reg:_(s32) = COPY $w0
 182     %cst:_(s32) = G_CONSTANT i32 4097
 183     %cmp:_(s32) = G_ICMP intpred(ult), %reg(s32), %cst
 184     $w0 = COPY %cmp(s32)
 185     RET_ReallyLR implicit $w0
 186
 187 ...
 188 ---
 189 name:            ult_to_ule_s64
 190 legalized:       true
 191 tracksRegLiveness: true
 192 body:             |
 193   bb.0:
 194     liveins: $x0
 195
 196     ; x ult c => x ule c - 1
 197     ;
 198     ; log_2(4096) == 12, so we can represent this as a 12 bit value with a
 199     ; left shift.
 200
 201     ; LOWER-LABEL: name: ult_to_ule_s64
 202     ; LOWER: liveins: $x0
 203     ; LOWER-NEXT: {{  $}}
 204     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 205     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4096
 206     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(ule), %reg(s64), [[C]]
 207     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 208     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 209     ; SELECT-LABEL: name: ult_to_ule_s64
 210     ; SELECT: liveins: $x0
 211     ; SELECT-NEXT: {{  $}}
 212     ; SELECT-NEXT: %reg:gpr64sp = COPY $x0
 213     ; SELECT-NEXT: [[SUBSXri:%[0-9]+]]:gpr64 = SUBSXri %reg, 1, 12, implicit-def $nzcv
 214     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 8, implicit $nzcv
 215     ; SELECT-NEXT: $w0 = COPY %cmp
 216     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 217     %reg:_(s64) = COPY $x0
 218     %cst:_(s64) = G_CONSTANT i64 4097
 219     %cmp:_(s32) = G_ICMP intpred(ult), %reg(s64), %cst
 220     $w0 = COPY %cmp(s32)
 221     RET_ReallyLR implicit $w0
 222
 223 ...
 224 ---
 225 name:            uge_to_ugt_s32
 226 legalized:       true
 227 tracksRegLiveness: true
 228 body:             |
 229   bb.0:
 230     liveins: $w0
 231
 232     ; x uge c => x ugt c - 1
 233     ;
 234     ; log_2(4096) == 12, so we can represent this as a 12 bit value with a
 235     ; left shift.
 236
 237     ; LOWER-LABEL: name: uge_to_ugt_s32
 238     ; LOWER: liveins: $w0
 239     ; LOWER-NEXT: {{  $}}
 240     ; LOWER-NEXT: %reg:_(s32) = COPY $w0
 241     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4096
 242     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(ugt), %reg(s32), [[C]]
 243     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 244     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 245     ; SELECT-LABEL: name: uge_to_ugt_s32
 246     ; SELECT: liveins: $w0
 247     ; SELECT-NEXT: {{  $}}
 248     ; SELECT-NEXT: %reg:gpr32sp = COPY $w0
 249     ; SELECT-NEXT: [[SUBSWri:%[0-9]+]]:gpr32 = SUBSWri %reg, 1, 12, implicit-def $nzcv
 250     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 9, implicit $nzcv
 251     ; SELECT-NEXT: $w0 = COPY %cmp
 252     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 253     %reg:_(s32) = COPY $w0
 254     %cst:_(s32) = G_CONSTANT i32 4097
 255     %cmp:_(s32) = G_ICMP intpred(uge), %reg(s32), %cst
 256     $w0 = COPY %cmp(s32)
 257     RET_ReallyLR implicit $w0
 258
 259 ...
 260 ---
 261 name:            uge_to_ugt_s64
 262 legalized:       true
 263 tracksRegLiveness: true
 264 body:             |
 265   bb.0:
 266     liveins: $x0
 267
 268     ; x uge c => x ugt c - 1
 269     ;
 270     ; log_2(4096) == 12, so we can represent this as a 12 bit value with a
 271     ; left shift.
 272
 273     ; LOWER-LABEL: name: uge_to_ugt_s64
 274     ; LOWER: liveins: $x0
 275     ; LOWER-NEXT: {{  $}}
 276     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 277     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4096
 278     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(ugt), %reg(s64), [[C]]
 279     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 280     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 281     ; SELECT-LABEL: name: uge_to_ugt_s64
 282     ; SELECT: liveins: $x0
 283     ; SELECT-NEXT: {{  $}}
 284     ; SELECT-NEXT: %reg:gpr64sp = COPY $x0
 285     ; SELECT-NEXT: [[SUBSXri:%[0-9]+]]:gpr64 = SUBSXri %reg, 1, 12, implicit-def $nzcv
 286     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 9, implicit $nzcv
 287     ; SELECT-NEXT: $w0 = COPY %cmp
 288     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 289     %reg:_(s64) = COPY $x0
 290     %cst:_(s64) = G_CONSTANT i64 4097
 291     %cmp:_(s32) = G_ICMP intpred(uge), %reg(s64), %cst
 292     $w0 = COPY %cmp(s32)
 293     RET_ReallyLR implicit $w0
 294
 295 ...
 296 ---
 297 name:            sle_to_slt_s32
 298 legalized:       true
 299 tracksRegLiveness: true
 300 body:             |
 301   bb.0:
 302     liveins: $w0
 303
 304     ; x sle c => x slt c + 1
 305     ;
 306     ; log_2(8192) == 13, so we can represent this as a 12 bit value with a
 307     ; left shift.
 308     ;
 309     ; (We can't use 4095 here, because that's a legal arithmetic immediate.)
 310
 311     ; LOWER-LABEL: name: sle_to_slt_s32
 312     ; LOWER: liveins: $w0
 313     ; LOWER-NEXT: {{  $}}
 314     ; LOWER-NEXT: %reg:_(s32) = COPY $w0
 315     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 8192
 316     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %reg(s32), [[C]]
 317     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 318     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 319     ; SELECT-LABEL: name: sle_to_slt_s32
 320     ; SELECT: liveins: $w0
 321     ; SELECT-NEXT: {{  $}}
 322     ; SELECT-NEXT: %reg:gpr32sp = COPY $w0
 323     ; SELECT-NEXT: [[SUBSWri:%[0-9]+]]:gpr32 = SUBSWri %reg, 2, 12, implicit-def $nzcv
 324     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 10, implicit $nzcv
 325     ; SELECT-NEXT: $w0 = COPY %cmp
 326     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 327     %reg:_(s32) = COPY $w0
 328     %cst:_(s32) = G_CONSTANT i32 8191
 329     %cmp:_(s32) = G_ICMP intpred(sle), %reg(s32), %cst
 330     $w0 = COPY %cmp(s32)
 331     RET_ReallyLR implicit $w0
 332
 333 ...
 334 ---
 335 name:            sle_to_slt_s64
 336 legalized:       true
 337 tracksRegLiveness: true
 338 body:             |
 339   bb.0:
 340     liveins: $x0
 341
 342     ; x sle c => x slt c + 1
 343     ;
 344     ; log_2(8192) == 13, so we can represent this as a 12 bit value with a
 345     ; left shift.
 346
 347     ; LOWER-LABEL: name: sle_to_slt_s64
 348     ; LOWER: liveins: $x0
 349     ; LOWER-NEXT: {{  $}}
 350     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 351     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 8192
 352     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %reg(s64), [[C]]
 353     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 354     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 355     ; SELECT-LABEL: name: sle_to_slt_s64
 356     ; SELECT: liveins: $x0
 357     ; SELECT-NEXT: {{  $}}
 358     ; SELECT-NEXT: %reg:gpr64sp = COPY $x0
 359     ; SELECT-NEXT: [[SUBSXri:%[0-9]+]]:gpr64 = SUBSXri %reg, 2, 12, implicit-def $nzcv
 360     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 10, implicit $nzcv
 361     ; SELECT-NEXT: $w0 = COPY %cmp
 362     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 363     %reg:_(s64) = COPY $x0
 364     %cst:_(s64) = G_CONSTANT i64 8191
 365     %cmp:_(s32) = G_ICMP intpred(sle), %reg(s64), %cst
 366     $w0 = COPY %cmp(s32)
 367     RET_ReallyLR implicit $w0
 368
 369 ...
 370 ---
 371 name:            sgt_to_sge_s32
 372 legalized:       true
 373 tracksRegLiveness: true
 374 body:             |
 375   bb.0:
 376     liveins: $w0
 377
 378     ; x sgt c => s sge c + 1
 379     ;
 380     ; log_2(8192) == 13, so we can represent this as a 12 bit value with a
 381     ; left shift.
 382
 383     ; LOWER-LABEL: name: sgt_to_sge_s32
 384     ; LOWER: liveins: $w0
 385     ; LOWER-NEXT: {{  $}}
 386     ; LOWER-NEXT: %reg:_(s32) = COPY $w0
 387     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 8192
 388     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sge), %reg(s32), [[C]]
 389     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 390     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 391     ; SELECT-LABEL: name: sgt_to_sge_s32
 392     ; SELECT: liveins: $w0
 393     ; SELECT-NEXT: {{  $}}
 394     ; SELECT-NEXT: %reg:gpr32sp = COPY $w0
 395     ; SELECT-NEXT: [[SUBSWri:%[0-9]+]]:gpr32 = SUBSWri %reg, 2, 12, implicit-def $nzcv
 396     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 11, implicit $nzcv
 397     ; SELECT-NEXT: $w0 = COPY %cmp
 398     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 399     %reg:_(s32) = COPY $w0
 400     %cst:_(s32) = G_CONSTANT i32 8191
 401     %cmp:_(s32) = G_ICMP intpred(sgt), %reg(s32), %cst
 402     $w0 = COPY %cmp(s32)
 403     RET_ReallyLR implicit $w0
 404
 405 ...
 406 ---
 407 name:            sgt_to_sge_s64
 408 legalized:       true
 409 tracksRegLiveness: true
 410 body:             |
 411   bb.0:
 412     liveins: $x0
 413
 414     ; x sgt c => s sge c + 1
 415     ;
 416     ; log_2(8192) == 13, so we can represent this as a 12 bit value with a
 417     ; left shift.
 418
 419     ; LOWER-LABEL: name: sgt_to_sge_s64
 420     ; LOWER: liveins: $x0
 421     ; LOWER-NEXT: {{  $}}
 422     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 423     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 8192
 424     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sge), %reg(s64), [[C]]
 425     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 426     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 427     ; SELECT-LABEL: name: sgt_to_sge_s64
 428     ; SELECT: liveins: $x0
 429     ; SELECT-NEXT: {{  $}}
 430     ; SELECT-NEXT: %reg:gpr64sp = COPY $x0
 431     ; SELECT-NEXT: [[SUBSXri:%[0-9]+]]:gpr64 = SUBSXri %reg, 2, 12, implicit-def $nzcv
 432     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 11, implicit $nzcv
 433     ; SELECT-NEXT: $w0 = COPY %cmp
 434     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 435     %reg:_(s64) = COPY $x0
 436     %cst:_(s64) = G_CONSTANT i64 8191
 437     %cmp:_(s32) = G_ICMP intpred(sgt), %reg(s64), %cst
 438     $w0 = COPY %cmp(s32)
 439     RET_ReallyLR implicit $w0
 440
 441 ...
 442 ---
 443 name:            no_opt_int32_min
 444 legalized:       true
 445 tracksRegLiveness: true
 446 body:             |
 447   bb.0:
 448     liveins: $w0
 449
 450     ; The cmp should not change.
 451     ;
 452     ; If we subtract 1 from the constant, it will wrap around, and so it's not
 453     ; true that
 454     ;
 455     ; x slt c => x sle c - 1
 456     ; x sge c => x sgt c - 1
 457
 458     ; LOWER-LABEL: name: no_opt_int32_min
 459     ; LOWER: liveins: $w0
 460     ; LOWER-NEXT: {{  $}}
 461     ; LOWER-NEXT: %reg:_(s32) = COPY $w0
 462     ; LOWER-NEXT: %cst:_(s32) = G_CONSTANT i32 -2147483648
 463     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %reg(s32), %cst
 464     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 465     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 466     ; SELECT-LABEL: name: no_opt_int32_min
 467     ; SELECT: liveins: $w0
 468     ; SELECT-NEXT: {{  $}}
 469     ; SELECT-NEXT: %reg:gpr32 = COPY $w0
 470     ; SELECT-NEXT: %cst:gpr32 = MOVi32imm -2147483648
 471     ; SELECT-NEXT: [[SUBSWrr:%[0-9]+]]:gpr32 = SUBSWrr %reg, %cst, implicit-def $nzcv
 472     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 10, implicit $nzcv
 473     ; SELECT-NEXT: $w0 = COPY %cmp
 474     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 475     %reg:_(s32) = COPY $w0
 476     %cst:_(s32) = G_CONSTANT i32 -2147483648
 477     %cmp:_(s32) = G_ICMP intpred(slt), %reg(s32), %cst
 478     $w0 = COPY %cmp(s32)
 479     RET_ReallyLR implicit $w0
 480
 481 ...
 482 ---
 483 name:            no_opt_int64_min
 484 legalized:       true
 485 tracksRegLiveness: true
 486 body:             |
 487   bb.0:
 488     liveins: $x0
 489
 490     ; The cmp should not change.
 491     ;
 492     ; If we subtract 1 from the constant, it will wrap around, and so it's not
 493     ; true that
 494     ;
 495     ; x slt c => x sle c - 1
 496     ; x sge c => x sgt c - 1
 497
 498     ; LOWER-LABEL: name: no_opt_int64_min
 499     ; LOWER: liveins: $x0
 500     ; LOWER-NEXT: {{  $}}
 501     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 502     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 -9223372036854775808
 503     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %reg(s64), %cst
 504     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 505     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 506     ; SELECT-LABEL: name: no_opt_int64_min
 507     ; SELECT: liveins: $x0
 508     ; SELECT-NEXT: {{  $}}
 509     ; SELECT-NEXT: %reg:gpr64 = COPY $x0
 510     ; SELECT-NEXT: %cst:gpr64 = MOVi64imm -9223372036854775808
 511     ; SELECT-NEXT: [[SUBSXrr:%[0-9]+]]:gpr64 = SUBSXrr %reg, %cst, implicit-def $nzcv
 512     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 10, implicit $nzcv
 513     ; SELECT-NEXT: $w0 = COPY %cmp
 514     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 515     %reg:_(s64) = COPY $x0
 516     %cst:_(s64) = G_CONSTANT i64 -9223372036854775808
 517     %cmp:_(s32) = G_ICMP intpred(slt), %reg(s64), %cst
 518     $w0 = COPY %cmp(s32)
 519     RET_ReallyLR implicit $w0
 520
 521 ...
 522 ---
 523 name:            no_opt_int32_max
 524 legalized:       true
 525 tracksRegLiveness: true
 526 body:             |
 527   bb.0:
 528     liveins: $w0
 529
 530     ; The cmp should not change.
 531     ;
 532     ; If we add 1 to the constant, it will wrap around, and so it's not true
 533     ; that
 534     ;
 535     ; x slt c => x sle c - 1
 536     ; x sge c => x sgt c - 1
 537
 538     ; LOWER-LABEL: name: no_opt_int32_max
 539     ; LOWER: liveins: $w0
 540     ; LOWER-NEXT: {{  $}}
 541     ; LOWER-NEXT: %reg:_(s32) = COPY $w0
 542     ; LOWER-NEXT: %cst:_(s32) = G_CONSTANT i32 2147483647
 543     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %reg(s32), %cst
 544     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 545     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 546     ; SELECT-LABEL: name: no_opt_int32_max
 547     ; SELECT: liveins: $w0
 548     ; SELECT-NEXT: {{  $}}
 549     ; SELECT-NEXT: %reg:gpr32 = COPY $w0
 550     ; SELECT-NEXT: %cst:gpr32 = MOVi32imm 2147483647
 551     ; SELECT-NEXT: [[SUBSWrr:%[0-9]+]]:gpr32 = SUBSWrr %reg, %cst, implicit-def $nzcv
 552     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
 553     ; SELECT-NEXT: $w0 = COPY %cmp
 554     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 555     %reg:_(s32) = COPY $w0
 556     %cst:_(s32) = G_CONSTANT i32 2147483647
 557     %cmp:_(s32) = G_ICMP intpred(sle), %reg(s32), %cst
 558     $w0 = COPY %cmp(s32)
 559     RET_ReallyLR implicit $w0
 560
 561 ...
 562 ---
 563 name:            no_opt_int64_max
 564 legalized:       true
 565 tracksRegLiveness: true
 566 body:             |
 567   bb.0:
 568     liveins: $x0
 569
 570     ; The cmp should not change.
 571     ;
 572     ; If we add 1 to the constant, it will wrap around, and so it's not true
 573     ; that
 574     ;
 575     ; x slt c => x sle c - 1
 576     ; x sge c => x sgt c - 1
 577
 578
 579     ; LOWER-LABEL: name: no_opt_int64_max
 580     ; LOWER: liveins: $x0
 581     ; LOWER-NEXT: {{  $}}
 582     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 583     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 9223372036854775807
 584     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %reg(s64), %cst
 585     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 586     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 587     ; SELECT-LABEL: name: no_opt_int64_max
 588     ; SELECT: liveins: $x0
 589     ; SELECT-NEXT: {{  $}}
 590     ; SELECT-NEXT: %reg:gpr64 = COPY $x0
 591     ; SELECT-NEXT: %cst:gpr64 = MOVi64imm 9223372036854775807
 592     ; SELECT-NEXT: [[SUBSXrr:%[0-9]+]]:gpr64 = SUBSXrr %reg, %cst, implicit-def $nzcv
 593     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
 594     ; SELECT-NEXT: $w0 = COPY %cmp
 595     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 596     %reg:_(s64) = COPY $x0
 597     %cst:_(s64) = G_CONSTANT i64 9223372036854775807
 598     %cmp:_(s32) = G_ICMP intpred(sle), %reg(s64), %cst
 599     $w0 = COPY %cmp(s32)
 600     RET_ReallyLR implicit $w0
 601
 602 ...
 603 ---
 604 name:            no_opt_zero
 605 legalized:       true
 606 tracksRegLiveness: true
 607 body:             |
 608   bb.0:
 609     liveins: $x0
 610
 611     ; The cmp should not change during the lowering pass.
 612     ;
 613     ; This is an unsigned comparison, so when the constant is 0, the following
 614     ; does not hold:
 615     ;
 616     ; x slt c => x sle c - 1
 617     ; x sge c => x sgt c - 1
 618
 619     ; LOWER-LABEL: name: no_opt_zero
 620     ; LOWER: liveins: $x0
 621     ; LOWER-NEXT: {{  $}}
 622     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 623     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 0
 624     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(ult), %reg(s64), %cst
 625     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 626     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 627     ; SELECT-LABEL: name: no_opt_zero
 628     ; SELECT: liveins: $x0
 629     ; SELECT-NEXT: {{  $}}
 630     ; SELECT-NEXT: %reg:gpr64sp = COPY $x0
 631     ; SELECT-NEXT: [[SUBSXri:%[0-9]+]]:gpr64 = SUBSXri %reg, 0, 0, implicit-def $nzcv
 632     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 2, implicit $nzcv
 633     ; SELECT-NEXT: $w0 = COPY %cmp
 634     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 635     %reg:_(s64) = COPY $x0
 636     %cst:_(s64) = G_CONSTANT i64 0
 637     %cmp:_(s32) = G_ICMP intpred(ult), %reg(s64), %cst
 638     $w0 = COPY %cmp(s32)
 639     RET_ReallyLR implicit $w0
 640
 641 ...
 642 ---
 643 name:            cmp_and_select
 644 legalized:       true
 645 tracksRegLiveness: true
 646 body:             |
 647   bb.0:
 648     liveins: $w0, $w1
 649     ; The G_ICMP is optimized here to be a slt comparison by adding 1 to the
 650     ; constant. So, the CSELWr should use the predicate code 11, rather than
 651     ; 13.
 652
 653     ; LOWER-LABEL: name: cmp_and_select
 654     ; LOWER: liveins: $w0, $w1
 655     ; LOWER-NEXT: {{  $}}
 656     ; LOWER-NEXT: %reg0:_(s32) = COPY $w0
 657     ; LOWER-NEXT: %reg1:_(s32) = COPY $w1
 658     ; LOWER-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 659     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %reg0(s32), [[C]]
 660     ; LOWER-NEXT: %select:_(s32) = G_SELECT %cmp(s32), %reg0, %reg1
 661     ; LOWER-NEXT: $w0 = COPY %select(s32)
 662     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 663     ; SELECT-LABEL: name: cmp_and_select
 664     ; SELECT: liveins: $w0, $w1
 665     ; SELECT-NEXT: {{  $}}
 666     ; SELECT-NEXT: %reg0:gpr32common = COPY $w0
 667     ; SELECT-NEXT: %reg1:gpr32 = COPY $w1
 668     ; SELECT-NEXT: [[SUBSWri:%[0-9]+]]:gpr32 = SUBSWri %reg0, 0, 0, implicit-def $nzcv
 669     ; SELECT-NEXT: %select:gpr32 = CSELWr %reg0, %reg1, 11, implicit $nzcv
 670     ; SELECT-NEXT: $w0 = COPY %select
 671     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 672     %reg0:_(s32) = COPY $w0
 673     %reg1:_(s32) = COPY $w1
 674     %cst:_(s32) = G_CONSTANT i32 -1
 675     %cmp:_(s32) = G_ICMP intpred(sle), %reg0(s32), %cst
 676     %select:_(s32) = G_SELECT %cmp, %reg0, %reg1
 677     $w0 = COPY %select(s32)
 678     RET_ReallyLR implicit $w0
 679
 680 ...
 681 ---
 682 name:             andsxri
 683 legalized: true
 684 tracksRegLiveness: true
 685 body:             |
 686   bb.0:
 687     liveins: $x0
 688     ; Show that we can select a tst/ands by optimizing the G_ICMP in the
 689     ; lowering phase.
 690
 691     ; LOWER-LABEL: name: andsxri
 692     ; LOWER: liveins: $x0
 693     ; LOWER-NEXT: {{  $}}
 694     ; LOWER-NEXT: %reg0:gpr(s64) = COPY $x0
 695     ; LOWER-NEXT: %bit:gpr(s64) = G_CONSTANT i64 8
 696     ; LOWER-NEXT: %and:gpr(s64) = G_AND %reg0, %bit
 697     ; LOWER-NEXT: [[C:%[0-9]+]]:gpr(s64) = G_CONSTANT i64 0
 698     ; LOWER-NEXT: %cmp:gpr(s32) = G_ICMP intpred(sge), %and(s64), [[C]]
 699     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 700     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 701     ; SELECT-LABEL: name: andsxri
 702     ; SELECT: liveins: $x0
 703     ; SELECT-NEXT: {{  $}}
 704     ; SELECT-NEXT: %reg0:gpr64 = COPY $x0
 705     ; SELECT-NEXT: [[ANDSXri:%[0-9]+]]:gpr64 = ANDSXri %reg0, 8000, implicit-def $nzcv
 706     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 11, implicit $nzcv
 707     ; SELECT-NEXT: $w0 = COPY %cmp
 708     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 709     %reg0:gpr(s64) = COPY $x0
 710     %bit:gpr(s64) = G_CONSTANT i64 8
 711     %and:gpr(s64) = G_AND %reg0, %bit
 712     %cst:gpr(s64) = G_CONSTANT i64 -1
 713     %cmp:gpr(s32) = G_ICMP intpred(sgt), %and(s64), %cst
 714     $w0 = COPY %cmp(s32)
 715     RET_ReallyLR implicit $w0