llvm/test/CodeGen/AArch64/GlobalISel/legalize-select.mir

   1 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
   2 # RUN: llc %s -verify-machineinstrs -O0 -run-pass=legalizer -mtriple aarch64-unknown-unknown -o - | FileCheck %s
   3 ...
   4 ---
   5 name:            v2s64
   6 alignment:       4
   7 tracksRegLiveness: true
   8 body:             |
   9   bb.0:
  10     liveins: $q0, $q1
  11
  12     ; CHECK-LABEL: name: v2s64
  13     ; CHECK: liveins: $q0, $q1
  14     ; CHECK-NEXT: {{  $}}
  15     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(<2 x s64>) = COPY $q0
  16     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<2 x s64>) = COPY $q1
  17     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
  18     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[C]](s64), [[C]](s64)
  19     ; CHECK-NEXT: [[ICMP:%[0-9]+]]:_(<2 x s64>) = G_ICMP intpred(sgt), [[COPY]](<2 x s64>), [[BUILD_VECTOR]]
  20     ; CHECK-NEXT: [[SEXT_INREG:%[0-9]+]]:_(<2 x s64>) = G_SEXT_INREG [[ICMP]], 1
  21     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1
  22     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[C1]](s64), [[C1]](s64)
  23     ; CHECK-NEXT: [[XOR:%[0-9]+]]:_(<2 x s64>) = G_XOR [[SEXT_INREG]], [[BUILD_VECTOR1]]
  24     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(<2 x s64>) = G_AND [[COPY1]], [[SEXT_INREG]]
  25     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(<2 x s64>) = G_AND [[COPY]], [[XOR]]
  26     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(<2 x s64>) = G_OR [[AND]], [[AND1]]
  27     ; CHECK-NEXT: $q0 = COPY [[OR]](<2 x s64>)
  28     ; CHECK-NEXT: RET_ReallyLR implicit $q0
  29     %0:_(<2 x s64>) = COPY $q0
  30     %1:_(<2 x s64>) = COPY $q1
  31     %3:_(s64) = G_CONSTANT i64 0
  32     %2:_(<2 x s64>) = G_BUILD_VECTOR %3(s64), %3(s64)
  33     %4:_(<2 x s1>) = G_ICMP intpred(sgt), %0(<2 x s64>), %2
  34     %5:_(<2 x s64>) = G_SELECT %4(<2 x s1>), %1, %0
  35     $q0 = COPY %5(<2 x s64>)
  36     RET_ReallyLR implicit $q0
  37
  38 ...
  39 ---
  40 name:            v2s32
  41 alignment:       4
  42 tracksRegLiveness: true
  43 body:             |
  44   bb.0:
  45     liveins: $d0, $d1
  46
  47     ; CHECK-LABEL: name: v2s32
  48     ; CHECK: liveins: $d0, $d1
  49     ; CHECK-NEXT: {{  $}}
  50     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(<2 x s32>) = COPY $d0
  51     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<2 x s32>) = COPY $d1
  52     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
  53     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[C]](s32), [[C]](s32)
  54     ; CHECK-NEXT: [[ICMP:%[0-9]+]]:_(<2 x s32>) = G_ICMP intpred(sgt), [[COPY]](<2 x s32>), [[BUILD_VECTOR]]
  55     ; CHECK-NEXT: [[SEXT_INREG:%[0-9]+]]:_(<2 x s32>) = G_SEXT_INREG [[ICMP]], 1
  56     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 -1
  57     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[C1]](s32), [[C1]](s32)
  58     ; CHECK-NEXT: [[XOR:%[0-9]+]]:_(<2 x s32>) = G_XOR [[SEXT_INREG]], [[BUILD_VECTOR1]]
  59     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(<2 x s32>) = G_AND [[COPY1]], [[SEXT_INREG]]
  60     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(<2 x s32>) = G_AND [[COPY]], [[XOR]]
  61     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(<2 x s32>) = G_OR [[AND]], [[AND1]]
  62     ; CHECK-NEXT: $d0 = COPY [[OR]](<2 x s32>)
  63     ; CHECK-NEXT: RET_ReallyLR implicit $d0
  64     %0:_(<2 x s32>) = COPY $d0
  65     %1:_(<2 x s32>) = COPY $d1
  66     %3:_(s32) = G_CONSTANT i32 0
  67     %2:_(<2 x s32>) = G_BUILD_VECTOR %3(s32), %3(s32)
  68     %4:_(<2 x s1>) = G_ICMP intpred(sgt), %0(<2 x s32>), %2
  69     %5:_(<2 x s32>) = G_SELECT %4(<2 x s1>), %1, %0
  70     $d0 = COPY %5(<2 x s32>)
  71     RET_ReallyLR implicit $d0
  72
  73 ...
  74 ---
  75 name:            v16s8
  76 alignment:       4
  77 tracksRegLiveness: true
  78 body:             |
  79   bb.0:
  80     liveins: $q0, $q1
  81
  82     ; CHECK-LABEL: name: v16s8
  83     ; CHECK: liveins: $q0, $q1
  84     ; CHECK-NEXT: {{  $}}
  85     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(<16 x s8>) = COPY $q0
  86     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<16 x s8>) = COPY $q1
  87     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s8) = G_CONSTANT i8 0
  88     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<16 x s8>) = G_BUILD_VECTOR [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8), [[C]](s8)
  89     ; CHECK-NEXT: [[ICMP:%[0-9]+]]:_(<16 x s8>) = G_ICMP intpred(sgt), [[COPY]](<16 x s8>), [[BUILD_VECTOR]]
  90     ; CHECK-NEXT: [[SEXT_INREG:%[0-9]+]]:_(<16 x s8>) = G_SEXT_INREG [[ICMP]], 1
  91     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s8) = G_CONSTANT i8 -1
  92     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<16 x s8>) = G_BUILD_VECTOR [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8), [[C1]](s8)
  93     ; CHECK-NEXT: [[XOR:%[0-9]+]]:_(<16 x s8>) = G_XOR [[SEXT_INREG]], [[BUILD_VECTOR1]]
  94     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(<16 x s8>) = G_AND [[COPY1]], [[SEXT_INREG]]
  95     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(<16 x s8>) = G_AND [[COPY]], [[XOR]]
  96     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(<16 x s8>) = G_OR [[AND]], [[AND1]]
  97     ; CHECK-NEXT: $q0 = COPY [[OR]](<16 x s8>)
  98     ; CHECK-NEXT: RET_ReallyLR implicit $q0
  99     %0:_(<16 x s8>) = COPY $q0
 100     %1:_(<16 x s8>) = COPY $q1
 101     %3:_(s8) = G_CONSTANT i8 0
 102     %2:_(<16 x s8>) = G_BUILD_VECTOR %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8), %3(s8)
 103     %4:_(<16 x s1>) = G_ICMP intpred(sgt), %0(<16 x s8>), %2
 104     %5:_(<16 x s8>) = G_SELECT %4(<16 x s1>), %1, %0
 105     $q0 = COPY %5(<16 x s8>)
 106     RET_ReallyLR implicit $q0
 107 ...
 108 ---
 109 name:            scalar_mask
 110 alignment:       4
 111 tracksRegLiveness: true
 112 liveins:
 113   - { reg: '$w0' }
 114   - { reg: '$q0' }
 115 body:             |
 116   bb.1:
 117     liveins: $q0, $w0
 118
 119     ; CHECK-LABEL: name: scalar_mask
 120     ; CHECK: liveins: $q0, $w0
 121     ; CHECK-NEXT: {{  $}}
 122     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
 123     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<4 x s32>) = COPY $q0
 124     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4100
 125     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00
 126     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<4 x s32>) = G_BUILD_VECTOR [[C1]](s32), [[C1]](s32), [[C1]](s32), [[C1]](s32)
 127     ; CHECK-NEXT: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[C]]
 128     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
 129     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(s32) = G_AND [[ICMP]], [[C2]]
 130     ; CHECK-NEXT: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[AND]], 1
 131     ; CHECK-NEXT: [[COPY2:%[0-9]+]]:_(s32) = COPY [[SEXT_INREG]](s32)
 132     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<4 x s32>) = G_IMPLICIT_DEF
 133     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
 134     ; CHECK-NEXT: [[IVEC:%[0-9]+]]:_(<4 x s32>) = G_INSERT_VECTOR_ELT [[DEF]], [[COPY2]](s32), [[C3]](s64)
 135     ; CHECK-NEXT: [[SHUF:%[0-9]+]]:_(<4 x s32>) = G_SHUFFLE_VECTOR [[IVEC]](<4 x s32>), [[DEF]], shufflemask(0, 0, 0, 0)
 136     ; CHECK-NEXT: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 -1
 137     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<4 x s32>) = G_BUILD_VECTOR [[C4]](s32), [[C4]](s32), [[C4]](s32), [[C4]](s32)
 138     ; CHECK-NEXT: [[XOR:%[0-9]+]]:_(<4 x s32>) = G_XOR [[SHUF]], [[BUILD_VECTOR1]]
 139     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(<4 x s32>) = G_AND [[COPY1]], [[SHUF]]
 140     ; CHECK-NEXT: [[AND2:%[0-9]+]]:_(<4 x s32>) = G_AND [[BUILD_VECTOR]], [[XOR]]
 141     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(<4 x s32>) = G_OR [[AND1]], [[AND2]]
 142     ; CHECK-NEXT: $q0 = COPY [[OR]](<4 x s32>)
 143     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 144     %0:_(s32) = COPY $w0
 145     %1:_(<4 x s32>) = COPY $q0
 146     %2:_(s32) = G_CONSTANT i32 4100
 147     %6:_(s32) = G_FCONSTANT float 0.000000e+00
 148     %5:_(<4 x s32>) = G_BUILD_VECTOR %6(s32), %6(s32), %6(s32), %6(s32)
 149     %3:_(s1) = G_ICMP intpred(eq), %0(s32), %2
 150     %4:_(<4 x s32>) = G_SELECT %3(s1), %1, %5
 151     $q0 = COPY %4(<4 x s32>)
 152     RET_ReallyLR implicit $q0
 153
 154 ...
 155 ---
 156 name:            s88
 157 tracksRegLiveness: true
 158 body:             |
 159   bb.0:
 160     liveins: $w0, $w1, $x0
 161
 162     ; CHECK-LABEL: name: s88
 163     ; CHECK: liveins: $w0, $w1, $x0
 164     ; CHECK-NEXT: {{  $}}
 165     ; CHECK-NEXT: %a:_(s32) = COPY $w0
 166     ; CHECK-NEXT: %b:_(s32) = COPY $w1
 167     ; CHECK-NEXT: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(sgt), %a(s32), %b
 168     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(s64) = G_IMPLICIT_DEF
 169     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
 170     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(s32) = G_AND [[ICMP]], [[C]]
 171     ; CHECK-NEXT: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[AND]](s32), [[DEF]], [[DEF]]
 172     ; CHECK-NEXT: $x0 = COPY [[SELECT]](s64)
 173     ; CHECK-NEXT: RET_ReallyLR implicit $x0
 174     %a:_(s32) = COPY $w0
 175     %b:_(s32) = COPY $w1
 176     %cmp:_(s1) = G_ICMP intpred(sgt), %a(s32), %b
 177     %sel_a:_(s88) = G_IMPLICIT_DEF
 178     %sel_b:_(s88) = G_IMPLICIT_DEF
 179     %select:_(s88) = G_SELECT %cmp(s1), %sel_a, %sel_b
 180     %trunc:_(s64) = G_TRUNC %select
 181     $x0 = COPY %trunc
 182     RET_ReallyLR implicit $x0
 183 ...
 184
 185 # The select condition has already been zero extended to s32, and
 186 # needs a sext_inreg to get a vector boolean.
 187 ---
 188 name:            scalar_mask_already_promoted_select_s32_v4s32
 189 alignment:       4
 190 tracksRegLiveness: true
 191 body:             |
 192   bb.0:
 193     liveins: $q0, $w0
 194
 195     ; CHECK-LABEL: name: scalar_mask_already_promoted_select_s32_v4s32
 196     ; CHECK: liveins: $q0, $w0
 197     ; CHECK-NEXT: {{  $}}
 198     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
 199     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<4 x s32>) = COPY $q0
 200     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4100
 201     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00
 202     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<4 x s32>) = G_BUILD_VECTOR [[C1]](s32), [[C1]](s32), [[C1]](s32), [[C1]](s32)
 203     ; CHECK-NEXT: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[C]]
 204     ; CHECK-NEXT: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[ICMP]], 1
 205     ; CHECK-NEXT: [[COPY2:%[0-9]+]]:_(s32) = COPY [[SEXT_INREG]](s32)
 206     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<4 x s32>) = G_IMPLICIT_DEF
 207     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
 208     ; CHECK-NEXT: [[IVEC:%[0-9]+]]:_(<4 x s32>) = G_INSERT_VECTOR_ELT [[DEF]], [[COPY2]](s32), [[C2]](s64)
 209     ; CHECK-NEXT: [[SHUF:%[0-9]+]]:_(<4 x s32>) = G_SHUFFLE_VECTOR [[IVEC]](<4 x s32>), [[DEF]], shufflemask(0, 0, 0, 0)
 210     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 -1
 211     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<4 x s32>) = G_BUILD_VECTOR [[C3]](s32), [[C3]](s32), [[C3]](s32), [[C3]](s32)
 212     ; CHECK-NEXT: [[XOR:%[0-9]+]]:_(<4 x s32>) = G_XOR [[SHUF]], [[BUILD_VECTOR1]]
 213     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(<4 x s32>) = G_AND [[COPY1]], [[SHUF]]
 214     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(<4 x s32>) = G_AND [[BUILD_VECTOR]], [[XOR]]
 215     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(<4 x s32>) = G_OR [[AND]], [[AND1]]
 216     ; CHECK-NEXT: $q0 = COPY [[OR]](<4 x s32>)
 217     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 218     %0:_(s32) = COPY $w0
 219     %1:_(<4 x s32>) = COPY $q0
 220     %2:_(s32) = G_CONSTANT i32 4100
 221     %6:_(s32) = G_FCONSTANT float 0.000000e+00
 222     %5:_(<4 x s32>) = G_BUILD_VECTOR %6(s32), %6(s32), %6(s32), %6(s32)
 223     %3:_(s32) = G_ICMP intpred(eq), %0(s32), %2
 224     %4:_(<4 x s32>) = G_SELECT %3(s32), %1, %5
 225     $q0 = COPY %4(<4 x s32>)
 226     RET_ReallyLR implicit $q0
 227
 228 ...
 229
 230 # The scalar select condition was zero extended to s32, to a different
 231 # type from the vector width. It needs to be sign extended inreg, and
 232 # then sign extended to the full element width.
 233
 234 ---
 235 name:            scalar_mask_select_s32_v4s64
 236 alignment:       4
 237 tracksRegLiveness: true
 238 body:             |
 239   bb.0:
 240     liveins: $q0, $w0
 241
 242     ; CHECK-LABEL: name: scalar_mask_select_s32_v4s64
 243     ; CHECK: liveins: $q0, $w0
 244     ; CHECK-NEXT: {{  $}}
 245     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
 246     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<2 x s64>) = COPY $q0
 247     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4100
 248     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00
 249     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[C1]](s64), [[C1]](s64)
 250     ; CHECK-NEXT: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[C]]
 251     ; CHECK-NEXT: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[ICMP]], 1
 252     ; CHECK-NEXT: [[SEXT:%[0-9]+]]:_(s64) = G_SEXT [[SEXT_INREG]](s32)
 253     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<2 x s64>) = G_IMPLICIT_DEF
 254     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
 255     ; CHECK-NEXT: [[IVEC:%[0-9]+]]:_(<2 x s64>) = G_INSERT_VECTOR_ELT [[DEF]], [[SEXT]](s64), [[C2]](s64)
 256     ; CHECK-NEXT: [[SHUF:%[0-9]+]]:_(<2 x s64>) = G_SHUFFLE_VECTOR [[IVEC]](<2 x s64>), [[DEF]], shufflemask(0, 0)
 257     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1
 258     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[C3]](s64), [[C3]](s64)
 259     ; CHECK-NEXT: [[XOR:%[0-9]+]]:_(<2 x s64>) = G_XOR [[SHUF]], [[BUILD_VECTOR1]]
 260     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(<2 x s64>) = G_AND [[COPY1]], [[SHUF]]
 261     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(<2 x s64>) = G_AND [[BUILD_VECTOR]], [[XOR]]
 262     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(<2 x s64>) = G_OR [[AND]], [[AND1]]
 263     ; CHECK-NEXT: $q0 = COPY [[OR]](<2 x s64>)
 264     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 265     %0:_(s32) = COPY $w0
 266     %1:_(<2 x s64>) = COPY $q0
 267     %2:_(s32) = G_CONSTANT i32 4100
 268     %6:_(s64) = G_FCONSTANT double 0.000000e+00
 269     %5:_(<2 x s64>) = G_BUILD_VECTOR %6, %6
 270     %3:_(s32) = G_ICMP intpred(eq), %0(s32), %2
 271     %4:_(<2 x s64>) = G_SELECT %3(s32), %1, %5
 272     $q0 = COPY %4
 273     RET_ReallyLR implicit $q0
 274
 275 ...
 276
 277 # Check degenerate case where the selected element size is the same as
 278 # the condition bitwidth.
 279 ---
 280 name:            select_v4s1_s1
 281 alignment:       4
 282 tracksRegLiveness: true
 283 body:             |
 284   bb.0:
 285     liveins: $q0, $q1, $q2, $w0
 286
 287     ; CHECK-LABEL: name: select_v4s1_s1
 288     ; CHECK: liveins: $q0, $q1, $q2, $w0
 289     ; CHECK-NEXT: {{  $}}
 290     ; CHECK-NEXT: %w0:_(s32) = COPY $w0
 291     ; CHECK-NEXT: %q0:_(<4 x s32>) = COPY $q0
 292     ; CHECK-NEXT: %q1:_(<4 x s32>) = COPY $q1
 293     ; CHECK-NEXT: %q2:_(<4 x s32>) = COPY $q2
 294     ; CHECK-NEXT: %vec_cond0:_(<4 x s1>) = G_ICMP intpred(eq), %q0(<4 x s32>), %q1
 295     ; CHECK-NEXT: %vec_cond1:_(<4 x s1>) = G_ICMP intpred(eq), %q0(<4 x s32>), %q2
 296     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4100
 297     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00
 298     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<4 x s32>) = G_BUILD_VECTOR [[C1]](s32), [[C1]](s32), [[C1]](s32), [[C1]](s32)
 299     ; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(eq), %w0(s32), [[C]]
 300     ; CHECK-NEXT: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT %cmp(s1)
 301     ; CHECK-NEXT: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[ZEXT]], 1
 302     ; CHECK-NEXT: [[TRUNC:%[0-9]+]]:_(s1) = G_TRUNC [[SEXT_INREG]](s32)
 303     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<4 x s1>) = G_IMPLICIT_DEF
 304     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
 305     ; CHECK-NEXT: [[IVEC:%[0-9]+]]:_(<4 x s1>) = G_INSERT_VECTOR_ELT [[DEF]], [[TRUNC]](s1), [[C2]](s64)
 306     ; CHECK-NEXT: [[SHUF:%[0-9]+]]:_(<4 x s1>) = G_SHUFFLE_VECTOR [[IVEC]](<4 x s1>), [[DEF]], shufflemask(0, 0, 0, 0)
 307     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s8) = G_CONSTANT i8 1
 308     ; CHECK-NEXT: [[TRUNC1:%[0-9]+]]:_(s1) = G_TRUNC [[C3]](s8)
 309     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<4 x s1>) = G_BUILD_VECTOR [[TRUNC1]](s1), [[TRUNC1]](s1), [[TRUNC1]](s1), [[TRUNC1]](s1)
 310     ; CHECK-NEXT: [[ANYEXT:%[0-9]+]]:_(<4 x s16>) = G_ANYEXT [[SHUF]](<4 x s1>)
 311     ; CHECK-NEXT: [[ANYEXT1:%[0-9]+]]:_(<4 x s16>) = G_ANYEXT [[BUILD_VECTOR1]](<4 x s1>)
 312     ; CHECK-NEXT: [[XOR:%[0-9]+]]:_(<4 x s16>) = G_XOR [[ANYEXT]], [[ANYEXT1]]
 313     ; CHECK-NEXT: [[TRUNC2:%[0-9]+]]:_(<4 x s1>) = G_TRUNC [[XOR]](<4 x s16>)
 314     ; CHECK-NEXT: [[ANYEXT3:%[0-9]+]]:_(<4 x s16>) = G_ANYEXT %vec_cond0(<4 x s1>)
 315     ; CHECK-NEXT: [[ANYEXT4:%[0-9]+]]:_(<4 x s16>) = G_ANYEXT [[SHUF]](<4 x s1>)
 316     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(<4 x s16>) = G_AND [[ANYEXT3]], [[ANYEXT4]]
 317     ; CHECK-NEXT: [[TRUNC3:%[0-9]+]]:_(<4 x s1>) = G_TRUNC [[AND]](<4 x s16>)
 318     ; CHECK-NEXT: [[ANYEXT5:%[0-9]+]]:_(<4 x s16>) = G_ANYEXT %vec_cond1(<4 x s1>)
 319     ; CHECK-NEXT: [[ANYEXT6:%[0-9]+]]:_(<4 x s16>) = G_ANYEXT [[TRUNC2]](<4 x s1>)
 320     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(<4 x s16>) = G_AND [[ANYEXT5]], [[ANYEXT6]]
 321     ; CHECK-NEXT: [[TRUNC4:%[0-9]+]]:_(<4 x s1>) = G_TRUNC [[AND1]](<4 x s16>)
 322     ; CHECK-NEXT: [[ANYEXT7:%[0-9]+]]:_(<4 x s16>) = G_ANYEXT [[TRUNC3]](<4 x s1>)
 323     ; CHECK-NEXT: [[ANYEXT8:%[0-9]+]]:_(<4 x s16>) = G_ANYEXT [[TRUNC4]](<4 x s1>)
 324     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(<4 x s16>) = G_OR [[ANYEXT7]], [[ANYEXT8]]
 325     ; CHECK-NEXT: %select:_(<4 x s1>) = G_TRUNC [[OR]](<4 x s16>)
 326     ; CHECK-NEXT: %zext_select:_(<4 x s32>) = G_ZEXT %select(<4 x s1>)
 327     ; CHECK-NEXT: $q0 = COPY %zext_select(<4 x s32>)
 328     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 329     %w0:_(s32) = COPY $w0
 330     %q0:_(<4 x s32>) = COPY $q0
 331     %q1:_(<4 x s32>) = COPY $q1
 332     %q2:_(<4 x s32>) = COPY $q2
 333     %vec_cond0:_(<4 x s1>) = G_ICMP intpred(eq), %q0, %q1
 334     %vec_cond1:_(<4 x s1>) = G_ICMP intpred(eq), %q0, %q2
 335     %2:_(s32) = G_CONSTANT i32 4100
 336     %6:_(s32) = G_FCONSTANT float 0.000000e+00
 337     %5:_(<4 x s32>) = G_BUILD_VECTOR %6(s32), %6(s32), %6(s32), %6(s32)
 338     %cmp:_(s1) = G_ICMP intpred(eq), %w0, %2
 339     %select:_(<4 x s1>) = G_SELECT %cmp, %vec_cond0, %vec_cond1
 340     %zext_select:_(<4 x s32>) = G_ZEXT %select
 341     $q0 = COPY %zext_select
 342     RET_ReallyLR implicit $q0
 343
 344 ...
 345 ---
 346 name:            lower_select_vec_ptr
 347 liveins:
 348   - { reg: '$x0' }
 349   - { reg: '$q0' }
 350 body:             |
 351   bb.1:
 352     liveins: $q0, $x0
 353
 354     ; CHECK-LABEL: name: lower_select_vec_ptr
 355     ; CHECK: liveins: $q0, $x0
 356     ; CHECK-NEXT: {{  $}}
 357     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 358     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<2 x p0>) = COPY $q0
 359     ; CHECK-NEXT: [[C:%[0-9]+]]:_(p0) = G_CONSTANT i64 0
 360     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x p0>) = G_BUILD_VECTOR [[C]](p0), [[C]](p0)
 361     ; CHECK-NEXT: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(eq), [[COPY]](p0), [[C]]
 362     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
 363     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(s32) = G_AND [[ICMP]], [[C1]]
 364     ; CHECK-NEXT: [[PTRTOINT:%[0-9]+]]:_(<2 x s64>) = G_PTRTOINT [[COPY1]](<2 x p0>)
 365     ; CHECK-NEXT: [[PTRTOINT1:%[0-9]+]]:_(<2 x s64>) = G_PTRTOINT [[BUILD_VECTOR]](<2 x p0>)
 366     ; CHECK-NEXT: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[AND]], 1
 367     ; CHECK-NEXT: [[SEXT:%[0-9]+]]:_(s64) = G_SEXT [[SEXT_INREG]](s32)
 368     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<2 x s64>) = G_IMPLICIT_DEF
 369     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
 370     ; CHECK-NEXT: [[IVEC:%[0-9]+]]:_(<2 x s64>) = G_INSERT_VECTOR_ELT [[DEF]], [[SEXT]](s64), [[C2]](s64)
 371     ; CHECK-NEXT: [[SHUF:%[0-9]+]]:_(<2 x s64>) = G_SHUFFLE_VECTOR [[IVEC]](<2 x s64>), [[DEF]], shufflemask(0, 0)
 372     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1
 373     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[C3]](s64), [[C3]](s64)
 374     ; CHECK-NEXT: [[XOR:%[0-9]+]]:_(<2 x s64>) = G_XOR [[SHUF]], [[BUILD_VECTOR1]]
 375     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(<2 x s64>) = G_AND [[PTRTOINT]], [[SHUF]]
 376     ; CHECK-NEXT: [[AND2:%[0-9]+]]:_(<2 x s64>) = G_AND [[PTRTOINT1]], [[XOR]]
 377     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(<2 x s64>) = G_OR [[AND1]], [[AND2]]
 378     ; CHECK-NEXT: [[INTTOPTR:%[0-9]+]]:_(<2 x p0>) = G_INTTOPTR [[OR]](<2 x s64>)
 379     ; CHECK-NEXT: $q0 = COPY [[INTTOPTR]](<2 x p0>)
 380     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 381     %0:_(p0) = COPY $x0
 382     %1:_(<2 x p0>) = COPY $q0
 383     %2:_(p0) = G_CONSTANT i64 0
 384     %5:_(<2 x p0>) = G_BUILD_VECTOR %2(p0), %2(p0)
 385     %3:_(s1) = G_ICMP intpred(eq), %0(p0), %2
 386     %4:_(<2 x p0>) = G_SELECT %3(s1), %1, %5
 387     $q0 = COPY %4(<2 x p0>)
 388     RET_ReallyLR implicit $q0
 389
 390 ...