llvm/test/CodeGen/AArch64/GlobalISel/postlegalizer-lowering-swap-compare-operands.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 # Check that we swap the order of operands on comparisons when it is likely
   6 # to introduce a folding opportunity.
   7 #
   8 # The condition code for the compare should be changed when appropriate.
   9 #
  10 # TODO: emitBinOp doesn't know about selectArithExtendedRegister, so some of
  11 # these cases don't hit in selection yet.
  12
  13 ...
  14 ---
  15 name:            swap_sextinreg_lhs
  16 legalized:       true
  17 tracksRegLiveness: true
  18 body:             |
  19   bb.0:
  20     liveins: $x0, $x1
  21
  22     ; LOWER-LABEL: name: swap_sextinreg_lhs
  23     ; LOWER: liveins: $x0, $x1
  24     ; LOWER-NEXT: {{  $}}
  25     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
  26     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SEXT_INREG %reg, 8
  27     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
  28     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %cmp_rhs(s64), %cmp_lhs
  29     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
  30     ; LOWER-NEXT: RET_ReallyLR implicit $w0
  31     ;
  32     ; SELECT-LABEL: name: swap_sextinreg_lhs
  33     ; SELECT: liveins: $x0, $x1
  34     ; SELECT-NEXT: {{  $}}
  35     ; SELECT-NEXT: %reg:gpr64all = COPY $x0
  36     ; SELECT-NEXT: [[COPY:%[0-9]+]]:gpr32all = COPY %reg.sub_32
  37     ; SELECT-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
  38     ; SELECT-NEXT: %cmp_rhs:gpr64sp = COPY $x1
  39     ; SELECT-NEXT: [[SUBSXrx:%[0-9]+]]:gpr64 = SUBSXrx %cmp_rhs, [[COPY1]], 32, implicit-def $nzcv
  40     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
  41     ; SELECT-NEXT: $w0 = COPY %cmp
  42     ; SELECT-NEXT: RET_ReallyLR implicit $w0
  43     %reg:_(s64) = COPY $x0
  44     %cmp_lhs:_(s64) = G_SEXT_INREG %reg, 8
  45     %cmp_rhs:_(s64) = COPY $x1
  46     %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
  47     $w0 = COPY %cmp(s32)
  48     RET_ReallyLR implicit $w0
  49
  50 ...
  51 ---
  52 name:            dont_swap_more_than_one_use
  53 legalized:       true
  54 tracksRegLiveness: true
  55 body:             |
  56   bb.0:
  57     liveins: $x0, $x1
  58
  59     ; The LHS of the compare is used in an add, and a second compare. Don't
  60     ; swap, since we don't gain any folding opportunities here.
  61
  62     ; LOWER-LABEL: name: dont_swap_more_than_one_use
  63     ; LOWER: liveins: $x0, $x1
  64     ; LOWER-NEXT: {{  $}}
  65     ; LOWER-NEXT: %reg0:_(s64) = COPY $x0
  66     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SEXT_INREG %reg0, 8
  67     ; LOWER-NEXT: %reg1:_(s64) = COPY $x1
  68     ; LOWER-NEXT: %cmp1:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %reg1
  69     ; LOWER-NEXT: %add:_(s64) = G_ADD %cmp_lhs, %reg0
  70     ; LOWER-NEXT: %cmp2:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %add
  71     ; LOWER-NEXT: $w0 = COPY %cmp2(s32)
  72     ; LOWER-NEXT: $w1 = COPY %cmp1(s32)
  73     ; LOWER-NEXT: RET_ReallyLR implicit $w0, implicit $w1
  74     ;
  75     ; SELECT-LABEL: name: dont_swap_more_than_one_use
  76     ; SELECT: liveins: $x0, $x1
  77     ; SELECT-NEXT: {{  $}}
  78     ; SELECT-NEXT: %reg0:gpr64 = COPY $x0
  79     ; SELECT-NEXT: %cmp_lhs:gpr64 = SBFMXri %reg0, 0, 7
  80     ; SELECT-NEXT: %reg1:gpr64 = COPY $x1
  81     ; SELECT-NEXT: [[SUBSXrr:%[0-9]+]]:gpr64 = SUBSXrr %cmp_lhs, %reg1, implicit-def $nzcv
  82     ; SELECT-NEXT: %cmp1:gpr32 = CSINCWr $wzr, $wzr, 11, implicit $nzcv
  83     ; SELECT-NEXT: %add:gpr64 = ADDXrr %cmp_lhs, %reg0
  84     ; SELECT-NEXT: [[SUBSXrr1:%[0-9]+]]:gpr64 = SUBSXrr %cmp_lhs, %add, implicit-def $nzcv
  85     ; SELECT-NEXT: %cmp2:gpr32 = CSINCWr $wzr, $wzr, 11, implicit $nzcv
  86     ; SELECT-NEXT: $w0 = COPY %cmp2
  87     ; SELECT-NEXT: $w1 = COPY %cmp1
  88     ; SELECT-NEXT: RET_ReallyLR implicit $w0, implicit $w1
  89     %reg0:_(s64) = COPY $x0
  90     %cmp_lhs:_(s64) = G_SEXT_INREG %reg0, 8
  91     %reg1:_(s64) = COPY $x1
  92     %cmp1:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %reg1
  93
  94     %add:_(s64) = G_ADD %cmp_lhs(s64), %reg0
  95     %cmp2:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %add
  96
  97     $w0 = COPY %cmp2(s32)
  98     $w1 = COPY %cmp1(s32)
  99     RET_ReallyLR implicit $w0, implicit $w1
 100
 101 ...
 102 ---
 103 name:            dont_swap_legal_arith_immed_on_rhs
 104 legalized:       true
 105 tracksRegLiveness: true
 106 body:             |
 107   bb.0:
 108     liveins: $x0, $x1
 109     ; Arithmetic immediates can be folded into compares. If we have one, then
 110     ; don't bother changing anything.
 111
 112     ; LOWER-LABEL: name: dont_swap_legal_arith_immed_on_rhs
 113     ; LOWER: liveins: $x0, $x1
 114     ; LOWER-NEXT: {{  $}}
 115     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 116     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SEXT_INREG %reg, 8
 117     ; LOWER-NEXT: %cmp_rhs:_(s64) = G_CONSTANT i64 12
 118     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
 119     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 120     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 121     ;
 122     ; SELECT-LABEL: name: dont_swap_legal_arith_immed_on_rhs
 123     ; SELECT: liveins: $x0, $x1
 124     ; SELECT-NEXT: {{  $}}
 125     ; SELECT-NEXT: %reg:gpr64 = COPY $x0
 126     ; SELECT-NEXT: %cmp_lhs:gpr64common = SBFMXri %reg, 0, 7
 127     ; SELECT-NEXT: [[SUBSXri:%[0-9]+]]:gpr64 = SUBSXri %cmp_lhs, 12, 0, implicit-def $nzcv
 128     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 11, implicit $nzcv
 129     ; SELECT-NEXT: $w0 = COPY %cmp
 130     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 131     %reg:_(s64) = COPY $x0
 132     %cmp_lhs:_(s64) = G_SEXT_INREG %reg, 8
 133     %cmp_rhs:_(s64) = G_CONSTANT i64 12
 134     %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
 135     $w0 = COPY %cmp(s32)
 136     RET_ReallyLR implicit $w0
 137
 138 ...
 139 ---
 140 name:            swap_non_arith_immed_on_rhs
 141 legalized:       true
 142 tracksRegLiveness: true
 143 body:             |
 144   bb.0:
 145     liveins: $x0, $x1
 146     ; If we have a non-arithmetic immediate on the rhs, then we can swap to get
 147     ; a guaranteed folding opportunity.
 148
 149     ; LOWER-LABEL: name: swap_non_arith_immed_on_rhs
 150     ; LOWER: liveins: $x0, $x1
 151     ; LOWER-NEXT: {{  $}}
 152     ; LOWER-NEXT: %reg:_(s64) = COPY $x0
 153     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SEXT_INREG %reg, 8
 154     ; LOWER-NEXT: %cmp_rhs:_(s64) = G_CONSTANT i64 1234567
 155     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %cmp_rhs(s64), %cmp_lhs
 156     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 157     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 158     ;
 159     ; SELECT-LABEL: name: swap_non_arith_immed_on_rhs
 160     ; SELECT: liveins: $x0, $x1
 161     ; SELECT-NEXT: {{  $}}
 162     ; SELECT-NEXT: %reg:gpr64all = COPY $x0
 163     ; SELECT-NEXT: [[COPY:%[0-9]+]]:gpr32all = COPY %reg.sub_32
 164     ; SELECT-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
 165     ; SELECT-NEXT: [[MOVi32imm:%[0-9]+]]:gpr32 = MOVi32imm 1234567
 166     ; SELECT-NEXT: %cmp_rhs:gpr64sp = SUBREG_TO_REG 0, [[MOVi32imm]], %subreg.sub_32
 167     ; SELECT-NEXT: [[SUBSXrx:%[0-9]+]]:gpr64 = SUBSXrx %cmp_rhs, [[COPY1]], 32, implicit-def $nzcv
 168     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
 169     ; SELECT-NEXT: $w0 = COPY %cmp
 170     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 171     %reg:_(s64) = COPY $x0
 172     %cmp_lhs:_(s64) = G_SEXT_INREG %reg, 8
 173     %cmp_rhs:_(s64) = G_CONSTANT i64 1234567
 174     %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
 175     $w0 = COPY %cmp(s32)
 176     RET_ReallyLR implicit $w0
 177
 178 ...
 179 ---
 180 name:            swap_and_lhs_0xFF
 181 legalized:       true
 182 tracksRegLiveness: true
 183 body:             |
 184   bb.0:
 185     liveins: $x0, $x1
 186     ; LOWER-LABEL: name: swap_and_lhs_0xFF
 187     ; LOWER: liveins: $x0, $x1
 188     ; LOWER-NEXT: {{  $}}
 189     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 190     ; LOWER-NEXT: %and_lhs:_(s64) = COPY $x0
 191     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 255
 192     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_AND %and_lhs, %cst
 193     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %cmp_rhs(s64), %cmp_lhs
 194     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 195     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 196     ;
 197     ; SELECT-LABEL: name: swap_and_lhs_0xFF
 198     ; SELECT: liveins: $x0, $x1
 199     ; SELECT-NEXT: {{  $}}
 200     ; SELECT-NEXT: %cmp_rhs:gpr64sp = COPY $x1
 201     ; SELECT-NEXT: %and_lhs:gpr64all = COPY $x0
 202     ; SELECT-NEXT: [[COPY:%[0-9]+]]:gpr32all = COPY %and_lhs.sub_32
 203     ; SELECT-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
 204     ; SELECT-NEXT: [[SUBSXrx:%[0-9]+]]:gpr64 = SUBSXrx %cmp_rhs, [[COPY1]], 0, implicit-def $nzcv
 205     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
 206     ; SELECT-NEXT: $w0 = COPY %cmp
 207     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 208     %cmp_rhs:_(s64) = COPY $x1
 209
 210     %and_lhs:_(s64) = COPY $x0
 211     %cst:_(s64) = G_CONSTANT i64 255
 212     %cmp_lhs:_(s64) = G_AND %and_lhs, %cst(s64)
 213
 214     %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
 215     $w0 = COPY %cmp(s32)
 216     RET_ReallyLR implicit $w0
 217
 218 ...
 219 ---
 220 name:            swap_and_lhs_0xFFFF
 221 legalized:       true
 222 tracksRegLiveness: true
 223 body:             |
 224   bb.0:
 225     liveins: $x0, $x1
 226     ; LOWER-LABEL: name: swap_and_lhs_0xFFFF
 227     ; LOWER: liveins: $x0, $x1
 228     ; LOWER-NEXT: {{  $}}
 229     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 230     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 65535
 231     ; LOWER-NEXT: %and_lhs:_(s64) = COPY $x0
 232     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_AND %and_lhs, %cst
 233     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %cmp_rhs(s64), %cmp_lhs
 234     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 235     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 236     ;
 237     ; SELECT-LABEL: name: swap_and_lhs_0xFFFF
 238     ; SELECT: liveins: $x0, $x1
 239     ; SELECT-NEXT: {{  $}}
 240     ; SELECT-NEXT: %cmp_rhs:gpr64sp = COPY $x1
 241     ; SELECT-NEXT: %and_lhs:gpr64all = COPY $x0
 242     ; SELECT-NEXT: [[COPY:%[0-9]+]]:gpr32all = COPY %and_lhs.sub_32
 243     ; SELECT-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
 244     ; SELECT-NEXT: [[SUBSXrx:%[0-9]+]]:gpr64 = SUBSXrx %cmp_rhs, [[COPY1]], 8, implicit-def $nzcv
 245     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
 246     ; SELECT-NEXT: $w0 = COPY %cmp
 247     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 248     %cmp_rhs:_(s64) = COPY $x1
 249
 250     %cst:_(s64) = G_CONSTANT i64 65535
 251     %and_lhs:_(s64) = COPY $x0
 252     %cmp_lhs:_(s64) = G_AND %and_lhs, %cst(s64)
 253
 254     %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
 255     $w0 = COPY %cmp(s32)
 256     RET_ReallyLR implicit $w0
 257
 258 ...
 259 ---
 260 name:            swap_and_lhs_0xFFFFFFFF
 261 legalized:       true
 262 tracksRegLiveness: true
 263 body:             |
 264   bb.0:
 265     liveins: $x0, $x1
 266     ; LOWER-LABEL: name: swap_and_lhs_0xFFFFFFFF
 267     ; LOWER: liveins: $x0, $x1
 268     ; LOWER-NEXT: {{  $}}
 269     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 270     ; LOWER-NEXT: %and_lhs:_(s64) = COPY $x0
 271     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 4294967295
 272     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_AND %and_lhs, %cst
 273     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sle), %cmp_rhs(s64), %cmp_lhs
 274     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 275     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 276     ;
 277     ; SELECT-LABEL: name: swap_and_lhs_0xFFFFFFFF
 278     ; SELECT: liveins: $x0, $x1
 279     ; SELECT-NEXT: {{  $}}
 280     ; SELECT-NEXT: %cmp_rhs:gpr64sp = COPY $x1
 281     ; SELECT-NEXT: %and_lhs:gpr64all = COPY $x0
 282     ; SELECT-NEXT: [[COPY:%[0-9]+]]:gpr32all = COPY %and_lhs.sub_32
 283     ; SELECT-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
 284     ; SELECT-NEXT: [[SUBSXrx:%[0-9]+]]:gpr64 = SUBSXrx %cmp_rhs, [[COPY1]], 16, implicit-def $nzcv
 285     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 12, implicit $nzcv
 286     ; SELECT-NEXT: $w0 = COPY %cmp
 287     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 288     %cmp_rhs:_(s64) = COPY $x1
 289
 290     %and_lhs:_(s64) = COPY $x0
 291     %cst:_(s64) = G_CONSTANT i64 4294967295
 292     %cmp_lhs:_(s64) = G_AND %and_lhs, %cst(s64)
 293
 294     %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
 295     $w0 = COPY %cmp(s32)
 296     RET_ReallyLR implicit $w0
 297
 298 ...
 299 ---
 300 name:            dont_swap_and_lhs_wrong_mask
 301 legalized:       true
 302 tracksRegLiveness: true
 303 body:             |
 304   bb.0:
 305     liveins: $x0, $x1
 306     ; 7 isn't an extend mask for G_AND, so there's no folding opportunities
 307     ; here.
 308     ;
 309     ; LOWER-LABEL: name: dont_swap_and_lhs_wrong_mask
 310     ; LOWER: liveins: $x0, $x1
 311     ; LOWER-NEXT: {{  $}}
 312     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 313     ; LOWER-NEXT: %and_lhs:_(s64) = COPY $x0
 314     ; LOWER-NEXT: %not_an_extend_mask:_(s64) = G_CONSTANT i64 7
 315     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_AND %and_lhs, %not_an_extend_mask
 316     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
 317     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 318     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 319     ;
 320     ; SELECT-LABEL: name: dont_swap_and_lhs_wrong_mask
 321     ; SELECT: liveins: $x0, $x1
 322     ; SELECT-NEXT: {{  $}}
 323     ; SELECT-NEXT: %cmp_rhs:gpr64 = COPY $x1
 324     ; SELECT-NEXT: %and_lhs:gpr64 = COPY $x0
 325     ; SELECT-NEXT: %cmp_lhs:gpr64common = ANDXri %and_lhs, 4098
 326     ; SELECT-NEXT: [[SUBSXrr:%[0-9]+]]:gpr64 = SUBSXrr %cmp_lhs, %cmp_rhs, implicit-def $nzcv
 327     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 11, implicit $nzcv
 328     ; SELECT-NEXT: $w0 = COPY %cmp
 329     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 330     %cmp_rhs:_(s64) = COPY $x1
 331
 332     %and_lhs:_(s64) = COPY $x0
 333     %not_an_extend_mask:_(s64) = G_CONSTANT i64 7
 334     %cmp_lhs:_(s64) = G_AND %and_lhs, %not_an_extend_mask(s64)
 335
 336     %cmp:_(s32) = G_ICMP intpred(sge), %cmp_lhs(s64), %cmp_rhs
 337     $w0 = COPY %cmp(s32)
 338     RET_ReallyLR implicit $w0
 339
 340 ...
 341 ---
 342 name:            swap_shl_lhs
 343 legalized:       true
 344 tracksRegLiveness: true
 345 body:             |
 346   bb.0:
 347     liveins: $x0, $x1
 348
 349     ; LOWER-LABEL: name: swap_shl_lhs
 350     ; LOWER: liveins: $x0, $x1
 351     ; LOWER-NEXT: {{  $}}
 352     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 353     ; LOWER-NEXT: %shl_lhs:_(s64) = COPY $x0
 354     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 1
 355     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SHL %shl_lhs, %cst(s64)
 356     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sgt), %cmp_rhs(s64), %cmp_lhs
 357     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 358     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 359     ;
 360     ; SELECT-LABEL: name: swap_shl_lhs
 361     ; SELECT: liveins: $x0, $x1
 362     ; SELECT-NEXT: {{  $}}
 363     ; SELECT-NEXT: %cmp_rhs:gpr64 = COPY $x1
 364     ; SELECT-NEXT: %shl_lhs:gpr64 = COPY $x0
 365     ; SELECT-NEXT: [[SUBSXrs:%[0-9]+]]:gpr64 = SUBSXrs %cmp_rhs, %shl_lhs, 1, implicit-def $nzcv
 366     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 13, implicit $nzcv
 367     ; SELECT-NEXT: $w0 = COPY %cmp
 368     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 369     %cmp_rhs:_(s64) = COPY $x1
 370
 371     %shl_lhs:_(s64) = COPY $x0
 372     %cst:_(s64) = G_CONSTANT i64 1
 373     %cmp_lhs:_(s64) = G_SHL %shl_lhs, %cst(s64)
 374
 375     %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s64), %cmp_rhs
 376     $w0 = COPY %cmp(s32)
 377     RET_ReallyLR implicit $w0
 378
 379 ...
 380 ---
 381 name:            swap_ashr_lhs
 382 legalized:       true
 383 tracksRegLiveness: true
 384 body:             |
 385   bb.0:
 386     liveins: $x0, $x1
 387
 388     ; LOWER-LABEL: name: swap_ashr_lhs
 389     ; LOWER: liveins: $x0, $x1
 390     ; LOWER-NEXT: {{  $}}
 391     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 392     ; LOWER-NEXT: %ashr_lhs:_(s64) = COPY $x0
 393     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 1
 394     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_ASHR %ashr_lhs, %cst(s64)
 395     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sgt), %cmp_rhs(s64), %cmp_lhs
 396     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 397     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 398     ;
 399     ; SELECT-LABEL: name: swap_ashr_lhs
 400     ; SELECT: liveins: $x0, $x1
 401     ; SELECT-NEXT: {{  $}}
 402     ; SELECT-NEXT: %cmp_rhs:gpr64 = COPY $x1
 403     ; SELECT-NEXT: %ashr_lhs:gpr64 = COPY $x0
 404     ; SELECT-NEXT: [[SUBSXrs:%[0-9]+]]:gpr64 = SUBSXrs %cmp_rhs, %ashr_lhs, 129, implicit-def $nzcv
 405     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 13, implicit $nzcv
 406     ; SELECT-NEXT: $w0 = COPY %cmp
 407     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 408     %cmp_rhs:_(s64) = COPY $x1
 409
 410     %ashr_lhs:_(s64) = COPY $x0
 411     %cst:_(s64) = G_CONSTANT i64 1
 412     %cmp_lhs:_(s64) = G_ASHR %ashr_lhs, %cst(s64)
 413
 414     %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s64), %cmp_rhs
 415     $w0 = COPY %cmp(s32)
 416     RET_ReallyLR implicit $w0
 417
 418 ...
 419 ---
 420 name:            swap_lshr_lhs
 421 legalized:       true
 422 tracksRegLiveness: true
 423 body:             |
 424   bb.0:
 425     liveins: $x0, $x1
 426
 427     ; LOWER-LABEL: name: swap_lshr_lhs
 428     ; LOWER: liveins: $x0, $x1
 429     ; LOWER-NEXT: {{  $}}
 430     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 431     ; LOWER-NEXT: %lshr_lhs:_(s64) = COPY $x0
 432     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 1
 433     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_LSHR %lshr_lhs, %cst(s64)
 434     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(sgt), %cmp_rhs(s64), %cmp_lhs
 435     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 436     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 437     ;
 438     ; SELECT-LABEL: name: swap_lshr_lhs
 439     ; SELECT: liveins: $x0, $x1
 440     ; SELECT-NEXT: {{  $}}
 441     ; SELECT-NEXT: %cmp_rhs:gpr64 = COPY $x1
 442     ; SELECT-NEXT: %lshr_lhs:gpr64 = COPY $x0
 443     ; SELECT-NEXT: [[SUBSXrs:%[0-9]+]]:gpr64 = SUBSXrs %cmp_rhs, %lshr_lhs, 65, implicit-def $nzcv
 444     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 13, implicit $nzcv
 445     ; SELECT-NEXT: $w0 = COPY %cmp
 446     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 447     %cmp_rhs:_(s64) = COPY $x1
 448
 449     %lshr_lhs:_(s64) = COPY $x0
 450     %cst:_(s64) = G_CONSTANT i64 1
 451     %cmp_lhs:_(s64) = G_LSHR %lshr_lhs, %cst(s64)
 452
 453     %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s64), %cmp_rhs
 454     $w0 = COPY %cmp(s32)
 455     RET_ReallyLR implicit $w0
 456
 457 ...
 458 ---
 459 name:            dont_swap_shift_s64_cst_too_large
 460 legalized:       true
 461 tracksRegLiveness: true
 462 body:             |
 463   bb.0:
 464     liveins: $x0, $x1
 465
 466     ; Constant for the shift must be <= 63.
 467
 468     ; LOWER-LABEL: name: dont_swap_shift_s64_cst_too_large
 469     ; LOWER: liveins: $x0, $x1
 470     ; LOWER-NEXT: {{  $}}
 471     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 472     ; LOWER-NEXT: %shl_lhs:_(s64) = COPY $x0
 473     ; LOWER-NEXT: %too_large:_(s64) = G_CONSTANT i64 64
 474     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SHL %shl_lhs, %too_large(s64)
 475     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s64), %cmp_rhs
 476     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 477     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 478     ;
 479     ; SELECT-LABEL: name: dont_swap_shift_s64_cst_too_large
 480     ; SELECT: liveins: $x0, $x1
 481     ; SELECT-NEXT: {{  $}}
 482     ; SELECT-NEXT: %cmp_rhs:gpr64 = COPY $x1
 483     ; SELECT-NEXT: %shl_lhs:gpr64 = COPY $x0
 484     ; SELECT-NEXT: [[MOVi32imm:%[0-9]+]]:gpr32 = MOVi32imm 64
 485     ; SELECT-NEXT: %too_large:gpr64 = SUBREG_TO_REG 0, [[MOVi32imm]], %subreg.sub_32
 486     ; SELECT-NEXT: %cmp_lhs:gpr64 = LSLVXr %shl_lhs, %too_large
 487     ; SELECT-NEXT: [[SUBSXrr:%[0-9]+]]:gpr64 = SUBSXrr %cmp_lhs, %cmp_rhs, implicit-def $nzcv
 488     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 10, implicit $nzcv
 489     ; SELECT-NEXT: $w0 = COPY %cmp
 490     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 491     %cmp_rhs:_(s64) = COPY $x1
 492
 493     %shl_lhs:_(s64) = COPY $x0
 494     %too_large:_(s64) = G_CONSTANT i64 64
 495     %cmp_lhs:_(s64) = G_SHL %shl_lhs, %too_large(s64)
 496
 497     %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s64), %cmp_rhs
 498     $w0 = COPY %cmp(s32)
 499     RET_ReallyLR implicit $w0
 500
 501
 502 ...
 503 ---
 504 name:            dont_swap_shift_s32_cst_too_large
 505 legalized:       true
 506 tracksRegLiveness: true
 507 body:             |
 508   bb.0:
 509     liveins: $w0, $w1
 510
 511     ; Constant for the shift must be <= 32.
 512
 513     ; LOWER-LABEL: name: dont_swap_shift_s32_cst_too_large
 514     ; LOWER: liveins: $w0, $w1
 515     ; LOWER-NEXT: {{  $}}
 516     ; LOWER-NEXT: %cmp_rhs:_(s32) = COPY $w1
 517     ; LOWER-NEXT: %shl_lhs:_(s32) = COPY $w0
 518     ; LOWER-NEXT: %cst:_(s32) = G_CONSTANT i32 32
 519     ; LOWER-NEXT: %cmp_lhs:_(s32) = G_SHL %shl_lhs, %cst(s32)
 520     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s32), %cmp_rhs
 521     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 522     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 523     ;
 524     ; SELECT-LABEL: name: dont_swap_shift_s32_cst_too_large
 525     ; SELECT: liveins: $w0, $w1
 526     ; SELECT-NEXT: {{  $}}
 527     ; SELECT-NEXT: %cmp_rhs:gpr32 = COPY $w1
 528     ; SELECT-NEXT: %shl_lhs:gpr32 = COPY $w0
 529     ; SELECT-NEXT: %cst:gpr32 = MOVi32imm 32
 530     ; SELECT-NEXT: %cmp_lhs:gpr32 = LSLVWr %shl_lhs, %cst
 531     ; SELECT-NEXT: [[SUBSWrr:%[0-9]+]]:gpr32 = SUBSWrr %cmp_lhs, %cmp_rhs, implicit-def $nzcv
 532     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 10, implicit $nzcv
 533     ; SELECT-NEXT: $w0 = COPY %cmp
 534     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 535     %cmp_rhs:_(s32) = COPY $w1
 536
 537     %shl_lhs:_(s32) = COPY $w0
 538     %cst:_(s32) = G_CONSTANT i32 32
 539     %cmp_lhs:_(s32) = G_SHL %shl_lhs, %cst(s32)
 540
 541     %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s32), %cmp_rhs
 542     $w0 = COPY %cmp(s32)
 543     RET_ReallyLR implicit $w0
 544
 545 ...
 546 ---
 547 name:            dont_swap_cmn_lhs_no_folding_opportunities
 548 legalized:       true
 549 tracksRegLiveness: true
 550 body:             |
 551   bb.0.entry:
 552     liveins: $x0, $x1
 553
 554     ; No reason to swap a CMN on the LHS when it won't introduce a constant
 555     ; folding opportunity. We can recognise CMNs on the LHS and RHS, so there's
 556     ; nothing to gain here.
 557
 558     ; LOWER-LABEL: name: dont_swap_cmn_lhs_no_folding_opportunities
 559     ; LOWER: liveins: $x0, $x1
 560     ; LOWER-NEXT: {{  $}}
 561     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 562     ; LOWER-NEXT: %sub_rhs:_(s64) = COPY $x0
 563     ; LOWER-NEXT: %zero:_(s64) = G_CONSTANT i64 0
 564     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SUB %zero, %sub_rhs
 565     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(ne), %cmp_lhs(s64), %cmp_rhs
 566     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 567     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 568     ;
 569     ; SELECT-LABEL: name: dont_swap_cmn_lhs_no_folding_opportunities
 570     ; SELECT: liveins: $x0, $x1
 571     ; SELECT-NEXT: {{  $}}
 572     ; SELECT-NEXT: %cmp_rhs:gpr64 = COPY $x1
 573     ; SELECT-NEXT: %sub_rhs:gpr64 = COPY $x0
 574     ; SELECT-NEXT: [[ADDSXrr:%[0-9]+]]:gpr64 = ADDSXrr %sub_rhs, %cmp_rhs, implicit-def $nzcv
 575     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 0, implicit $nzcv
 576     ; SELECT-NEXT: $w0 = COPY %cmp
 577     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 578     %cmp_rhs:_(s64) = COPY $x1
 579
 580     %sub_rhs:_(s64) = COPY $x0
 581     %zero:_(s64) = G_CONSTANT i64 0
 582     %cmp_lhs:_(s64) = G_SUB %zero, %sub_rhs
 583
 584     %cmp:_(s32) = G_ICMP intpred(ne), %cmp_lhs(s64), %cmp_rhs
 585     $w0 = COPY %cmp(s32)
 586     RET_ReallyLR implicit $w0
 587
 588 ...
 589 ---
 590 name:            swap_cmn_lhs
 591 legalized:       true
 592 tracksRegLiveness: true
 593 body:             |
 594   bb.0.entry:
 595     liveins: $x0, $x1
 596
 597     ; Swap when we can see a constant folding opportunity through the sub on
 598     ; the LHS.
 599
 600
 601     ; LOWER-LABEL: name: swap_cmn_lhs
 602     ; LOWER: liveins: $x0, $x1
 603     ; LOWER-NEXT: {{  $}}
 604     ; LOWER-NEXT: %cmp_rhs:_(s64) = COPY $x1
 605     ; LOWER-NEXT: %shl_lhs:_(s64) = COPY $x0
 606     ; LOWER-NEXT: %zero:_(s64) = G_CONSTANT i64 0
 607     ; LOWER-NEXT: %cst:_(s64) = G_CONSTANT i64 63
 608     ; LOWER-NEXT: %sub_rhs:_(s64) = G_SHL %shl_lhs, %cst(s64)
 609     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SUB %zero, %sub_rhs
 610     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(ne), %cmp_rhs(s64), %cmp_lhs
 611     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 612     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 613     ;
 614     ; SELECT-LABEL: name: swap_cmn_lhs
 615     ; SELECT: liveins: $x0, $x1
 616     ; SELECT-NEXT: {{  $}}
 617     ; SELECT-NEXT: %cmp_rhs:gpr64 = COPY $x1
 618     ; SELECT-NEXT: %shl_lhs:gpr64 = COPY $x0
 619     ; SELECT-NEXT: [[ADDSXrs:%[0-9]+]]:gpr64 = ADDSXrs %cmp_rhs, %shl_lhs, 63, implicit-def $nzcv
 620     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 0, implicit $nzcv
 621     ; SELECT-NEXT: $w0 = COPY %cmp
 622     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 623     %cmp_rhs:_(s64) = COPY $x1
 624
 625     %shl_lhs:_(s64) = COPY $x0
 626     %zero:_(s64) = G_CONSTANT i64 0
 627     %cst:_(s64) = G_CONSTANT i64 63
 628     %sub_rhs:_(s64) = G_SHL %shl_lhs, %cst(s64)
 629     %cmp_lhs:_(s64) = G_SUB %zero, %sub_rhs
 630
 631     %cmp:_(s32) = G_ICMP intpred(ne), %cmp_lhs(s64), %cmp_rhs
 632     $w0 = COPY %cmp(s32)
 633     RET_ReallyLR implicit $w0
 634
 635 ...
 636 ---
 637 name:            dont_swap_cmn_lhs_when_rhs_more_profitable
 638 legalized:       true
 639 tracksRegLiveness: true
 640 body:             |
 641   bb.0.entry:
 642     liveins: $x0, $x1
 643
 644     ; Don't swap when the RHS's subtract offers a better constant folding
 645     ; opportunity than the LHS's subtract.
 646     ;
 647     ; In this case, the RHS has a supported extend, plus a shift with a constant
 648     ; <= 4.
 649
 650     ; LOWER-LABEL: name: dont_swap_cmn_lhs_when_rhs_more_profitable
 651     ; LOWER: liveins: $x0, $x1
 652     ; LOWER-NEXT: {{  $}}
 653     ; LOWER-NEXT: %zero:_(s64) = G_CONSTANT i64 0
 654     ; LOWER-NEXT: %reg0:_(s64) = COPY $x0
 655     ; LOWER-NEXT: %shl_cst:_(s64) = G_CONSTANT i64 63
 656     ; LOWER-NEXT: %shl:_(s64) = G_SHL %reg0, %shl_cst(s64)
 657     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SUB %zero, %shl
 658     ; LOWER-NEXT: %reg1:_(s64) = COPY $x1
 659     ; LOWER-NEXT: %sext_in_reg:_(s64) = G_SEXT_INREG %reg1, 1
 660     ; LOWER-NEXT: %ashr_cst:_(s64) = G_CONSTANT i64 3
 661     ; LOWER-NEXT: %ashr:_(s64) = G_ASHR %sext_in_reg, %ashr_cst(s64)
 662     ; LOWER-NEXT: %cmp_rhs:_(s64) = G_SUB %zero, %ashr
 663     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(eq), %cmp_lhs(s64), %cmp_rhs
 664     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 665     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 666     ;
 667     ; SELECT-LABEL: name: dont_swap_cmn_lhs_when_rhs_more_profitable
 668     ; SELECT: liveins: $x0, $x1
 669     ; SELECT-NEXT: {{  $}}
 670     ; SELECT-NEXT: %zero:gpr64 = COPY $xzr
 671     ; SELECT-NEXT: %reg0:gpr64 = COPY $x0
 672     ; SELECT-NEXT: %shl:gpr64 = UBFMXri %reg0, 1, 0
 673     ; SELECT-NEXT: %reg1:gpr64 = COPY $x1
 674     ; SELECT-NEXT: %sext_in_reg:gpr64 = SBFMXri %reg1, 0, 0
 675     ; SELECT-NEXT: %cmp_rhs:gpr64 = SUBSXrs %zero, %sext_in_reg, 131, implicit-def dead $nzcv
 676     ; SELECT-NEXT: [[ADDSXrr:%[0-9]+]]:gpr64 = ADDSXrr %shl, %cmp_rhs, implicit-def $nzcv
 677     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 1, implicit $nzcv
 678     ; SELECT-NEXT: $w0 = COPY %cmp
 679     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 680     %zero:_(s64) = G_CONSTANT i64 0
 681
 682     %reg0:_(s64) = COPY $x0
 683     %shl_cst:_(s64) = G_CONSTANT i64 63
 684     %shl:_(s64) = G_SHL %reg0, %shl_cst(s64)
 685     %cmp_lhs:_(s64) = G_SUB %zero, %shl
 686
 687     %reg1:_(s64) = COPY $x1
 688     %sext_in_reg:_(s64) = G_SEXT_INREG %reg1, 1
 689     %ashr_cst:_(s64) = G_CONSTANT i64 3
 690     %ashr:_(s64) = G_ASHR %sext_in_reg, %ashr_cst(s64)
 691     %cmp_rhs:_(s64) = G_SUB %zero, %ashr
 692
 693     %cmp:_(s32) = G_ICMP intpred(eq), %cmp_lhs(s64), %cmp_rhs
 694     $w0 = COPY %cmp(s32)
 695     RET_ReallyLR implicit $w0
 696
 697 ...
 698 ---
 699 name:            dont_swap_rhs_with_supported_extend
 700 legalized:       true
 701 tracksRegLiveness: true
 702 body:             |
 703   bb.0:
 704     liveins: $x0, $x1
 705     ; The RHS offers more constant folding opportunities than the LHS.
 706
 707     ; LOWER-LABEL: name: dont_swap_rhs_with_supported_extend
 708     ; LOWER: liveins: $x0, $x1
 709     ; LOWER-NEXT: {{  $}}
 710     ; LOWER-NEXT: %reg0:_(s64) = COPY $x0
 711     ; LOWER-NEXT: %lhs_cst:_(s64) = G_CONSTANT i64 1
 712     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SHL %reg0, %lhs_cst(s64)
 713     ; LOWER-NEXT: %reg1:_(s64) = COPY $x1
 714     ; LOWER-NEXT: %and_mask:_(s64) = G_CONSTANT i64 255
 715     ; LOWER-NEXT: %and:_(s64) = G_AND %reg1, %and_mask
 716     ; LOWER-NEXT: %rhs_cst:_(s64) = G_CONSTANT i64 1
 717     ; LOWER-NEXT: %cmp_rhs:_(s64) = G_ASHR %and, %rhs_cst(s64)
 718     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s64), %cmp_rhs
 719     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 720     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 721     ;
 722     ; SELECT-LABEL: name: dont_swap_rhs_with_supported_extend
 723     ; SELECT: liveins: $x0, $x1
 724     ; SELECT-NEXT: {{  $}}
 725     ; SELECT-NEXT: %reg0:gpr64 = COPY $x0
 726     ; SELECT-NEXT: %cmp_lhs:gpr64 = UBFMXri %reg0, 63, 62
 727     ; SELECT-NEXT: %reg1:gpr64 = COPY $x1
 728     ; SELECT-NEXT: %and:gpr64common = ANDXri %reg1, 4103
 729     ; SELECT-NEXT: [[SUBSXrs:%[0-9]+]]:gpr64 = SUBSXrs %cmp_lhs, %and, 129, implicit-def $nzcv
 730     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 10, implicit $nzcv
 731     ; SELECT-NEXT: $w0 = COPY %cmp
 732     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 733     %reg0:_(s64) = COPY $x0
 734     %lhs_cst:_(s64) = G_CONSTANT i64 1
 735     %cmp_lhs:_(s64) = G_SHL %reg0, %lhs_cst(s64)
 736
 737     %reg1:_(s64) = COPY $x1
 738     %and_mask:_(s64) = G_CONSTANT i64 255
 739     %and:_(s64) = G_AND %reg1, %and_mask(s64)
 740     %rhs_cst:_(s64) = G_CONSTANT i64 1
 741     %cmp_rhs:_(s64) = G_ASHR %and, %rhs_cst(s64)
 742
 743     %cmp:_(s32) = G_ICMP intpred(slt), %cmp_lhs(s64), %cmp_rhs
 744     $w0 = COPY %cmp(s32)
 745     RET_ReallyLR implicit $w0
 746
 747
 748 ...
 749 ---
 750 name:            swap_rhs_with_supported_extend
 751 legalized:       true
 752 tracksRegLiveness: true
 753 body:             |
 754   bb.0:
 755     liveins: $x0, $x1
 756
 757     ; In this case, both the LHS and RHS are fed by a supported extend. However,
 758     ; the LHS' shift has a constant <= 4. This makes it more profitable, so
 759     ; we should swap the operands.
 760
 761     ; LOWER-LABEL: name: swap_rhs_with_supported_extend
 762     ; LOWER: liveins: $x0, $x1
 763     ; LOWER-NEXT: {{  $}}
 764     ; LOWER-NEXT: %reg0:_(s64) = COPY $x0
 765     ; LOWER-NEXT: %and_mask:_(s64) = G_CONSTANT i64 255
 766     ; LOWER-NEXT: %and:_(s64) = G_AND %reg0, %and_mask
 767     ; LOWER-NEXT: %lhs_cst:_(s64) = G_CONSTANT i64 1
 768     ; LOWER-NEXT: %cmp_lhs:_(s64) = G_SHL %and, %lhs_cst(s64)
 769     ; LOWER-NEXT: %rhs_cst:_(s64) = G_CONSTANT i64 5
 770     ; LOWER-NEXT: %cmp_rhs:_(s64) = G_ASHR %and, %rhs_cst(s64)
 771     ; LOWER-NEXT: %cmp:_(s32) = G_ICMP intpred(slt), %cmp_rhs(s64), %cmp_lhs
 772     ; LOWER-NEXT: $w0 = COPY %cmp(s32)
 773     ; LOWER-NEXT: RET_ReallyLR implicit $w0
 774     ;
 775     ; SELECT-LABEL: name: swap_rhs_with_supported_extend
 776     ; SELECT: liveins: $x0, $x1
 777     ; SELECT-NEXT: {{  $}}
 778     ; SELECT-NEXT: %reg0:gpr64 = COPY $x0
 779     ; SELECT-NEXT: %and:gpr64common = ANDXri %reg0, 4103
 780     ; SELECT-NEXT: [[COPY:%[0-9]+]]:gpr32all = COPY %reg0.sub_32
 781     ; SELECT-NEXT: [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
 782     ; SELECT-NEXT: %cmp_rhs:gpr64common = SBFMXri %and, 5, 63
 783     ; SELECT-NEXT: [[SUBSXrx:%[0-9]+]]:gpr64 = SUBSXrx %cmp_rhs, [[COPY1]], 1, implicit-def $nzcv
 784     ; SELECT-NEXT: %cmp:gpr32 = CSINCWr $wzr, $wzr, 10, implicit $nzcv
 785     ; SELECT-NEXT: $w0 = COPY %cmp
 786     ; SELECT-NEXT: RET_ReallyLR implicit $w0
 787     %reg0:_(s64) = COPY $x0
 788     %and_mask:_(s64) = G_CONSTANT i64 255
 789     %and:_(s64) = G_AND %reg0, %and_mask(s64)
 790
 791     %lhs_cst:_(s64) = G_CONSTANT i64 1
 792     %cmp_lhs:_(s64) = G_SHL %and, %lhs_cst(s64)
 793
 794     %rhs_cst:_(s64) = G_CONSTANT i64 5
 795     %cmp_rhs:_(s64) = G_ASHR %and, %rhs_cst(s64)
 796
 797     %cmp:_(s32) = G_ICMP intpred(sgt), %cmp_lhs(s64), %cmp_rhs
 798     $w0 = COPY %cmp(s32)
 799     RET_ReallyLR implicit $w0