llvm/test/CodeGen/AArch64/GlobalISel/regbank-assert-zext.mir

   1 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
   2 # RUN: llc -mtriple=aarch64 -run-pass=regbankselect -verify-machineinstrs %s -o - | FileCheck %s
   3 #
   4 # Verify register banks for G_ASSERT_ZEXT.
   5 #
   6
   7 ...
   8 ---
   9 name:            gpr
  10 alignment:       4
  11 legalized:       true
  12 tracksRegLiveness: true
  13 body:             |
  14   bb.0:
  15     liveins: $w0, $w1
  16
  17     ; G_ASSERT_ZEXT should end up on a GPR.
  18
  19     ; CHECK-LABEL: name: gpr
  20     ; CHECK: liveins: $w0, $w1
  21     ; CHECK-NEXT: {{  $}}
  22     ; CHECK-NEXT: %copy:gpr(s32) = COPY $w0
  23     ; CHECK-NEXT: %copy_assert_zext:gpr(s32) = G_ASSERT_ZEXT %copy, 16
  24     ; CHECK-NEXT: $w1 = COPY %copy_assert_zext(s32)
  25     ; CHECK-NEXT: RET_ReallyLR implicit $w1
  26     %copy:_(s32) = COPY $w0
  27     %copy_assert_zext:_(s32) = G_ASSERT_ZEXT %copy(s32), 16
  28     $w1 = COPY %copy_assert_zext(s32)
  29     RET_ReallyLR implicit $w1
  30
  31 ...
  32 ---
  33 name:            gpr_vector
  34 alignment:       4
  35 legalized:       true
  36 tracksRegLiveness: true
  37 body:             |
  38   bb.0:
  39     liveins: $x0, $x1
  40
  41     ; G_ASSERT_ZEXT should end up on a GPR.
  42
  43     ; CHECK-LABEL: name: gpr_vector
  44     ; CHECK: liveins: $x0, $x1
  45     ; CHECK-NEXT: {{  $}}
  46     ; CHECK-NEXT: %copy:gpr(<2 x s32>) = COPY $x0
  47     ; CHECK-NEXT: %copy_assert_zext:gpr(<2 x s32>) = G_ASSERT_ZEXT %copy, 16
  48     ; CHECK-NEXT: $x1 = COPY %copy_assert_zext(<2 x s32>)
  49     ; CHECK-NEXT: RET_ReallyLR implicit $x1
  50     %copy:_(<2 x s32>) = COPY $x0
  51     %copy_assert_zext:_(<2 x s32>) = G_ASSERT_ZEXT %copy(<2 x s32>), 16
  52     $x1 = COPY %copy_assert_zext(<2 x s32>)
  53     RET_ReallyLR implicit $x1
  54
  55 ...
  56 ---
  57 name:            fpr
  58 alignment:       4
  59 legalized:       true
  60 tracksRegLiveness: true
  61 body:             |
  62   bb.0:
  63     liveins: $s0, $s1
  64
  65     ; G_ASSERT_ZEXT should end up on a FPR.
  66
  67     ; CHECK-LABEL: name: fpr
  68     ; CHECK: liveins: $s0, $s1
  69     ; CHECK-NEXT: {{  $}}
  70     ; CHECK-NEXT: %copy:fpr(s32) = COPY $s0
  71     ; CHECK-NEXT: %copy_assert_zext:fpr(s32) = G_ASSERT_ZEXT %copy, 16
  72     ; CHECK-NEXT: $s1 = COPY %copy_assert_zext(s32)
  73     ; CHECK-NEXT: RET_ReallyLR implicit $s1
  74     %copy:_(s32) = COPY $s0
  75     %copy_assert_zext:_(s32) = G_ASSERT_ZEXT %copy(s32), 16
  76     $s1 = COPY %copy_assert_zext(s32)
  77     RET_ReallyLR implicit $s1
  78
  79 ...
  80 ---
  81 name:            fpr_vector
  82 alignment:       4
  83 legalized:       true
  84 tracksRegLiveness: true
  85 body:             |
  86   bb.0:
  87     liveins: $d0, $d1
  88
  89     ; G_ASSERT_ZEXT should end up on a FPR.
  90
  91     ; CHECK-LABEL: name: fpr_vector
  92     ; CHECK: liveins: $d0, $d1
  93     ; CHECK-NEXT: {{  $}}
  94     ; CHECK-NEXT: %copy:fpr(<2 x s32>) = COPY $d0
  95     ; CHECK-NEXT: %copy_assert_zext:fpr(<2 x s32>) = G_ASSERT_ZEXT %copy, 16
  96     ; CHECK-NEXT: $d1 = COPY %copy_assert_zext(<2 x s32>)
  97     ; CHECK-NEXT: RET_ReallyLR implicit $d1
  98     %copy:_(<2 x s32>) = COPY $d0
  99     %copy_assert_zext:_(<2 x s32>) = G_ASSERT_ZEXT %copy(<2 x s32>), 16
 100     $d1 = COPY %copy_assert_zext(<2 x s32>)
 101     RET_ReallyLR implicit $d1
 102
 103 ...
 104 ---
 105 name:            in_between_cross_bank_copy
 106 alignment:       4
 107 legalized:       true
 108 tracksRegLiveness: true
 109 body:             |
 110   bb.0:
 111     liveins: $s0, $w1
 112
 113     ; CHECK-LABEL: name: in_between_cross_bank_copy
 114     ; CHECK: liveins: $s0, $w1
 115     ; CHECK-NEXT: {{  $}}
 116     ; CHECK-NEXT: %copy:fpr(s32) = COPY $s0
 117     ; CHECK-NEXT: %copy_assert_zext:fpr(s32) = G_ASSERT_ZEXT %copy, 16
 118     ; CHECK-NEXT: $w1 = COPY %copy_assert_zext(s32)
 119     ; CHECK-NEXT: RET_ReallyLR implicit $w1
 120     %copy:_(s32) = COPY $s0
 121     %copy_assert_zext:_(s32) = G_ASSERT_ZEXT %copy(s32), 16
 122     $w1 = COPY %copy_assert_zext(s32)
 123     RET_ReallyLR implicit $w1
 124
 125 ...
 126 ---
 127 name:            fpr_feeding_store
 128 alignment:       4
 129 legalized:       true
 130 tracksRegLiveness: true
 131 body:             |
 132   bb.0:
 133     liveins: $x0, $s0, $s1
 134
 135     ; The G_ASSERT_ZEXT should end up on a FPR, and there should be no copy
 136     ; between it and the G_STORE.
 137
 138     ; CHECK-LABEL: name: fpr_feeding_store
 139     ; CHECK: liveins: $x0, $s0, $s1
 140     ; CHECK-NEXT: {{  $}}
 141     ; CHECK-NEXT: %ptr:gpr(p0) = COPY $x0
 142     ; CHECK-NEXT: %copy:fpr(s32) = COPY $s0
 143     ; CHECK-NEXT: %copy_assert_zext:fpr(s32) = G_ASSERT_ZEXT %copy, 16
 144     ; CHECK-NEXT: G_STORE %copy_assert_zext(s32), %ptr(p0) :: (store (s32))
 145     ; CHECK-NEXT: RET_ReallyLR
 146     %ptr:_(p0) = COPY $x0
 147     %copy:_(s32) = COPY $s0
 148     %copy_assert_zext:_(s32) = G_ASSERT_ZEXT %copy(s32), 16
 149     G_STORE %copy_assert_zext(s32), %ptr(p0) :: (store (s32))
 150     RET_ReallyLR
 151
 152 ...
 153 ---
 154 name:            fpr_feeding_select
 155 alignment:       4
 156 legalized:       true
 157 tracksRegLiveness: true
 158 machineFunctionInfo: {}
 159 body:             |
 160   bb.0:
 161     liveins: $d0, $x1, $w0
 162
 163     ; G_ASSERT_ZEXT and G_SELECT should both end up on FPRs.
 164
 165     ; CHECK-LABEL: name: fpr_feeding_select
 166     ; CHECK: liveins: $d0, $x1, $w0
 167     ; CHECK-NEXT: {{  $}}
 168     ; CHECK-NEXT: %w0:gpr(s32) = COPY $w0
 169     ; CHECK-NEXT: %fpr:fpr(s64) = COPY $d0
 170     ; CHECK-NEXT: %fpr_assert_zext:fpr(s64) = G_ASSERT_ZEXT %fpr, 32
 171     ; CHECK-NEXT: %gpr:gpr(s64) = COPY $x1
 172     ; CHECK-NEXT: [[COPY:%[0-9]+]]:fpr(s64) = COPY %gpr(s64)
 173     ; CHECK-NEXT: %select:fpr(s64) = G_SELECT %w0(s32), %fpr_assert_zext, [[COPY]]
 174     ; CHECK-NEXT: $d0 = COPY %select(s64)
 175     ; CHECK-NEXT: RET_ReallyLR implicit $d0
 176     %w0:_(s32) = COPY $w0
 177     %fpr:_(s64) = COPY $d0
 178     %fpr_assert_zext:_(s64) = G_ASSERT_ZEXT %fpr, 32
 179     %gpr:_(s64) = COPY $x1
 180     %select:_(s64) = G_SELECT %w0, %fpr_assert_zext, %gpr
 181     $d0 = COPY %select(s64)
 182     RET_ReallyLR implicit $d0
 183
 184 ...
 185 ---
 186 name:            fpr_feeding_phi
 187 alignment:       4
 188 legalized:       true
 189 tracksRegLiveness: true
 190 body:             |
 191   ; CHECK-LABEL: name: fpr_feeding_phi
 192   ; CHECK: bb.0:
 193   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
 194   ; CHECK-NEXT:   liveins: $s0, $w1
 195   ; CHECK-NEXT: {{  $}}
 196   ; CHECK-NEXT:   %copy1:fpr(s32) = COPY $s0
 197   ; CHECK-NEXT:   %copy2:gpr(s32) = COPY $w1
 198   ; CHECK-NEXT:   %copy_assert_zext:fpr(s32) = G_ASSERT_ZEXT %copy1, 16
 199   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr(s32) = COPY %copy1(s32)
 200   ; CHECK-NEXT:   %cmp:gpr(s32) = G_ICMP intpred(eq), [[COPY]](s32), %copy2
 201   ; CHECK-NEXT:   G_BRCOND %cmp(s32), %bb.1
 202   ; CHECK-NEXT:   G_BR %bb.1
 203   ; CHECK-NEXT: {{  $}}
 204   ; CHECK-NEXT: bb.1:
 205   ; CHECK-NEXT:   successors: %bb.2(0x80000000)
 206   ; CHECK-NEXT: {{  $}}
 207   ; CHECK-NEXT:   %bb1_val:gpr(s32) = COPY %copy2(s32)
 208   ; CHECK-NEXT:   G_BR %bb.2
 209   ; CHECK-NEXT: {{  $}}
 210   ; CHECK-NEXT: bb.2:
 211   ; CHECK-NEXT:   successors: %bb.0(0x80000000)
 212   ; CHECK-NEXT: {{  $}}
 213   ; CHECK-NEXT:   %phi:fpr(s32) = G_PHI %copy_assert_zext(s32), %bb.0, %bb1_val(s32), %bb.1
 214   ; CHECK-NEXT:   G_BR %bb.0
 215   bb.0:
 216     successors: %bb.1, %bb.2
 217     liveins: $s0, $w1
 218     %copy1:_(s32) = COPY $s0
 219     %copy2:_(s32) = COPY $w1
 220
 221     ; This should produce a FPR.
 222     %copy_assert_zext:_(s32) = G_ASSERT_ZEXT %copy1(s32), 16
 223
 224     %cmp:_(s32) = G_ICMP intpred(eq), %copy1, %copy2
 225     G_BRCOND %cmp, %bb.1
 226     G_BR %bb.1
 227   bb.1:
 228     successors: %bb.2
 229     %bb1_val:_(s32) = COPY %copy2
 230     G_BR %bb.2
 231   bb.2:
 232     successors: %bb.0
 233     ; This should produce a FPR.
 234     %phi:_(s32) = G_PHI %copy_assert_zext, %bb.0, %bb1_val, %bb.1
 235     G_BR %bb.0
 236
 237 ...
 238 ---
 239 name:            fed_by_fpr_phi
 240 alignment:       4
 241 legalized:       true
 242 tracksRegLiveness: true
 243 body:             |
 244   ; CHECK-LABEL: name: fed_by_fpr_phi
 245   ; CHECK: bb.0:
 246   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
 247   ; CHECK-NEXT:   liveins: $s0, $s1
 248   ; CHECK-NEXT: {{  $}}
 249   ; CHECK-NEXT:   %copy1:fpr(s32) = COPY $s0
 250   ; CHECK-NEXT:   %copy2:fpr(s32) = COPY $s1
 251   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:gpr(s32) = COPY %copy1(s32)
 252   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:gpr(s32) = COPY %copy2(s32)
 253   ; CHECK-NEXT:   %cmp:gpr(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]]
 254   ; CHECK-NEXT:   G_BRCOND %cmp(s32), %bb.1
 255   ; CHECK-NEXT:   G_BR %bb.1
 256   ; CHECK-NEXT: {{  $}}
 257   ; CHECK-NEXT: bb.1:
 258   ; CHECK-NEXT:   successors: %bb.2(0x80000000)
 259   ; CHECK-NEXT: {{  $}}
 260   ; CHECK-NEXT:   %bb1_val:gpr(s32) = COPY %copy2(s32)
 261   ; CHECK-NEXT:   G_BR %bb.2
 262   ; CHECK-NEXT: {{  $}}
 263   ; CHECK-NEXT: bb.2:
 264   ; CHECK-NEXT:   successors: %bb.0(0x80000000)
 265   ; CHECK-NEXT: {{  $}}
 266   ; CHECK-NEXT:   %phi:fpr(s32) = G_PHI %copy1(s32), %bb.0, %bb1_val(s32), %bb.1
 267   ; CHECK-NEXT:   %assert_zext:fpr(s32) = G_ASSERT_ZEXT %phi, 16
 268   ; CHECK-NEXT:   G_BR %bb.0
 269   bb.0:
 270     successors: %bb.1, %bb.2
 271     liveins: $s0, $s1
 272     %copy1:_(s32) = COPY $s0
 273     %copy2:_(s32) = COPY $s1
 274     %cmp:_(s32) = G_ICMP intpred(eq), %copy1, %copy2
 275     G_BRCOND %cmp, %bb.1
 276     G_BR %bb.1
 277   bb.1:
 278     successors: %bb.2
 279     %bb1_val:_(s32) = COPY %copy2
 280     G_BR %bb.2
 281   bb.2:
 282     successors: %bb.0
 283     ; The G_PHI and G_ASSERT_ZEXT should both end up on FPRs.
 284     %phi:_(s32) = G_PHI %copy1, %bb.0, %bb1_val, %bb.1
 285     %assert_zext:_(s32) = G_ASSERT_ZEXT %phi(s32), 16
 286     G_BR %bb.0
 287
 288 ...
 289 ---
 290 name:            different_blocks_gpr
 291 alignment:       4
 292 legalized:       true
 293 tracksRegLiveness: true
 294 body:             |
 295   ; CHECK-LABEL: name: different_blocks_gpr
 296   ; CHECK: bb.0:
 297   ; CHECK-NEXT:   successors: %bb.1(0x80000000)
 298   ; CHECK-NEXT:   liveins: $w0, $w1
 299   ; CHECK-NEXT: {{  $}}
 300   ; CHECK-NEXT:   %copy:gpr(s32) = COPY $w0
 301   ; CHECK-NEXT:   G_BR %bb.1
 302   ; CHECK-NEXT: {{  $}}
 303   ; CHECK-NEXT: bb.1:
 304   ; CHECK-NEXT:   %copy_assert_zext:gpr(s32) = G_ASSERT_ZEXT %copy, 16
 305   ; CHECK-NEXT:   $w1 = COPY %copy_assert_zext(s32)
 306   ; CHECK-NEXT:   RET_ReallyLR implicit $w1
 307   bb.0:
 308     successors: %bb.1
 309     liveins: $w0, $w1
 310     %copy:_(s32) = COPY $w0
 311     G_BR %bb.1
 312   bb.1:
 313     ; The G_ASSERT_ZEXT should end up on a GPR.
 314     %copy_assert_zext:_(s32) = G_ASSERT_ZEXT %copy(s32), 16
 315     $w1 = COPY %copy_assert_zext
 316     RET_ReallyLR implicit $w1
 317
 318 ...
 319 ---
 320 name:            different_blocks_fpr
 321 alignment:       4
 322 legalized:       true
 323 tracksRegLiveness: true
 324 body:             |
 325   ; CHECK-LABEL: name: different_blocks_fpr
 326   ; CHECK: bb.0:
 327   ; CHECK-NEXT:   successors: %bb.1(0x80000000)
 328   ; CHECK-NEXT:   liveins: $s0, $s1
 329   ; CHECK-NEXT: {{  $}}
 330   ; CHECK-NEXT:   %copy:fpr(s32) = COPY $s0
 331   ; CHECK-NEXT:   G_BR %bb.1
 332   ; CHECK-NEXT: {{  $}}
 333   ; CHECK-NEXT: bb.1:
 334   ; CHECK-NEXT:   %copy_assert_zext:fpr(s32) = G_ASSERT_ZEXT %copy, 16
 335   ; CHECK-NEXT:   $s1 = COPY %copy_assert_zext(s32)
 336   ; CHECK-NEXT:   RET_ReallyLR implicit $s1
 337   bb.0:
 338     successors: %bb.1
 339     liveins: $s0, $s1
 340     %copy:_(s32) = COPY $s0
 341     G_BR %bb.1
 342   bb.1:
 343     ; The G_ASSERT_ZEXT should end up on a FPR.
 344     %copy_assert_zext:_(s32) = G_ASSERT_ZEXT %copy(s32), 16
 345     $s1 = COPY %copy_assert_zext
 346     RET_ReallyLR implicit $s1
 347
 348
 349 ...
 350 ---
 351 name:            different_blocks_fpr_backedge
 352 alignment:       4
 353 legalized:       true
 354 tracksRegLiveness: true
 355 body:             |
 356   ; CHECK-LABEL: name: different_blocks_fpr_backedge
 357   ; CHECK: bb.0:
 358   ; CHECK-NEXT:   successors: %bb.1(0x80000000)
 359   ; CHECK-NEXT:   liveins: $s0, $s1
 360   ; CHECK-NEXT: {{  $}}
 361   ; CHECK-NEXT:   %copy:fpr(s32) = COPY $s0
 362   ; CHECK-NEXT:   G_BR %bb.1
 363   ; CHECK-NEXT: {{  $}}
 364   ; CHECK-NEXT: bb.1:
 365   ; CHECK-NEXT:   successors: %bb.2(0x80000000)
 366   ; CHECK-NEXT: {{  $}}
 367   ; CHECK-NEXT:   %copy_assert_zext1:fpr(s32) = G_ASSERT_ZEXT %copy, 16
 368   ; CHECK-NEXT:   G_BR %bb.2
 369   ; CHECK-NEXT: {{  $}}
 370   ; CHECK-NEXT: bb.2:
 371   ; CHECK-NEXT:   successors: %bb.0(0x80000000)
 372   ; CHECK-NEXT: {{  $}}
 373   ; CHECK-NEXT:   %copy_assert_zext2:fpr(s32) = G_ASSERT_ZEXT %copy_assert_zext1, 16
 374   ; CHECK-NEXT:   %copy_assert_zext3:fpr(s32) = G_ASSERT_ZEXT %copy_assert_zext2, 16
 375   ; CHECK-NEXT:   G_BR %bb.0
 376   bb.0:
 377     successors: %bb.1
 378     liveins: $s0, $s1
 379     %copy:_(s32) = COPY $s0
 380     G_BR %bb.1
 381   bb.1:
 382     successors: %bb.2
 383     ; All of the G_ASSERT_ZEXTs should end up on FPRs.
 384     %copy_assert_zext1:_(s32) = G_ASSERT_ZEXT %copy(s32), 16
 385     G_BR %bb.2
 386   bb.2:
 387     successors: %bb.0
 388     %copy_assert_zext2:_(s32) = G_ASSERT_ZEXT %copy_assert_zext1(s32), 16
 389     %copy_assert_zext3:_(s32) = G_ASSERT_ZEXT %copy_assert_zext2(s32), 16
 390     G_BR %bb.0