llvm/test/CodeGen/AArch64/GlobalISel/prelegalizercombiner-prop-extends-phi.mir

   1 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
   2 # RUN: llc -mtriple aarch64-apple-darwin -debugify-and-strip-all-safe -run-pass=aarch64-prelegalizer-combiner -global-isel -verify-machineinstrs %s -o - | FileCheck %s
   3
   4 # Check that we propagate the G_SEXT to the sources of the phi operand.
   5 ---
   6 name:            sext_icst_through_phi
   7 tracksRegLiveness: true
   8 body:             |
   9   ; CHECK-LABEL: name: sext_icst_through_phi
  10   ; CHECK: bb.0.entry:
  11   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
  12   ; CHECK-NEXT:   liveins: $w0, $w1
  13   ; CHECK-NEXT: {{  $}}
  14   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $w0
  15   ; CHECK-NEXT:   %one:_(s32) = G_CONSTANT i32 2
  16   ; CHECK-NEXT:   %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
  17   ; CHECK-NEXT:   G_BRCOND %cmp(s1), %bb.2
  18   ; CHECK-NEXT:   G_BR %bb.1
  19   ; CHECK-NEXT: {{  $}}
  20   ; CHECK-NEXT: bb.1:
  21   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
  22   ; CHECK-NEXT: {{  $}}
  23   ; CHECK-NEXT:   [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
  24   ; CHECK-NEXT:   G_BR %bb.3
  25   ; CHECK-NEXT: {{  $}}
  26   ; CHECK-NEXT: bb.2:
  27   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
  28   ; CHECK-NEXT: {{  $}}
  29   ; CHECK-NEXT:   [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
  30   ; CHECK-NEXT: {{  $}}
  31   ; CHECK-NEXT: bb.3:
  32   ; CHECK-NEXT:   %ext:_(s64) = G_PHI [[C]](s64), %bb.1, [[C1]](s64), %bb.2
  33   ; CHECK-NEXT:   $x0 = COPY %ext(s64)
  34   ; CHECK-NEXT:   RET_ReallyLR implicit $x0
  35   bb.1.entry:
  36     liveins: $w0, $w1
  37
  38     %0:_(s32) = COPY $w0
  39     %1:_(s32) = COPY $w1
  40     %zero:_(s32) = G_CONSTANT i32 0
  41     %one:_(s32) = G_CONSTANT i32 2
  42     %cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
  43     G_BRCOND %cmp(s1), %bb.2
  44     G_BR %bb.3
  45
  46   bb.2:
  47     %cst32_4:_(s32) = G_CONSTANT i32 4
  48     G_BR %bb.4
  49
  50   bb.3:
  51     %cst32_10:_(s32) = G_CONSTANT i32 10
  52
  53   bb.4:
  54     %phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3
  55     %ext:_(s64) = G_SEXT %phi
  56     $x0 = COPY %ext(s64)
  57     RET_ReallyLR implicit $x0
  58
  59 ...
  60
  61 # Check that we propagate the G_ZEXT to the sources of the phi operand.
  62 ---
  63 name:            zext_icst_through_phi
  64 tracksRegLiveness: true
  65 body:             |
  66   ; CHECK-LABEL: name: zext_icst_through_phi
  67   ; CHECK: bb.0.entry:
  68   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
  69   ; CHECK-NEXT:   liveins: $w0, $w1
  70   ; CHECK-NEXT: {{  $}}
  71   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $w0
  72   ; CHECK-NEXT:   %one:_(s32) = G_CONSTANT i32 2
  73   ; CHECK-NEXT:   %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
  74   ; CHECK-NEXT:   G_BRCOND %cmp(s1), %bb.2
  75   ; CHECK-NEXT:   G_BR %bb.1
  76   ; CHECK-NEXT: {{  $}}
  77   ; CHECK-NEXT: bb.1:
  78   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
  79   ; CHECK-NEXT: {{  $}}
  80   ; CHECK-NEXT:   [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
  81   ; CHECK-NEXT:   G_BR %bb.3
  82   ; CHECK-NEXT: {{  $}}
  83   ; CHECK-NEXT: bb.2:
  84   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
  85   ; CHECK-NEXT: {{  $}}
  86   ; CHECK-NEXT:   [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
  87   ; CHECK-NEXT: {{  $}}
  88   ; CHECK-NEXT: bb.3:
  89   ; CHECK-NEXT:   %ext:_(s64) = G_PHI [[C]](s64), %bb.1, [[C1]](s64), %bb.2
  90   ; CHECK-NEXT:   $x0 = COPY %ext(s64)
  91   ; CHECK-NEXT:   RET_ReallyLR implicit $x0
  92   bb.1.entry:
  93     liveins: $w0, $w1
  94
  95     %0:_(s32) = COPY $w0
  96     %1:_(s32) = COPY $w1
  97     %zero:_(s32) = G_CONSTANT i32 0
  98     %one:_(s32) = G_CONSTANT i32 2
  99     %cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
 100     G_BRCOND %cmp(s1), %bb.2
 101     G_BR %bb.3
 102
 103   bb.2:
 104     %cst32_4:_(s32) = G_CONSTANT i32 4
 105     G_BR %bb.4
 106
 107   bb.3:
 108     %cst32_10:_(s32) = G_CONSTANT i32 10
 109
 110   bb.4:
 111     %phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3
 112     %ext:_(s64) = G_ZEXT %phi
 113     $x0 = COPY %ext(s64)
 114     RET_ReallyLR implicit $x0
 115
 116 ...
 117
 118 # Don't handle vectors because of potential cost issues.
 119 ---
 120 name:            sext_load_through_phi_vector
 121 tracksRegLiveness: true
 122 body:             |
 123   ; CHECK-LABEL: name: sext_load_through_phi_vector
 124   ; CHECK: bb.0.entry:
 125   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
 126   ; CHECK-NEXT:   liveins: $x0, $q0, $q1
 127   ; CHECK-NEXT: {{  $}}
 128   ; CHECK-NEXT:   %ptr:_(p0) = COPY $x0
 129   ; CHECK-NEXT:   %cmp:_(s1) = G_IMPLICIT_DEF
 130   ; CHECK-NEXT:   G_BRCOND %cmp(s1), %bb.2
 131   ; CHECK-NEXT:   G_BR %bb.1
 132   ; CHECK-NEXT: {{  $}}
 133   ; CHECK-NEXT: bb.1:
 134   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 135   ; CHECK-NEXT: {{  $}}
 136   ; CHECK-NEXT:   %ld1:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))
 137   ; CHECK-NEXT:   G_BR %bb.3
 138   ; CHECK-NEXT: {{  $}}
 139   ; CHECK-NEXT: bb.2:
 140   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 141   ; CHECK-NEXT: {{  $}}
 142   ; CHECK-NEXT:   %ld2:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))
 143   ; CHECK-NEXT: {{  $}}
 144   ; CHECK-NEXT: bb.3:
 145   ; CHECK-NEXT:   %phi:_(<4 x s32>) = G_PHI %ld1(<4 x s32>), %bb.1, %ld2(<4 x s32>), %bb.2
 146   ; CHECK-NEXT:   %ext:_(<4 x s64>) = G_SEXT %phi(<4 x s32>)
 147   ; CHECK-NEXT:   G_STORE %ext(<4 x s64>), %ptr(p0) :: (store (<4 x s64>))
 148   ; CHECK-NEXT:   RET_ReallyLR
 149   bb.1.entry:
 150     liveins: $x0, $q0, $q1
 151
 152     %0:_(<4 x s32>) = COPY $q0
 153     %1:_(<4 x s32>) = COPY $q1
 154     %ptr:_(p0) = COPY $x0
 155     %cmp:_(s1) = G_IMPLICIT_DEF
 156     G_BRCOND %cmp(s1), %bb.2
 157     G_BR %bb.3
 158
 159   bb.2:
 160     %ld1:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))
 161     G_BR %bb.4
 162
 163   bb.3:
 164     %ld2:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))
 165
 166   bb.4:
 167     %phi:_(<4 x s32>) = G_PHI %ld1(<4 x s32>), %bb.2, %ld2(<4 x s32>), %bb.3
 168     %ext:_(<4 x s64>) = G_SEXT %phi
 169     G_STORE %ext(<4 x s64>), %ptr(p0) :: (store (<4 x s64>))
 170     RET_ReallyLR
 171
 172 ...
 173
 174
 175 # Check that we don't propagate if the extend is used by a G_PTR_ADD, which on
 176 # AArch64 has a good chance of folding in the extend.
 177 ---
 178 name:            sext_icst_through_phi_used_by_ptradd
 179 tracksRegLiveness: true
 180 body:             |
 181   ; CHECK-LABEL: name: sext_icst_through_phi_used_by_ptradd
 182   ; CHECK: bb.0.entry:
 183   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
 184   ; CHECK-NEXT:   liveins: $w0, $w1, $x2
 185   ; CHECK-NEXT: {{  $}}
 186   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $w0
 187   ; CHECK-NEXT:   %base:_(p0) = COPY $x2
 188   ; CHECK-NEXT:   %one:_(s32) = G_CONSTANT i32 2
 189   ; CHECK-NEXT:   %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
 190   ; CHECK-NEXT:   G_BRCOND %cmp(s1), %bb.2
 191   ; CHECK-NEXT:   G_BR %bb.1
 192   ; CHECK-NEXT: {{  $}}
 193   ; CHECK-NEXT: bb.1:
 194   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 195   ; CHECK-NEXT: {{  $}}
 196   ; CHECK-NEXT:   %cst32_4:_(s32) = G_CONSTANT i32 4
 197   ; CHECK-NEXT:   G_BR %bb.3
 198   ; CHECK-NEXT: {{  $}}
 199   ; CHECK-NEXT: bb.2:
 200   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 201   ; CHECK-NEXT: {{  $}}
 202   ; CHECK-NEXT:   %cst32_10:_(s32) = G_CONSTANT i32 10
 203   ; CHECK-NEXT: {{  $}}
 204   ; CHECK-NEXT: bb.3:
 205   ; CHECK-NEXT:   %phi:_(s32) = G_PHI %cst32_4(s32), %bb.1, %cst32_10(s32), %bb.2
 206   ; CHECK-NEXT:   %ext:_(s64) = G_SEXT %phi(s32)
 207   ; CHECK-NEXT:   %ptr:_(p0) = G_PTR_ADD %base, %ext(s64)
 208   ; CHECK-NEXT:   $x0 = COPY %ptr(p0)
 209   ; CHECK-NEXT:   RET_ReallyLR implicit $x0
 210   bb.1.entry:
 211     liveins: $w0, $w1, $x2
 212
 213     %0:_(s32) = COPY $w0
 214     %1:_(s32) = COPY $w1
 215     %base:_(p0) = COPY $x2
 216     %zero:_(s32) = G_CONSTANT i32 0
 217     %one:_(s32) = G_CONSTANT i32 2
 218     %cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
 219     G_BRCOND %cmp(s1), %bb.2
 220     G_BR %bb.3
 221
 222   bb.2:
 223     %cst32_4:_(s32) = G_CONSTANT i32 4
 224     G_BR %bb.4
 225
 226   bb.3:
 227     %cst32_10:_(s32) = G_CONSTANT i32 10
 228
 229   bb.4:
 230     %phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3
 231     %ext:_(s64) = G_SEXT %phi
 232     %ptr:_(p0) = G_PTR_ADD %base, %ext
 233     $x0 = COPY %ptr(p0)
 234     RET_ReallyLR implicit $x0
 235
 236 ...
 237
 238 # Same as above but we do it here because the extend has multiple users, so the
 239 # it probably won't cost extra instructions if we remove it.
 240 ---
 241 name:            sext_icst_through_phi_used_by_ptradd_multiuse
 242 tracksRegLiveness: true
 243 body:             |
 244   ; CHECK-LABEL: name: sext_icst_through_phi_used_by_ptradd_multiuse
 245   ; CHECK: bb.0.entry:
 246   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
 247   ; CHECK-NEXT:   liveins: $w0, $w1, $x2
 248   ; CHECK-NEXT: {{  $}}
 249   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $w0
 250   ; CHECK-NEXT:   %base:_(p0) = COPY $x2
 251   ; CHECK-NEXT:   %one:_(s32) = G_CONSTANT i32 2
 252   ; CHECK-NEXT:   %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
 253   ; CHECK-NEXT:   G_BRCOND %cmp(s1), %bb.2
 254   ; CHECK-NEXT:   G_BR %bb.1
 255   ; CHECK-NEXT: {{  $}}
 256   ; CHECK-NEXT: bb.1:
 257   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 258   ; CHECK-NEXT: {{  $}}
 259   ; CHECK-NEXT:   [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
 260   ; CHECK-NEXT:   G_BR %bb.3
 261   ; CHECK-NEXT: {{  $}}
 262   ; CHECK-NEXT: bb.2:
 263   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 264   ; CHECK-NEXT: {{  $}}
 265   ; CHECK-NEXT:   [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
 266   ; CHECK-NEXT: {{  $}}
 267   ; CHECK-NEXT: bb.3:
 268   ; CHECK-NEXT:   %ext:_(s64) = G_PHI [[C]](s64), %bb.1, [[C1]](s64), %bb.2
 269   ; CHECK-NEXT:   %ptr:_(p0) = G_PTR_ADD %base, %ext(s64)
 270   ; CHECK-NEXT:   $x0 = COPY %ptr(p0)
 271   ; CHECK-NEXT:   $x1 = COPY %ext(s64)
 272   ; CHECK-NEXT:   RET_ReallyLR implicit $x0
 273   bb.1.entry:
 274     liveins: $w0, $w1, $x2
 275
 276     %0:_(s32) = COPY $w0
 277     %1:_(s32) = COPY $w1
 278     %base:_(p0) = COPY $x2
 279     %zero:_(s32) = G_CONSTANT i32 0
 280     %one:_(s32) = G_CONSTANT i32 2
 281     %cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
 282     G_BRCOND %cmp(s1), %bb.2
 283     G_BR %bb.3
 284
 285   bb.2:
 286     %cst32_4:_(s32) = G_CONSTANT i32 4
 287     G_BR %bb.4
 288
 289   bb.3:
 290     %cst32_10:_(s32) = G_CONSTANT i32 10
 291
 292   bb.4:
 293     %phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3
 294     %ext:_(s64) = G_SEXT %phi
 295     %ptr:_(p0) = G_PTR_ADD %base, %ext
 296     $x0 = COPY %ptr(p0)
 297     $x1 = COPY %ext(s64)
 298     RET_ReallyLR implicit $x0
 299
 300 ...
 301
 302 # Check we don't propagate if there are more than 2 unique incoming values in the phi.
 303 # Doing so might cause too much code bloat.
 304 ---
 305 name:            zext_icst_through_phi_too_many_incoming
 306 tracksRegLiveness: true
 307 body:             |
 308   ; CHECK-LABEL: name: zext_icst_through_phi_too_many_incoming
 309   ; CHECK: bb.0.entry:
 310   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
 311   ; CHECK-NEXT:   liveins: $w0, $w1
 312   ; CHECK-NEXT: {{  $}}
 313   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $w0
 314   ; CHECK-NEXT:   %one:_(s32) = G_CONSTANT i32 2
 315   ; CHECK-NEXT:   %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
 316   ; CHECK-NEXT:   G_BRCOND %cmp(s1), %bb.2
 317   ; CHECK-NEXT:   G_BR %bb.1
 318   ; CHECK-NEXT: {{  $}}
 319   ; CHECK-NEXT: bb.1:
 320   ; CHECK-NEXT:   successors: %bb.3(0x40000000), %bb.4(0x40000000)
 321   ; CHECK-NEXT: {{  $}}
 322   ; CHECK-NEXT:   %cst32_4:_(s32) = G_CONSTANT i32 4
 323   ; CHECK-NEXT:   %cond:_(s1) = G_IMPLICIT_DEF
 324   ; CHECK-NEXT:   G_BRCOND %cond(s1), %bb.3
 325   ; CHECK-NEXT:   G_BR %bb.4
 326   ; CHECK-NEXT: {{  $}}
 327   ; CHECK-NEXT: bb.2:
 328   ; CHECK-NEXT:   successors: %bb.4(0x80000000)
 329   ; CHECK-NEXT: {{  $}}
 330   ; CHECK-NEXT:   %cst32_10:_(s32) = G_CONSTANT i32 10
 331   ; CHECK-NEXT:   G_BR %bb.4
 332   ; CHECK-NEXT: {{  $}}
 333   ; CHECK-NEXT: bb.3:
 334   ; CHECK-NEXT:   successors: %bb.4(0x80000000)
 335   ; CHECK-NEXT: {{  $}}
 336   ; CHECK-NEXT:   %cst32_42:_(s32) = G_CONSTANT i32 42
 337   ; CHECK-NEXT: {{  $}}
 338   ; CHECK-NEXT: bb.4:
 339   ; CHECK-NEXT:   %phi:_(s32) = G_PHI %cst32_4(s32), %bb.1, %cst32_10(s32), %bb.2, %cst32_42(s32), %bb.3
 340   ; CHECK-NEXT:   %ext:_(s64) = G_ZEXT %phi(s32)
 341   ; CHECK-NEXT:   $x0 = COPY %ext(s64)
 342   ; CHECK-NEXT:   RET_ReallyLR implicit $x0
 343   bb.1.entry:
 344     liveins: $w0, $w1
 345
 346     %0:_(s32) = COPY $w0
 347     %1:_(s32) = COPY $w1
 348     %zero:_(s32) = G_CONSTANT i32 0
 349     %one:_(s32) = G_CONSTANT i32 2
 350     %cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
 351     G_BRCOND %cmp(s1), %bb.2
 352     G_BR %bb.3
 353
 354   bb.2:
 355     %cst32_4:_(s32) = G_CONSTANT i32 4
 356     %cond:_(s1) = G_IMPLICIT_DEF
 357     G_BRCOND %cond, %bb.5
 358     G_BR %bb.4
 359
 360   bb.3:
 361     %cst32_10:_(s32) = G_CONSTANT i32 10
 362     G_BR %bb.4
 363
 364   bb.5:
 365     %cst32_42:_(s32) = G_CONSTANT i32 42
 366
 367   bb.4:
 368     %phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3, %cst32_42(s32), %bb.5
 369     %ext:_(s64) = G_ZEXT %phi
 370     $x0 = COPY %ext(s64)
 371     RET_ReallyLR implicit $x0
 372
 373 ...
 374
 375 # Check that we don't propagate if the extension would be of a non-allowed inst.
 376 ---
 377 name:            sext_add_through_phi
 378 tracksRegLiveness: true
 379 body:             |
 380   ; CHECK-LABEL: name: sext_add_through_phi
 381   ; CHECK: bb.0.entry:
 382   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
 383   ; CHECK-NEXT:   liveins: $w0, $w1
 384   ; CHECK-NEXT: {{  $}}
 385   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $w0
 386   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
 387   ; CHECK-NEXT:   %one:_(s32) = G_CONSTANT i32 2
 388   ; CHECK-NEXT:   %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
 389   ; CHECK-NEXT:   G_BRCOND %cmp(s1), %bb.2
 390   ; CHECK-NEXT:   G_BR %bb.1
 391   ; CHECK-NEXT: {{  $}}
 392   ; CHECK-NEXT: bb.1:
 393   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 394   ; CHECK-NEXT: {{  $}}
 395   ; CHECK-NEXT:   %add:_(s32) = G_ADD [[COPY]], [[COPY1]]
 396   ; CHECK-NEXT:   G_BR %bb.3
 397   ; CHECK-NEXT: {{  $}}
 398   ; CHECK-NEXT: bb.2:
 399   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 400   ; CHECK-NEXT: {{  $}}
 401   ; CHECK-NEXT:   %cst32_10:_(s32) = G_CONSTANT i32 10
 402   ; CHECK-NEXT: {{  $}}
 403   ; CHECK-NEXT: bb.3:
 404   ; CHECK-NEXT:   %phi:_(s32) = G_PHI %add(s32), %bb.1, %cst32_10(s32), %bb.2
 405   ; CHECK-NEXT:   %ext:_(s64) = G_SEXT %phi(s32)
 406   ; CHECK-NEXT:   $x0 = COPY %ext(s64)
 407   ; CHECK-NEXT:   RET_ReallyLR implicit $x0
 408   bb.1.entry:
 409     liveins: $w0, $w1
 410
 411     %0:_(s32) = COPY $w0
 412     %1:_(s32) = COPY $w1
 413     %zero:_(s32) = G_CONSTANT i32 0
 414     %one:_(s32) = G_CONSTANT i32 2
 415     %cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
 416     G_BRCOND %cmp(s1), %bb.2
 417     G_BR %bb.3
 418
 419   bb.2:
 420     %add:_(s32) = G_ADD %0, %1
 421     G_BR %bb.4
 422
 423   bb.3:
 424     %cst32_10:_(s32) = G_CONSTANT i32 10
 425
 426   bb.4:
 427     %phi:_(s32) = G_PHI %add(s32), %bb.2, %cst32_10(s32), %bb.3
 428     %ext:_(s64) = G_SEXT %phi
 429     $x0 = COPY %ext(s64)
 430     RET_ReallyLR implicit $x0
 431
 432 ...
 433
 434 # Same as above but allowed with a G_ANYEXT.
 435 ---
 436 name:            anyext_add_through_phi
 437 tracksRegLiveness: true
 438 body:             |
 439   ; CHECK-LABEL: name: anyext_add_through_phi
 440   ; CHECK: bb.0.entry:
 441   ; CHECK-NEXT:   successors: %bb.1(0x40000000), %bb.2(0x40000000)
 442   ; CHECK-NEXT:   liveins: $w0, $w1
 443   ; CHECK-NEXT: {{  $}}
 444   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $w0
 445   ; CHECK-NEXT:   [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
 446   ; CHECK-NEXT:   %one:_(s32) = G_CONSTANT i32 2
 447   ; CHECK-NEXT:   %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
 448   ; CHECK-NEXT:   G_BRCOND %cmp(s1), %bb.2
 449   ; CHECK-NEXT:   G_BR %bb.1
 450   ; CHECK-NEXT: {{  $}}
 451   ; CHECK-NEXT: bb.1:
 452   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 453   ; CHECK-NEXT: {{  $}}
 454   ; CHECK-NEXT:   %add:_(s32) = G_ADD [[COPY]], [[COPY1]]
 455   ; CHECK-NEXT:   [[ANYEXT:%[0-9]+]]:_(s64) = G_ANYEXT %add(s32)
 456   ; CHECK-NEXT:   G_BR %bb.3
 457   ; CHECK-NEXT: {{  $}}
 458   ; CHECK-NEXT: bb.2:
 459   ; CHECK-NEXT:   successors: %bb.3(0x80000000)
 460   ; CHECK-NEXT: {{  $}}
 461   ; CHECK-NEXT:   [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
 462   ; CHECK-NEXT: {{  $}}
 463   ; CHECK-NEXT: bb.3:
 464   ; CHECK-NEXT:   %ext:_(s64) = G_PHI [[ANYEXT]](s64), %bb.1, [[C]](s64), %bb.2
 465   ; CHECK-NEXT:   $x0 = COPY %ext(s64)
 466   ; CHECK-NEXT:   RET_ReallyLR implicit $x0
 467   bb.1.entry:
 468     liveins: $w0, $w1
 469
 470     %0:_(s32) = COPY $w0
 471     %1:_(s32) = COPY $w1
 472     %zero:_(s32) = G_CONSTANT i32 0
 473     %one:_(s32) = G_CONSTANT i32 2
 474     %cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
 475     G_BRCOND %cmp(s1), %bb.2
 476     G_BR %bb.3
 477
 478   bb.2:
 479     %add:_(s32) = G_ADD %0, %1
 480     G_BR %bb.4
 481
 482   bb.3:
 483     %cst32_10:_(s32) = G_CONSTANT i32 10
 484
 485   bb.4:
 486     %phi:_(s32) = G_PHI %add(s32), %bb.2, %cst32_10(s32), %bb.3
 487     %ext:_(s64) = G_ANYEXT %phi
 488     $x0 = COPY %ext(s64)
 489     RET_ReallyLR implicit $x0
 490
 491 ...