# RUN: llc -run-pass=aarch64-ldst-opt -mtriple=arm64-apple-iphoneos -verify-machineinstrs -aarch64-load-store-renaming=true -o - %s | FileCheck %s
# RUN: llc -run-pass=aarch64-ldst-opt -mtriple=arm64-apple-iphoneos -verify-machineinstrs -aarch64-load-store-renaming=false -o - %s | FileCheck --check-prefix=NO-RENAME %s

# NO-RENAME-NOT: STP
# NO-RENAME:     test12
# NO-RENAME:     STP
# NO-RENAME-NOT: STP
#
---
# CHECK-LABEL: name: test1
# CHECK: bb.0:
# CHECK-NEXT: liveins: $x0, $x1
# CHECK:       $x10, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
# CHECK-NEXT:  renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
# CHECK-NEXT:  STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
# CHECK-NEXT:  renamable $x8 = ADDXrr $x8, $x8
# CHECK-NEXT:  STPXi renamable $x8, killed $x10, renamable $x0, 10 :: (store (s64), align 4)
# CHECK-NEXT:  RET undef $lr

name:            test1
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1
    renamable $x9, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
    STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
    renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
    STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
    renamable $x8 = ADDXrr $x8, $x8
    STRXui renamable $x8, renamable $x0, 10 :: (store (s64), align 4)
    RET undef $lr

...
---
# CHECK-LABEL: name: test2
# CHECK-LABEL: bb.0:
# CHECK-NEXT:    liveins: $x0, $x9, $x1

# CHECK:         $x10, renamable $x8 = LDPXi renamable $x9, 0 :: (load (s64))
# CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
# CHECK-NEXT:    STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
# CHECK-NEXT:    renamable $x8 = ADDXrr $x8, $x8
# CHECK-NEXT:    STPXi renamable $x8, killed $x10, renamable $x0, 10 :: (store (s64), align 4)
# CHECK-NEXT:    RET undef $lr

name:            test2
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x9' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x9, $x1
    renamable $x9, renamable $x8 = LDPXi renamable $x9, 0 :: (load (s64))
    STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
    STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
    renamable $x8 = ADDXrr $x8, $x8
    STRXui renamable $x8, renamable $x0, 10 :: (store (s64), align 4)
    RET undef $lr

...
---
# MOVK has a tied operand and we currently do not rename across tied defs.
# CHECK-LABEL: bb.0:
# CHECK-NEXT:    liveins: $x0
#
# CHECK:         renamable $x8 = MRS 58880
# CHECK-NEXT:    renamable $x8 = MOVZXi 15309, 0
# CHECK-NEXT:    renamable $x8 = MOVKXi renamable $x8, 26239, 16
# CHECK-NEXT:    STRXui renamable $x8, renamable $x0, 0, implicit killed $x8 :: (store (s64))
# CHECK-NEXT:    renamable $x8 = MRS 55840
# CHECK-NEXT:    STRXui killed renamable $x8, killed renamable $x0, 1, implicit killed $x8 :: (store (s64))
# CHECK-NEXT:    RET undef $lr
#
name:            test3
alignment:       2
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
frameInfo:
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0

    renamable $x8 = MRS 58880, implicit-def $nzcv
    renamable $x8 = MOVZXi 15309, 0
    renamable $x8 = MOVKXi renamable $x8, 26239, 16
    STRXui renamable $x8, renamable $x0, 0, implicit killed $x8 :: (store (s64))
    renamable $x8 = MRS 55840, implicit-def $nzcv
    STRXui killed renamable  $x8, renamable killed $x0, 1, implicit killed $x8 :: (store (s64))
    RET undef $lr

...
---
# CHECK-LABEL: name: test4
# CHECK-LABEL:  bb.0:
# CHECK-NEXT:    liveins: $x0, $x1

# CHECK:         $x9 = MRS 58880
# CHECK-NEXT:    renamable $x8 = MRS 55840
# CHECK-NEXT:    STPXi $x9, killed renamable $x8, killed renamable $x0, 0 :: (store (s32))
# CHECK-NEXT:    RET undef $lr

name:            test4
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1

    renamable $x8 = MRS 58880, implicit-def $nzcv
    STRXui renamable $x8, renamable $x0, 0, implicit killed $x8 :: (store (s32))
    renamable $x8 = MRS 55840, implicit-def $nzcv
    STRXui killed renamable  $x8, renamable killed $x0, 1, implicit killed $x8 :: (store (s32))
    RET undef $lr

...
---
# CHECK-LABEL: name: test5
# CHECK-LABEL:  bb.0:
# CHECK-NEXT:    liveins: $x0, $x1

# CHECK:         $x9 = MRS 58880
# CHECK-NEXT:    renamable $x8 = MRS 55840
# CHECK-NEXT:    STPWi $w9, killed renamable $w8, killed renamable $x0, 0 :: (store (s32))
# CHECK-NEXT:    RET undef $lr

name:            test5
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1

    renamable $x8 = MRS 58880, implicit-def $nzcv
    STRWui renamable $w8, renamable $x0, 0, implicit killed $x8 :: (store (s32))
    renamable $x8 = MRS 55840, implicit-def $nzcv
    STRWui killed renamable $w8, renamable killed $x0, 1, implicit killed $x8 :: (store (s32))
    RET undef $lr

...
---
# CHECK-LABEL: name: test6
# CHECK-LABEL: bb.0:
# CHECK:    liveins: $x0, $x1, $q3

# CHECK:         renamable $q9 = LDRQui $x0, 0 :: (load (s128))
# CHECK-NEXT:    renamable $q9 = XTNv8i16 renamable $q9, killed renamable $q3
# CHECK-NEXT:    STRQui renamable $q9, renamable $x0, 11 :: (store (s128), align 4)
# CHECK-NEXT:    renamable $q9 = FADDv2f64 renamable $q9, renamable $q9, implicit $fpcr
# CHECK-NEXT:    STRQui renamable $q9, renamable $x0, 10 :: (store (s128), align 4)
# CHECK-NEXT:    RET undef $lr

# XTN has a tied use-def.
name:            test6
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
  - { reg: '$q3' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1, $q3
    renamable $q9 = LDRQui $x0, 0 :: (load (s128))
    renamable $q9 = XTNv8i16 renamable $q9, killed renamable $q3
    STRQui renamable $q9, renamable $x0, 11 :: (store (s128), align 4)
    renamable $q9 = FADDv2f64 renamable $q9, renamable $q9, implicit $fpcr
    STRQui renamable $q9, renamable $x0, 10 :: (store (s128), align 4)
    RET undef $lr

...
---
# Currently we do not rename across frame-setup instructions.
# CHECK-LABEL: name: test7
# CHECK-LABEL: bb.0:
# CHECK-NEXT:    liveins: $x0, $x1

# CHECK:         $sp = frame-setup SUBXri $sp, 64, 0
# CHECK-NEXT:    renamable $x9 = frame-setup LDRXui renamable $x0, 0 :: (load (s64))
# CHECK-NEXT:    STRXui renamable $x9, $x0, 10 :: (store (s64), align 4)
# CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
# CHECK-NEXT:    STRXui renamable $x9, $x0, 11 :: (store (s64), align 4)
# CHECK-NEXT:    RET undef $lr
#
name:            test7
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  stackSize:       64
  maxAlignment:    16
  adjustsStack:    true
  hasCalls:        true
  maxCallFrameSize: 0
stack:
  - { id: 0, type: spill-slot, offset: -48, size: 16, alignment: 16 }
  - { id: 1, type: spill-slot, offset: -64, size: 16, alignment: 16 }
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1
    $sp = frame-setup SUBXri $sp, 64, 0
    renamable $x9 = frame-setup LDRXui renamable $x0, 0 :: (load (s64))
    STRXui renamable $x9, $x0, 10 :: (store (s64), align 4)
    renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
    STRXui renamable $x9, $x0, 11 :: (store (s64), align 4)
    RET undef $lr
...
---
# CHECK-LABEL: name: test8
# CHECK-LABEL:  bb.0:
# CHECK-NEXT:    liveins: $x0, $x1

# CHECK:         renamable $x8 = MRS 58880
# CHECK-NEXT:    $w9 = ORRWrs $wzr, killed renamable $w8, 0, implicit-def $x9
# CHECK-NEXT:    renamable $x8 = MRS 55840
# CHECK-NEXT:    STPWi $w9, killed renamable $w8, killed renamable $x0, 0 :: (store (s32))
# CHECK-NEXT:    RET undef $lr

name:            test8
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1

    renamable $x8 = MRS 58880, implicit-def $nzcv
    renamable $w8 = ORRWrs $wzr, killed renamable $w8, 0, implicit-def $x8
    STRWui renamable $w8, renamable $x0, 0, implicit killed $x8 :: (store (s32))
    renamable $x8 = MRS 55840, implicit-def $nzcv
    STRWui killed renamable $w8, renamable killed $x0, 1, implicit killed $x8 :: (store (s32))
    RET undef $lr

...
---
# The reg class returned for $q9 contains only the first 16 Q registers.
# TODO: Can we check that all instructions that require renaming also support
#       the second 16 Q registers?
# CHECK-LABEL: name: test9
# CHECK-LABEL: bb.0:
# CHECK:    liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7

# CHECK:         renamable $q9 = LDRQui $x0, 0 :: (load (s128))
# CHECK-NEXT:    STRQui killed renamable $q9, renamable $x0, 10 :: (store (s128), align 4)
# CHECK:         renamable $q9 = LDRQui $x0, 1 :: (load (s128))
# CHECK-NEXT:    STRQui renamable $q9, renamable $x0, 11 :: (store (s128), align 4)
# CHECK-NEXT:    RET undef $lr

name:            test9
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
  - { reg: '$q3' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7
    renamable $q9 = LDRQui $x0, 0 :: (load (s128))
    STRQui renamable killed $q9, renamable $x0, 10 :: (store (s128), align 4)
    renamable $q9 = LDRQui $x0, 1 :: (load (s128))
    STRQui renamable $q9, renamable $x0, 11 :: (store (s128), align 4)
    RET undef $lr

...
---
# The livein $q7 is killed early, so we can re-use it for renaming.
# CHECK-LABEL: name: test10
# CHECK-LABEL: bb.0:
# CHECK:    liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7

# CHECK:         renamable $q7 = FADDv2f64 renamable $q7, renamable $q7, implicit $fpcr
# CHECK-NEXT:    STRQui killed renamable $q7, renamable $x0, 100 :: (store (s128), align 4)
# CHECK-NEXT:    $q7, renamable $q9 = LDPQi $x0, 0 :: (load (s128))
# CHECK-NEXT:    STPQi killed renamable $q9, killed $q7, renamable $x0, 10 :: (store (s128), align 4)
# CHECK-NEXT:    RET undef $lr

name:            test10
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
  - { reg: '$q3' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7
    renamable $q7 = FADDv2f64 renamable $q7, renamable $q7, implicit $fpcr
    STRQui renamable killed $q7, renamable $x0, 100 :: (store (s128), align 4)
    renamable $q9 = LDRQui $x0, 0 :: (load (s128))
    STRQui renamable killed $q9, renamable $x0, 11 :: (store (s128), align 4)
    renamable $q9 = LDRQui $x0, 1 :: (load (s128))
    STRQui renamable killed $q9, renamable $x0, 10 :: (store (s128), align 4)
    RET undef $lr

...
---
# Make sure we do not use any registers that are defined between paired candidates
# ($x14 in this example)
# CHECK-LABEL: name: test11
# CHECK: bb.0:
# CHECK-NEXT: liveins: $x0, $x1, $x2, $x3, $x4, $x5, $x6, $x7, $x11, $x12, $x13

# CHECK:         renamable $w10 = LDRWui renamable $x0, 0 :: (load (s64))
# CHECK-NEXT:    renamable $x9, renamable $x8 = LDPXi renamable $x0, 1 :: (load (s64))
# CHECK-NEXT:    STRXui killed renamable $x9, renamable $x0, 11 :: (store (s64), align 4)
# CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 3 :: (load (s64))
# CHECK-NEXT:    renamable $x14 = LDRXui renamable $x0, 5 :: (load (s64))
# CHECK-NEXT:    STRXui renamable $x9, renamable $x0, 10 :: (store (s64), align 4)
# CHECK-NEXT:    STRXui killed renamable $x14, renamable $x0, 200 :: (store (s64), align 4)
# CHECK-NEXT:    renamable $w8 = ADDWrr $w10, $w10
# CHECK-NEXT:    STRWui renamable $w8, renamable $x0, 100 :: (store (s64), align 4)
# CHECK-NEXT:    RET undef $lr
#
name:            test11
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1, $x2, $x3, $x4, $x5, $x6, $x7, $x11, $x12, $x13
    renamable $w10 = LDRWui renamable $x0, 0 :: (load (s64))
    renamable $x9, renamable $x8 = LDPXi renamable $x0, 1 :: (load (s64))
    STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
    renamable $x9 = LDRXui renamable $x0, 3 :: (load (s64))
    renamable $x14 = LDRXui renamable $x0, 5 :: (load (s64))
    STRXui renamable $x9, renamable $x0, 10 :: (store (s64), align 4)
    STRXui renamable killed $x14, renamable $x0, 200 :: (store (s64), align 4)
    renamable $w8 = ADDWrr $w10, $w10
    STRWui renamable $w8, renamable $x0, 100 :: (store (s64), align 4)
    RET undef $lr

...
---
# Check that we correctly deal with killed registers in stores that get merged forward,
# which extends the live range of the first store operand.
# CHECK-LABEL: name: test12
# CHECK: bb.0:
# CHECK-NEXT: liveins: $x0, $x1
#
# CHECK:         renamable $x10 = LDRXui renamable $x0, 0 :: (load (s64))
# CHECK-NEXT:    $x11, renamable $x8 = LDPXi renamable $x0, 3 :: (load (s64))
# CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
# CHECK-NEXT:    renamable $x8 = ADDXrr $x8, $x8
# CHECK-NEXT:    STPXi renamable $x8, killed $x11, renamable $x0, 10 :: (store (s64), align 4)
# CHECK-NEXT:    STPXi killed renamable $x10, renamable $x9, renamable $x0, 20 :: (store (s64), align 4)
# CHECK-NEXT:    RET undef $lr

name:            test12
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1
    renamable $x10 = LDRXui renamable $x0, 0 :: (load (s64))
    STRXui renamable killed $x10, renamable $x0, 20 :: (store (s64), align 4)
    renamable $x9, renamable $x8 = LDPXi renamable $x0, 3 :: (load (s64))
    STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
    renamable $x8 = ADDXrr $x8, $x8
    STRXui renamable $x8, renamable $x0, 10 :: (store (s64), align 4)
    STRXui renamable $x9, renamable $x0, 21 :: (store (s64), align 4)
    RET undef $lr

...
---
# Make sure we do not use any registers that are defined between def to rename and the first
# paired store. ($x14 in this example)
# CHECK-LABEL: name: test13
# CHECK: bb.0:
# CHECK-NEXT: liveins: $x0, $x1, $x2, $x3, $x4, $x5, $x6, $x7, $x10, $x11, $x12, $x13
# CHECK:    renamable $x9, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
# CHECK-NEXT:    renamable $x14 = LDRXui renamable $x0, 4 :: (load (s64))
# CHECK-NEXT:    STRXui killed renamable $x14, renamable $x0, 100 :: (store (s64), align 4)
# CHECK-NEXT:    STRXui killed renamable $x9, renamable $x0, 11 :: (store (s64), align 4)
# CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
# CHECK-NEXT:    STRXui renamable $x9, renamable $x0, 10 :: (store (s64))
# CHECK-NEXT:    RET undef $lr
#
name:            test13
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1, $x2, $x3, $x4, $x5, $x6, $x7, $x10, $x11, $x12, $x13
    renamable $x9, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
    renamable $x14 = LDRXui renamable $x0, 4 :: (load (s64))
    STRXui renamable killed $x14, renamable $x0, 100 :: (store (s64), align 4)
    STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
    STRXui renamable $x9, renamable $x0, 10 :: (store (s64))
    RET undef $lr

...
# Make sure we do not rename if pseudo-defs. Noop pseudo instructions like KILL
# may lead to a missing definition of the rename register.
#
# CHECK-LABEL: name: test14_pseudo
# CHECK: bb.0:
# CHECK-NEXT:    liveins: $w8, $fp, $w25
# CHECK:         renamable $w8 = KILL killed renamable $w8, implicit-def $x8
# CHECK-NEXT:    STURXi killed renamable $x8, $fp, -40 :: (store (s64))
# CHECK-NEXT:    $w8 = ORRWrs $wzr, killed $w25, 0, implicit-def $x8
# CHECK-NEXT:    STURXi killed renamable $x8, $fp, -32 :: (store (s64))
# CHECK-NEXT:    RET undef $lr
#
name:            test14_pseudo
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $w8, $fp, $w25

    renamable $w8 = KILL killed renamable $w8, implicit-def $x8
    STURXi killed renamable $x8, $fp, -40 :: (store (s64))
    $w8 = ORRWrs $wzr, killed $w25, 0, implicit-def $x8
    STURXi killed renamable $x8, $fp, -32 :: (store (s64))
    RET undef $lr
...
---
# Make sure we do not pick a register marked as undef for renaming.
#
# CHECK-LABEL: name: test15_undef_op
# CHECK: bb.0:
# CHECK-NEXT: liveins: $x0, $x1, $x8
# CHECK:       renamable $x10, $x11 = LDPXi renamable $x0, 0 :: (load (s64))
# CHECK-NEXT:  renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
# CHECK-NEXT:  STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
# CHECK-NEXT:  renamable $x10 = ADDXrr $x10, $x10
# CHECK-NEXT:  STPXi renamable $x10, killed $x11, renamable $x0, 10 :: (store (s64), align 4)
# CHECK-NEXT:  RET undef $lr
#
name:            test15_undef_op
alignment:       4
tracksRegLiveness: true
liveins:
  - { reg: '$x0' }
  - { reg: '$x1' }
  - { reg: '$x8' }
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo: {}
body:             |
  bb.0:
    liveins: $x0, $x1, $x8
    renamable $x10, renamable $x9 = LDPXi renamable $x0, 0 :: (load (s64))
    STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
    renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
    STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
    renamable $x10 = ADDXrr $x10, $x10
    STRXui renamable $x10, renamable $x0, 10 :: (store (s64), align 4)
    RET undef $lr

...

# During ISel, the order of load/store pairs can be optimized and changed
# so that only a single register is used. Due to this register reuse, LDP/STPs
# are not generated. These tests check that LDP/STPs will be generated after
# register renaming is attempted.

---
#
# CHECK-LABEL: name: ldst32
# CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 32)
# CHECK-NEXT: STPQi killed renamable $q0, killed $q1, $sp, 2 :: (store (s128), align 32)
# CHECK-NEXT: RET undef $lr
#
name:            ldst32
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    renamable $q0 = LDRQui $sp, 1 :: (load 16)
    STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 32)
    renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
    STRQui killed renamable $q0, $sp, 2 :: (store 16, align 32)
    RET undef $lr

...
---
#
# CHECK-LABEL: name: ldst64
# CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 64)
# CHECK-NEXT: STPQi killed renamable $q0, killed $q1, $sp, 2 :: (store (s128), align 64)
# CHECK-NEXT: RET undef $lr
#
name:            ldst64
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    renamable $q0 = LDRQui $sp, 1 :: (load 16)
    STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 64)
    renamable $q0 = LDRQui $sp, 0 :: (load 16, align 64)
    STRQui killed renamable $q0, $sp, 2 :: (store 16, align 64)
    RET undef $lr

...
---
#
# CHECK-LABEL: name: ldst128
# CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 128)
# CHECK-NEXT: STPQi killed renamable $q0, killed $q1, $sp, 2 :: (store (s128), align 128)
# CHECK-NEXT: RET undef $lr
#
name:            ldst128
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    renamable $q0 = LDRQui $sp, 1 :: (load 16)
    STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 128)
    renamable $q0 = LDRQui $sp, 0 :: (load 16, align 128)
    STRQui killed renamable $q0, $sp, 2 :: (store 16, align 128)
    RET undef $lr

...
---
#
# CHECK-LABEL: name: ldst-no-reg-available
# CHECK: liveins: $q1, $q2, $q3, $q4, $q5, $q6, $q7, $q8, $q9, $q10
# CHECK: renamable $q0 = LDRQui $sp, 1 :: (load (s128))
# CHECK-NEXT: STRQui killed renamable $q0, $sp, 3 :: (store (s128), align 32)
# CHECK-NEXT: renamable $q0 = LDRQui $sp, 0 :: (load (s128), align 32)
# CHECK-NEXT: STRQui killed renamable $q0, $sp, 2 :: (store (s128), align 32)
# CHECK-NEXT: RET undef $lr
#
name:            ldst-no-reg-available
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    liveins: $q1, $q2, $q3, $q4, $q5, $q6, $q7, $q8, $q9, $q10
    renamable $q0 = LDRQui $sp, 1 :: (load 16)
    STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 32)
    renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
    STRQui killed renamable $q0, $sp, 2 :: (store 16, align 32)
    RET undef $lr

...
---
#
# CHECK-LABEL: name: ldst-basereg-modified
# CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 32)
# CHECK-NEXT: STRQui killed $q1, $sp, 3 :: (store (s128), align 32)
# CHECK-NEXT: $sp = ADDXri $sp, 16, 0
# CHECK-NEXT: STRQui killed renamable $q0, $sp, 2 :: (store (s128), align 32)
# CHECK-NEXT: RET undef $lr
#
name:            ldst-basereg-modified
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    renamable $q0 = LDRQui $sp, 1 :: (load 16)
    STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 32)
    renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
    $sp = ADDXri $sp, 16, 0
    STRQui killed renamable $q0, $sp, 2 :: (store 16, align 32)
    RET undef $lr

...
---
#
# CHECK-LABEL: name: ldr-dest-reg-implicit-killed
# CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 32)
# CHECK-NEXT: STPSi $s1, renamable $s0, $sp, 9 :: (store (s32))
# CHECK-NEXT: RET undef $lr
#
name:            ldr-dest-reg-implicit-killed
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    renamable $q0 = LDRQui $sp, 1 :: (load 16)
    STRSui renamable $s0, $sp, 9, implicit killed $q0 :: (store (s32))
    renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
    STRSui renamable $s0, $sp, 10, implicit killed $q0 :: (store (s32))
    RET undef $lr

...
---
#
# CHECK-LABEL: name: bundled
# CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 32)
# CHECK-NEXT: STPSi $s1, renamable $s0, $sp, 9 :: (store (s32))
# CHECK-NEXT: BUNDLE implicit-def $z3
# CHECK-NEXT:  $z3 = MOVPRFX_ZZ $z19
# CHECK-NEXT:  $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z16
# CHECK-NEXT: }
# CHECK-NEXT: RET undef $lr
#
name:            bundled
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    liveins: $z3, $z19, $p0, $z16
    renamable $q0 = LDRQui $sp, 1 :: (load 16)
    STRSui renamable $s0, $sp, 9, implicit killed $q0 :: (store (s32))
    BUNDLE implicit-def $z3, implicit-def $q3, implicit-def $d3, implicit-def $s3, implicit-def $h3, implicit-def $b3, implicit $z19, implicit $p0, implicit $z16 {
      $z3 = MOVPRFX_ZZ $z19
      $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z16
    }
    renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
    STRSui renamable $s0, $sp, 10, implicit killed $q0 :: (store (s32))
    RET undef $lr
...
---
#
# CHECK-LABEL: name: bundled_use
# CHECK: renamable $q0 = LDRQui $sp, 1
# CHECK-NEXT: STRQui renamable $q0, $sp, 3, implicit-def $z0
# CHECK-NEXT: BUNDLE implicit-def $z3
# CHECK-NEXT:  $z3 = MOVPRFX_ZZ $z19
# CHECK-NEXT:  $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z0
# CHECK-NEXT: }
# CHECK-NEXT: renamable $q0 = LDRQui $sp, 0
# CHECK-NEXT: STRQui killed renamable $q0, $sp, 2
# CHECK-NEXT: RET undef $lr
#
name:            bundled_use
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    liveins: $z3, $z19, $p0, $z16
    renamable $q0 = LDRQui $sp, 1 :: (load 16)
    STRQui renamable $q0, $sp, 3, implicit-def $z0 :: (store 16, basealign 128)
    BUNDLE implicit-def $z3, implicit-def $q3, implicit-def $d3, implicit-def $s3, implicit-def $h3, implicit-def $b3, implicit $z19, implicit $p0, implicit $z0, implicit $q0 {
      $z3 = MOVPRFX_ZZ $z19
      $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z0
    }
    renamable $q0 = LDRQui $sp, 0 :: (load 16, align 128)
    STRQui killed renamable $q0, $sp, 2 :: (store 16, align 128)
    RET undef $lr

...
---
#
# CHECK-LABEL: name: bundle_at_limit
# CHECK: renamable $x3, $x4 = LDPXi $sp, 1 :: (load (s64))
#
name:            bundle_at_limit
alignment:       4
tracksRegLiveness: true
frameInfo:
  maxAlignment:    1
  maxCallFrameSize: 0
machineFunctionInfo:
  hasRedZone:      false
body:             |
  bb.0.entry:
    liveins: $x0, $x1, $x2, $z0, $p0, $z3, $z19
    renamable $x3 = LDRXui $sp, 2 :: (load (s64))
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x3, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x2, 1, 0
    $x2 = ADDXri renamable $x3, 1, 0
    BUNDLE implicit-def $z3, implicit-def $q3, implicit-def $d3, implicit-def $s3, implicit-def $h3, implicit-def $b3, implicit $z19, implicit $p0, implicit $z0 {
      $z3 = MOVPRFX_ZZ $z19
      $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z0
    }
    $x2 = ADDXri renamable $x3, 1, 0
    renamable $x3 = LDRXui $sp, 1 :: (load (s64))
    RET undef $lr

...