test/CodeGen/AArch64/GlobalISel/arm64-regbankselect.mir

   1 # RUN: llc -O0 -run-pass=regbankselect -global-isel %s -o - -verify-machineinstrs | FileCheck %s --check-prefix=CHECK --check-prefix=FAST
   2 # RUN: llc -O0 -run-pass=regbankselect -global-isel %s -regbankselect-greedy -o - -verify-machineinstrs | FileCheck %s --check-prefix=CHECK --check-prefix=GREEDY
   3
   4 --- |
   5   ; ModuleID = 'generic-virtual-registers-type-error.mir'
   6   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
   7   target triple = "aarch64--"
   8   define void @defaultMapping() {
   9   entry:
  10     ret void
  11   }
  12   define void @defaultMappingVector() {
  13   entry:
  14     ret void
  15   }
  16   define void @defaultMapping1Repair() {
  17   entry:
  18     ret void
  19   }
  20   define void @defaultMapping2Repairs() {
  21   entry:
  22     ret void
  23   }
  24   define void @defaultMappingDefRepair() {
  25   entry:
  26     ret void
  27   }
  28   define void @phiPropagation(i32* %src, i32* %dst, i1 %cond) {
  29   entry:
  30     %srcVal = load i32, i32* %src
  31     br i1 %cond, label %end, label %then
  32   then:
  33     %res = add i32 %srcVal, 36
  34     br label %end
  35   end:
  36     %toStore = phi i32 [ %srcVal, %entry ], [ %res, %then ]
  37     store i32 %toStore, i32* %dst
  38     ret void
  39   }
  40   define void @defaultMappingUseRepairPhysReg() {
  41   entry:
  42     ret void
  43   }
  44   define void @defaultMappingDefRepairPhysReg() {
  45   entry:
  46     ret void
  47   }
  48   define void @greedyMappingOr() {
  49   entry:
  50     ret void
  51   }
  52   define void @greedyMappingOrWithConstraints() {
  53   entry:
  54     ret void
  55   }
  56
  57   define void @ignoreTargetSpecificInst() { ret void }
  58
  59   define void @regBankSelected_property() { ret void }
  60
  61   define void @bitcast_s32_gpr() { ret void }
  62   define void @bitcast_s32_fpr() { ret void }
  63   define void @bitcast_s32_gpr_fpr() { ret void }
  64   define void @bitcast_s32_fpr_gpr() { ret void }
  65   define void @bitcast_s64_gpr() { ret void }
  66   define void @bitcast_s64_fpr() { ret void }
  67   define void @bitcast_s64_gpr_fpr() { ret void }
  68   define void @bitcast_s64_fpr_gpr() { ret void }
  69
  70   define i64 @greedyWithChainOfComputation(i64 %arg1, <2 x i32>* %addr) {
  71     %varg1 = bitcast i64 %arg1 to <2 x i32>
  72     %varg2 = load <2 x i32>, <2 x i32>* %addr
  73     %vres = or <2 x i32> %varg1, %varg2
  74     %res = bitcast <2 x i32> %vres to i64
  75     ret i64 %res
  76   }
  77
  78   define i64 @floatingPointLoad(i64 %arg1, double* %addr) {
  79     %varg1 = bitcast i64 %arg1 to double
  80     %varg2 = load double, double* %addr
  81     %vres = fadd double %varg1, %varg2
  82     %res = bitcast double %vres to i64
  83     ret i64 %res
  84   }
  85
  86   define void @floatingPointStore(i64 %arg1, double* %addr) {
  87     %varg1 = bitcast i64 %arg1 to double
  88     %vres = fadd double %varg1, %varg1
  89     store double %vres, double* %addr
  90     ret void
  91   }
  92 ...
  93
  94 ---
  95 # Check that we assign a relevant register bank for %0.
  96 # Based on the type i32, this should be gpr.
  97 name:            defaultMapping
  98 legalized:       true
  99 # CHECK-LABEL: name: defaultMapping
 100 # CHECK:      registers:
 101 # CHECK:   - { id: 0, class: gpr, preferred-register: '' }
 102 # CHECK:   - { id: 1, class: gpr, preferred-register: '' }
 103 registers:
 104   - { id: 0, class: _ }
 105   - { id: 1, class: _ }
 106 body: |
 107   bb.0.entry:
 108     liveins: %x0
 109     ; CHECK:      %1(s32) = G_ADD %0
 110     %0(s32) = COPY %w0
 111     %1(s32) = G_ADD %0, %0
 112 ...
 113
 114 ---
 115 # Check that we assign a relevant register bank for %0.
 116 # Based on the type <2 x i32>, this should be fpr.
 117 # FPR is used for both floating point and vector registers.
 118 name:            defaultMappingVector
 119 legalized:       true
 120 # CHECK-LABEL: name: defaultMappingVector
 121 # CHECK:      registers:
 122 # CHECK:   - { id: 0, class: fpr, preferred-register: '' }
 123 # CHECK:   - { id: 1, class: fpr, preferred-register: '' }
 124 registers:
 125   - { id: 0, class: _ }
 126   - { id: 1, class: _ }
 127 body: |
 128   bb.0.entry:
 129     liveins: %d0
 130     ; CHECK:      %0(<2 x s32>) = COPY %d0
 131     ; CHECK:      %1(<2 x s32>) = G_ADD %0
 132     %0(<2 x s32>) = COPY %d0
 133     %1(<2 x s32>) = G_ADD %0, %0
 134 ...
 135
 136 ---
 137 # Check that we repair the assignment for %0.
 138 # Indeed based on the source of the copy it should live
 139 # in FPR, but at the use, it should be GPR.
 140 name:            defaultMapping1Repair
 141 legalized:       true
 142 # CHECK-LABEL: name: defaultMapping1Repair
 143 # CHECK:      registers:
 144 # CHECK-NEXT:   - { id: 0, class: fpr, preferred-register: '' }
 145 # CHECK-NEXT:   - { id: 1, class: gpr, preferred-register: '' }
 146 # CHECK-NEXT:   - { id: 2, class: gpr, preferred-register: '' }
 147 # CHECK-NEXT:   - { id: 3, class: gpr, preferred-register: '' }
 148 registers:
 149   - { id: 0, class: _ }
 150   - { id: 1, class: _ }
 151   - { id: 2, class: _ }
 152 body: |
 153   bb.0.entry:
 154     liveins: %s0, %x0
 155     ; CHECK:           %0(s32) = COPY %s0
 156     ; CHECK-NEXT:      %1(s32) = COPY %w0
 157     ; CHECK-NEXT:      %3(s32) = COPY %0
 158     ; CHECK-NEXT:      %2(s32) = G_ADD %3, %1
 159     %0(s32) = COPY %s0
 160     %1(s32) = COPY %w0
 161     %2(s32) = G_ADD %0, %1
 162 ...
 163
 164 # Check that we repair the assignment for %0 differently for both uses.
 165 name:            defaultMapping2Repairs
 166 legalized:       true
 167 # CHECK-LABEL: name: defaultMapping2Repairs
 168 # CHECK:      registers:
 169 # CHECK-NEXT:   - { id: 0, class: fpr, preferred-register: '' }
 170 # CHECK-NEXT:   - { id: 1, class: gpr, preferred-register: '' }
 171 # CHECK-NEXT:   - { id: 2, class: gpr, preferred-register: '' }
 172 # CHECK-NEXT:   - { id: 3, class: gpr, preferred-register: '' }
 173 registers:
 174   - { id: 0, class: _ }
 175   - { id: 1, class: _ }
 176 body: |
 177   bb.0.entry:
 178     liveins: %s0, %x0
 179     ; CHECK:           %0(s32) = COPY %s0
 180     ; CHECK-NEXT:      %2(s32) = COPY %0
 181     ; CHECK-NEXT:      %3(s32) = COPY %0
 182     ; CHECK-NEXT:      %1(s32) = G_ADD %2, %3
 183     %0(s32) = COPY %s0
 184     %1(s32) = G_ADD %0, %0
 185 ...
 186
 187 ---
 188 # Check that we repair the definition of %1.
 189 # %1 is forced to be into FPR, but its definition actually
 190 # requires that it lives in GPR. Make sure regbankselect
 191 # fixes that.
 192 name:            defaultMappingDefRepair
 193 legalized:       true
 194 # CHECK-LABEL: name: defaultMappingDefRepair
 195 # CHECK:      registers:
 196 # CHECK-NEXT:   - { id: 0, class: gpr, preferred-register: '' }
 197 # CHECK-NEXT:   - { id: 1, class: fpr, preferred-register: '' }
 198 # CHECK-NEXT:   - { id: 2, class: gpr, preferred-register: '' }
 199 registers:
 200   - { id: 0, class: _ }
 201   - { id: 1, class: fpr }
 202 body: |
 203   bb.0.entry:
 204     liveins: %w0
 205     ; CHECK:           %0(s32) = COPY %w0
 206     ; CHECK-NEXT:      %2(s32) = G_ADD %0, %0
 207     ; CHECK-NEXT:      %1(s32) = COPY %2
 208     %0(s32) = COPY %w0
 209     %1(s32) = G_ADD %0, %0
 210 ...
 211
 212 ---
 213 # Check that we are able to propagate register banks from phis.
 214 name:            phiPropagation
 215 legalized:       true
 216 tracksRegLiveness:   true
 217 # CHECK:      registers:
 218 # CHECK-NEXT:   - { id: 0, class: gpr32, preferred-register: '' }
 219 # CHECK-NEXT:   - { id: 1, class: gpr64sp, preferred-register: '' }
 220 # CHECK-NEXT:   - { id: 2, class: gpr32, preferred-register: '' }
 221 # CHECK-NEXT:   - { id: 3, class: gpr, preferred-register: '' }
 222 # CHECK-NEXT:   - { id: 4, class: gpr, preferred-register: '' }
 223 registers:
 224   - { id: 0, class: gpr32 }
 225   - { id: 1, class: gpr64sp }
 226   - { id: 2, class: gpr32 }
 227   - { id: 3, class: _ }
 228   - { id: 4, class: _ }
 229   - { id: 5, class: _ }
 230 body: |
 231   bb.0.entry:
 232     successors: %bb.2.end, %bb.1.then
 233     liveins: %x0, %x1, %w2
 234
 235     %0 = LDRWui killed %x0, 0 :: (load 4 from %ir.src)
 236     %5(s32) = COPY %0
 237     %1(p0) = COPY %x1
 238     %2 = COPY %w2
 239     TBNZW killed %2, 0, %bb.2.end
 240
 241   bb.1.then:
 242     successors: %bb.2.end
 243     %3(s32) = G_ADD %5, %5
 244
 245   bb.2.end:
 246     %4(s32) = PHI %0, %bb.0.entry, %3, %bb.1.then
 247     G_STORE killed %4, killed %1 :: (store 4 into %ir.dst)
 248     RET_ReallyLR
 249 ...
 250
 251 ---
 252 # Make sure we can repair physical register uses as well.
 253 name:            defaultMappingUseRepairPhysReg
 254 legalized:       true
 255 # CHECK-LABEL: name: defaultMappingUseRepairPhysReg
 256 # CHECK:      registers:
 257 # CHECK-NEXT:   - { id: 0, class: gpr, preferred-register: '' }
 258 # CHECK-NEXT:   - { id: 1, class: fpr, preferred-register: '' }
 259 # CHECK-NEXT:   - { id: 2, class: gpr, preferred-register: '' }
 260 # CHECK-NEXT:   - { id: 3, class: gpr, preferred-register: '' }
 261 registers:
 262   - { id: 0, class: _ }
 263   - { id: 1, class: _ }
 264   - { id: 2, class: _ }
 265 body: |
 266   bb.0.entry:
 267     liveins: %w0, %s0
 268     ; CHECK:           %0(s32) = COPY %w0
 269     ; CHECK-NEXT:      %1(s32) = COPY %s0
 270     ; CHECK-NEXT:      %3(s32) = COPY %1
 271     ; CHECK-NEXT:      %2(s32) = G_ADD %0, %3
 272     %0(s32) = COPY %w0
 273     %1(s32) = COPY %s0
 274     %2(s32) = G_ADD %0, %1
 275 ...
 276
 277 ---
 278 # Make sure we can repair physical register defs.
 279 name:            defaultMappingDefRepairPhysReg
 280 legalized:       true
 281 # CHECK-LABEL: name: defaultMappingDefRepairPhysReg
 282 # CHECK:      registers:
 283 # CHECK-NEXT:   - { id: 0, class: gpr, preferred-register: '' }
 284 # CHECK-NEXT:   - { id: 1, class: gpr, preferred-register: '' }
 285 registers:
 286   - { id: 0, class: _ }
 287   - { id: 1, class: _ }
 288 body: |
 289   bb.0.entry:
 290     liveins: %w0
 291     ; CHECK:           %0(s32) = COPY %w0
 292     ; CHECK-NEXT:      %1(s32) = G_ADD %0, %0
 293     ; CHECK-NEXT:      %s0 = COPY %1
 294     %0(s32) = COPY %w0
 295     %1(s32) = G_ADD %0, %0
 296     %s0 = COPY %1
 297 ...
 298
 299 ---
 300 # Check that the greedy mode is able to switch the
 301 # G_OR instruction from fpr to gpr.
 302 name:            greedyMappingOr
 303 legalized:       true
 304 # CHECK-LABEL: name: greedyMappingOr
 305 # CHECK:      registers:
 306 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 307 # CHECK-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 308
 309 # Fast mode maps vector instruction on FPR.
 310 # FAST-NEXT:  - { id: 2, class: fpr, preferred-register: '' }
 311 # Fast mode needs two extra copies.
 312 # FAST-NEXT:  - { id: 3, class: fpr, preferred-register: '' }
 313 # FAST-NEXT:  - { id: 4, class: fpr, preferred-register: '' }
 314
 315 # Greedy mode coalesce the computation on the GPR register
 316 # because it is the cheapest.
 317 # GREEDY-NEXT:  - { id: 2, class: gpr, preferred-register: '' }
 318
 319 registers:
 320   - { id: 0, class: _ }
 321   - { id: 1, class: _ }
 322   - { id: 2, class: _ }
 323 body: |
 324   bb.0.entry:
 325     liveins: %x0, %x1
 326     ; CHECK: %0(<2 x s32>) = COPY %x0
 327     ; CHECK-NEXT: %1(<2 x s32>) = COPY %x1
 328
 329
 330     ; Fast mode tries to reuse the source of the copy for the destination.
 331     ; Now, the default mapping says that %0 and %1 need to be in FPR.
 332     ; The repairing code insert two copies to materialize that.
 333     ; FAST-NEXT: %3(<2 x s32>) = COPY %0
 334     ; FAST-NEXT: %4(<2 x s32>) = COPY %1
 335     ; The mapping of G_OR is on FPR.
 336     ; FAST-NEXT: %2(<2 x s32>) = G_OR %3, %4
 337
 338     ; Greedy mode remapped the instruction on the GPR bank.
 339     ; GREEDY-NEXT: %2(<2 x s32>) = G_OR %0, %1
 340     %0(<2 x s32>) = COPY %x0
 341     %1(<2 x s32>) = COPY %x1
 342     %2(<2 x s32>) = G_OR %0, %1
 343 ...
 344
 345 ---
 346 # Check that the greedy mode is able to switch the
 347 # G_OR instruction from fpr to gpr, while still honoring
 348 # %2 constraint.
 349 name:            greedyMappingOrWithConstraints
 350 legalized:       true
 351 # CHECK-LABEL: name: greedyMappingOrWithConstraints
 352 # CHECK:      registers:
 353 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 354 # CHECK-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 355 # CHECK-NEXT:  - { id: 2, class: fpr, preferred-register: '' }
 356
 357 # Fast mode maps vector instruction on FPR.
 358 # Fast mode needs two extra copies.
 359 # FAST-NEXT:  - { id: 3, class: fpr, preferred-register: '' }
 360 # FAST-NEXT:  - { id: 4, class: fpr, preferred-register: '' }
 361
 362 # Greedy mode coalesce the computation on the GPR register because it
 363 # is the cheapest, but will need one extra copy to materialize %2 into a FPR.
 364 # GREEDY-NEXT:  - { id: 3, class: gpr, preferred-register: '' }
 365
 366 registers:
 367   - { id: 0, class: _ }
 368   - { id: 1, class: _ }
 369   - { id: 2, class: fpr }
 370 body: |
 371   bb.0.entry:
 372     liveins: %x0, %x1
 373     ; CHECK: %0(<2 x s32>) = COPY %x0
 374     ; CHECK-NEXT: %1(<2 x s32>) = COPY %x1
 375
 376
 377     ; Fast mode tries to reuse the source of the copy for the destination.
 378     ; Now, the default mapping says that %0 and %1 need to be in FPR.
 379     ; The repairing code insert two copies to materialize that.
 380     ; FAST-NEXT: %3(<2 x s32>) = COPY %0
 381     ; FAST-NEXT: %4(<2 x s32>) = COPY %1
 382     ; The mapping of G_OR is on FPR.
 383     ; FAST-NEXT: %2(<2 x s32>) = G_OR %3, %4
 384
 385     ; Greedy mode remapped the instruction on the GPR bank.
 386     ; GREEDY-NEXT: %3(<2 x s32>) = G_OR %0, %1
 387     ; We need to keep %2 into FPR because we do not know anything about it.
 388     ; GREEDY-NEXT: %2(<2 x s32>) = COPY %3
 389     %0(<2 x s32>) = COPY %x0
 390     %1(<2 x s32>) = COPY %x1
 391     %2(<2 x s32>) = G_OR %0, %1
 392 ...
 393
 394 ---
 395 # CHECK-LABEL: name: ignoreTargetSpecificInst
 396 name:            ignoreTargetSpecificInst
 397 legalized:       true
 398 # CHECK:      registers:
 399 # CHECK-NEXT:  - { id: 0, class: gpr64, preferred-register: '' }
 400 # CHECK-NEXT:  - { id: 1, class: gpr64, preferred-register: '' }
 401 registers:
 402   - { id: 0, class: gpr64 }
 403   - { id: 1, class: gpr64 }
 404 body: |
 405   bb.0:
 406     liveins: %x0
 407
 408     ; CHECK: %0 = COPY %x0
 409     ; CHECK-NEXT: %1 = ADDXrr %0, %0
 410     ; CHECK-NEXT: %x0 = COPY %1
 411     ; CHECK-NEXT: RET_ReallyLR implicit %x0
 412
 413     %0 = COPY %x0
 414     %1 = ADDXrr %0, %0
 415     %x0 = COPY %1
 416     RET_ReallyLR implicit %x0
 417 ...
 418
 419 ---
 420 # Check that we set the "regBankSelected" property.
 421 # CHECK-LABEL: name: regBankSelected_property
 422 # CHECK: legalized: true
 423 # CHECK: regBankSelected: true
 424 name:            regBankSelected_property
 425 legalized:       true
 426 regBankSelected: false
 427 body:             |
 428   bb.0:
 429 ...
 430
 431 ---
 432 # CHECK-LABEL: name: bitcast_s32_gpr
 433 name:            bitcast_s32_gpr
 434 legalized:       true
 435
 436 # CHECK:      registers:
 437 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 438 # CHECK-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 439 registers:
 440   - { id: 0, class: _ }
 441   - { id: 1, class: _ }
 442
 443 # CHECK:  body:
 444 # CHECK:    %0(s32) = COPY %w0
 445 # CHECK:    %1(s32) = G_BITCAST %0
 446 body:             |
 447   bb.0:
 448     liveins: %w0
 449
 450     %0(s32) = COPY %w0
 451     %1(s32) = G_BITCAST %0
 452 ...
 453
 454 ---
 455 # CHECK-LABEL: name: bitcast_s32_fpr
 456 name:            bitcast_s32_fpr
 457 legalized:       true
 458
 459 # CHECK:      registers:
 460 # CHECK-NEXT:  - { id: 0, class: fpr, preferred-register: '' }
 461 # CHECK-NEXT:  - { id: 1, class: fpr, preferred-register: '' }
 462 registers:
 463   - { id: 0, class: _ }
 464   - { id: 1, class: _ }
 465
 466 # CHECK:  body:
 467 # CHECK:    %0(<2 x s16>) = COPY %s0
 468 # CHECK:    %1(<2 x s16>) = G_BITCAST %0
 469 body:             |
 470   bb.0:
 471     liveins: %s0
 472
 473     %0(<2 x s16>) = COPY %s0
 474     %1(<2 x s16>) = G_BITCAST %0
 475 ...
 476
 477 ---
 478 # CHECK-LABEL: name: bitcast_s32_gpr_fpr
 479 name:            bitcast_s32_gpr_fpr
 480 legalized:       true
 481
 482 # CHECK:      registers:
 483 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 484 # FAST-NEXT:  - { id: 1, class: fpr, preferred-register: '' }
 485 # GREEDY-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 486 registers:
 487   - { id: 0, class: _ }
 488   - { id: 1, class: _ }
 489
 490 # CHECK:  body:
 491 # CHECK:    %0(s32) = COPY %w0
 492 # CHECK:    %1(<2 x s16>) = G_BITCAST %0
 493 body:             |
 494   bb.0:
 495     liveins: %w0
 496
 497     %0(s32) = COPY %w0
 498     %1(<2 x s16>) = G_BITCAST %0
 499 ...
 500
 501 ---
 502 # CHECK-LABEL: name: bitcast_s32_fpr_gpr
 503 name:            bitcast_s32_fpr_gpr
 504 legalized:       true
 505
 506 # CHECK:      registers:
 507 # CHECK-NEXT:  - { id: 0, class: fpr, preferred-register: '' }
 508 # FAST-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 509 # GREEDY-NEXT:  - { id: 1, class: fpr, preferred-register: '' }
 510 registers:
 511   - { id: 0, class: _ }
 512   - { id: 1, class: _ }
 513
 514 # CHECK:  body:
 515 # CHECK:    %0(<2 x s16>) = COPY %s0
 516 # CHECK:    %1(s32) = G_BITCAST %0
 517 body:             |
 518   bb.0:
 519     liveins: %s0
 520
 521     %0(<2 x s16>) = COPY %s0
 522     %1(s32) = G_BITCAST %0
 523 ...
 524
 525 ---
 526 # CHECK-LABEL: name: bitcast_s64_gpr
 527 name:            bitcast_s64_gpr
 528 legalized:       true
 529
 530 # CHECK:      registers:
 531 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 532 # CHECK-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 533 registers:
 534   - { id: 0, class: _ }
 535   - { id: 1, class: _ }
 536
 537 # CHECK:  body:
 538 # CHECK:    %0(s64) = COPY %x0
 539 # CHECK:    %1(s64) = G_BITCAST %0
 540 body:             |
 541   bb.0:
 542     liveins: %x0
 543
 544     %0(s64) = COPY %x0
 545     %1(s64) = G_BITCAST %0
 546 ...
 547
 548 ---
 549 # CHECK-LABEL: name: bitcast_s64_fpr
 550 name:            bitcast_s64_fpr
 551 legalized:       true
 552
 553 # CHECK:      registers:
 554 # CHECK-NEXT:  - { id: 0, class: fpr, preferred-register: '' }
 555 # CHECK-NEXT:  - { id: 1, class: fpr, preferred-register: '' }
 556 registers:
 557   - { id: 0, class: _ }
 558   - { id: 1, class: _ }
 559
 560 # CHECK:  body:
 561 # CHECK:    %0(<2 x s32>) = COPY %d0
 562 # CHECK:    %1(<2 x s32>) = G_BITCAST %0
 563 body:             |
 564   bb.0:
 565     liveins: %d0
 566
 567     %0(<2 x s32>) = COPY %d0
 568     %1(<2 x s32>) = G_BITCAST %0
 569 ...
 570
 571 ---
 572 # CHECK-LABEL: name: bitcast_s64_gpr_fpr
 573 name:            bitcast_s64_gpr_fpr
 574 legalized:       true
 575
 576 # CHECK:      registers:
 577 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 578 # FAST-NEXT:  - { id: 1, class: fpr, preferred-register: '' }
 579 # GREEDY-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 580 registers:
 581   - { id: 0, class: _ }
 582   - { id: 1, class: _ }
 583 # CHECK:  body:
 584 # CHECK:    %0(s64) = COPY %x0
 585 # CHECK:    %1(<2 x s32>) = G_BITCAST %0
 586 body:             |
 587   bb.0:
 588     liveins: %x0
 589
 590     %0(s64) = COPY %x0
 591     %1(<2 x s32>) = G_BITCAST %0
 592 ...
 593
 594 ---
 595 # CHECK-LABEL: name: bitcast_s64_fpr_gpr
 596 name:            bitcast_s64_fpr_gpr
 597 legalized:       true
 598
 599 # CHECK:      registers:
 600 # CHECK-NEXT:  - { id: 0, class: fpr, preferred-register: '' }
 601 # FAST-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 602 # GREEDY-NEXT:  - { id: 1, class: fpr, preferred-register: '' }
 603 registers:
 604   - { id: 0, class: _ }
 605   - { id: 1, class: _ }
 606
 607 # CHECK:  body:
 608 # CHECK:    %0(<2 x s32>) = COPY %d0
 609 # CHECK:    %1(s64) = G_BITCAST %0
 610 body:             |
 611   bb.0:
 612     liveins: %d0
 613
 614     %0(<2 x s32>) = COPY %d0
 615     %1(s64) = G_BITCAST %0
 616 ...
 617
 618 ---
 619 # Make sure the greedy mode is able to take advantage of the
 620 # alternative mappings of G_LOAD to coalesce the whole chain
 621 # of computation on GPR.
 622 # CHECK-LABEL: name: greedyWithChainOfComputation
 623 name:            greedyWithChainOfComputation
 624 legalized:       true
 625
 626 # CHECK: registers:
 627 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 628 # CHECK-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 629 # FAST-NEXT:   - { id: 2, class: fpr, preferred-register: '' }
 630 # FAST-NEXT:   - { id: 3, class: fpr, preferred-register: '' }
 631 # FAST-NEXT:   - { id: 4, class: fpr, preferred-register: '' }
 632 # GREEDY-NEXT: - { id: 2, class: gpr, preferred-register: '' }
 633 # GREEDY-NEXT: - { id: 3, class: gpr, preferred-register: '' }
 634 # GREEDY-NEXT: - { id: 4, class: gpr, preferred-register: '' }
 635 # CHECK-NEXT:  - { id: 5, class: gpr, preferred-register: '' }
 636 registers:
 637   - { id: 0, class: _ }
 638   - { id: 1, class: _ }
 639   - { id: 2, class: _ }
 640   - { id: 3, class: _ }
 641   - { id: 4, class: _ }
 642   - { id: 5, class: _ }
 643
 644 # No repairing should be necessary for both modes.
 645 # CHECK:         %0(s64) = COPY %x0
 646 # CHECK-NEXT:    %1(p0) = COPY %x1
 647 # CHECK-NEXT:    %2(<2 x s32>) = G_BITCAST %0(s64)
 648 # CHECK-NEXT:    %3(<2 x s32>) = G_LOAD %1(p0) :: (load 8 from %ir.addr)
 649 # CHECK-NEXT:    %4(<2 x s32>) = G_OR %2, %3
 650 # CHECK-NEXT:    %5(s64) = G_BITCAST %4(<2 x s32>)
 651 # CHECK-NEXT:    %x0 = COPY %5(s64)
 652 # CHECK-NEXT:    RET_ReallyLR implicit %x0
 653
 654 body:             |
 655   bb.0:
 656     liveins: %x0, %x1
 657
 658     %0(s64) = COPY %x0
 659     %1(p0) = COPY %x1
 660     %2(<2 x s32>) = G_BITCAST %0(s64)
 661     %3(<2 x s32>) = G_LOAD %1(p0) :: (load 8 from %ir.addr)
 662     %4(<2 x s32>) = G_OR %2, %3
 663     %5(s64) = G_BITCAST %4(<2 x s32>)
 664     %x0 = COPY %5(s64)
 665     RET_ReallyLR implicit %x0
 666
 667 ...
 668
 669 ---
 670 # Make sure we map what looks like floating point
 671 # loads to floating point register bank.
 672 # CHECK-LABEL: name: floatingPointLoad
 673 name:            floatingPointLoad
 674 legalized:       true
 675
 676 # CHECK: registers:
 677 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 678 # CHECK-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 679 # CHECK-NEXT:   - { id: 2, class: fpr, preferred-register: '' }
 680 # CHECK-NEXT:   - { id: 3, class: fpr, preferred-register: '' }
 681 # CHECK-NEXT:   - { id: 4, class: fpr, preferred-register: '' }
 682 registers:
 683   - { id: 0, class: _ }
 684   - { id: 1, class: _ }
 685   - { id: 2, class: _ }
 686   - { id: 3, class: _ }
 687
 688 # No repairing should be necessary for both modes.
 689 # CHECK:         %0(s64) = COPY %x0
 690 # CHECK-NEXT:    %1(p0) = COPY %x1
 691 # CHECK-NEXT:    %2(s64) = G_LOAD %1(p0) :: (load 8 from %ir.addr)
 692 # %0 has been mapped to GPR, we need to repair to match FPR.
 693 # CHECK-NEXT:    %4(s64) = COPY %0
 694 # CHECK-NEXT:    %3(s64) = G_FADD %4, %2
 695 # CHECK-NEXT:    %x0 = COPY %3(s64)
 696 # CHECK-NEXT:    RET_ReallyLR implicit %x0
 697
 698 body:             |
 699   bb.0:
 700     liveins: %x0, %x1
 701
 702     %0(s64) = COPY %x0
 703     %1(p0) = COPY %x1
 704     %2(s64) = G_LOAD %1(p0) :: (load 8 from %ir.addr)
 705     %3(s64) = G_FADD %0, %2
 706     %x0 = COPY %3(s64)
 707     RET_ReallyLR implicit %x0
 708
 709 ...
 710
 711 ---
 712 # Make sure we map what looks like floating point
 713 # stores to floating point register bank.
 714 # CHECK-LABEL: name: floatingPointStore
 715 name:            floatingPointStore
 716 legalized:       true
 717
 718 # CHECK: registers:
 719 # CHECK-NEXT:  - { id: 0, class: gpr, preferred-register: '' }
 720 # CHECK-NEXT:  - { id: 1, class: gpr, preferred-register: '' }
 721 # CHECK-NEXT:   - { id: 2, class: fpr, preferred-register: '' }
 722 # CHECK-NEXT:   - { id: 3, class: fpr, preferred-register: '' }
 723 # CHECK-NEXT:   - { id: 4, class: fpr, preferred-register: '' }
 724 registers:
 725   - { id: 0, class: _ }
 726   - { id: 1, class: _ }
 727   - { id: 2, class: _ }
 728
 729 # CHECK:         %0(s64) = COPY %x0
 730 # CHECK-NEXT:    %1(p0) = COPY %x1
 731 # %0 has been mapped to GPR, we need to repair to match FPR.
 732 # CHECK-NEXT:    %3(s64) = COPY %0
 733 # CHECK-NEXT:    %4(s64) = COPY %0
 734 # CHECK-NEXT:    %2(s64) = G_FADD %3, %4
 735 # CHECK-NEXT:    G_STORE %2(s64), %1(p0) :: (store 8 into %ir.addr)
 736 # CHECK-NEXT:    RET_ReallyLR
 737
 738 body:             |
 739   bb.0:
 740     liveins: %x0, %x1
 741
 742     %0(s64) = COPY %x0
 743     %1(p0) = COPY %x1
 744     %2(s64) = G_FADD %0, %0
 745     G_STORE %2(s64), %1(p0) :: (store 8 into %ir.addr)
 746     RET_ReallyLR
 747
 748 ...