llvm/test/CodeGen/AArch64/GlobalISel/store-merging.mir

   1 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
   2 # RUN: llc -mtriple=aarch64-- -run-pass=loadstore-opt -verify-machineinstrs %s -o - | FileCheck %s
   3 --- |
   4   target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
   5   target triple = "aarch64"
   6
   7   define void @test_simple_2xs8(i8* %ptr) {
   8     %addr11 = bitcast i8* %ptr to i8*
   9     store i8 4, i8* %addr11, align 1
  10     %addr2 = getelementptr i8, i8* %ptr, i64 1
  11     store i8 5, i8* %addr2, align 1
  12     ret void
  13   }
  14
  15   define void @test_simple_2xs16(i16* %ptr) {
  16     %addr11 = bitcast i16* %ptr to i16*
  17     store i16 4, i16* %addr11, align 2
  18     %addr2 = getelementptr i16, i16* %ptr, i64 1
  19     store i16 5, i16* %addr2, align 2
  20     ret void
  21   }
  22
  23   define void @test_simple_4xs16(i16* %ptr) {
  24     %addr11 = bitcast i16* %ptr to i16*
  25     store i16 4, i16* %addr11, align 2
  26     %addr2 = getelementptr i16, i16* %ptr, i64 1
  27     store i16 5, i16* %addr2, align 2
  28     %addr3 = getelementptr i16, i16* %ptr, i64 2
  29     store i16 9, i16* %addr3, align 2
  30     %addr4 = getelementptr i16, i16* %ptr, i64 3
  31     store i16 14, i16* %addr4, align 2
  32     ret void
  33   }
  34
  35   define void @test_simple_2xs32(i32* %ptr) {
  36     %addr11 = bitcast i32* %ptr to i32*
  37     store i32 4, i32* %addr11, align 4
  38     %addr2 = getelementptr i32, i32* %ptr, i64 1
  39     store i32 5, i32* %addr2, align 4
  40     ret void
  41   }
  42
  43   define void @test_simple_2xs64_illegal(i64* %ptr) {
  44     %addr11 = bitcast i64* %ptr to i64*
  45     store i64 4, i64* %addr11, align 8
  46     %addr2 = getelementptr i64, i64* %ptr, i64 1
  47     store i64 5, i64* %addr2, align 8
  48     ret void
  49   }
  50
  51   define void @test_simple_vector(<2 x i16>* %ptr) {
  52     %addr11 = bitcast <2 x i16>* %ptr to <2 x i16>*
  53     store <2 x i16> <i16 4, i16 7>, <2 x i16>* %addr11, align 4
  54     %addr2 = getelementptr <2 x i16>, <2 x i16>* %ptr, i64 1
  55     store <2 x i16> <i16 5, i16 8>, <2 x i16>* %addr2, align 4
  56     ret void
  57   }
  58
  59   define i32 @test_unknown_alias(i32* %ptr, i32* %aliasptr) {
  60     %addr11 = bitcast i32* %ptr to i32*
  61     store i32 4, i32* %addr11, align 4
  62     %ld = load i32, i32* %aliasptr, align 4
  63     %addr2 = getelementptr i32, i32* %ptr, i64 1
  64     store i32 5, i32* %addr2, align 4
  65     ret i32 %ld
  66   }
  67
  68   define void @test_2x_2xs32(i32* %ptr, i32* %ptr2) {
  69     %addr11 = bitcast i32* %ptr to i32*
  70     store i32 4, i32* %addr11, align 4
  71     %addr2 = getelementptr i32, i32* %ptr, i64 1
  72     store i32 5, i32* %addr2, align 4
  73     %addr32 = bitcast i32* %ptr2 to i32*
  74     store i32 9, i32* %addr32, align 4
  75     %addr4 = getelementptr i32, i32* %ptr2, i64 1
  76     store i32 17, i32* %addr4, align 4
  77     ret void
  78   }
  79
  80   define void @test_simple_var_2xs8(i8* %ptr, i8 %v1, i8 %v2) {
  81     %addr11 = bitcast i8* %ptr to i8*
  82     store i8 %v1, i8* %addr11, align 1
  83     %addr2 = getelementptr i8, i8* %ptr, i64 1
  84     store i8 %v2, i8* %addr2, align 1
  85     ret void
  86   }
  87
  88   define void @test_simple_var_2xs16(i16* %ptr, i16 %v1, i16 %v2) {
  89     %addr11 = bitcast i16* %ptr to i16*
  90     store i16 %v1, i16* %addr11, align 2
  91     %addr2 = getelementptr i16, i16* %ptr, i64 1
  92     store i16 %v2, i16* %addr2, align 2
  93     ret void
  94   }
  95
  96   define void @test_simple_var_2xs32(i32* %ptr, i32 %v1, i32 %v2) {
  97     %addr11 = bitcast i32* %ptr to i32*
  98     store i32 %v1, i32* %addr11, align 4
  99     %addr2 = getelementptr i32, i32* %ptr, i64 1
 100     store i32 %v2, i32* %addr2, align 4
 101     ret void
 102   }
 103
 104   define void @test_alias_4xs16(i16* %ptr, i16* %ptr2) {
 105     %addr11 = bitcast i16* %ptr to i16*
 106     store i16 4, i16* %addr11, align 2
 107     %addr2 = getelementptr i16, i16* %ptr, i64 1
 108     store i16 5, i16* %addr2, align 2
 109     %addr3 = getelementptr i16, i16* %ptr, i64 2
 110     store i16 9, i16* %addr3, align 2
 111     store i16 0, i16* %ptr2, align 2
 112     %addr4 = getelementptr i16, i16* %ptr, i64 3
 113     store i16 14, i16* %addr4, align 2
 114     ret void
 115   }
 116
 117   define void @test_alias2_4xs16(i16* %ptr, i16* %ptr2, i16* %ptr3) {
 118     %addr11 = bitcast i16* %ptr to i16*
 119     store i16 4, i16* %addr11, align 2
 120     %addr2 = getelementptr i16, i16* %ptr, i64 1
 121     store i16 0, i16* %ptr3, align 2
 122     store i16 5, i16* %addr2, align 2
 123     %addr3 = getelementptr i16, i16* %ptr, i64 2
 124     store i16 9, i16* %addr3, align 2
 125     store i16 0, i16* %ptr2, align 2
 126     %addr4 = getelementptr i16, i16* %ptr, i64 3
 127     store i16 14, i16* %addr4, align 2
 128     ret void
 129   }
 130
 131   define void @test_alias3_4xs16(i16* %ptr, i16* %ptr2, i16* %ptr3, i16* %ptr4) {
 132     %addr11 = bitcast i16* %ptr to i16*
 133     store i16 4, i16* %addr11, align 2
 134     %addr2 = getelementptr i16, i16* %ptr, i64 1
 135     store i16 0, i16* %ptr3, align 2
 136     store i16 5, i16* %addr2, align 2
 137     store i16 0, i16* %ptr4, align 2
 138     %addr3 = getelementptr i16, i16* %ptr, i64 2
 139     store i16 9, i16* %addr3, align 2
 140     store i16 0, i16* %ptr2, align 2
 141     %addr4 = getelementptr i16, i16* %ptr, i64 3
 142     store i16 14, i16* %addr4, align 2
 143     ret void
 144   }
 145
 146   define i32 @test_alias_allocas_2xs32(i32* %ptr) {
 147     %a1 = alloca [6 x i32], align 4
 148     %a2 = alloca i32, align 4
 149     %addr11 = bitcast [6 x i32]* %a1 to i32*
 150     store i32 4, i32* %addr11, align 4
 151     %ld = load i32, i32* %a2, align 4
 152     %addr2 = getelementptr [6 x i32], [6 x i32]* %a1, i64 0, i32 1
 153     store i32 5, i32* %addr2, align 4
 154     ret i32 %ld
 155   }
 156
 157   define void @test_simple_2xs32_with_align(i32* %ptr) {
 158     %addr11 = bitcast i32* %ptr to i32*
 159     store i32 4, i32* %addr11, align 4
 160     %addr2 = getelementptr i32, i32* %ptr, i64 1
 161     store i32 5, i32* %addr2, align 4
 162     ret void
 163   }
 164
 165 ...
 166 ---
 167 name:            test_simple_2xs8
 168 alignment:       4
 169 tracksRegLiveness: true
 170 liveins:
 171   - { reg: '$x0' }
 172 frameInfo:
 173   maxAlignment:    1
 174 machineFunctionInfo: {}
 175 body:             |
 176   bb.1 (%ir-block.0):
 177     liveins: $x0
 178
 179     ; CHECK-LABEL: name: test_simple_2xs8
 180     ; CHECK: liveins: $x0
 181     ; CHECK-NEXT: {{  $}}
 182     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 183     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s8) = G_CONSTANT i8 4
 184     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s8) = G_CONSTANT i8 5
 185     ; CHECK-NEXT: G_STORE [[C]](s8), [[COPY]](p0) :: (store (s8) into %ir.addr11)
 186     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 1
 187     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C2]](s64)
 188     ; CHECK-NEXT: G_STORE [[C1]](s8), [[PTR_ADD]](p0) :: (store (s8) into %ir.addr2)
 189     ; CHECK-NEXT: RET_ReallyLR
 190     %0:_(p0) = COPY $x0
 191     %1:_(s8) = G_CONSTANT i8 4
 192     %4:_(s8) = G_CONSTANT i8 5
 193     G_STORE %1(s8), %0(p0) :: (store (s8) into %ir.addr11)
 194     %2:_(s64) = G_CONSTANT i64 1
 195     %3:_(p0) = G_PTR_ADD %0, %2(s64)
 196     G_STORE %4(s8), %3(p0) :: (store (s8) into %ir.addr2)
 197     RET_ReallyLR
 198
 199 ...
 200 ---
 201 name:            test_simple_2xs16
 202 alignment:       4
 203 tracksRegLiveness: true
 204 liveins:
 205   - { reg: '$x0' }
 206 frameInfo:
 207   maxAlignment:    1
 208 machineFunctionInfo: {}
 209 body:             |
 210   bb.1 (%ir-block.0):
 211     liveins: $x0
 212
 213     ; CHECK-LABEL: name: test_simple_2xs16
 214     ; CHECK: liveins: $x0
 215     ; CHECK-NEXT: {{  $}}
 216     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 217     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 327684
 218     ; CHECK-NEXT: G_STORE [[C]](s32), [[COPY]](p0) :: (store (s32) into %ir.addr11, align 2)
 219     ; CHECK-NEXT: RET_ReallyLR
 220     %0:_(p0) = COPY $x0
 221     %1:_(s16) = G_CONSTANT i16 4
 222     %4:_(s16) = G_CONSTANT i16 5
 223     G_STORE %1(s16), %0(p0) :: (store (s16) into %ir.addr11)
 224     %2:_(s64) = G_CONSTANT i64 2
 225     %3:_(p0) = G_PTR_ADD %0, %2(s64)
 226     G_STORE %4(s16), %3(p0) :: (store (s16) into %ir.addr2)
 227     RET_ReallyLR
 228
 229 ...
 230 ---
 231 name:            test_simple_4xs16
 232 alignment:       4
 233 tracksRegLiveness: true
 234 liveins:
 235   - { reg: '$x0' }
 236 frameInfo:
 237   maxAlignment:    1
 238 machineFunctionInfo: {}
 239 body:             |
 240   bb.1 (%ir-block.0):
 241     liveins: $x0
 242
 243     ; CHECK-LABEL: name: test_simple_4xs16
 244     ; CHECK: liveins: $x0
 245     ; CHECK-NEXT: {{  $}}
 246     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 247     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 3940688328982532
 248     ; CHECK-NEXT: G_STORE [[C]](s64), [[COPY]](p0) :: (store (s64) into %ir.addr11, align 2)
 249     ; CHECK-NEXT: RET_ReallyLR
 250     %0:_(p0) = COPY $x0
 251     %1:_(s16) = G_CONSTANT i16 4
 252     %4:_(s16) = G_CONSTANT i16 5
 253     %7:_(s16) = G_CONSTANT i16 9
 254     %10:_(s16) = G_CONSTANT i16 14
 255     G_STORE %1(s16), %0(p0) :: (store (s16) into %ir.addr11)
 256     %2:_(s64) = G_CONSTANT i64 2
 257     %3:_(p0) = G_PTR_ADD %0, %2(s64)
 258     G_STORE %4(s16), %3(p0) :: (store (s16) into %ir.addr2)
 259     %5:_(s64) = G_CONSTANT i64 4
 260     %6:_(p0) = G_PTR_ADD %0, %5(s64)
 261     G_STORE %7(s16), %6(p0) :: (store (s16) into %ir.addr3)
 262     %8:_(s64) = G_CONSTANT i64 6
 263     %9:_(p0) = G_PTR_ADD %0, %8(s64)
 264     G_STORE %10(s16), %9(p0) :: (store (s16) into %ir.addr4)
 265     RET_ReallyLR
 266
 267 ...
 268 ---
 269 name:            test_simple_2xs32
 270 alignment:       4
 271 tracksRegLiveness: true
 272 liveins:
 273   - { reg: '$x0' }
 274 frameInfo:
 275   maxAlignment:    1
 276 machineFunctionInfo: {}
 277 body:             |
 278   bb.1 (%ir-block.0):
 279     liveins: $x0
 280
 281     ; CHECK-LABEL: name: test_simple_2xs32
 282     ; CHECK: liveins: $x0
 283     ; CHECK-NEXT: {{  $}}
 284     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 285     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 21474836484
 286     ; CHECK-NEXT: G_STORE [[C]](s64), [[COPY]](p0) :: (store (s64) into %ir.addr11, align 4)
 287     ; CHECK-NEXT: RET_ReallyLR
 288     %0:_(p0) = COPY $x0
 289     %1:_(s32) = G_CONSTANT i32 4
 290     %4:_(s32) = G_CONSTANT i32 5
 291     G_STORE %1(s32), %0(p0) :: (store (s32) into %ir.addr11)
 292     %2:_(s64) = G_CONSTANT i64 4
 293     %3:_(p0) = G_PTR_ADD %0, %2(s64)
 294     G_STORE %4(s32), %3(p0) :: (store (s32) into %ir.addr2)
 295     RET_ReallyLR
 296
 297 ...
 298 ---
 299 name:            test_simple_2xs64_illegal
 300 alignment:       4
 301 tracksRegLiveness: true
 302 liveins:
 303   - { reg: '$x0' }
 304 frameInfo:
 305   maxAlignment:    1
 306 machineFunctionInfo: {}
 307 body:             |
 308   bb.1 (%ir-block.0):
 309     liveins: $x0
 310
 311     ; CHECK-LABEL: name: test_simple_2xs64_illegal
 312     ; CHECK: liveins: $x0
 313     ; CHECK-NEXT: {{  $}}
 314     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 315     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
 316     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 5
 317     ; CHECK-NEXT: G_STORE [[C]](s64), [[COPY]](p0) :: (store (s64) into %ir.addr11)
 318     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 8
 319     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C2]](s64)
 320     ; CHECK-NEXT: G_STORE [[C1]](s64), [[PTR_ADD]](p0) :: (store (s64) into %ir.addr2)
 321     ; CHECK-NEXT: RET_ReallyLR
 322     %0:_(p0) = COPY $x0
 323     %1:_(s64) = G_CONSTANT i64 4
 324     %4:_(s64) = G_CONSTANT i64 5
 325     G_STORE %1(s64), %0(p0) :: (store (s64) into %ir.addr11)
 326     %2:_(s64) = G_CONSTANT i64 8
 327     %3:_(p0) = G_PTR_ADD %0, %2(s64)
 328     G_STORE %4(s64), %3(p0) :: (store (s64) into %ir.addr2)
 329     RET_ReallyLR
 330
 331 ...
 332 ---
 333 name:            test_simple_vector
 334 alignment:       4
 335 tracksRegLiveness: true
 336 liveins:
 337   - { reg: '$x0' }
 338 frameInfo:
 339   maxAlignment:    1
 340 machineFunctionInfo: {}
 341 body:             |
 342   bb.1 (%ir-block.0):
 343     liveins: $x0
 344
 345     ; CHECK-LABEL: name: test_simple_vector
 346     ; CHECK: liveins: $x0
 347     ; CHECK-NEXT: {{  $}}
 348     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 349     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s16) = G_CONSTANT i16 4
 350     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s16) = G_CONSTANT i16 7
 351     ; CHECK-NEXT: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s16>) = G_BUILD_VECTOR [[C]](s16), [[C1]](s16)
 352     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s16) = G_CONSTANT i16 5
 353     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 8
 354     ; CHECK-NEXT: [[BUILD_VECTOR1:%[0-9]+]]:_(<2 x s16>) = G_BUILD_VECTOR [[C2]](s16), [[C3]](s16)
 355     ; CHECK-NEXT: G_STORE [[BUILD_VECTOR]](<2 x s16>), [[COPY]](p0) :: (store (<2 x s16>) into %ir.addr11)
 356     ; CHECK-NEXT: [[C4:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
 357     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C4]](s64)
 358     ; CHECK-NEXT: G_STORE [[BUILD_VECTOR1]](<2 x s16>), [[PTR_ADD]](p0) :: (store (<2 x s16>) into %ir.addr2)
 359     ; CHECK-NEXT: RET_ReallyLR
 360     %0:_(p0) = COPY $x0
 361     %2:_(s16) = G_CONSTANT i16 4
 362     %3:_(s16) = G_CONSTANT i16 7
 363     %1:_(<2 x s16>) = G_BUILD_VECTOR %2(s16), %3(s16)
 364     %7:_(s16) = G_CONSTANT i16 5
 365     %8:_(s16) = G_CONSTANT i16 8
 366     %6:_(<2 x s16>) = G_BUILD_VECTOR %7(s16), %8(s16)
 367     G_STORE %1(<2 x s16>), %0(p0) :: (store (<2 x s16>) into %ir.addr11)
 368     %4:_(s64) = G_CONSTANT i64 4
 369     %5:_(p0) = G_PTR_ADD %0, %4(s64)
 370     G_STORE %6(<2 x s16>), %5(p0) :: (store (<2 x s16>) into %ir.addr2)
 371     RET_ReallyLR
 372
 373 ...
 374 ---
 375 name:            test_unknown_alias
 376 alignment:       4
 377 tracksRegLiveness: true
 378 liveins:
 379   - { reg: '$x0' }
 380   - { reg: '$x1' }
 381 frameInfo:
 382   maxAlignment:    1
 383 machineFunctionInfo: {}
 384 body:             |
 385   bb.1 (%ir-block.0):
 386     liveins: $x0, $x1
 387
 388     ; CHECK-LABEL: name: test_unknown_alias
 389     ; CHECK: liveins: $x0, $x1
 390     ; CHECK-NEXT: {{  $}}
 391     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 392     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x1
 393     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
 394     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 5
 395     ; CHECK-NEXT: G_STORE [[C]](s32), [[COPY]](p0) :: (store (s32) into %ir.addr11)
 396     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s32) = G_LOAD [[COPY1]](p0) :: (load (s32) from %ir.aliasptr)
 397     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
 398     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C2]](s64)
 399     ; CHECK-NEXT: G_STORE [[C1]](s32), [[PTR_ADD]](p0) :: (store (s32) into %ir.addr2)
 400     ; CHECK-NEXT: $w0 = COPY [[LOAD]](s32)
 401     ; CHECK-NEXT: RET_ReallyLR implicit $w0
 402     %0:_(p0) = COPY $x0
 403     %1:_(p0) = COPY $x1
 404     %2:_(s32) = G_CONSTANT i32 4
 405     %6:_(s32) = G_CONSTANT i32 5
 406     G_STORE %2(s32), %0(p0) :: (store (s32) into %ir.addr11)
 407     %3:_(s32) = G_LOAD %1(p0) :: (load (s32) from %ir.aliasptr)
 408     %4:_(s64) = G_CONSTANT i64 4
 409     %5:_(p0) = G_PTR_ADD %0, %4(s64)
 410     G_STORE %6(s32), %5(p0) :: (store (s32) into %ir.addr2)
 411     $w0 = COPY %3(s32)
 412     RET_ReallyLR implicit $w0
 413
 414 ...
 415 ---
 416 name:            test_2x_2xs32
 417 alignment:       4
 418 tracksRegLiveness: true
 419 liveins:
 420   - { reg: '$x0' }
 421   - { reg: '$x1' }
 422 frameInfo:
 423   maxAlignment:    1
 424 machineFunctionInfo: {}
 425 body:             |
 426   bb.1 (%ir-block.0):
 427     liveins: $x0, $x1
 428
 429     ; CHECK-LABEL: name: test_2x_2xs32
 430     ; CHECK: liveins: $x0, $x1
 431     ; CHECK-NEXT: {{  $}}
 432     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 433     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x1
 434     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
 435     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 5
 436     ; CHECK-NEXT: G_STORE [[C]](s32), [[COPY]](p0) :: (store (s32) into %ir.addr11)
 437     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
 438     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C2]](s64)
 439     ; CHECK-NEXT: G_STORE [[C1]](s32), [[PTR_ADD]](p0) :: (store (s32) into %ir.addr2)
 440     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s64) = G_CONSTANT i64 73014444041
 441     ; CHECK-NEXT: G_STORE [[C3]](s64), [[COPY1]](p0) :: (store (s64) into %ir.addr32, align 4)
 442     ; CHECK-NEXT: RET_ReallyLR
 443     %0:_(p0) = COPY $x0
 444     %1:_(p0) = COPY $x1
 445     %2:_(s32) = G_CONSTANT i32 4
 446     %5:_(s32) = G_CONSTANT i32 5
 447     %6:_(s32) = G_CONSTANT i32 9
 448     %8:_(s32) = G_CONSTANT i32 17
 449     G_STORE %2(s32), %0(p0) :: (store (s32) into %ir.addr11)
 450     %3:_(s64) = G_CONSTANT i64 4
 451     %4:_(p0) = G_PTR_ADD %0, %3(s64)
 452     G_STORE %5(s32), %4(p0) :: (store (s32) into %ir.addr2)
 453     G_STORE %6(s32), %1(p0) :: (store (s32) into %ir.addr32)
 454     %7:_(p0) = G_PTR_ADD %1, %3(s64)
 455     G_STORE %8(s32), %7(p0) :: (store (s32) into %ir.addr4)
 456     RET_ReallyLR
 457
 458 ...
 459 ---
 460 name:            test_simple_var_2xs8
 461 alignment:       4
 462 tracksRegLiveness: true
 463 liveins:
 464   - { reg: '$x0' }
 465   - { reg: '$w1' }
 466   - { reg: '$w2' }
 467 frameInfo:
 468   maxAlignment:    1
 469 machineFunctionInfo: {}
 470 body:             |
 471   bb.1 (%ir-block.0):
 472     liveins: $w1, $w2, $x0
 473
 474     ; CHECK-LABEL: name: test_simple_var_2xs8
 475     ; CHECK: liveins: $w1, $w2, $x0
 476     ; CHECK-NEXT: {{  $}}
 477     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 478     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
 479     ; CHECK-NEXT: [[TRUNC:%[0-9]+]]:_(s8) = G_TRUNC [[COPY1]](s32)
 480     ; CHECK-NEXT: [[COPY2:%[0-9]+]]:_(s32) = COPY $w2
 481     ; CHECK-NEXT: [[TRUNC1:%[0-9]+]]:_(s8) = G_TRUNC [[COPY2]](s32)
 482     ; CHECK-NEXT: G_STORE [[TRUNC]](s8), [[COPY]](p0) :: (store (s8) into %ir.addr11)
 483     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 1
 484     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C]](s64)
 485     ; CHECK-NEXT: G_STORE [[TRUNC1]](s8), [[PTR_ADD]](p0) :: (store (s8) into %ir.addr2)
 486     ; CHECK-NEXT: RET_ReallyLR
 487     %0:_(p0) = COPY $x0
 488     %3:_(s32) = COPY $w1
 489     %1:_(s8) = G_TRUNC %3(s32)
 490     %4:_(s32) = COPY $w2
 491     %2:_(s8) = G_TRUNC %4(s32)
 492     G_STORE %1(s8), %0(p0) :: (store (s8) into %ir.addr11)
 493     %5:_(s64) = G_CONSTANT i64 1
 494     %6:_(p0) = G_PTR_ADD %0, %5(s64)
 495     G_STORE %2(s8), %6(p0) :: (store (s8) into %ir.addr2)
 496     RET_ReallyLR
 497
 498 ...
 499 ---
 500 name:            test_simple_var_2xs16
 501 alignment:       4
 502 tracksRegLiveness: true
 503 liveins:
 504   - { reg: '$x0' }
 505   - { reg: '$w1' }
 506   - { reg: '$w2' }
 507 frameInfo:
 508   maxAlignment:    1
 509 machineFunctionInfo: {}
 510 body:             |
 511   bb.1 (%ir-block.0):
 512     liveins: $w1, $w2, $x0
 513
 514     ; CHECK-LABEL: name: test_simple_var_2xs16
 515     ; CHECK: liveins: $w1, $w2, $x0
 516     ; CHECK-NEXT: {{  $}}
 517     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 518     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
 519     ; CHECK-NEXT: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY1]](s32)
 520     ; CHECK-NEXT: [[COPY2:%[0-9]+]]:_(s32) = COPY $w2
 521     ; CHECK-NEXT: [[TRUNC1:%[0-9]+]]:_(s16) = G_TRUNC [[COPY2]](s32)
 522     ; CHECK-NEXT: G_STORE [[TRUNC]](s16), [[COPY]](p0) :: (store (s16) into %ir.addr11)
 523     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 2
 524     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C]](s64)
 525     ; CHECK-NEXT: G_STORE [[TRUNC1]](s16), [[PTR_ADD]](p0) :: (store (s16) into %ir.addr2)
 526     ; CHECK-NEXT: RET_ReallyLR
 527     %0:_(p0) = COPY $x0
 528     %3:_(s32) = COPY $w1
 529     %1:_(s16) = G_TRUNC %3(s32)
 530     %4:_(s32) = COPY $w2
 531     %2:_(s16) = G_TRUNC %4(s32)
 532     G_STORE %1(s16), %0(p0) :: (store (s16) into %ir.addr11)
 533     %5:_(s64) = G_CONSTANT i64 2
 534     %6:_(p0) = G_PTR_ADD %0, %5(s64)
 535     G_STORE %2(s16), %6(p0) :: (store (s16) into %ir.addr2)
 536     RET_ReallyLR
 537
 538 ...
 539 ---
 540 name:            test_simple_var_2xs32
 541 alignment:       4
 542 tracksRegLiveness: true
 543 liveins:
 544   - { reg: '$x0' }
 545   - { reg: '$w1' }
 546   - { reg: '$w2' }
 547 frameInfo:
 548   maxAlignment:    1
 549 machineFunctionInfo: {}
 550 body:             |
 551   bb.1 (%ir-block.0):
 552     liveins: $w1, $w2, $x0
 553
 554     ; CHECK-LABEL: name: test_simple_var_2xs32
 555     ; CHECK: liveins: $w1, $w2, $x0
 556     ; CHECK-NEXT: {{  $}}
 557     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 558     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
 559     ; CHECK-NEXT: [[COPY2:%[0-9]+]]:_(s32) = COPY $w2
 560     ; CHECK-NEXT: G_STORE [[COPY1]](s32), [[COPY]](p0) :: (store (s32) into %ir.addr11)
 561     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
 562     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C]](s64)
 563     ; CHECK-NEXT: G_STORE [[COPY2]](s32), [[PTR_ADD]](p0) :: (store (s32) into %ir.addr2)
 564     ; CHECK-NEXT: RET_ReallyLR
 565     %0:_(p0) = COPY $x0
 566     %1:_(s32) = COPY $w1
 567     %2:_(s32) = COPY $w2
 568     G_STORE %1(s32), %0(p0) :: (store (s32) into %ir.addr11)
 569     %3:_(s64) = G_CONSTANT i64 4
 570     %4:_(p0) = G_PTR_ADD %0, %3(s64)
 571     G_STORE %2(s32), %4(p0) :: (store (s32) into %ir.addr2)
 572     RET_ReallyLR
 573
 574 ...
 575 ---
 576 name:            test_alias_4xs16
 577 alignment:       4
 578 tracksRegLiveness: true
 579 liveins:
 580   - { reg: '$x0' }
 581   - { reg: '$x1' }
 582 frameInfo:
 583   maxAlignment:    1
 584 machineFunctionInfo: {}
 585 body:             |
 586   bb.1 (%ir-block.0):
 587     liveins: $x0, $x1
 588
 589     ; The store to ptr2 prevents merging into a single store.
 590     ; We can still merge the stores into addr1 and addr2.
 591
 592     ; CHECK-LABEL: name: test_alias_4xs16
 593     ; CHECK: liveins: $x0, $x1
 594     ; CHECK-NEXT: {{  $}}
 595     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 596     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x1
 597     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s16) = G_CONSTANT i16 9
 598     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s16) = G_CONSTANT i16 0
 599     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s16) = G_CONSTANT i16 14
 600     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 327684
 601     ; CHECK-NEXT: G_STORE [[C3]](s32), [[COPY]](p0) :: (store (s32) into %ir.addr11, align 2)
 602     ; CHECK-NEXT: [[C4:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
 603     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C4]](s64)
 604     ; CHECK-NEXT: G_STORE [[C]](s16), [[PTR_ADD]](p0) :: (store (s16) into %ir.addr3)
 605     ; CHECK-NEXT: G_STORE [[C1]](s16), [[COPY1]](p0) :: (store (s16) into %ir.ptr2)
 606     ; CHECK-NEXT: [[C5:%[0-9]+]]:_(s64) = G_CONSTANT i64 6
 607     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C5]](s64)
 608     ; CHECK-NEXT: G_STORE [[C2]](s16), [[PTR_ADD1]](p0) :: (store (s16) into %ir.addr4)
 609     ; CHECK-NEXT: RET_ReallyLR
 610     %0:_(p0) = COPY $x0
 611     %1:_(p0) = COPY $x1
 612     %2:_(s16) = G_CONSTANT i16 4
 613     %5:_(s16) = G_CONSTANT i16 5
 614     %8:_(s16) = G_CONSTANT i16 9
 615     %9:_(s16) = G_CONSTANT i16 0
 616     %12:_(s16) = G_CONSTANT i16 14
 617     G_STORE %2(s16), %0(p0) :: (store (s16) into %ir.addr11)
 618     %3:_(s64) = G_CONSTANT i64 2
 619     %4:_(p0) = G_PTR_ADD %0, %3(s64)
 620     G_STORE %5(s16), %4(p0) :: (store (s16) into %ir.addr2)
 621     %6:_(s64) = G_CONSTANT i64 4
 622     %7:_(p0) = G_PTR_ADD %0, %6(s64)
 623     G_STORE %8(s16), %7(p0) :: (store (s16) into %ir.addr3)
 624     G_STORE %9(s16), %1(p0) :: (store (s16) into %ir.ptr2)
 625     %10:_(s64) = G_CONSTANT i64 6
 626     %11:_(p0) = G_PTR_ADD %0, %10(s64)
 627     G_STORE %12(s16), %11(p0) :: (store (s16) into %ir.addr4)
 628     RET_ReallyLR
 629
 630 ...
 631 ---
 632 name:            test_alias2_4xs16
 633 alignment:       4
 634 tracksRegLiveness: true
 635 liveins:
 636   - { reg: '$x0' }
 637   - { reg: '$x1' }
 638   - { reg: '$x2' }
 639 frameInfo:
 640   maxAlignment:    1
 641 machineFunctionInfo: {}
 642 body:             |
 643   bb.1 (%ir-block.0):
 644     liveins: $x0, $x1, $x2
 645     ; Here store of 5 and 9 can be merged, others have aliasing barriers.
 646     ; CHECK-LABEL: name: test_alias2_4xs16
 647     ; CHECK: liveins: $x0, $x1, $x2
 648     ; CHECK-NEXT: {{  $}}
 649     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 650     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x1
 651     ; CHECK-NEXT: [[COPY2:%[0-9]+]]:_(p0) = COPY $x2
 652     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s16) = G_CONSTANT i16 4
 653     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s16) = G_CONSTANT i16 0
 654     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s16) = G_CONSTANT i16 14
 655     ; CHECK-NEXT: G_STORE [[C]](s16), [[COPY]](p0) :: (store (s16) into %ir.addr11)
 656     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s64) = G_CONSTANT i64 2
 657     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C3]](s64)
 658     ; CHECK-NEXT: G_STORE [[C1]](s16), [[COPY2]](p0) :: (store (s16) into %ir.ptr3)
 659     ; CHECK-NEXT: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 589829
 660     ; CHECK-NEXT: G_STORE [[C4]](s32), [[PTR_ADD]](p0) :: (store (s32) into %ir.addr2, align 2)
 661     ; CHECK-NEXT: G_STORE [[C1]](s16), [[COPY1]](p0) :: (store (s16) into %ir.ptr2)
 662     ; CHECK-NEXT: [[C5:%[0-9]+]]:_(s64) = G_CONSTANT i64 6
 663     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C5]](s64)
 664     ; CHECK-NEXT: G_STORE [[C2]](s16), [[PTR_ADD1]](p0) :: (store (s16) into %ir.addr4)
 665     ; CHECK-NEXT: RET_ReallyLR
 666     %0:_(p0) = COPY $x0
 667     %1:_(p0) = COPY $x1
 668     %2:_(p0) = COPY $x2
 669     %3:_(s16) = G_CONSTANT i16 4
 670     %6:_(s16) = G_CONSTANT i16 0
 671     %7:_(s16) = G_CONSTANT i16 5
 672     %10:_(s16) = G_CONSTANT i16 9
 673     %13:_(s16) = G_CONSTANT i16 14
 674     G_STORE %3(s16), %0(p0) :: (store (s16) into %ir.addr11)
 675     %4:_(s64) = G_CONSTANT i64 2
 676     %5:_(p0) = G_PTR_ADD %0, %4(s64)
 677     G_STORE %6(s16), %2(p0) :: (store (s16) into %ir.ptr3)
 678     G_STORE %7(s16), %5(p0) :: (store (s16) into %ir.addr2)
 679     %8:_(s64) = G_CONSTANT i64 4
 680     %9:_(p0) = G_PTR_ADD %0, %8(s64)
 681     G_STORE %10(s16), %9(p0) :: (store (s16) into %ir.addr3)
 682     G_STORE %6(s16), %1(p0) :: (store (s16) into %ir.ptr2)
 683     %11:_(s64) = G_CONSTANT i64 6
 684     %12:_(p0) = G_PTR_ADD %0, %11(s64)
 685     G_STORE %13(s16), %12(p0) :: (store (s16) into %ir.addr4)
 686     RET_ReallyLR
 687
 688 ...
 689 ---
 690 name:            test_alias3_4xs16
 691 alignment:       4
 692 tracksRegLiveness: true
 693 liveins:
 694   - { reg: '$x0' }
 695   - { reg: '$x1' }
 696   - { reg: '$x2' }
 697   - { reg: '$x3' }
 698 frameInfo:
 699   maxAlignment:    1
 700 machineFunctionInfo: {}
 701 body:             |
 702   bb.1 (%ir-block.0):
 703     liveins: $x0, $x1, $x2, $x3
 704
 705     ; No merging can be done here.
 706
 707     ; CHECK-LABEL: name: test_alias3_4xs16
 708     ; CHECK: liveins: $x0, $x1, $x2, $x3
 709     ; CHECK-NEXT: {{  $}}
 710     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 711     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x1
 712     ; CHECK-NEXT: [[COPY2:%[0-9]+]]:_(p0) = COPY $x2
 713     ; CHECK-NEXT: [[COPY3:%[0-9]+]]:_(p0) = COPY $x3
 714     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s16) = G_CONSTANT i16 4
 715     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s16) = G_CONSTANT i16 0
 716     ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s16) = G_CONSTANT i16 5
 717     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 9
 718     ; CHECK-NEXT: [[C4:%[0-9]+]]:_(s16) = G_CONSTANT i16 14
 719     ; CHECK-NEXT: G_STORE [[C]](s16), [[COPY]](p0) :: (store (s16) into %ir.addr11)
 720     ; CHECK-NEXT: [[C5:%[0-9]+]]:_(s64) = G_CONSTANT i64 2
 721     ; CHECK-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C5]](s64)
 722     ; CHECK-NEXT: G_STORE [[C1]](s16), [[COPY2]](p0) :: (store (s16) into %ir.ptr3)
 723     ; CHECK-NEXT: G_STORE [[C2]](s16), [[PTR_ADD]](p0) :: (store (s16) into %ir.addr2)
 724     ; CHECK-NEXT: G_STORE [[C1]](s16), [[COPY3]](p0) :: (store (s16) into %ir.ptr4)
 725     ; CHECK-NEXT: [[C6:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
 726     ; CHECK-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C6]](s64)
 727     ; CHECK-NEXT: G_STORE [[C3]](s16), [[PTR_ADD1]](p0) :: (store (s16) into %ir.addr3)
 728     ; CHECK-NEXT: G_STORE [[C1]](s16), [[COPY1]](p0) :: (store (s16) into %ir.ptr2)
 729     ; CHECK-NEXT: [[C7:%[0-9]+]]:_(s64) = G_CONSTANT i64 6
 730     ; CHECK-NEXT: [[PTR_ADD2:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C7]](s64)
 731     ; CHECK-NEXT: G_STORE [[C4]](s16), [[PTR_ADD2]](p0) :: (store (s16) into %ir.addr4)
 732     ; CHECK-NEXT: RET_ReallyLR
 733     %0:_(p0) = COPY $x0
 734     %1:_(p0) = COPY $x1
 735     %2:_(p0) = COPY $x2
 736     %3:_(p0) = COPY $x3
 737     %4:_(s16) = G_CONSTANT i16 4
 738     %7:_(s16) = G_CONSTANT i16 0
 739     %8:_(s16) = G_CONSTANT i16 5
 740     %11:_(s16) = G_CONSTANT i16 9
 741     %14:_(s16) = G_CONSTANT i16 14
 742     G_STORE %4(s16), %0(p0) :: (store (s16) into %ir.addr11)
 743     %5:_(s64) = G_CONSTANT i64 2
 744     %6:_(p0) = G_PTR_ADD %0, %5(s64)
 745     G_STORE %7(s16), %2(p0) :: (store (s16) into %ir.ptr3)
 746     G_STORE %8(s16), %6(p0) :: (store (s16) into %ir.addr2)
 747     G_STORE %7(s16), %3(p0) :: (store (s16) into %ir.ptr4)
 748     %9:_(s64) = G_CONSTANT i64 4
 749     %10:_(p0) = G_PTR_ADD %0, %9(s64)
 750     G_STORE %11(s16), %10(p0) :: (store (s16) into %ir.addr3)
 751     G_STORE %7(s16), %1(p0) :: (store (s16) into %ir.ptr2)
 752     %12:_(s64) = G_CONSTANT i64 6
 753     %13:_(p0) = G_PTR_ADD %0, %12(s64)
 754     G_STORE %14(s16), %13(p0) :: (store (s16) into %ir.addr4)
 755     RET_ReallyLR
 756
 757 ...
 758 ---
 759 name:            test_alias_allocas_2xs32
 760 alignment:       4
 761 tracksRegLiveness: true
 762 liveins:
 763   - { reg: '$x0' }
 764 frameInfo:
 765   maxAlignment:    4
 766 stack:
 767   - { id: 0, name: a1, size: 24, alignment: 4 }
 768   - { id: 1, name: a2, size: 4, alignment: 4 }
 769 machineFunctionInfo: {}
 770 body:             |
 771   bb.1 (%ir-block.0):
 772     liveins: $x0
 773
 774     ; Can merge because the load is from a different alloca and can't alias.
 775
 776     ; CHECK-LABEL: name: test_alias_allocas_2xs32
 777     ; CHECK: liveins: $x0
 778     ; CHECK-NEXT: {{  $}}
 779     ; CHECK-NEXT: [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0.a1
 780     ; CHECK-NEXT: [[FRAME_INDEX1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.1.a2
 781     ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s32) = G_LOAD [[FRAME_INDEX1]](p0) :: (dereferenceable load (s32) from %ir.a2)
 782     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 21474836484
 783     ; CHECK-NEXT: G_STORE [[C]](s64), [[FRAME_INDEX]](p0) :: (store (s64) into %ir.addr11, align 4)
 784     ; CHECK-NEXT: $w0 = COPY [[LOAD]](s32)
 785     ; CHECK-NEXT: RET_ReallyLR implicit $w0
 786     %3:_(s32) = G_CONSTANT i32 4
 787     %7:_(s32) = G_CONSTANT i32 5
 788     %1:_(p0) = G_FRAME_INDEX %stack.0.a1
 789     %2:_(p0) = G_FRAME_INDEX %stack.1.a2
 790     G_STORE %3(s32), %1(p0) :: (store (s32) into %ir.addr11)
 791     %4:_(s32) = G_LOAD %2(p0) :: (dereferenceable load (s32) from %ir.a2)
 792     %5:_(s64) = G_CONSTANT i64 4
 793     %6:_(p0) = G_PTR_ADD %1, %5(s64)
 794     G_STORE %7(s32), %6(p0) :: (store (s32) into %ir.addr2)
 795     $w0 = COPY %4(s32)
 796     RET_ReallyLR implicit $w0
 797
 798 ...
 799 ---
 800 name:            test_simple_2xs32_with_align
 801 alignment:       4
 802 tracksRegLiveness: true
 803 liveins:
 804   - { reg: '$x0' }
 805 frameInfo:
 806   maxAlignment:    1
 807 machineFunctionInfo: {}
 808 body:             |
 809   bb.1 (%ir-block.0):
 810     liveins: $x0
 811
 812     ; CHECK-LABEL: name: test_simple_2xs32_with_align
 813     ; CHECK: liveins: $x0
 814     ; CHECK-NEXT: {{  $}}
 815     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 816     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 21474836484
 817     ; CHECK-NEXT: G_STORE [[C]](s64), [[COPY]](p0) :: (store (s64) into %ir.addr11, align 2)
 818     ; CHECK-NEXT: RET_ReallyLR
 819     %0:_(p0) = COPY $x0
 820     %1:_(s32) = G_CONSTANT i32 4
 821     %4:_(s32) = G_CONSTANT i32 5
 822     G_STORE %1(s32), %0(p0) :: (store (s32) into %ir.addr11, align 2)
 823     %2:_(s64) = G_CONSTANT i64 4
 824     %3:_(p0) = G_PTR_ADD %0, %2(s64)
 825     G_STORE %4(s32), %3(p0) :: (store (s32) into %ir.addr2, align 2)
 826     RET_ReallyLR
 827
 828 ...