llvm/test/CodeGen/AArch64/GlobalISel/opt-fold-xor-tbz-tbnz.mir

   1 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
   2 # RUN: llc -mtriple aarch64-unknown-unknown -run-pass=instruction-select -global-isel-abort=1 -verify-machineinstrs %s -o - | FileCheck %s
   3 ...
   4 ---
   5 name:            flip_eq
   6 alignment:       4
   7 legalized:       true
   8 regBankSelected: true
   9 body:             |
  10   ; CHECK-LABEL: name: flip_eq
  11   ; CHECK: bb.0:
  12   ; CHECK-NEXT:   successors: %bb.0(0x40000000), %bb.1(0x40000000)
  13   ; CHECK-NEXT:   liveins: $x0
  14   ; CHECK-NEXT: {{  $}}
  15   ; CHECK-NEXT:   %copy:gpr64all = COPY $x0
  16   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr32all = COPY %copy.sub_32
  17   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
  18   ; CHECK-NEXT:   TBNZW [[COPY1]], 3, %bb.1
  19   ; CHECK-NEXT:   B %bb.0
  20   ; CHECK-NEXT: {{  $}}
  21   ; CHECK-NEXT: bb.1:
  22   ; CHECK-NEXT:   RET_ReallyLR
  23   bb.0:
  24     successors: %bb.0, %bb.1
  25     liveins: $x0
  26     %copy:gpr(s64) = COPY $x0
  27
  28     ; Check bit 3.
  29     %bit:gpr(s64) = G_CONSTANT i64 8
  30     %zero:gpr(s64) = G_CONSTANT i64 0
  31
  32     ; 8 has the third bit set.
  33     %fold_cst:gpr(s64) = G_CONSTANT i64 8
  34
  35     ; This only has the third bit set if %copy does not. So, to walk through
  36     ; this, we want to use a TBNZW on %copy.
  37     %fold_me:gpr(s64) = G_XOR %copy, %fold_cst
  38
  39     %and:gpr(s64) = G_AND %fold_me, %bit
  40     %cmp:gpr(s32) = G_ICMP intpred(eq), %and(s64), %zero
  41     G_BRCOND %cmp, %bb.1
  42     G_BR %bb.0
  43   bb.1:
  44     RET_ReallyLR
  45 ...
  46 ---
  47 name:            flip_ne
  48 alignment:       4
  49 legalized:       true
  50 regBankSelected: true
  51 body:             |
  52   ; CHECK-LABEL: name: flip_ne
  53   ; CHECK: bb.0:
  54   ; CHECK-NEXT:   successors: %bb.0(0x40000000), %bb.1(0x40000000)
  55   ; CHECK-NEXT:   liveins: $x0
  56   ; CHECK-NEXT: {{  $}}
  57   ; CHECK-NEXT:   %copy:gpr64all = COPY $x0
  58   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr32all = COPY %copy.sub_32
  59   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
  60   ; CHECK-NEXT:   TBZW [[COPY1]], 3, %bb.1
  61   ; CHECK-NEXT:   B %bb.0
  62   ; CHECK-NEXT: {{  $}}
  63   ; CHECK-NEXT: bb.1:
  64   ; CHECK-NEXT:   RET_ReallyLR
  65   bb.0:
  66     successors: %bb.0, %bb.1
  67     liveins: $x0
  68
  69     ; Same as eq case, but we should get a TBZW instead.
  70
  71     %copy:gpr(s64) = COPY $x0
  72     %bit:gpr(s64) = G_CONSTANT i64 8
  73     %zero:gpr(s64) = G_CONSTANT i64 0
  74     %fold_cst:gpr(s64) = G_CONSTANT i64 8
  75     %fold_me:gpr(s64) = G_XOR %copy, %fold_cst
  76     %and:gpr(s64) = G_AND %fold_me, %bit
  77     %cmp:gpr(s32) = G_ICMP intpred(ne), %and(s64), %zero
  78     G_BRCOND %cmp, %bb.1
  79     G_BR %bb.0
  80   bb.1:
  81     RET_ReallyLR
  82 ...
  83 ---
  84 name:            dont_flip_eq
  85 alignment:       4
  86 legalized:       true
  87 regBankSelected: true
  88 body:             |
  89   ; CHECK-LABEL: name: dont_flip_eq
  90   ; CHECK: bb.0:
  91   ; CHECK-NEXT:   successors: %bb.0(0x40000000), %bb.1(0x40000000)
  92   ; CHECK-NEXT:   liveins: $x0
  93   ; CHECK-NEXT: {{  $}}
  94   ; CHECK-NEXT:   %copy:gpr64all = COPY $x0
  95   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr32all = COPY %copy.sub_32
  96   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
  97   ; CHECK-NEXT:   TBZW [[COPY1]], 3, %bb.1
  98   ; CHECK-NEXT:   B %bb.0
  99   ; CHECK-NEXT: {{  $}}
 100   ; CHECK-NEXT: bb.1:
 101   ; CHECK-NEXT:   RET_ReallyLR
 102   bb.0:
 103     successors: %bb.0, %bb.1
 104     liveins: $x0
 105     %copy:gpr(s64) = COPY $x0
 106
 107     ; Check bit 3.
 108     %bit:gpr(s64) = G_CONSTANT i64 8
 109     %zero:gpr(s64) = G_CONSTANT i64 0
 110
 111     ; 7 does not have the third bit set.
 112     %fold_cst:gpr(s64) = G_CONSTANT i64 7
 113
 114     ; This only has the third bit set if %copy does. So, to walk through this,
 115     ; we should have a TBZW on %copy.
 116     %fold_me:gpr(s64) = G_XOR %fold_cst, %copy
 117
 118     %and:gpr(s64) = G_AND %fold_me, %bit
 119     %cmp:gpr(s32) = G_ICMP intpred(eq), %and(s64), %zero
 120     G_BRCOND %cmp, %bb.1
 121     G_BR %bb.0
 122   bb.1:
 123     RET_ReallyLR
 124 ...
 125 ---
 126 name:            dont_flip_eq_zext
 127 alignment:       4
 128 legalized:       true
 129 regBankSelected: true
 130 tracksRegLiveness: true
 131 body:             |
 132   ; CHECK-LABEL: name: dont_flip_eq_zext
 133   ; CHECK: bb.0:
 134   ; CHECK-NEXT:   successors: %bb.0(0x40000000), %bb.1(0x40000000)
 135   ; CHECK-NEXT: {{  $}}
 136   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr32 = COPY $wzr
 137   ; CHECK-NEXT:   [[SUBREG_TO_REG:%[0-9]+]]:gpr64all = SUBREG_TO_REG 0, [[COPY]], %subreg.sub_32
 138   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr64 = COPY [[SUBREG_TO_REG]]
 139   ; CHECK-NEXT:   TBNZX [[COPY1]], 63, %bb.1
 140   ; CHECK-NEXT:   B %bb.0
 141   ; CHECK-NEXT: {{  $}}
 142   ; CHECK-NEXT: bb.1:
 143   ; CHECK-NEXT:   RET_ReallyLR
 144   bb.0:
 145     successors: %bb.0(0x40000000), %bb.1(0x40000000)
 146
 147     %1:gpr(s32) = G_CONSTANT i32 0
 148     %3:gpr(s32) = G_CONSTANT i32 -1
 149     %4:gpr(s32) = G_XOR %1, %3
 150     %5:gpr(s64) = G_ZEXT %4(s32)
 151     %15:gpr(s64) = G_CONSTANT i64 0
 152     %13:gpr(s32) = G_ICMP intpred(slt), %5(s64), %15
 153     G_BRCOND %13, %bb.1
 154     G_BR %bb.0
 155   bb.1:
 156     RET_ReallyLR
 157 ...
 158 ---
 159 name:            dont_flip_ne
 160 alignment:       4
 161 legalized:       true
 162 regBankSelected: true
 163 body:             |
 164   ; CHECK-LABEL: name: dont_flip_ne
 165   ; CHECK: bb.0:
 166   ; CHECK-NEXT:   successors: %bb.0(0x40000000), %bb.1(0x40000000)
 167   ; CHECK-NEXT:   liveins: $x0
 168   ; CHECK-NEXT: {{  $}}
 169   ; CHECK-NEXT:   %copy:gpr64all = COPY $x0
 170   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr32all = COPY %copy.sub_32
 171   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
 172   ; CHECK-NEXT:   TBNZW [[COPY1]], 3, %bb.1
 173   ; CHECK-NEXT:   B %bb.0
 174   ; CHECK-NEXT: {{  $}}
 175   ; CHECK-NEXT: bb.1:
 176   ; CHECK-NEXT:   RET_ReallyLR
 177   bb.0:
 178     successors: %bb.0, %bb.1
 179     liveins: $x0
 180
 181     ; Same as eq case, but we should get a TBNZW instead.
 182
 183     %copy:gpr(s64) = COPY $x0
 184     %bit:gpr(s64) = G_CONSTANT i64 8
 185     %zero:gpr(s64) = G_CONSTANT i64 0
 186     %fold_cst:gpr(s64) = G_CONSTANT i64 7
 187     %fold_me:gpr(s64) = G_XOR %fold_cst, %copy
 188     %and:gpr(s64) = G_AND %fold_me, %bit
 189     %cmp:gpr(s32) = G_ICMP intpred(ne), %and(s64), %zero
 190     G_BRCOND %cmp, %bb.1
 191     G_BR %bb.0
 192   bb.1:
 193     RET_ReallyLR
 194 ...
 195 ---
 196 name:            xor_chain
 197 alignment:       4
 198 legalized:       true
 199 regBankSelected: true
 200 body:             |
 201   ; CHECK-LABEL: name: xor_chain
 202   ; CHECK: bb.0:
 203   ; CHECK-NEXT:   successors: %bb.0(0x40000000), %bb.1(0x40000000)
 204   ; CHECK-NEXT:   liveins: $x0
 205   ; CHECK-NEXT: {{  $}}
 206   ; CHECK-NEXT:   %copy:gpr64all = COPY $x0
 207   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr32all = COPY %copy.sub_32
 208   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr32 = COPY [[COPY]]
 209   ; CHECK-NEXT:   TBZW [[COPY1]], 3, %bb.1
 210   ; CHECK-NEXT:   B %bb.0
 211   ; CHECK-NEXT: {{  $}}
 212   ; CHECK-NEXT: bb.1:
 213   ; CHECK-NEXT:   RET_ReallyLR
 214   bb.0:
 215     successors: %bb.0, %bb.1
 216     liveins: $x0
 217     %copy:gpr(s64) = COPY $x0
 218     %bit:gpr(s64) = G_CONSTANT i64 8
 219     %zero:gpr(s64) = G_CONSTANT i64 0
 220     %fold_cst:gpr(s64) = G_CONSTANT i64 8
 221
 222     ; The G_XORs cancel each other out, so we should get a TBZW.
 223     %xor1:gpr(s64) = G_XOR %copy, %fold_cst
 224     %xor2:gpr(s64) = G_XOR %xor1, %fold_cst
 225
 226     %and:gpr(s64) = G_AND %xor2, %bit
 227     %cmp:gpr(s32) = G_ICMP intpred(eq), %and(s64), %zero
 228     G_BRCOND %cmp, %bb.1
 229     G_BR %bb.0
 230   bb.1:
 231     RET_ReallyLR