llvm/test/CodeGen/AArch64/stp-opt-with-renaming.mir

   1 # RUN: llc -run-pass=aarch64-ldst-opt -mtriple=arm64-apple-iphoneos -verify-machineinstrs -aarch64-load-store-renaming=true -o - %s | FileCheck %s
   2 # 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
   3
   4 # NO-RENAME-NOT: STP
   5 # NO-RENAME:     test12
   6 # NO-RENAME:     STP
   7 # NO-RENAME-NOT: STP
   8 #
   9 ---
  10 # CHECK-LABEL: name: test1
  11 # CHECK: bb.0:
  12 # CHECK-NEXT: liveins: $x0, $x1
  13 # CHECK:       $x10, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
  14 # CHECK-NEXT:  renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
  15 # CHECK-NEXT:  STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
  16 # CHECK-NEXT:  renamable $x8 = ADDXrr $x8, $x8
  17 # CHECK-NEXT:  STPXi renamable $x8, killed $x10, renamable $x0, 10 :: (store (s64), align 4)
  18 # CHECK-NEXT:  RET undef $lr
  19
  20 name:            test1
  21 alignment:       4
  22 tracksRegLiveness: true
  23 liveins:
  24   - { reg: '$x0' }
  25   - { reg: '$x1' }
  26   - { reg: '$x8' }
  27 frameInfo:
  28   maxAlignment:    1
  29   maxCallFrameSize: 0
  30 machineFunctionInfo: {}
  31 body:             |
  32   bb.0:
  33     liveins: $x0, $x1
  34     renamable $x9, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
  35     STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
  36     renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
  37     STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
  38     renamable $x8 = ADDXrr $x8, $x8
  39     STRXui renamable $x8, renamable $x0, 10 :: (store (s64), align 4)
  40     RET undef $lr
  41
  42 ...
  43 ---
  44 # CHECK-LABEL: name: test2
  45 # CHECK-LABEL: bb.0:
  46 # CHECK-NEXT:    liveins: $x0, $x9, $x1
  47
  48 # CHECK:         $x10, renamable $x8 = LDPXi renamable $x9, 0 :: (load (s64))
  49 # CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
  50 # CHECK-NEXT:    STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
  51 # CHECK-NEXT:    renamable $x8 = ADDXrr $x8, $x8
  52 # CHECK-NEXT:    STPXi renamable $x8, killed $x10, renamable $x0, 10 :: (store (s64), align 4)
  53 # CHECK-NEXT:    RET undef $lr
  54
  55 name:            test2
  56 alignment:       4
  57 tracksRegLiveness: true
  58 liveins:
  59   - { reg: '$x0' }
  60   - { reg: '$x1' }
  61   - { reg: '$x9' }
  62 frameInfo:
  63   maxAlignment:    1
  64   maxCallFrameSize: 0
  65 machineFunctionInfo: {}
  66 body:             |
  67   bb.0:
  68     liveins: $x0, $x9, $x1
  69     renamable $x9, renamable $x8 = LDPXi renamable $x9, 0 :: (load (s64))
  70     STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
  71     renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
  72     STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
  73     renamable $x8 = ADDXrr $x8, $x8
  74     STRXui renamable $x8, renamable $x0, 10 :: (store (s64), align 4)
  75     RET undef $lr
  76
  77 ...
  78 ---
  79 # MOVK has a tied operand and we currently do not rename across tied defs.
  80 # CHECK-LABEL: bb.0:
  81 # CHECK-NEXT:    liveins: $x0
  82 #
  83 # CHECK:         renamable $x8 = MRS 58880
  84 # CHECK-NEXT:    renamable $x8 = MOVZXi 15309, 0
  85 # CHECK-NEXT:    renamable $x8 = MOVKXi renamable $x8, 26239, 16
  86 # CHECK-NEXT:    STRXui renamable $x8, renamable $x0, 0, implicit killed $x8 :: (store (s64))
  87 # CHECK-NEXT:    renamable $x8 = MRS 55840
  88 # CHECK-NEXT:    STRXui killed renamable $x8, killed renamable $x0, 1, implicit killed $x8 :: (store (s64))
  89 # CHECK-NEXT:    RET undef $lr
  90 #
  91 name:            test3
  92 alignment:       2
  93 tracksRegLiveness: true
  94 liveins:
  95   - { reg: '$x0' }
  96 frameInfo:
  97   maxCallFrameSize: 0
  98 machineFunctionInfo: {}
  99 body:             |
 100   bb.0:
 101     liveins: $x0
 102
 103     renamable $x8 = MRS 58880, implicit-def $nzcv
 104     renamable $x8 = MOVZXi 15309, 0
 105     renamable $x8 = MOVKXi renamable $x8, 26239, 16
 106     STRXui renamable $x8, renamable $x0, 0, implicit killed $x8 :: (store (s64))
 107     renamable $x8 = MRS 55840, implicit-def $nzcv
 108     STRXui killed renamable  $x8, renamable killed $x0, 1, implicit killed $x8 :: (store (s64))
 109     RET undef $lr
 110
 111 ...
 112 ---
 113 # CHECK-LABEL: name: test4
 114 # CHECK-LABEL:  bb.0:
 115 # CHECK-NEXT:    liveins: $x0, $x1
 116
 117 # CHECK:         $x9 = MRS 58880
 118 # CHECK-NEXT:    renamable $x8 = MRS 55840
 119 # CHECK-NEXT:    STPXi $x9, killed renamable $x8, killed renamable $x0, 0 :: (store (s32))
 120 # CHECK-NEXT:    RET undef $lr
 121
 122 name:            test4
 123 alignment:       4
 124 tracksRegLiveness: true
 125 liveins:
 126   - { reg: '$x0' }
 127   - { reg: '$x1' }
 128   - { reg: '$x8' }
 129 frameInfo:
 130   maxAlignment:    1
 131   maxCallFrameSize: 0
 132 machineFunctionInfo: {}
 133 body:             |
 134   bb.0:
 135     liveins: $x0, $x1
 136
 137     renamable $x8 = MRS 58880, implicit-def $nzcv
 138     STRXui renamable $x8, renamable $x0, 0, implicit killed $x8 :: (store (s32))
 139     renamable $x8 = MRS 55840, implicit-def $nzcv
 140     STRXui killed renamable  $x8, renamable killed $x0, 1, implicit killed $x8 :: (store (s32))
 141     RET undef $lr
 142
 143 ...
 144 ---
 145 # CHECK-LABEL: name: test5
 146 # CHECK-LABEL:  bb.0:
 147 # CHECK-NEXT:    liveins: $x0, $x1
 148
 149 # CHECK:         $x9 = MRS 58880
 150 # CHECK-NEXT:    renamable $x8 = MRS 55840
 151 # CHECK-NEXT:    STPWi $w9, killed renamable $w8, killed renamable $x0, 0 :: (store (s32))
 152 # CHECK-NEXT:    RET undef $lr
 153
 154 name:            test5
 155 alignment:       4
 156 tracksRegLiveness: true
 157 liveins:
 158   - { reg: '$x0' }
 159   - { reg: '$x1' }
 160   - { reg: '$x8' }
 161 frameInfo:
 162   maxAlignment:    1
 163   maxCallFrameSize: 0
 164 machineFunctionInfo: {}
 165 body:             |
 166   bb.0:
 167     liveins: $x0, $x1
 168
 169     renamable $x8 = MRS 58880, implicit-def $nzcv
 170     STRWui renamable $w8, renamable $x0, 0, implicit killed $x8 :: (store (s32))
 171     renamable $x8 = MRS 55840, implicit-def $nzcv
 172     STRWui killed renamable $w8, renamable killed $x0, 1, implicit killed $x8 :: (store (s32))
 173     RET undef $lr
 174
 175 ...
 176 ---
 177 # CHECK-LABEL: name: test6
 178 # CHECK-LABEL: bb.0:
 179 # CHECK:    liveins: $x0, $x1, $q3
 180
 181 # CHECK:         renamable $q9 = LDRQui $x0, 0 :: (load (s128))
 182 # CHECK-NEXT:    renamable $q9 = XTNv8i16 renamable $q9, killed renamable $q3
 183 # CHECK-NEXT:    STRQui renamable $q9, renamable $x0, 11 :: (store (s128), align 4)
 184 # CHECK-NEXT:    renamable $q9 = FADDv2f64 renamable $q9, renamable $q9, implicit $fpcr
 185 # CHECK-NEXT:    STRQui renamable $q9, renamable $x0, 10 :: (store (s128), align 4)
 186 # CHECK-NEXT:    RET undef $lr
 187
 188 # XTN has a tied use-def.
 189 name:            test6
 190 alignment:       4
 191 tracksRegLiveness: true
 192 liveins:
 193   - { reg: '$x0' }
 194   - { reg: '$x1' }
 195   - { reg: '$x8' }
 196   - { reg: '$q3' }
 197 frameInfo:
 198   maxAlignment:    1
 199   maxCallFrameSize: 0
 200 machineFunctionInfo: {}
 201 body:             |
 202   bb.0:
 203     liveins: $x0, $x1, $q3
 204     renamable $q9 = LDRQui $x0, 0 :: (load (s128))
 205     renamable $q9 = XTNv8i16 renamable $q9, killed renamable $q3
 206     STRQui renamable $q9, renamable $x0, 11 :: (store (s128), align 4)
 207     renamable $q9 = FADDv2f64 renamable $q9, renamable $q9, implicit $fpcr
 208     STRQui renamable $q9, renamable $x0, 10 :: (store (s128), align 4)
 209     RET undef $lr
 210
 211 ...
 212 ---
 213 # Currently we do not rename across frame-setup instructions.
 214 # CHECK-LABEL: name: test7
 215 # CHECK-LABEL: bb.0:
 216 # CHECK-NEXT:    liveins: $x0, $x1
 217
 218 # CHECK:         $sp = frame-setup SUBXri $sp, 64, 0
 219 # CHECK-NEXT:    renamable $x9 = frame-setup LDRXui renamable $x0, 0 :: (load (s64))
 220 # CHECK-NEXT:    STRXui renamable $x9, $x0, 10 :: (store (s64), align 4)
 221 # CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
 222 # CHECK-NEXT:    STRXui renamable $x9, $x0, 11 :: (store (s64), align 4)
 223 # CHECK-NEXT:    RET undef $lr
 224 #
 225 name:            test7
 226 alignment:       4
 227 tracksRegLiveness: true
 228 liveins:
 229   - { reg: '$x0' }
 230   - { reg: '$x1' }
 231   - { reg: '$x8' }
 232 frameInfo:
 233   stackSize:       64
 234   maxAlignment:    16
 235   adjustsStack:    true
 236   hasCalls:        true
 237   maxCallFrameSize: 0
 238 stack:
 239   - { id: 0, type: spill-slot, offset: -48, size: 16, alignment: 16 }
 240   - { id: 1, type: spill-slot, offset: -64, size: 16, alignment: 16 }
 241 machineFunctionInfo: {}
 242 body:             |
 243   bb.0:
 244     liveins: $x0, $x1
 245     $sp = frame-setup SUBXri $sp, 64, 0
 246     renamable $x9 = frame-setup LDRXui renamable $x0, 0 :: (load (s64))
 247     STRXui renamable $x9, $x0, 10 :: (store (s64), align 4)
 248     renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
 249     STRXui renamable $x9, $x0, 11 :: (store (s64), align 4)
 250     RET undef $lr
 251 ...
 252 ---
 253 # CHECK-LABEL: name: test8
 254 # CHECK-LABEL:  bb.0:
 255 # CHECK-NEXT:    liveins: $x0, $x1
 256
 257 # CHECK:         renamable $x8 = MRS 58880
 258 # CHECK-NEXT:    $w9 = ORRWrs $wzr, killed renamable $w8, 0, implicit-def $x9
 259 # CHECK-NEXT:    renamable $x8 = MRS 55840
 260 # CHECK-NEXT:    STPWi $w9, killed renamable $w8, killed renamable $x0, 0 :: (store (s32))
 261 # CHECK-NEXT:    RET undef $lr
 262
 263 name:            test8
 264 alignment:       4
 265 tracksRegLiveness: true
 266 liveins:
 267   - { reg: '$x0' }
 268   - { reg: '$x1' }
 269   - { reg: '$x8' }
 270 frameInfo:
 271   maxAlignment:    1
 272   maxCallFrameSize: 0
 273 machineFunctionInfo: {}
 274 body:             |
 275   bb.0:
 276     liveins: $x0, $x1
 277
 278     renamable $x8 = MRS 58880, implicit-def $nzcv
 279     renamable $w8 = ORRWrs $wzr, killed renamable $w8, 0, implicit-def $x8
 280     STRWui renamable $w8, renamable $x0, 0, implicit killed $x8 :: (store (s32))
 281     renamable $x8 = MRS 55840, implicit-def $nzcv
 282     STRWui killed renamable $w8, renamable killed $x0, 1, implicit killed $x8 :: (store (s32))
 283     RET undef $lr
 284
 285 ...
 286 ---
 287 # The reg class returned for $q9 contains only the first 16 Q registers.
 288 # TODO: Can we check that all instructions that require renaming also support
 289 #       the second 16 Q registers?
 290 # CHECK-LABEL: name: test9
 291 # CHECK-LABEL: bb.0:
 292 # CHECK:    liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7
 293
 294 # CHECK:         renamable $q9 = LDRQui $x0, 0 :: (load (s128))
 295 # CHECK-NEXT:    STRQui killed renamable $q9, renamable $x0, 10 :: (store (s128), align 4)
 296 # CHECK:         renamable $q9 = LDRQui $x0, 1 :: (load (s128))
 297 # CHECK-NEXT:    STRQui renamable $q9, renamable $x0, 11 :: (store (s128), align 4)
 298 # CHECK-NEXT:    RET undef $lr
 299
 300 name:            test9
 301 alignment:       4
 302 tracksRegLiveness: true
 303 liveins:
 304   - { reg: '$x0' }
 305   - { reg: '$x1' }
 306   - { reg: '$x8' }
 307   - { reg: '$q3' }
 308 frameInfo:
 309   maxAlignment:    1
 310   maxCallFrameSize: 0
 311 machineFunctionInfo: {}
 312 body:             |
 313   bb.0:
 314     liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7
 315     renamable $q9 = LDRQui $x0, 0 :: (load (s128))
 316     STRQui renamable killed $q9, renamable $x0, 10 :: (store (s128), align 4)
 317     renamable $q9 = LDRQui $x0, 1 :: (load (s128))
 318     STRQui renamable $q9, renamable $x0, 11 :: (store (s128), align 4)
 319     RET undef $lr
 320
 321 ...
 322 ---
 323 # The livein $q7 is killed early, so we can re-use it for renaming.
 324 # CHECK-LABEL: name: test10
 325 # CHECK-LABEL: bb.0:
 326 # CHECK:    liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7
 327
 328 # CHECK:         renamable $q7 = FADDv2f64 renamable $q7, renamable $q7, implicit $fpcr
 329 # CHECK-NEXT:    STRQui killed renamable $q7, renamable $x0, 100 :: (store (s128), align 4)
 330 # CHECK-NEXT:    $q7, renamable $q9 = LDPQi $x0, 0 :: (load (s128))
 331 # CHECK-NEXT:    STPQi killed renamable $q9, killed $q7, renamable $x0, 10 :: (store (s128), align 4)
 332 # CHECK-NEXT:    RET undef $lr
 333
 334 name:            test10
 335 alignment:       4
 336 tracksRegLiveness: true
 337 liveins:
 338   - { reg: '$x0' }
 339   - { reg: '$x1' }
 340   - { reg: '$x8' }
 341   - { reg: '$q3' }
 342 frameInfo:
 343   maxAlignment:    1
 344   maxCallFrameSize: 0
 345 machineFunctionInfo: {}
 346 body:             |
 347   bb.0:
 348     liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7
 349     renamable $q7 = FADDv2f64 renamable $q7, renamable $q7, implicit $fpcr
 350     STRQui renamable killed $q7, renamable $x0, 100 :: (store (s128), align 4)
 351     renamable $q9 = LDRQui $x0, 0 :: (load (s128))
 352     STRQui renamable killed $q9, renamable $x0, 11 :: (store (s128), align 4)
 353     renamable $q9 = LDRQui $x0, 1 :: (load (s128))
 354     STRQui renamable killed $q9, renamable $x0, 10 :: (store (s128), align 4)
 355     RET undef $lr
 356
 357 ...
 358 ---
 359 # Make sure we do not use any registers that are defined between paired candidates
 360 # ($x14 in this example)
 361 # CHECK-LABEL: name: test11
 362 # CHECK: bb.0:
 363 # CHECK-NEXT: liveins: $x0, $x1, $x2, $x3, $x4, $x5, $x6, $x7, $x11, $x12, $x13
 364
 365 # CHECK:         renamable $w10 = LDRWui renamable $x0, 0 :: (load (s64))
 366 # CHECK-NEXT:    renamable $x9, renamable $x8 = LDPXi renamable $x0, 1 :: (load (s64))
 367 # CHECK-NEXT:    STRXui killed renamable $x9, renamable $x0, 11 :: (store (s64), align 4)
 368 # CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 3 :: (load (s64))
 369 # CHECK-NEXT:    renamable $x14 = LDRXui renamable $x0, 5 :: (load (s64))
 370 # CHECK-NEXT:    STRXui renamable $x9, renamable $x0, 10 :: (store (s64), align 4)
 371 # CHECK-NEXT:    STRXui killed renamable $x14, renamable $x0, 200 :: (store (s64), align 4)
 372 # CHECK-NEXT:    renamable $w8 = ADDWrr $w10, $w10
 373 # CHECK-NEXT:    STRWui renamable $w8, renamable $x0, 100 :: (store (s64), align 4)
 374 # CHECK-NEXT:    RET undef $lr
 375 #
 376 name:            test11
 377 alignment:       4
 378 tracksRegLiveness: true
 379 liveins:
 380   - { reg: '$x0' }
 381   - { reg: '$x1' }
 382   - { reg: '$x8' }
 383 frameInfo:
 384   maxAlignment:    1
 385   maxCallFrameSize: 0
 386 machineFunctionInfo: {}
 387 body:             |
 388   bb.0:
 389     liveins: $x0, $x1, $x2, $x3, $x4, $x5, $x6, $x7, $x11, $x12, $x13
 390     renamable $w10 = LDRWui renamable $x0, 0 :: (load (s64))
 391     renamable $x9, renamable $x8 = LDPXi renamable $x0, 1 :: (load (s64))
 392     STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
 393     renamable $x9 = LDRXui renamable $x0, 3 :: (load (s64))
 394     renamable $x14 = LDRXui renamable $x0, 5 :: (load (s64))
 395     STRXui renamable $x9, renamable $x0, 10 :: (store (s64), align 4)
 396     STRXui renamable killed $x14, renamable $x0, 200 :: (store (s64), align 4)
 397     renamable $w8 = ADDWrr $w10, $w10
 398     STRWui renamable $w8, renamable $x0, 100 :: (store (s64), align 4)
 399     RET undef $lr
 400
 401 ...
 402 ---
 403 # Check that we correctly deal with killed registers in stores that get merged forward,
 404 # which extends the live range of the first store operand.
 405 # CHECK-LABEL: name: test12
 406 # CHECK: bb.0:
 407 # CHECK-NEXT: liveins: $x0, $x1
 408 #
 409 # CHECK:         renamable $x10 = LDRXui renamable $x0, 0 :: (load (s64))
 410 # CHECK-NEXT:    $x11, renamable $x8 = LDPXi renamable $x0, 3 :: (load (s64))
 411 # CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
 412 # CHECK-NEXT:    renamable $x8 = ADDXrr $x8, $x8
 413 # CHECK-NEXT:    STPXi renamable $x8, killed $x11, renamable $x0, 10 :: (store (s64), align 4)
 414 # CHECK-NEXT:    STPXi killed renamable $x10, renamable $x9, renamable $x0, 20 :: (store (s64), align 4)
 415 # CHECK-NEXT:    RET undef $lr
 416
 417 name:            test12
 418 alignment:       4
 419 tracksRegLiveness: true
 420 liveins:
 421   - { reg: '$x0' }
 422   - { reg: '$x1' }
 423   - { reg: '$x8' }
 424 frameInfo:
 425   maxAlignment:    1
 426   maxCallFrameSize: 0
 427 machineFunctionInfo: {}
 428 body:             |
 429   bb.0:
 430     liveins: $x0, $x1
 431     renamable $x10 = LDRXui renamable $x0, 0 :: (load (s64))
 432     STRXui renamable killed $x10, renamable $x0, 20 :: (store (s64), align 4)
 433     renamable $x9, renamable $x8 = LDPXi renamable $x0, 3 :: (load (s64))
 434     STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
 435     renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
 436     renamable $x8 = ADDXrr $x8, $x8
 437     STRXui renamable $x8, renamable $x0, 10 :: (store (s64), align 4)
 438     STRXui renamable $x9, renamable $x0, 21 :: (store (s64), align 4)
 439     RET undef $lr
 440
 441 ...
 442 ---
 443 # Make sure we do not use any registers that are defined between def to rename and the first
 444 # paired store. ($x14 in this example)
 445 # CHECK-LABEL: name: test13
 446 # CHECK: bb.0:
 447 # CHECK-NEXT: liveins: $x0, $x1, $x2, $x3, $x4, $x5, $x6, $x7, $x10, $x11, $x12, $x13
 448 # CHECK:    renamable $x9, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
 449 # CHECK-NEXT:    renamable $x14 = LDRXui renamable $x0, 4 :: (load (s64))
 450 # CHECK-NEXT:    STRXui killed renamable $x14, renamable $x0, 100 :: (store (s64), align 4)
 451 # CHECK-NEXT:    STRXui killed renamable $x9, renamable $x0, 11 :: (store (s64), align 4)
 452 # CHECK-NEXT:    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
 453 # CHECK-NEXT:    STRXui renamable $x9, renamable $x0, 10 :: (store (s64))
 454 # CHECK-NEXT:    RET undef $lr
 455 #
 456 name:            test13
 457 alignment:       4
 458 tracksRegLiveness: true
 459 liveins:
 460   - { reg: '$x0' }
 461   - { reg: '$x1' }
 462   - { reg: '$x8' }
 463 frameInfo:
 464   maxAlignment:    1
 465   maxCallFrameSize: 0
 466 machineFunctionInfo: {}
 467 body:             |
 468   bb.0:
 469     liveins: $x0, $x1, $x2, $x3, $x4, $x5, $x6, $x7, $x10, $x11, $x12, $x13
 470     renamable $x9, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
 471     renamable $x14 = LDRXui renamable $x0, 4 :: (load (s64))
 472     STRXui renamable killed $x14, renamable $x0, 100 :: (store (s64), align 4)
 473     STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
 474     renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
 475     STRXui renamable $x9, renamable $x0, 10 :: (store (s64))
 476     RET undef $lr
 477
 478 ...
 479 # Make sure we do not rename if pseudo-defs. Noop pseudo instructions like KILL
 480 # may lead to a missing definition of the rename register.
 481 #
 482 # CHECK-LABEL: name: test14_pseudo
 483 # CHECK: bb.0:
 484 # CHECK-NEXT:    liveins: $w8, $fp, $w25
 485 # CHECK:         renamable $w8 = KILL killed renamable $w8, implicit-def $x8
 486 # CHECK-NEXT:    STURXi killed renamable $x8, $fp, -40 :: (store (s64))
 487 # CHECK-NEXT:    $w8 = ORRWrs $wzr, killed $w25, 0, implicit-def $x8
 488 # CHECK-NEXT:    STURXi killed renamable $x8, $fp, -32 :: (store (s64))
 489 # CHECK-NEXT:    RET undef $lr
 490 #
 491 name:            test14_pseudo
 492 alignment:       4
 493 tracksRegLiveness: true
 494 liveins:
 495   - { reg: '$x0' }
 496   - { reg: '$x1' }
 497   - { reg: '$x8' }
 498 frameInfo:
 499   maxAlignment:    1
 500   maxCallFrameSize: 0
 501 machineFunctionInfo: {}
 502 body:             |
 503   bb.0:
 504     liveins: $w8, $fp, $w25
 505
 506     renamable $w8 = KILL killed renamable $w8, implicit-def $x8
 507     STURXi killed renamable $x8, $fp, -40 :: (store (s64))
 508     $w8 = ORRWrs $wzr, killed $w25, 0, implicit-def $x8
 509     STURXi killed renamable $x8, $fp, -32 :: (store (s64))
 510     RET undef $lr
 511 ...
 512 ---
 513 # Make sure we do not pick a register marked as undef for renaming.
 514 #
 515 # CHECK-LABEL: name: test15_undef_op
 516 # CHECK: bb.0:
 517 # CHECK-NEXT: liveins: $x0, $x1, $x8
 518 # CHECK:       renamable $x10, $x11 = LDPXi renamable $x0, 0 :: (load (s64))
 519 # CHECK-NEXT:  renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
 520 # CHECK-NEXT:  STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
 521 # CHECK-NEXT:  renamable $x10 = ADDXrr $x10, $x10
 522 # CHECK-NEXT:  STPXi renamable $x10, killed $x11, renamable $x0, 10 :: (store (s64), align 4)
 523 # CHECK-NEXT:  RET undef $lr
 524 #
 525 name:            test15_undef_op
 526 alignment:       4
 527 tracksRegLiveness: true
 528 liveins:
 529   - { reg: '$x0' }
 530   - { reg: '$x1' }
 531   - { reg: '$x8' }
 532 frameInfo:
 533   maxAlignment:    1
 534   maxCallFrameSize: 0
 535 machineFunctionInfo: {}
 536 body:             |
 537   bb.0:
 538     liveins: $x0, $x1, $x8
 539     renamable $x10, renamable $x9 = LDPXi renamable $x0, 0 :: (load (s64))
 540     STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
 541     renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
 542     STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
 543     renamable $x10 = ADDXrr $x10, $x10
 544     STRXui renamable $x10, renamable $x0, 10 :: (store (s64), align 4)
 545     RET undef $lr
 546
 547 ...
 548
 549 # During ISel, the order of load/store pairs can be optimized and changed
 550 # so that only a single register is used. Due to this register reuse, LDP/STPs
 551 # are not generated. These tests check that LDP/STPs will be generated after
 552 # register renaming is attempted.
 553
 554 ---
 555 #
 556 # CHECK-LABEL: name: ldst32
 557 # CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 32)
 558 # CHECK-NEXT: STPQi killed renamable $q0, killed $q1, $sp, 2 :: (store (s128), align 32)
 559 # CHECK-NEXT: RET undef $lr
 560 #
 561 name:            ldst32
 562 alignment:       4
 563 tracksRegLiveness: true
 564 frameInfo:
 565   maxAlignment:    1
 566   maxCallFrameSize: 0
 567 machineFunctionInfo:
 568   hasRedZone:      false
 569 body:             |
 570   bb.0.entry:
 571     renamable $q0 = LDRQui $sp, 1 :: (load 16)
 572     STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 32)
 573     renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
 574     STRQui killed renamable $q0, $sp, 2 :: (store 16, align 32)
 575     RET undef $lr
 576
 577 ...
 578 ---
 579 #
 580 # CHECK-LABEL: name: ldst64
 581 # CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 64)
 582 # CHECK-NEXT: STPQi killed renamable $q0, killed $q1, $sp, 2 :: (store (s128), align 64)
 583 # CHECK-NEXT: RET undef $lr
 584 #
 585 name:            ldst64
 586 alignment:       4
 587 tracksRegLiveness: true
 588 frameInfo:
 589   maxAlignment:    1
 590   maxCallFrameSize: 0
 591 machineFunctionInfo:
 592   hasRedZone:      false
 593 body:             |
 594   bb.0.entry:
 595     renamable $q0 = LDRQui $sp, 1 :: (load 16)
 596     STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 64)
 597     renamable $q0 = LDRQui $sp, 0 :: (load 16, align 64)
 598     STRQui killed renamable $q0, $sp, 2 :: (store 16, align 64)
 599     RET undef $lr
 600
 601 ...
 602 ---
 603 #
 604 # CHECK-LABEL: name: ldst128
 605 # CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 128)
 606 # CHECK-NEXT: STPQi killed renamable $q0, killed $q1, $sp, 2 :: (store (s128), align 128)
 607 # CHECK-NEXT: RET undef $lr
 608 #
 609 name:            ldst128
 610 alignment:       4
 611 tracksRegLiveness: true
 612 frameInfo:
 613   maxAlignment:    1
 614   maxCallFrameSize: 0
 615 machineFunctionInfo:
 616   hasRedZone:      false
 617 body:             |
 618   bb.0.entry:
 619     renamable $q0 = LDRQui $sp, 1 :: (load 16)
 620     STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 128)
 621     renamable $q0 = LDRQui $sp, 0 :: (load 16, align 128)
 622     STRQui killed renamable $q0, $sp, 2 :: (store 16, align 128)
 623     RET undef $lr
 624
 625 ...
 626 ---
 627 #
 628 # CHECK-LABEL: name: ldst-no-reg-available
 629 # CHECK: liveins: $q1, $q2, $q3, $q4, $q5, $q6, $q7, $q8, $q9, $q10
 630 # CHECK: renamable $q0 = LDRQui $sp, 1 :: (load (s128))
 631 # CHECK-NEXT: STRQui killed renamable $q0, $sp, 3 :: (store (s128), align 32)
 632 # CHECK-NEXT: renamable $q0 = LDRQui $sp, 0 :: (load (s128), align 32)
 633 # CHECK-NEXT: STRQui killed renamable $q0, $sp, 2 :: (store (s128), align 32)
 634 # CHECK-NEXT: RET undef $lr
 635 #
 636 name:            ldst-no-reg-available
 637 alignment:       4
 638 tracksRegLiveness: true
 639 frameInfo:
 640   maxAlignment:    1
 641   maxCallFrameSize: 0
 642 machineFunctionInfo:
 643   hasRedZone:      false
 644 body:             |
 645   bb.0.entry:
 646     liveins: $q1, $q2, $q3, $q4, $q5, $q6, $q7, $q8, $q9, $q10
 647     renamable $q0 = LDRQui $sp, 1 :: (load 16)
 648     STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 32)
 649     renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
 650     STRQui killed renamable $q0, $sp, 2 :: (store 16, align 32)
 651     RET undef $lr
 652
 653 ...
 654 ---
 655 #
 656 # CHECK-LABEL: name: ldst-basereg-modified
 657 # CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 32)
 658 # CHECK-NEXT: STRQui killed $q1, $sp, 3 :: (store (s128), align 32)
 659 # CHECK-NEXT: $sp = ADDXri $sp, 16, 0
 660 # CHECK-NEXT: STRQui killed renamable $q0, $sp, 2 :: (store (s128), align 32)
 661 # CHECK-NEXT: RET undef $lr
 662 #
 663 name:            ldst-basereg-modified
 664 alignment:       4
 665 tracksRegLiveness: true
 666 frameInfo:
 667   maxAlignment:    1
 668   maxCallFrameSize: 0
 669 machineFunctionInfo:
 670   hasRedZone:      false
 671 body:             |
 672   bb.0.entry:
 673     renamable $q0 = LDRQui $sp, 1 :: (load 16)
 674     STRQui killed renamable $q0, $sp, 3 :: (store 16, basealign 32)
 675     renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
 676     $sp = ADDXri $sp, 16, 0
 677     STRQui killed renamable $q0, $sp, 2 :: (store 16, align 32)
 678     RET undef $lr
 679
 680 ...
 681 ---
 682 #
 683 # CHECK-LABEL: name: ldr-dest-reg-implicit-killed
 684 # CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 32)
 685 # CHECK-NEXT: STPSi $s1, renamable $s0, $sp, 9 :: (store (s32))
 686 # CHECK-NEXT: RET undef $lr
 687 #
 688 name:            ldr-dest-reg-implicit-killed
 689 alignment:       4
 690 tracksRegLiveness: true
 691 frameInfo:
 692   maxAlignment:    1
 693   maxCallFrameSize: 0
 694 machineFunctionInfo:
 695   hasRedZone:      false
 696 body:             |
 697   bb.0.entry:
 698     renamable $q0 = LDRQui $sp, 1 :: (load 16)
 699     STRSui renamable $s0, $sp, 9, implicit killed $q0 :: (store (s32))
 700     renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
 701     STRSui renamable $s0, $sp, 10, implicit killed $q0 :: (store (s32))
 702     RET undef $lr
 703
 704 ...
 705 ---
 706 #
 707 # CHECK-LABEL: name: bundled
 708 # CHECK: renamable $q0, $q1 = LDPQi $sp, 0 :: (load (s128)), (load (s128), align 32)
 709 # CHECK-NEXT: STPSi $s1, renamable $s0, $sp, 9 :: (store (s32))
 710 # CHECK-NEXT: BUNDLE implicit-def $z3
 711 # CHECK-NEXT:  $z3 = MOVPRFX_ZZ $z19
 712 # CHECK-NEXT:  $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z16
 713 # CHECK-NEXT: }
 714 # CHECK-NEXT: RET undef $lr
 715 #
 716 name:            bundled
 717 alignment:       4
 718 tracksRegLiveness: true
 719 frameInfo:
 720   maxAlignment:    1
 721   maxCallFrameSize: 0
 722 machineFunctionInfo:
 723   hasRedZone:      false
 724 body:             |
 725   bb.0.entry:
 726     liveins: $z3, $z19, $p0, $z16
 727     renamable $q0 = LDRQui $sp, 1 :: (load 16)
 728     STRSui renamable $s0, $sp, 9, implicit killed $q0 :: (store (s32))
 729     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 {
 730       $z3 = MOVPRFX_ZZ $z19
 731       $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z16
 732     }
 733     renamable $q0 = LDRQui $sp, 0 :: (load 16, align 32)
 734     STRSui renamable $s0, $sp, 10, implicit killed $q0 :: (store (s32))
 735     RET undef $lr
 736 ...
 737 ---
 738 #
 739 # CHECK-LABEL: name: bundled_use
 740 # CHECK: renamable $q0 = LDRQui $sp, 1
 741 # CHECK-NEXT: STRQui renamable $q0, $sp, 3, implicit-def $z0
 742 # CHECK-NEXT: BUNDLE implicit-def $z3
 743 # CHECK-NEXT:  $z3 = MOVPRFX_ZZ $z19
 744 # CHECK-NEXT:  $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z0
 745 # CHECK-NEXT: }
 746 # CHECK-NEXT: renamable $q0 = LDRQui $sp, 0
 747 # CHECK-NEXT: STRQui killed renamable $q0, $sp, 2
 748 # CHECK-NEXT: RET undef $lr
 749 #
 750 name:            bundled_use
 751 alignment:       4
 752 tracksRegLiveness: true
 753 frameInfo:
 754   maxAlignment:    1
 755   maxCallFrameSize: 0
 756 machineFunctionInfo:
 757   hasRedZone:      false
 758 body:             |
 759   bb.0.entry:
 760     liveins: $z3, $z19, $p0, $z16
 761     renamable $q0 = LDRQui $sp, 1 :: (load 16)
 762     STRQui renamable $q0, $sp, 3, implicit-def $z0 :: (store 16, basealign 128)
 763     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 {
 764       $z3 = MOVPRFX_ZZ $z19
 765       $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z0
 766     }
 767     renamable $q0 = LDRQui $sp, 0 :: (load 16, align 128)
 768     STRQui killed renamable $q0, $sp, 2 :: (store 16, align 128)
 769     RET undef $lr
 770
 771 ...
 772 ---
 773 #
 774 # CHECK-LABEL: name: bundle_at_limit
 775 # CHECK: renamable $x3, $x4 = LDPXi $sp, 1 :: (load (s64))
 776 #
 777 name:            bundle_at_limit
 778 alignment:       4
 779 tracksRegLiveness: true
 780 frameInfo:
 781   maxAlignment:    1
 782   maxCallFrameSize: 0
 783 machineFunctionInfo:
 784   hasRedZone:      false
 785 body:             |
 786   bb.0.entry:
 787     liveins: $x0, $x1, $x2, $z0, $p0, $z3, $z19
 788     renamable $x3 = LDRXui $sp, 2 :: (load (s64))
 789     $x2 = ADDXri renamable $x2, 1, 0
 790     $x2 = ADDXri renamable $x3, 1, 0
 791     $x2 = ADDXri renamable $x2, 1, 0
 792     $x2 = ADDXri renamable $x2, 1, 0
 793     $x2 = ADDXri renamable $x2, 1, 0
 794     $x2 = ADDXri renamable $x2, 1, 0
 795     $x2 = ADDXri renamable $x2, 1, 0
 796     $x2 = ADDXri renamable $x2, 1, 0
 797     $x2 = ADDXri renamable $x2, 1, 0
 798     $x2 = ADDXri renamable $x2, 1, 0
 799     $x2 = ADDXri renamable $x2, 1, 0
 800     $x2 = ADDXri renamable $x2, 1, 0
 801     $x2 = ADDXri renamable $x2, 1, 0
 802     $x2 = ADDXri renamable $x2, 1, 0
 803     $x2 = ADDXri renamable $x2, 1, 0
 804     $x2 = ADDXri renamable $x2, 1, 0
 805     $x2 = ADDXri renamable $x3, 1, 0
 806     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 {
 807       $z3 = MOVPRFX_ZZ $z19
 808       $z3 = FMUL_ZPmZ_S renamable $p0, killed $z3, renamable $z0
 809     }
 810     $x2 = ADDXri renamable $x3, 1, 0
 811     renamable $x3 = LDRXui $sp, 1 :: (load (s64))
 812     RET undef $lr
 813
 814 ...