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
 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
 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
 329 # CHECK-NEXT:    STRQui killed renamable $q7, renamable $x0, 100 :: (store (s128), align 4)
 330 # CHECK-NEXT:    $q7 = LDRQui $x0, 0 :: (load (s128))
 331 # CHECK-NEXT:    renamable $q9 = LDRQui $x0, 1 :: (load (s128))
 332 # CHECK-NEXT:    STPQi killed renamable $q9, killed $q7, renamable $x0, 10 :: (store (s128), align 4)
 333 # CHECK-NEXT:    RET undef $lr
 334
 335 name:            test10
 336 alignment:       4
 337 tracksRegLiveness: true
 338 liveins:
 339   - { reg: '$x0' }
 340   - { reg: '$x1' }
 341   - { reg: '$x8' }
 342   - { reg: '$q3' }
 343 frameInfo:
 344   maxAlignment:    1
 345   maxCallFrameSize: 0
 346 machineFunctionInfo: {}
 347 body:             |
 348   bb.0:
 349     liveins: $x0, $x1, $q0, $q1, $q2, $q3, $q4, $q5, $q6, $q7
 350     renamable $q7 = FADDv2f64 renamable $q7, renamable $q7
 351     STRQui renamable killed $q7, renamable $x0, 100 :: (store (s128), align 4)
 352     renamable $q9 = LDRQui $x0, 0 :: (load (s128))
 353     STRQui renamable killed $q9, renamable $x0, 11 :: (store (s128), align 4)
 354     renamable $q9 = LDRQui $x0, 1 :: (load (s128))
 355     STRQui renamable killed $q9, renamable $x0, 10 :: (store (s128), align 4)
 356     RET undef $lr
 357
 358 ...
 359 ---
 360 # Make sure we do not use any registers that are defined between paired candidates
 361 # ($x14 in this example)
 362 # CHECK-LABEL: name: test11
 363 # CHECK: bb.0:
 364 # CHECK-NEXT: liveins: $x0, $x1, $x11, $x12, $x13
 365
 366 # CHECK:         renamable $w10 = LDRWui renamable $x0, 0 :: (load (s64))
 367 # CHECK-NEXT:    $x18, renamable $x8 = LDPXi renamable $x0, 1 :: (load (s64))
 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:    STPXi renamable $x9, killed $x18, 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, $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, $x10, $x11, $x12, $x13
 448 # CHECK:        $x18, 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:    renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
 452 # CHECK-NEXT:    STPXi renamable $x9, killed $x18, renamable $x0, 10 :: (store (s64), align 4)
 453 # CHECK-NEXT:    RET undef $lr
 454 #
 455 name:            test13
 456 alignment:       4
 457 tracksRegLiveness: true
 458 liveins:
 459   - { reg: '$x0' }
 460   - { reg: '$x1' }
 461   - { reg: '$x8' }
 462 frameInfo:
 463   maxAlignment:    1
 464   maxCallFrameSize: 0
 465 machineFunctionInfo: {}
 466 body:             |
 467   bb.0:
 468     liveins: $x0, $x1, $x10, $x11, $x12, $x13
 469     renamable $x9, renamable $x8 = LDPXi renamable $x0, 0 :: (load (s64))
 470     renamable $x14 = LDRXui renamable $x0, 4 :: (load (s64))
 471     STRXui renamable killed $x14, renamable $x0, 100 :: (store (s64), align 4)
 472     STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
 473     renamable $x9 = LDRXui renamable $x0, 2 :: (load (s64))
 474     STRXui renamable $x9, renamable $x0, 10 :: (store (s64))
 475     RET undef $lr
 476
 477 ...
 478 # Make sure we do not rename if pseudo-defs. Noop pseudo instructions like KILL
 479 # may lead to a missing definition of the rename register.
 480 #
 481 # CHECK-LABEL: name: test14_pseudo
 482 # CHECK: bb.0:
 483 # CHECK-NEXT:    liveins: $w8, $fp, $w25
 484 # CHECK:         renamable $w8 = KILL killed renamable $w8, implicit-def $x8
 485 # CHECK-NEXT:    STURXi killed renamable $x8, $fp, -40 :: (store (s64))
 486 # CHECK-NEXT:    $w8 = ORRWrs $wzr, killed $w25, 0, implicit-def $x8
 487 # CHECK-NEXT:    STURXi killed renamable $x8, $fp, -32 :: (store (s64))
 488 # CHECK-NEXT:    RET undef $lr
 489 #
 490 name:            test14_pseudo
 491 alignment:       4
 492 tracksRegLiveness: true
 493 liveins:
 494   - { reg: '$x0' }
 495   - { reg: '$x1' }
 496   - { reg: '$x8' }
 497 frameInfo:
 498   maxAlignment:    1
 499   maxCallFrameSize: 0
 500 machineFunctionInfo: {}
 501 body:             |
 502   bb.0:
 503     liveins: $w8, $fp, $w25
 504
 505     renamable $w8 = KILL killed renamable $w8, implicit-def $x8
 506     STURXi killed renamable $x8, $fp, -40 :: (store (s64))
 507     $w8 = ORRWrs $wzr, killed $w25, 0, implicit-def $x8
 508     STURXi killed renamable $x8, $fp, -32 :: (store (s64))
 509     RET undef $lr
 510 ...
 511 ---
 512 # Make sure we do not pick a register marked as undef for renaming.
 513 #
 514 # CHECK-LABEL: name: test15_undef_op
 515 # CHECK: bb.0:
 516 # CHECK-NEXT: liveins: $x0, $x1, $x8
 517 # CHECK:       undef renamable $x10, $x11 = LDPXi renamable $x0, 0 :: (load (s64))
 518 # CHECK-NEXT:  renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
 519 # CHECK-NEXT:  STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
 520 # CHECK-NEXT:  renamable $x10 = ADDXrr $x10, $x10
 521 # CHECK-NEXT:  STPXi renamable $x10, killed $x11, renamable $x0, 10 :: (store (s64), align 4)
 522 # CHECK-NEXT:  RET undef $lr
 523 #
 524 name:            test15_undef_op
 525 alignment:       4
 526 tracksRegLiveness: true
 527 liveins:
 528   - { reg: '$x0' }
 529   - { reg: '$x1' }
 530   - { reg: '$x8' }
 531 frameInfo:
 532   maxAlignment:    1
 533   maxCallFrameSize: 0
 534 machineFunctionInfo: {}
 535 body:             |
 536   bb.0:
 537     liveins: $x0, $x1, $x8
 538     renamable undef $x10, renamable $x9 = LDPXi renamable $x0, 0 :: (load (s64))
 539     STRXui renamable killed $x9, renamable $x0, 11 :: (store (s64), align 4)
 540     renamable $x9 = LDRXui renamable $x0, 1 :: (load (s64))
 541     STRXui renamable $x9, renamable $x0, 100 :: (store (s64), align 4)
 542     renamable $x10 = ADDXrr $x10, $x10
 543     STRXui renamable $x10, renamable $x0, 10 :: (store (s64), align 4)
 544     RET undef $lr
 545
 546 ...