llvm/test/CodeGen/AArch64/GlobalISel/legalize-load-store.mir

   1 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
   2 # RUN: llc -O0 -mtriple=aarch64 -run-pass=legalizer -global-isel-abort=1 %s -o - | FileCheck %s
   3 ---
   4 name:            test_load
   5 body: |
   6   bb.0:
   7     liveins: $x0
   8
   9     ; CHECK-LABEL: name: test_load
  10     ; CHECK: liveins: $x0
  11     ; CHECK-NEXT: {{  $}}
  12     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
  13     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s8) = G_LOAD [[COPY]](p0) :: (load (s8))
  14     ; CHECK-NEXT: [[ASSERT_ZEXT:%[0-9]+]]:_(s8) = G_ASSERT_ZEXT [[LOAD]], 1
  15     ; CHECK-NEXT: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[ASSERT_ZEXT]](s8)
  16     ; CHECK-NEXT: $w0 = COPY [[ANYEXT]](s32)
  17     ; CHECK-NEXT: [[LOAD1:%[0-9]+]]:_(s8) = G_LOAD [[COPY]](p0) :: (load (s8))
  18     ; CHECK-NEXT: [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[LOAD1]](s8)
  19     ; CHECK-NEXT: $w0 = COPY [[ANYEXT1]](s32)
  20     ; CHECK-NEXT: [[LOAD2:%[0-9]+]]:_(s16) = G_LOAD [[COPY]](p0) :: (load (s16))
  21     ; CHECK-NEXT: [[ANYEXT2:%[0-9]+]]:_(s32) = G_ANYEXT [[LOAD2]](s16)
  22     ; CHECK-NEXT: $w0 = COPY [[ANYEXT2]](s32)
  23     ; CHECK-NEXT: $w0 = COPY [[ANYEXT1]](s32)
  24     ; CHECK-NEXT: [[LOAD3:%[0-9]+]]:_(s64) = G_LOAD [[COPY]](p0) :: (load (s64))
  25     ; CHECK-NEXT: $x0 = COPY [[LOAD3]](s64)
  26     ; CHECK-NEXT: [[LOAD4:%[0-9]+]]:_(p0) = G_LOAD [[COPY]](p0) :: (load (p0))
  27     ; CHECK-NEXT: [[PTRTOINT:%[0-9]+]]:_(s64) = G_PTRTOINT [[LOAD4]](p0)
  28     ; CHECK-NEXT: $x0 = COPY [[PTRTOINT]](s64)
  29     ; CHECK-NEXT: [[LOAD5:%[0-9]+]]:_(<2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<2 x s32>))
  30     ; CHECK-NEXT: [[BITCAST:%[0-9]+]]:_(s64) = G_BITCAST [[LOAD5]](<2 x s32>)
  31     ; CHECK-NEXT: $x0 = COPY [[BITCAST]](s64)
  32     ; CHECK-NEXT: [[LOAD6:%[0-9]+]]:_(s128) = G_LOAD [[COPY]](p0) :: (load (s128))
  33     ; CHECK-NEXT: [[TRUNC:%[0-9]+]]:_(s64) = G_TRUNC [[LOAD6]](s128)
  34     ; CHECK-NEXT: $x0 = COPY [[TRUNC]](s64)
  35     %0:_(p0) = COPY $x0
  36     %1:_(s1) = G_LOAD %0(p0) :: (load (s1))
  37     %2:_(s32) = G_ANYEXT %1(s1)
  38     $w0 = COPY %2(s32)
  39     %3:_(s8) = G_LOAD %0(p0) :: (load (s8))
  40     %4:_(s32) = G_ANYEXT %3(s8)
  41     $w0 = COPY %4(s32)
  42     %5:_(s16) = G_LOAD %0(p0) :: (load (s16))
  43     %6:_(s32) = G_ANYEXT %5(s16)
  44     $w0 = COPY %6(s32)
  45     %7:_(s32) = G_LOAD %0(p0) :: (load (s32))
  46     $w0 = COPY %4(s32)
  47     %8:_(s64) = G_LOAD %0(p0) :: (load (s64))
  48     $x0 = COPY %8(s64)
  49     %9:_(p0) = G_LOAD %0(p0) :: (load (p0))
  50     %10:_(s64) = G_PTRTOINT %9(p0)
  51     $x0 = COPY %10(s64)
  52     %11:_(<2 x s32>) = G_LOAD %0(p0) :: (load (<2 x s32>))
  53     %12:_(s64) = G_BITCAST %11(<2 x s32>)
  54     $x0 = COPY %12(s64)
  55     %13:_(s128) = G_LOAD %0(p0) :: (load (s128))
  56     %14:_(s64) = G_TRUNC %13(s128)
  57     $x0 = COPY %14(s64)
  58 ...
  59
  60 ---
  61 name:            test_store
  62 body: |
  63   bb.0:
  64     liveins: $x0, $w1
  65
  66     ; CHECK-LABEL: name: test_store
  67     ; CHECK: liveins: $x0, $w1
  68     ; CHECK-NEXT: {{  $}}
  69     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
  70     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
  71     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
  72     ; CHECK-NEXT: [[AND:%[0-9]+]]:_(s32) = G_AND [[COPY1]], [[C]]
  73     ; CHECK-NEXT: [[AND1:%[0-9]+]]:_(s32) = G_AND [[AND]], [[C]]
  74     ; CHECK-NEXT: [[TRUNC:%[0-9]+]]:_(s8) = G_TRUNC [[AND1]](s32)
  75     ; CHECK-NEXT: G_STORE [[TRUNC]](s8), [[COPY]](p0) :: (store (s8))
  76     ; CHECK-NEXT: [[TRUNC1:%[0-9]+]]:_(s8) = G_TRUNC [[COPY1]](s32)
  77     ; CHECK-NEXT: G_STORE [[TRUNC1]](s8), [[COPY]](p0) :: (store (s8))
  78     ; CHECK-NEXT: [[TRUNC2:%[0-9]+]]:_(s16) = G_TRUNC [[COPY1]](s32)
  79     ; CHECK-NEXT: G_STORE [[TRUNC2]](s16), [[COPY]](p0) :: (store (s16))
  80     ; CHECK-NEXT: G_STORE [[COPY1]](s32), [[COPY]](p0) :: (store (s32))
  81     ; CHECK-NEXT: [[PTRTOINT:%[0-9]+]]:_(s64) = G_PTRTOINT [[COPY]](p0)
  82     ; CHECK-NEXT: G_STORE [[PTRTOINT]](s64), [[COPY]](p0) :: (store (s64))
  83     ; CHECK-NEXT: G_STORE [[COPY]](p0), [[COPY]](p0) :: (store (p0))
  84     ; CHECK-NEXT: [[PTRTOINT1:%[0-9]+]]:_(s64) = G_PTRTOINT [[COPY]](p0)
  85     ; CHECK-NEXT: [[MV:%[0-9]+]]:_(s128) = G_MERGE_VALUES [[PTRTOINT1]](s64), [[PTRTOINT1]](s64)
  86     ; CHECK-NEXT: G_STORE [[MV]](s128), [[COPY]](p0) :: (store (s128))
  87     %0:_(p0) = COPY $x0
  88     %1:_(s32) = COPY $w1
  89     %2:_(s1) = G_TRUNC %1(s32)
  90     G_STORE %2(s1), %0(p0) :: (store (s1))
  91     %3:_(s8) = G_TRUNC %1(s32)
  92     G_STORE %3(s8), %0(p0) :: (store (s8))
  93     %4:_(s16) = G_TRUNC %1(s32)
  94     G_STORE %4(s16), %0(p0) :: (store (s16))
  95     G_STORE %1(s32), %0(p0) :: (store (s32))
  96     %5:_(s64) = G_PTRTOINT %0(p0)
  97     G_STORE %5(s64), %0(p0) :: (store (s64))
  98     G_STORE %0(p0), %0(p0) :: (store (p0))
  99     %6:_(s64) = G_PTRTOINT %0(p0)
 100     %7:_(s128) = G_MERGE_VALUES %6(s64), %6
 101     G_STORE %7(s128), %0(p0) :: (store (s128))
 102 ...
 103 ---
 104 name:            store_4xi16
 105 alignment:       4
 106 tracksRegLiveness: true
 107 machineFunctionInfo: {}
 108 body:             |
 109   bb.1:
 110     liveins: $d0, $x0
 111
 112     ; CHECK-LABEL: name: store_4xi16
 113     ; CHECK: liveins: $d0, $x0
 114     ; CHECK-NEXT: {{  $}}
 115     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(<4 x s16>) = COPY $d0
 116     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x0
 117     ; CHECK-NEXT: G_STORE [[COPY]](<4 x s16>), [[COPY1]](p0) :: (store (<4 x s16>))
 118     ; CHECK-NEXT: RET_ReallyLR
 119     %0:_(<4 x s16>) = COPY $d0
 120     %1:_(p0) = COPY $x0
 121     G_STORE %0(<4 x s16>), %1(p0) :: (store (<4 x s16>))
 122     RET_ReallyLR
 123
 124 ...
 125 ---
 126 name:            store_4xi32
 127 alignment:       4
 128 tracksRegLiveness: true
 129 machineFunctionInfo: {}
 130 body:             |
 131   bb.1:
 132     liveins: $q0, $x0
 133
 134     ; CHECK-LABEL: name: store_4xi32
 135     ; CHECK: liveins: $q0, $x0
 136     ; CHECK-NEXT: {{  $}}
 137     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(<4 x s32>) = COPY $q0
 138     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x0
 139     ; CHECK-NEXT: G_STORE [[COPY]](<4 x s32>), [[COPY1]](p0) :: (store (<4 x s32>))
 140     ; CHECK-NEXT: RET_ReallyLR
 141     %0:_(<4 x s32>) = COPY $q0
 142     %1:_(p0) = COPY $x0
 143     G_STORE %0(<4 x s32>), %1(p0) :: (store (<4 x s32>))
 144     RET_ReallyLR
 145
 146 ...
 147 ---
 148 name:            store_8xi16
 149 alignment:       4
 150 tracksRegLiveness: true
 151 machineFunctionInfo: {}
 152 body:             |
 153   bb.1:
 154     liveins: $q0, $x0
 155
 156     ; CHECK-LABEL: name: store_8xi16
 157     ; CHECK: liveins: $q0, $x0
 158     ; CHECK-NEXT: {{  $}}
 159     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(<8 x s16>) = COPY $q0
 160     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x0
 161     ; CHECK-NEXT: G_STORE [[COPY]](<8 x s16>), [[COPY1]](p0) :: (store (<8 x s16>))
 162     ; CHECK-NEXT: RET_ReallyLR
 163     %0:_(<8 x s16>) = COPY $q0
 164     %1:_(p0) = COPY $x0
 165     G_STORE %0(<8 x s16>), %1(p0) :: (store (<8 x s16>))
 166     RET_ReallyLR
 167
 168 ...
 169 ---
 170 name:            store_16xi8
 171 alignment:       4
 172 tracksRegLiveness: true
 173 machineFunctionInfo: {}
 174 body:             |
 175   bb.1:
 176     liveins: $q0, $x0
 177
 178     ; CHECK-LABEL: name: store_16xi8
 179     ; CHECK: liveins: $q0, $x0
 180     ; CHECK-NEXT: {{  $}}
 181     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(<16 x s8>) = COPY $q0
 182     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x0
 183     ; CHECK-NEXT: G_STORE [[COPY]](<16 x s8>), [[COPY1]](p0) :: (store (<16 x s8>))
 184     ; CHECK-NEXT: RET_ReallyLR
 185     %0:_(<16 x s8>) = COPY $q0
 186     %1:_(p0) = COPY $x0
 187     G_STORE %0(<16 x s8>), %1(p0) :: (store (<16 x s8>))
 188     RET_ReallyLR
 189
 190 ...
 191 ---
 192 name:            load_4xi16
 193 alignment:       4
 194 tracksRegLiveness: true
 195 machineFunctionInfo: {}
 196 body:             |
 197   bb.1:
 198     liveins: $x0
 199
 200     ; CHECK-LABEL: name: load_4xi16
 201     ; CHECK: liveins: $x0
 202     ; CHECK-NEXT: {{  $}}
 203     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 204     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<4 x s16>))
 205     ; CHECK-NEXT: $d0 = COPY [[LOAD]](<4 x s16>)
 206     ; CHECK-NEXT: RET_ReallyLR implicit $d0
 207     %0:_(p0) = COPY $x0
 208     %1:_(<4 x s16>) = G_LOAD %0(p0) :: (load (<4 x s16>))
 209     $d0 = COPY %1(<4 x s16>)
 210     RET_ReallyLR implicit $d0
 211
 212 ...
 213 ---
 214 name:            load_4xi32
 215 alignment:       4
 216 tracksRegLiveness: true
 217 machineFunctionInfo: {}
 218 body:             |
 219   bb.1:
 220     liveins: $x0
 221
 222     ; CHECK-LABEL: name: load_4xi32
 223     ; CHECK: liveins: $x0
 224     ; CHECK-NEXT: {{  $}}
 225     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 226     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<4 x s32>) = G_LOAD [[COPY]](p0) :: (load (<4 x s32>))
 227     ; CHECK-NEXT: $q0 = COPY [[LOAD]](<4 x s32>)
 228     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 229     %0:_(p0) = COPY $x0
 230     %1:_(<4 x s32>) = G_LOAD %0(p0) :: (load (<4 x s32>))
 231     $q0 = COPY %1(<4 x s32>)
 232     RET_ReallyLR implicit $q0
 233
 234 ...
 235 ---
 236 name:            load_8xi16
 237 alignment:       4
 238 tracksRegLiveness: true
 239 machineFunctionInfo: {}
 240 body:             |
 241   bb.1:
 242     liveins: $x0
 243
 244     ; CHECK-LABEL: name: load_8xi16
 245     ; CHECK: liveins: $x0
 246     ; CHECK-NEXT: {{  $}}
 247     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 248     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<8 x s16>) = G_LOAD [[COPY]](p0) :: (load (<8 x s16>))
 249     ; CHECK-NEXT: $q0 = COPY [[LOAD]](<8 x s16>)
 250     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 251     %0:_(p0) = COPY $x0
 252     %1:_(<8 x s16>) = G_LOAD %0(p0) :: (load (<8 x s16>))
 253     $q0 = COPY %1(<8 x s16>)
 254     RET_ReallyLR implicit $q0
 255
 256 ...
 257 ---
 258 name:            load_16xi8
 259 alignment:       4
 260 tracksRegLiveness: true
 261 machineFunctionInfo: {}
 262 body:             |
 263   bb.1:
 264     liveins: $x0
 265
 266     ; CHECK-LABEL: name: load_16xi8
 267     ; CHECK: liveins: $x0
 268     ; CHECK-NEXT: {{  $}}
 269     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 270     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<16 x s8>))
 271     ; CHECK-NEXT: $q0 = COPY [[LOAD]](<16 x s8>)
 272     ; CHECK-NEXT: RET_ReallyLR implicit $q0
 273     %0:_(p0) = COPY $x0
 274     %1:_(<16 x s8>) = G_LOAD %0(p0) :: (load (<16 x s8>))
 275     $q0 = COPY %1(<16 x s8>)
 276     RET_ReallyLR implicit $q0
 277
 278 ...
 279 ---
 280 name:            load_8xi8
 281 alignment:       4
 282 tracksRegLiveness: true
 283 machineFunctionInfo: {}
 284 body:             |
 285   bb.1:
 286     liveins: $x0
 287     ; CHECK-LABEL: name: load_8xi8
 288     ; CHECK: liveins: $x0
 289     ; CHECK-NEXT: {{  $}}
 290     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 291     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<8 x s8>) = G_LOAD [[COPY]](p0) :: (load (<8 x s8>))
 292     ; CHECK-NEXT: $d0 = COPY [[LOAD]](<8 x s8>)
 293     ; CHECK-NEXT: RET_ReallyLR implicit $d0
 294     %0:_(p0) = COPY $x0
 295     %1:_(<8 x s8>) = G_LOAD %0(p0) :: (load (<8 x s8>))
 296     $d0 = COPY %1(<8 x s8>)
 297     RET_ReallyLR implicit $d0
 298
 299 ...
 300 ---
 301 name:            store_8xi8
 302 alignment:       4
 303 tracksRegLiveness: true
 304 machineFunctionInfo: {}
 305 body:             |
 306   bb.1:
 307     liveins: $x0, $d0
 308     ; CHECK-LABEL: name: store_8xi8
 309     ; CHECK: liveins: $x0, $d0
 310     ; CHECK-NEXT: {{  $}}
 311     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 312     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<8 x s8>) = COPY $d0
 313     ; CHECK-NEXT: G_STORE [[COPY1]](<8 x s8>), [[COPY]](p0) :: (store (<8 x s8>))
 314     ; CHECK-NEXT: RET_ReallyLR
 315     %0:_(p0) = COPY $x0
 316     %1:_(<8 x s8>) = COPY $d0
 317     G_STORE %1(<8 x s8>), %0(p0) :: (store (<8 x s8>))
 318     RET_ReallyLR
 319 ...
 320 ---
 321 name:            store_32xs8
 322 alignment:       4
 323 tracksRegLiveness: true
 324 machineFunctionInfo: {}
 325 body:             |
 326   bb.1:
 327     liveins: $x0
 328     ; CHECK-LABEL: name: store_32xs8
 329     ; CHECK: liveins: $x0
 330     ; CHECK-NEXT: {{  $}}
 331     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(s8) = G_IMPLICIT_DEF
 332     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<16 x s8>) = G_BUILD_VECTOR [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8)
 333     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<16 x s8>) = G_BUILD_VECTOR [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8), [[DEF]](s8)
 334     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 335     ; CHECK-NEXT: G_STORE [[BUILD_VECTOR]](<16 x s8>), %ptr(p0) :: (store (<16 x s8>), align 32)
 336     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 337     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 338     ; CHECK-NEXT: G_STORE [[BUILD_VECTOR1]](<16 x s8>), [[PTR_ADD]](p0) :: (store (<16 x s8>) into unknown-address + 16)
 339     ; CHECK-NEXT: RET_ReallyLR
 340     %val:_(<32 x s8>) = G_IMPLICIT_DEF
 341     %ptr:_(p0) = COPY $x0
 342     G_STORE %val(<32 x s8>), %ptr(p0) :: (store (<32 x s8>))
 343     RET_ReallyLR
 344 ...
 345 ---
 346 name:            store_16xs16
 347 alignment:       4
 348 tracksRegLiveness: true
 349 machineFunctionInfo: {}
 350 body:             |
 351   bb.1:
 352     liveins: $x0
 353     ; CHECK-LABEL: name: store_16xs16
 354     ; CHECK: liveins: $x0
 355     ; CHECK-NEXT: {{  $}}
 356     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(s16) = G_IMPLICIT_DEF
 357     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<8 x s16>) = G_BUILD_VECTOR [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16)
 358     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<8 x s16>) = G_BUILD_VECTOR [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16), [[DEF]](s16)
 359     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 360     ; CHECK-NEXT: G_STORE [[BUILD_VECTOR]](<8 x s16>), %ptr(p0) :: (store (<8 x s16>), align 32)
 361     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 362     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 363     ; CHECK-NEXT: G_STORE [[BUILD_VECTOR1]](<8 x s16>), [[PTR_ADD]](p0) :: (store (<8 x s16>) into unknown-address + 16)
 364     ; CHECK-NEXT: RET_ReallyLR
 365     %val:_(<16 x s16>) = G_IMPLICIT_DEF
 366     %ptr:_(p0) = COPY $x0
 367     G_STORE %val(<16 x s16>), %ptr(p0) :: (store (<16 x s16>))
 368     RET_ReallyLR
 369 ...
 370 ---
 371 name:            store_8xs32
 372 alignment:       4
 373 tracksRegLiveness: true
 374 machineFunctionInfo: {}
 375 body:             |
 376   bb.1:
 377     liveins: $x0
 378     ; CHECK-LABEL: name: store_8xs32
 379     ; CHECK: liveins: $x0
 380     ; CHECK-NEXT: {{  $}}
 381     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(s32) = G_IMPLICIT_DEF
 382     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<4 x s32>) = G_BUILD_VECTOR [[DEF]](s32), [[DEF]](s32), [[DEF]](s32), [[DEF]](s32)
 383     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<4 x s32>) = G_BUILD_VECTOR [[DEF]](s32), [[DEF]](s32), [[DEF]](s32), [[DEF]](s32)
 384     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 385     ; CHECK-NEXT: G_STORE [[BUILD_VECTOR]](<4 x s32>), %ptr(p0) :: (store (<4 x s32>), align 32)
 386     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 387     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 388     ; CHECK-NEXT: G_STORE [[BUILD_VECTOR1]](<4 x s32>), [[PTR_ADD]](p0) :: (store (<4 x s32>) into unknown-address + 16)
 389     ; CHECK-NEXT: RET_ReallyLR
 390     %val:_(<8 x s32>) = G_IMPLICIT_DEF
 391     %ptr:_(p0) = COPY $x0
 392     G_STORE %val(<8 x s32>), %ptr(p0) :: (store (<8 x s32>))
 393     RET_ReallyLR
 394 ...
 395 ---
 396 name:            store_4xs64
 397 alignment:       4
 398 tracksRegLiveness: true
 399 machineFunctionInfo: {}
 400 body:             |
 401   bb.1:
 402     liveins: $x0
 403     ; CHECK-LABEL: name: store_4xs64
 404     ; CHECK: liveins: $x0
 405     ; CHECK-NEXT: {{  $}}
 406     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<2 x s64>) = G_IMPLICIT_DEF
 407     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 408     ; CHECK-NEXT: G_STORE [[DEF]](<2 x s64>), %ptr(p0) :: (store (<2 x s64>), align 32)
 409     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 410     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 411     ; CHECK-NEXT: G_STORE [[DEF]](<2 x s64>), [[PTR_ADD]](p0) :: (store (<2 x s64>) into unknown-address + 16)
 412     ; CHECK-NEXT: RET_ReallyLR
 413     %val:_(<4 x s64>) = G_IMPLICIT_DEF
 414     %ptr:_(p0) = COPY $x0
 415     G_STORE %val(<4 x s64>), %ptr(p0) :: (store (<4 x s64>))
 416     RET_ReallyLR
 417 ...
 418 ---
 419 name:            load_32xs8
 420 alignment:       4
 421 tracksRegLiveness: true
 422 machineFunctionInfo: {}
 423 body:             |
 424   bb.1:
 425     liveins: $x0
 426     ; CHECK-LABEL: name: load_32xs8
 427     ; CHECK: liveins: $x0
 428     ; CHECK-NEXT: {{  $}}
 429     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 430     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<16 x s8>) = G_LOAD %ptr(p0) :: (load (<16 x s8>), align 32)
 431     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 432     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 433     ; CHECK-NEXT: [[LOAD1:%[0-9]+]]:_(<16 x s8>) = G_LOAD [[PTR_ADD]](p0) :: (load (<16 x s8>) from unknown-address + 16)
 434     ; CHECK-NEXT: G_STORE [[LOAD]](<16 x s8>), %ptr(p0) :: (store (<16 x s8>), align 32)
 435     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 436     ; CHECK-NEXT: G_STORE [[LOAD1]](<16 x s8>), [[PTR_ADD1]](p0) :: (store (<16 x s8>) into unknown-address + 16)
 437     ; CHECK-NEXT: RET_ReallyLR
 438     %ptr:_(p0) = COPY $x0
 439     %val:_(<32 x s8>) = G_LOAD %ptr(p0) :: (load (<32 x s8>))
 440     G_STORE %val(<32 x s8>), %ptr(p0) :: (store (<32 x s8>))
 441     RET_ReallyLR
 442 ...
 443 ---
 444 name:            load_16xs16
 445 alignment:       4
 446 tracksRegLiveness: true
 447 machineFunctionInfo: {}
 448 body:             |
 449   bb.1:
 450     liveins: $x0
 451     ; CHECK-LABEL: name: load_16xs16
 452     ; CHECK: liveins: $x0
 453     ; CHECK-NEXT: {{  $}}
 454     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 455     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<8 x s16>) = G_LOAD %ptr(p0) :: (load (<8 x s16>), align 32)
 456     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 457     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 458     ; CHECK-NEXT: [[LOAD1:%[0-9]+]]:_(<8 x s16>) = G_LOAD [[PTR_ADD]](p0) :: (load (<8 x s16>) from unknown-address + 16)
 459     ; CHECK-NEXT: G_STORE [[LOAD]](<8 x s16>), %ptr(p0) :: (store (<8 x s16>), align 32)
 460     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 461     ; CHECK-NEXT: G_STORE [[LOAD1]](<8 x s16>), [[PTR_ADD1]](p0) :: (store (<8 x s16>) into unknown-address + 16)
 462     ; CHECK-NEXT: RET_ReallyLR
 463     %ptr:_(p0) = COPY $x0
 464     %val:_(<16 x s16>) = G_LOAD %ptr(p0) :: (load (<16 x s16>))
 465     G_STORE %val(<16 x s16>), %ptr(p0) :: (store (<16 x s16>))
 466     RET_ReallyLR
 467 ...
 468 ---
 469 name:            load_8xs32
 470 alignment:       4
 471 tracksRegLiveness: true
 472 machineFunctionInfo: {}
 473 body:             |
 474   bb.1:
 475     liveins: $x0
 476     ; CHECK-LABEL: name: load_8xs32
 477     ; CHECK: liveins: $x0
 478     ; CHECK-NEXT: {{  $}}
 479     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 480     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>), align 32)
 481     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 482     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 483     ; CHECK-NEXT: [[LOAD1:%[0-9]+]]:_(<4 x s32>) = G_LOAD [[PTR_ADD]](p0) :: (load (<4 x s32>) from unknown-address + 16)
 484     ; CHECK-NEXT: G_STORE [[LOAD]](<4 x s32>), %ptr(p0) :: (store (<4 x s32>), align 32)
 485     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 486     ; CHECK-NEXT: G_STORE [[LOAD1]](<4 x s32>), [[PTR_ADD1]](p0) :: (store (<4 x s32>) into unknown-address + 16)
 487     ; CHECK-NEXT: RET_ReallyLR
 488     %ptr:_(p0) = COPY $x0
 489     %val:_(<8 x s32>) = G_LOAD %ptr(p0) :: (load (<8 x s32>))
 490     G_STORE %val(<8 x s32>), %ptr(p0) :: (store (<8 x s32>))
 491     RET_ReallyLR
 492 ...
 493 ---
 494 name:            load_4xs64
 495 alignment:       4
 496 tracksRegLiveness: true
 497 machineFunctionInfo: {}
 498 body:             |
 499   bb.1:
 500     liveins: $x0
 501     ; CHECK-LABEL: name: load_4xs64
 502     ; CHECK: liveins: $x0
 503     ; CHECK-NEXT: {{  $}}
 504     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 505     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(<2 x s64>) = G_LOAD %ptr(p0) :: (load (<2 x s64>), align 32)
 506     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 507     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 508     ; CHECK-NEXT: [[LOAD1:%[0-9]+]]:_(<2 x s64>) = G_LOAD [[PTR_ADD]](p0) :: (load (<2 x s64>) from unknown-address + 16)
 509     ; CHECK-NEXT: G_STORE [[LOAD]](<2 x s64>), %ptr(p0) :: (store (<2 x s64>), align 32)
 510     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 511     ; CHECK-NEXT: G_STORE [[LOAD1]](<2 x s64>), [[PTR_ADD1]](p0) :: (store (<2 x s64>) into unknown-address + 16)
 512     ; CHECK-NEXT: RET_ReallyLR
 513     %ptr:_(p0) = COPY $x0
 514     %val:_(<4 x s64>) = G_LOAD %ptr(p0) :: (load (<4 x s64>))
 515     G_STORE %val(<4 x s64>), %ptr(p0) :: (store (<4 x s64>))
 516     RET_ReallyLR
 517 ...
 518 ---
 519 name:            test_trunc_store
 520 body: |
 521   bb.0:
 522     liveins: $x0, $w1
 523
 524     ; CHECK-LABEL: name: test_trunc_store
 525     ; CHECK: liveins: $x0, $w1
 526     ; CHECK-NEXT: {{  $}}
 527     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 528     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
 529     ; CHECK-NEXT: %val64:_(s64) = COPY $x2
 530     ; CHECK-NEXT: G_STORE [[COPY1]](s32), [[COPY]](p0) :: (store (s8))
 531     ; CHECK-NEXT: G_STORE [[COPY1]](s32), [[COPY]](p0) :: (store (s16))
 532     ; CHECK-NEXT: G_STORE %val64(s64), [[COPY]](p0) :: (store (s8))
 533     ; CHECK-NEXT: G_STORE %val64(s64), [[COPY]](p0) :: (store (s16))
 534     ; CHECK-NEXT: G_STORE %val64(s64), [[COPY]](p0) :: (store (s32))
 535     %0:_(p0) = COPY $x0
 536     %1:_(s32) = COPY $w1
 537     %2:_(s8) = G_TRUNC %1(s32)
 538     %val64:_(s64) = COPY $x2
 539     G_STORE %1(s32), %0(p0) :: (store (s8))
 540     G_STORE %1(s32), %0(p0) :: (store (s16))
 541     G_STORE %val64(s64), %0(p0) :: (store (s8))
 542     G_STORE %val64(s64), %0(p0) :: (store (s16))
 543     G_STORE %val64(s64), %0(p0) :: (store (s32))
 544 ...
 545 ---
 546 name:            store_6xs64
 547 tracksRegLiveness: true
 548 body:             |
 549   bb.1:
 550     liveins: $x0
 551     ; CHECK-LABEL: name: store_6xs64
 552     ; CHECK: liveins: $x0
 553     ; CHECK-NEXT: {{  $}}
 554     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(<2 x s64>) = G_IMPLICIT_DEF
 555     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 556     ; CHECK-NEXT: G_STORE [[DEF]](<2 x s64>), %ptr(p0) :: (store (<2 x s64>))
 557     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 558     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 559     ; CHECK-NEXT: G_STORE [[DEF]](<2 x s64>), [[PTR_ADD]](p0) :: (store (<2 x s64>) into unknown-address + 16)
 560     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 32
 561     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C1]](s64)
 562     ; CHECK-NEXT: G_STORE [[DEF]](<2 x s64>), [[PTR_ADD1]](p0) :: (store (<2 x s64>) into unknown-address + 32)
 563     ; CHECK-NEXT: RET_ReallyLR
 564     %val:_(<6 x s64>) = G_IMPLICIT_DEF
 565     %ptr:_(p0) = COPY $x0
 566     G_STORE %val(<6 x s64>), %ptr(p0) :: (store (<6 x s64>), align 16)
 567     RET_ReallyLR
 568 ...
 569 ---
 570 name:            store_2xi16
 571 tracksRegLiveness: true
 572 body:             |
 573   bb.1:
 574     liveins: $s0, $x0
 575
 576     ; CHECK-LABEL: name: store_2xi16
 577     ; CHECK: liveins: $s0, $x0
 578     ; CHECK-NEXT: {{  $}}
 579     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 580     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(<2 x s16>) = COPY $s0
 581     ; CHECK-NEXT: [[UV:%[0-9]+]]:_(s16), [[UV1:%[0-9]+]]:_(s16) = G_UNMERGE_VALUES [[COPY1]](<2 x s16>)
 582     ; CHECK-NEXT: G_STORE [[UV]](s16), [[COPY]](p0) :: (store (s16), align 4)
 583     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 2
 584     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C]](s64)
 585     ; CHECK-NEXT: G_STORE [[UV1]](s16), [[PTR_ADD]](p0) :: (store (s16) into unknown-address + 2)
 586     ; CHECK-NEXT: RET_ReallyLR
 587     %0:_(p0) = COPY $x0
 588     %1:_(<2 x s16>) = COPY $s0
 589     G_STORE %1(<2 x s16>), %0(p0) :: (store (<2 x s16>))
 590     RET_ReallyLR
 591
 592 ...
 593 ---
 594 name:            load_2xi16
 595 tracksRegLiveness: true
 596 body:             |
 597   bb.1:
 598     liveins: $s0, $x0
 599
 600     ; CHECK-LABEL: name: load_2xi16
 601     ; CHECK: liveins: $s0, $x0
 602     ; CHECK-NEXT: {{  $}}
 603     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 604     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s16) = G_LOAD [[COPY]](p0) :: (load (s16), align 4)
 605     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 2
 606     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C]](s64)
 607     ; CHECK-NEXT: [[LOAD1:%[0-9]+]]:_(s16) = G_LOAD [[PTR_ADD]](p0) :: (load (s16) from unknown-address + 2)
 608     ; CHECK-NEXT: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[LOAD]](s16)
 609     ; CHECK-NEXT: [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[LOAD1]](s16)
 610     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[ANYEXT]](s32), [[ANYEXT1]](s32)
 611     ; CHECK-NEXT: [[TRUNC:%[0-9]+]]:_(<2 x s16>) = G_TRUNC [[BUILD_VECTOR]](<2 x s32>)
 612     ; CHECK-NEXT: $s0 = COPY [[TRUNC]](<2 x s16>)
 613     ; CHECK-NEXT: RET_ReallyLR
 614     %0:_(p0) = COPY $x0
 615     %1(<2 x s16>) = G_LOAD %0(p0) :: (load (<2 x s16>))
 616     $s0 = COPY %1:_(<2 x s16>)
 617     RET_ReallyLR
 618
 619 ...
 620 ---
 621 name:            load_store_s88_s88_mem_size
 622 tracksRegLiveness: true
 623 body:             |
 624   bb.0:
 625     liveins: $x0
 626     ; CHECK-LABEL: name: load_store_s88_s88_mem_size
 627     ; CHECK: liveins: $x0
 628     ; CHECK-NEXT: {{  $}}
 629     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 630     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s64) = G_LOAD %ptr(p0) :: (load (s64), align 16)
 631     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
 632     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 8
 633     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C1]](s64)
 634     ; CHECK-NEXT: [[ZEXTLOAD:%[0-9]+]]:_(s64) = G_ZEXTLOAD [[PTR_ADD]](p0) :: (load (s16) from unknown-address + 8, align 8)
 635     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 2
 636     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD [[PTR_ADD]], [[C2]](s64)
 637     ; CHECK-NEXT: [[LOAD1:%[0-9]+]]:_(s32) = G_LOAD [[PTR_ADD1]](p0) :: (load (s8) from unknown-address + 10, align 2)
 638     ; CHECK-NEXT: [[DEF:%[0-9]+]]:_(s32) = G_IMPLICIT_DEF
 639     ; CHECK-NEXT: [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[LOAD1]](s32), [[DEF]](s32)
 640     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 641     ; CHECK-NEXT: [[SHL:%[0-9]+]]:_(s64) = G_SHL [[MV]], [[C3]](s64)
 642     ; CHECK-NEXT: [[OR:%[0-9]+]]:_(s64) = G_OR [[SHL]], [[ZEXTLOAD]]
 643     ; CHECK-NEXT: [[OR1:%[0-9]+]]:_(s64) = G_OR [[C]], [[LOAD]]
 644     ; CHECK-NEXT: [[OR2:%[0-9]+]]:_(s64) = G_OR [[OR]], [[C]]
 645     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s64) = COPY [[OR1]](s64)
 646     ; CHECK-NEXT: [[TRUNC:%[0-9]+]]:_(s32) = G_TRUNC [[OR2]](s64)
 647     ; CHECK-NEXT: G_STORE [[COPY]](s64), %ptr(p0) :: (store (s64), align 16)
 648     ; CHECK-NEXT: [[PTR_ADD2:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C1]](s64)
 649     ; CHECK-NEXT: [[LSHR:%[0-9]+]]:_(s32) = G_LSHR [[TRUNC]], [[C3]](s64)
 650     ; CHECK-NEXT: [[PTR_ADD3:%[0-9]+]]:_(p0) = G_PTR_ADD [[PTR_ADD2]], [[C2]](s64)
 651     ; CHECK-NEXT: G_STORE [[TRUNC]](s32), [[PTR_ADD2]](p0) :: (store (s16) into unknown-address + 8, align 8)
 652     ; CHECK-NEXT: G_STORE [[LSHR]](s32), [[PTR_ADD3]](p0) :: (store (s8) into unknown-address + 10, align 2)
 653     ; CHECK-NEXT: RET_ReallyLR
 654     %ptr:_(p0) = COPY $x0
 655     %load:_(s88) = G_LOAD %ptr(p0) :: (load (s88))
 656     G_STORE %load(s88), %ptr(p0) :: (store (s88))
 657     RET_ReallyLR
 658 ...
 659 ---
 660 name:            load_store_s88_s64_mem_size
 661 tracksRegLiveness: true
 662 body:             |
 663   bb.0:
 664     liveins: $x0
 665     ; CHECK-LABEL: name: load_store_s88_s64_mem_size
 666     ; CHECK: liveins: $x0
 667     ; CHECK-NEXT: {{  $}}
 668     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 669     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s64) = G_LOAD %ptr(p0) :: (load (s64))
 670     ; CHECK-NEXT: G_STORE [[LOAD]](s64), %ptr(p0) :: (store (s64))
 671     ; CHECK-NEXT: RET_ReallyLR
 672     %ptr:_(p0) = COPY $x0
 673     %load:_(s88) = G_LOAD %ptr(p0) :: (load (s64))
 674     G_STORE %load(s88), %ptr(p0) :: (store (s64))
 675     RET_ReallyLR
 676 ...
 677 ---
 678 name:            load_s1
 679 alignment:       4
 680 tracksRegLiveness: true
 681 machineFunctionInfo: {}
 682 body:             |
 683   bb.1:
 684     liveins: $x0
 685     ; CHECK-LABEL: name: load_s1
 686     ; CHECK: liveins: $x0
 687     ; CHECK-NEXT: {{  $}}
 688     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 689     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s8) = G_LOAD %ptr(p0) :: (load (s8))
 690     ; CHECK-NEXT: [[ASSERT_ZEXT:%[0-9]+]]:_(s8) = G_ASSERT_ZEXT [[LOAD]], 1
 691     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 1
 692     ; CHECK-NEXT: [[ANYEXT:%[0-9]+]]:_(s64) = G_ANYEXT [[ASSERT_ZEXT]](s8)
 693     ; CHECK-NEXT: %ext:_(s64) = G_AND [[ANYEXT]], [[C]]
 694     ; CHECK-NEXT: $x0 = COPY %ext(s64)
 695     ; CHECK-NEXT: RET_ReallyLR implicit $x0
 696     %ptr:_(p0) = COPY $x0
 697     %load:_(s1) = G_LOAD %ptr(p0) :: (load (s1))
 698     %ext:_(s64) = G_ZEXT %load
 699     $x0 = COPY %ext
 700     RET_ReallyLR implicit $x0
 701 ...
 702 ---
 703 name:            load_store_6xp0
 704 alignment:       4
 705 tracksRegLiveness: true
 706 machineFunctionInfo: {}
 707 body:             |
 708   bb.1:
 709     liveins: $x0
 710     ; CHECK-LABEL: name: load_store_6xp0
 711     ; CHECK: liveins: $x0
 712     ; CHECK-NEXT: {{  $}}
 713     ; CHECK-NEXT: %ptr:_(p0) = COPY $x0
 714     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(p0) = G_LOAD %ptr(p0) :: (load (p0), align 64)
 715     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 8
 716     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C]](s64)
 717     ; CHECK-NEXT: [[LOAD1:%[0-9]+]]:_(p0) = G_LOAD [[PTR_ADD]](p0) :: (load (p0) from unknown-address + 8)
 718     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 16
 719     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C1]](s64)
 720     ; CHECK-NEXT: [[LOAD2:%[0-9]+]]:_(p0) = G_LOAD [[PTR_ADD1]](p0) :: (load (p0) from unknown-address + 16, align 16)
 721     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 24
 722     ; CHECK-NEXT: [[PTR_ADD2:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C2]](s64)
 723     ; CHECK-NEXT: [[LOAD3:%[0-9]+]]:_(p0) = G_LOAD [[PTR_ADD2]](p0) :: (load (p0) from unknown-address + 24)
 724     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s64) = G_CONSTANT i64 32
 725     ; CHECK-NEXT: [[PTR_ADD3:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C3]](s64)
 726     ; CHECK-NEXT: [[LOAD4:%[0-9]+]]:_(p0) = G_LOAD [[PTR_ADD3]](p0) :: (load (p0) from unknown-address + 32, align 32)
 727     ; CHECK-NEXT: [[C4:%[0-9]+]]:_(s64) = G_CONSTANT i64 40
 728     ; CHECK-NEXT: [[PTR_ADD4:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C4]](s64)
 729     ; CHECK-NEXT: [[LOAD5:%[0-9]+]]:_(p0) = G_LOAD [[PTR_ADD4]](p0) :: (load (p0) from unknown-address + 40)
 730     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x p0>) = G_BUILD_VECTOR [[LOAD]](p0), [[LOAD1]](p0)
 731     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<2 x p0>) = G_BUILD_VECTOR [[LOAD2]](p0), [[LOAD3]](p0)
 732     ; CHECK-NEXT: [[BUILD_VECTOR2:%[0-9]+]]:_(<2 x p0>) = G_BUILD_VECTOR [[LOAD4]](p0), [[LOAD5]](p0)
 733     ; CHECK-NEXT: [[BITCAST:%[0-9]+]]:_(<2 x s64>) = G_BITCAST [[BUILD_VECTOR]](<2 x p0>)
 734     ; CHECK-NEXT: G_STORE [[BITCAST]](<2 x s64>), %ptr(p0) :: (store (<2 x s64>), align 64)
 735     ; CHECK-NEXT: [[PTR_ADD5:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C1]](s64)
 736     ; CHECK-NEXT: [[BITCAST1:%[0-9]+]]:_(<2 x s64>) = G_BITCAST [[BUILD_VECTOR1]](<2 x p0>)
 737     ; CHECK-NEXT: G_STORE [[BITCAST1]](<2 x s64>), [[PTR_ADD5]](p0) :: (store (<2 x s64>) into unknown-address + 16)
 738     ; CHECK-NEXT: [[PTR_ADD6:%[0-9]+]]:_(p0) = G_PTR_ADD %ptr, [[C3]](s64)
 739     ; CHECK-NEXT: [[BITCAST2:%[0-9]+]]:_(<2 x s64>) = G_BITCAST [[BUILD_VECTOR2]](<2 x p0>)
 740     ; CHECK-NEXT: G_STORE [[BITCAST2]](<2 x s64>), [[PTR_ADD6]](p0) :: (store (<2 x s64>) into unknown-address + 32, align 32)
 741     ; CHECK-NEXT: RET_ReallyLR
 742     %ptr:_(p0) = COPY $x0
 743     %val:_(<6 x p0>) = G_LOAD %ptr(p0) :: (load (<6 x p0>))
 744     G_STORE %val(<6 x p0>), %ptr(p0) :: (store (<6 x p0>))
 745     RET_ReallyLR