llvm/test/CodeGen/AArch64/GlobalISel/postlegalizer-lowering-shuffle-splat.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
   3
   4 ---
   5 name:            splat_4xi32
   6 alignment:       4
   7 legalized:       true
   8 tracksRegLiveness: true
   9 body:             |
  10   bb.1.entry:
  11     liveins: $w0
  12
  13     ; CHECK-LABEL: name: splat_4xi32
  14     ; CHECK: liveins: $w0
  15     ; CHECK-NEXT: {{  $}}
  16     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
  17     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<4 x s32>) = G_DUP [[COPY]](s32)
  18     ; CHECK-NEXT: $q0 = COPY [[DUP]](<4 x s32>)
  19     ; CHECK-NEXT: RET_ReallyLR implicit $q0
  20     %0:_(s32) = COPY $w0
  21     %2:_(<4 x s32>) = G_IMPLICIT_DEF
  22     %3:_(s32) = G_CONSTANT i32 0
  23     %1:_(<4 x s32>) = G_INSERT_VECTOR_ELT %2, %0(s32), %3(s32)
  24     %4:_(<4 x s32>) = G_SHUFFLE_VECTOR %1(<4 x s32>), %2, shufflemask(0, 0, 0, 0)
  25     $q0 = COPY %4(<4 x s32>)
  26     RET_ReallyLR implicit $q0
  27
  28 ...
  29 ---
  30 name:            splat_2xi64
  31 alignment:       4
  32 legalized:       true
  33 tracksRegLiveness: true
  34 body:             |
  35   bb.1.entry:
  36     liveins: $x0
  37
  38     ; CHECK-LABEL: name: splat_2xi64
  39     ; CHECK: liveins: $x0
  40     ; CHECK-NEXT: {{  $}}
  41     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s64) = COPY $x0
  42     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<2 x s64>) = G_DUP [[COPY]](s64)
  43     ; CHECK-NEXT: $q0 = COPY [[DUP]](<2 x s64>)
  44     ; CHECK-NEXT: RET_ReallyLR implicit $q0
  45     %0:_(s64) = COPY $x0
  46     %2:_(<2 x s64>) = G_IMPLICIT_DEF
  47     %3:_(s32) = G_CONSTANT i32 0
  48     %1:_(<2 x s64>) = G_INSERT_VECTOR_ELT %2, %0(s64), %3(s32)
  49     %4:_(<2 x s64>) = G_SHUFFLE_VECTOR %1(<2 x s64>), %2, shufflemask(0, 0)
  50     $q0 = COPY %4(<2 x s64>)
  51     RET_ReallyLR implicit $q0
  52
  53 ...
  54 ---
  55 name:            splat_2xi32
  56 alignment:       4
  57 legalized:       true
  58 tracksRegLiveness: true
  59 body:             |
  60   bb.1.entry:
  61     liveins: $w0
  62
  63     ; CHECK-LABEL: name: splat_2xi32
  64     ; CHECK: liveins: $w0
  65     ; CHECK-NEXT: {{  $}}
  66     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
  67     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<2 x s32>) = G_DUP [[COPY]](s32)
  68     ; CHECK-NEXT: $d0 = COPY [[DUP]](<2 x s32>)
  69     ; CHECK-NEXT: RET_ReallyLR implicit $d0
  70     %0:_(s32) = COPY $w0
  71     %2:_(<2 x s32>) = G_IMPLICIT_DEF
  72     %3:_(s32) = G_CONSTANT i32 0
  73     %1:_(<2 x s32>) = G_INSERT_VECTOR_ELT %2, %0(s32), %3(s32)
  74     %4:_(<2 x s32>) = G_SHUFFLE_VECTOR %1(<2 x s32>), %2, shufflemask(0, 0)
  75     $d0 = COPY %4(<2 x s32>)
  76     RET_ReallyLR implicit $d0
  77
  78 ...
  79 ---
  80 name:            splat_4xf32
  81 alignment:       4
  82 legalized:       true
  83 tracksRegLiveness: true
  84 body:             |
  85   bb.1.entry:
  86     liveins: $s0
  87
  88     ; CHECK-LABEL: name: splat_4xf32
  89     ; CHECK: liveins: $s0
  90     ; CHECK-NEXT: {{  $}}
  91     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $s0
  92     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<4 x s32>) = G_DUP [[COPY]](s32)
  93     ; CHECK-NEXT: $q0 = COPY [[DUP]](<4 x s32>)
  94     ; CHECK-NEXT: RET_ReallyLR implicit $q0
  95     %0:_(s32) = COPY $s0
  96     %2:_(<4 x s32>) = G_IMPLICIT_DEF
  97     %3:_(s32) = G_CONSTANT i32 0
  98     %1:_(<4 x s32>) = G_INSERT_VECTOR_ELT %2, %0(s32), %3(s32)
  99     %4:_(<4 x s32>) = G_SHUFFLE_VECTOR %1(<4 x s32>), %2, shufflemask(0, 0, 0, 0)
 100     $q0 = COPY %4(<4 x s32>)
 101     RET_ReallyLR implicit $q0
 102
 103 ...
 104 ---
 105 name:            splat_2xf64
 106 alignment:       4
 107 legalized:       true
 108 tracksRegLiveness: true
 109 body:             |
 110   bb.1.entry:
 111     liveins: $d0
 112
 113     ; CHECK-LABEL: name: splat_2xf64
 114     ; CHECK: liveins: $d0
 115     ; CHECK-NEXT: {{  $}}
 116     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s64) = COPY $d0
 117     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<2 x s64>) = G_DUP [[COPY]](s64)
 118     ; CHECK-NEXT: $q0 = COPY [[DUP]](<2 x s64>)
 119     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 120     %0:_(s64) = COPY $d0
 121     %2:_(<2 x s64>) = G_IMPLICIT_DEF
 122     %3:_(s32) = G_CONSTANT i32 0
 123     %1:_(<2 x s64>) = G_INSERT_VECTOR_ELT %2, %0(s64), %3(s32)
 124     %4:_(<2 x s64>) = G_SHUFFLE_VECTOR %1(<2 x s64>), %2, shufflemask(0, 0)
 125     $q0 = COPY %4(<2 x s64>)
 126     RET_ReallyLR implicit $q0
 127
 128 ...
 129 ---
 130 name:            splat_2xf32
 131 alignment:       4
 132 legalized:       true
 133 tracksRegLiveness: true
 134 body:             |
 135   bb.1.entry:
 136     liveins: $s0
 137
 138     ; CHECK-LABEL: name: splat_2xf32
 139     ; CHECK: liveins: $s0
 140     ; CHECK-NEXT: {{  $}}
 141     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $s0
 142     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<2 x s32>) = G_DUP [[COPY]](s32)
 143     ; CHECK-NEXT: $d0 = COPY [[DUP]](<2 x s32>)
 144     ; CHECK-NEXT: RET_ReallyLR implicit $d0
 145     %0:_(s32) = COPY $s0
 146     %2:_(<2 x s32>) = G_IMPLICIT_DEF
 147     %3:_(s32) = G_CONSTANT i32 0
 148     %1:_(<2 x s32>) = G_INSERT_VECTOR_ELT %2, %0(s32), %3(s32)
 149     %4:_(<2 x s32>) = G_SHUFFLE_VECTOR %1(<2 x s32>), %2, shufflemask(0, 0)
 150     $d0 = COPY %4(<2 x s32>)
 151     RET_ReallyLR implicit $d0
 152
 153 ...
 154 ---
 155 name:            splat_2xf64_copies
 156 alignment:       4
 157 legalized:       true
 158 tracksRegLiveness: true
 159 body:             |
 160   bb.1.entry:
 161     liveins: $d0
 162
 163     ; This test is exactly the same as splat_2xf64, except it adds two copies.
 164     ; These copies shouldn't get in the way of matching the dup pattern.
 165     ; CHECK-LABEL: name: splat_2xf64_copies
 166     ; CHECK: liveins: $d0
 167     ; CHECK-NEXT: {{  $}}
 168     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s64) = COPY $d0
 169     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<2 x s64>) = G_DUP [[COPY]](s64)
 170     ; CHECK-NEXT: $q0 = COPY [[DUP]](<2 x s64>)
 171     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 172     %0:_(s64) = COPY $d0
 173     %2:_(<2 x s64>) = G_IMPLICIT_DEF
 174     %6:_(<2 x s64>) = COPY %2
 175     %3:_(s32) = G_CONSTANT i32 0
 176     %1:_(<2 x s64>) = G_INSERT_VECTOR_ELT %6, %0(s64), %3(s32)
 177     %7:_(<2 x s64>) = COPY %1
 178     %4:_(<2 x s64>) = G_SHUFFLE_VECTOR %7(<2 x s64>), %2, shufflemask(0, 0)
 179     $q0 = COPY %4(<2 x s64>)
 180     RET_ReallyLR implicit $q0
 181
 182 ...
 183 ---
 184 name:            not_all_zeros
 185 alignment:       4
 186 legalized:       true
 187 tracksRegLiveness: true
 188 body:             |
 189   bb.1.entry:
 190     liveins: $x0
 191     ; Make sure that we don't do the optimization when it's not all zeroes.
 192     ; CHECK-LABEL: name: not_all_zeros
 193     ; CHECK: liveins: $x0
 194     ; CHECK-NEXT: {{  $}}
 195     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s64) = COPY $x0
 196     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<2 x s64>) = G_IMPLICIT_DEF
 197     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 198     ; CHECK-NEXT: [[IVEC:%[0-9]+]]:_(<2 x s64>) = G_INSERT_VECTOR_ELT [[DEF]], [[COPY]](s64), [[C]](s32)
 199     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<2 x s64>) = COPY [[IVEC]](<2 x s64>)
 200     ; CHECK-NEXT: $q0 = COPY [[COPY1]](<2 x s64>)
 201     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 202     %0:_(s64) = COPY $x0
 203     %2:_(<2 x s64>) = G_IMPLICIT_DEF
 204     %3:_(s32) = G_CONSTANT i32 0
 205     %1:_(<2 x s64>) = G_INSERT_VECTOR_ELT %2, %0(s64), %3(s32)
 206     %4:_(<2 x s64>) = G_SHUFFLE_VECTOR %1(<2 x s64>), %2, shufflemask(0, 1)
 207     $q0 = COPY %4(<2 x s64>)
 208     RET_ReallyLR implicit $q0
 209
 210 ...
 211 ---
 212 name:            all_undef
 213 alignment:       4
 214 legalized:       true
 215 tracksRegLiveness: true
 216 body:             |
 217   bb.1.entry:
 218     liveins: $x0
 219     ; If all the elements are undefined, we consider it a splat. In this case,
 220     ; we can choose 0 as our index.
 221     ;
 222     ; We should get a G_DUP here.
 223     ;
 224     ; CHECK-LABEL: name: all_undef
 225     ; CHECK: liveins: $x0
 226     ; CHECK-NEXT: {{  $}}
 227     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s64) = COPY $x0
 228     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<2 x s64>) = G_DUP [[COPY]](s64)
 229     ; CHECK-NEXT: $q0 = COPY [[DUP]](<2 x s64>)
 230     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 231     %0:_(s64) = COPY $x0
 232     %2:_(<2 x s64>) = G_IMPLICIT_DEF
 233     %3:_(s32) = G_CONSTANT i32 0
 234     %1:_(<2 x s64>) = G_INSERT_VECTOR_ELT %2, %0(s64), %3(s32)
 235     %4:_(<2 x s64>) = G_SHUFFLE_VECTOR %1(<2 x s64>), %2, shufflemask(-1, -1)
 236     $q0 = COPY %4(<2 x s64>)
 237     RET_ReallyLR implicit $q0
 238
 239 ...
 240 ---
 241 name:            one_undef
 242 alignment:       4
 243 legalized:       true
 244 tracksRegLiveness: true
 245 body:             |
 246   bb.1.entry:
 247     liveins: $s0
 248     ; Make sure we can skip past undef values.
 249     ;
 250     ; We should get a G_DUP here.
 251     ;
 252     ; CHECK-LABEL: name: one_undef
 253     ; CHECK: liveins: $s0
 254     ; CHECK-NEXT: {{  $}}
 255     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $s0
 256     ; CHECK-NEXT: [[DUP:%[0-9]+]]:_(<4 x s32>) = G_DUP [[COPY]](s32)
 257     ; CHECK-NEXT: $q0 = COPY [[DUP]](<4 x s32>)
 258     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 259     %0:_(s32) = COPY $s0
 260     %2:_(<4 x s32>) = G_IMPLICIT_DEF
 261     %3:_(s32) = G_CONSTANT i32 0
 262     %1:_(<4 x s32>) = G_INSERT_VECTOR_ELT %2, %0(s32), %3(s32)
 263     %4:_(<4 x s32>) = G_SHUFFLE_VECTOR %1(<4 x s32>), %2, shufflemask(0, -1, 0, 0)
 264     $q0 = COPY %4(<4 x s32>)
 265     RET_ReallyLR implicit $q0
 266
 267 ...
 268 ---
 269 name:            not_all_zeros_with_undefs
 270 alignment:       4
 271 legalized:       true
 272 tracksRegLiveness: true
 273 body:             |
 274   bb.1.entry:
 275     liveins: $s0
 276     ; Check a non-splat mask with an undef value. We shouldn't get a G_DUP here.
 277     ;
 278     ; CHECK-LABEL: name: not_all_zeros_with_undefs
 279     ; CHECK: liveins: $s0
 280     ; CHECK-NEXT: {{  $}}
 281     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $s0
 282     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<4 x s32>) = G_IMPLICIT_DEF
 283     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 284     ; CHECK-NEXT: [[IVEC:%[0-9]+]]:_(<4 x s32>) = G_INSERT_VECTOR_ELT [[DEF]], [[COPY]](s32), [[C]](s32)
 285     ; CHECK-NEXT: [[SHUF:%[0-9]+]]:_(<4 x s32>) = G_SHUFFLE_VECTOR [[IVEC]](<4 x s32>), [[DEF]], shufflemask(undef, 0, 0, 3)
 286     ; CHECK-NEXT: $q0 = COPY [[SHUF]](<4 x s32>)
 287     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 288     %0:_(s32) = COPY $s0
 289     %2:_(<4 x s32>) = G_IMPLICIT_DEF
 290     %3:_(s32) = G_CONSTANT i32 0
 291     %1:_(<4 x s32>) = G_INSERT_VECTOR_ELT %2, %0(s32), %3(s32)
 292     %4:_(<4 x s32>) = G_SHUFFLE_VECTOR %1(<4 x s32>), %2, shufflemask(-1, 0, 0, 3)
 293     $q0 = COPY %4(<4 x s32>)
 294     RET_ReallyLR implicit $q0
 295
 296 ...
 297 ---
 298 name:            splat_4xi16
 299 alignment:       4
 300 legalized:       true
 301 tracksRegLiveness: true
 302 body:             |
 303   bb.1.entry:
 304     liveins: $h0
 305     ; CHECK-LABEL: name: splat_4xi16
 306     ; CHECK: liveins: $h0
 307     ; CHECK-NEXT: {{  $}}
 308     ; CHECK-NEXT: %copy:_(s16) = COPY $h0
 309     ; CHECK-NEXT: %splat:_(<4 x s16>) = G_DUP %copy(s16)
 310     ; CHECK-NEXT: $d0 = COPY %splat(<4 x s16>)
 311     ; CHECK-NEXT: RET_ReallyLR implicit $d0
 312     %copy:_(s16) = COPY $h0
 313     %undef:_(<4 x s16>) = G_IMPLICIT_DEF
 314     %cst:_(s32) = G_CONSTANT i32 0
 315     %ins:_(<4 x s16>) = G_INSERT_VECTOR_ELT %undef, %copy(s16), %cst(s32)
 316     %splat:_(<4 x s16>) = G_SHUFFLE_VECTOR %ins(<4 x s16>), %undef, shufflemask(0, 0, 0, 0)
 317     $d0 = COPY %splat(<4 x s16>)
 318     RET_ReallyLR implicit $d0
 319
 320 ...
 321 ---
 322 name:            splat_8xi8
 323 alignment:       4
 324 legalized:       true
 325 tracksRegLiveness: true
 326 body:             |
 327   bb.1.entry:
 328     liveins: $w0
 329     ; CHECK-LABEL: name: splat_8xi8
 330     ; CHECK: liveins: $w0
 331     ; CHECK-NEXT: {{  $}}
 332     ; CHECK-NEXT: %copy:_(s32) = COPY $w0
 333     ; CHECK-NEXT: %splat:_(<8 x s8>) = G_DUP %copy(s32)
 334     ; CHECK-NEXT: $d0 = COPY %splat(<8 x s8>)
 335     ; CHECK-NEXT: RET_ReallyLR implicit $d0
 336     %copy:_(s32) = COPY $w0
 337     %undef:_(<8 x s8>) = G_IMPLICIT_DEF
 338     %cst:_(s32) = G_CONSTANT i32 0
 339     %ins:_(<8 x s8>) = G_INSERT_VECTOR_ELT %undef, %copy(s32), %cst(s32)
 340     %splat:_(<8 x s8>) = G_SHUFFLE_VECTOR %ins(<8 x s8>), %undef, shufflemask(0, 0, 0, 0, 0, 0, 0, 0)
 341     $d0 = COPY %splat(<8 x s8>)
 342     RET_ReallyLR implicit $d0
 343
 344 ...
 345 ---
 346 name:            build_vector
 347 alignment:       4
 348 legalized:       true
 349 tracksRegLiveness: true
 350 body:             |
 351   bb.1.entry:
 352     liveins: $w0, $w1, $w2, $w3
 353     ; The G_SHUFFLE_VECTOR is fed by a G_BUILD_VECTOR, and the 0th input
 354     ; operand is not a constant. We should get a G_DUP.
 355     ;
 356     ; CHECK-LABEL: name: build_vector
 357     ; CHECK: liveins: $w0, $w1, $w2, $w3
 358     ; CHECK-NEXT: {{  $}}
 359     ; CHECK-NEXT: %lane:_(s32) = COPY $w0
 360     ; CHECK-NEXT: %shuf:_(<4 x s32>) = G_DUP %lane(s32)
 361     ; CHECK-NEXT: $q0 = COPY %shuf(<4 x s32>)
 362     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 363     %lane:_(s32) = COPY $w0
 364     %b:_(s32) = COPY $w1
 365     %c:_(s32) = COPY $w2
 366     %d:_(s32) = COPY $w3
 367     %undef:_(<4 x s32>) = G_IMPLICIT_DEF
 368     %buildvec:_(<4 x s32>) = G_BUILD_VECTOR %lane, %b, %c, %d
 369     %shuf:_(<4 x s32>) = G_SHUFFLE_VECTOR %buildvec(<4 x s32>), %undef, shufflemask(0, 0, 0, 0)
 370     $q0 = COPY %shuf(<4 x s32>)
 371     RET_ReallyLR implicit $q0