# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple aarch64-apple-darwin -debugify-and-strip-all-safe -run-pass=aarch64-prelegalizer-combiner -global-isel -verify-machineinstrs %s -o - | FileCheck %s
# Check that we propagate the G_SEXT to the sources of the phi operand.
---
name: sext_icst_through_phi
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: sext_icst_through_phi
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $w0, $w1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
; CHECK-NEXT: %one:_(s32) = G_CONSTANT i32 2
; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
; CHECK-NEXT: G_BR %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: %ext:_(s64) = G_PHI [[C]](s64), %bb.1, [[C1]](s64), %bb.2
; CHECK-NEXT: $x0 = COPY %ext(s64)
; CHECK-NEXT: RET_ReallyLR implicit $x0
bb.1.entry:
liveins: $w0, $w1
%0:_(s32) = COPY $w0
%1:_(s32) = COPY $w1
%zero:_(s32) = G_CONSTANT i32 0
%one:_(s32) = G_CONSTANT i32 2
%cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%cst32_4:_(s32) = G_CONSTANT i32 4
G_BR %bb.4
bb.3:
%cst32_10:_(s32) = G_CONSTANT i32 10
bb.4:
%phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3
%ext:_(s64) = G_SEXT %phi
$x0 = COPY %ext(s64)
RET_ReallyLR implicit $x0
...
# Check that we propagate the G_ZEXT to the sources of the phi operand.
---
name: zext_icst_through_phi
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: zext_icst_through_phi
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $w0, $w1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
; CHECK-NEXT: %one:_(s32) = G_CONSTANT i32 2
; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
; CHECK-NEXT: G_BR %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: %ext:_(s64) = G_PHI [[C]](s64), %bb.1, [[C1]](s64), %bb.2
; CHECK-NEXT: $x0 = COPY %ext(s64)
; CHECK-NEXT: RET_ReallyLR implicit $x0
bb.1.entry:
liveins: $w0, $w1
%0:_(s32) = COPY $w0
%1:_(s32) = COPY $w1
%zero:_(s32) = G_CONSTANT i32 0
%one:_(s32) = G_CONSTANT i32 2
%cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%cst32_4:_(s32) = G_CONSTANT i32 4
G_BR %bb.4
bb.3:
%cst32_10:_(s32) = G_CONSTANT i32 10
bb.4:
%phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3
%ext:_(s64) = G_ZEXT %phi
$x0 = COPY %ext(s64)
RET_ReallyLR implicit $x0
...
# Don't handle vectors because of potential cost issues.
---
name: sext_load_through_phi_vector
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: sext_load_through_phi_vector
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $x0, $q0, $q1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %ptr:_(p0) = COPY $x0
; CHECK-NEXT: %cmp:_(s1) = G_IMPLICIT_DEF
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %ld1:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))
; CHECK-NEXT: G_BR %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %ld2:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: %phi:_(<4 x s32>) = G_PHI %ld1(<4 x s32>), %bb.1, %ld2(<4 x s32>), %bb.2
; CHECK-NEXT: %ext:_(<4 x s64>) = G_SEXT %phi(<4 x s32>)
; CHECK-NEXT: G_STORE %ext(<4 x s64>), %ptr(p0) :: (store (<4 x s64>))
; CHECK-NEXT: RET_ReallyLR
bb.1.entry:
liveins: $x0, $q0, $q1
%0:_(<4 x s32>) = COPY $q0
%1:_(<4 x s32>) = COPY $q1
%ptr:_(p0) = COPY $x0
%cmp:_(s1) = G_IMPLICIT_DEF
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%ld1:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))
G_BR %bb.4
bb.3:
%ld2:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))
bb.4:
%phi:_(<4 x s32>) = G_PHI %ld1(<4 x s32>), %bb.2, %ld2(<4 x s32>), %bb.3
%ext:_(<4 x s64>) = G_SEXT %phi
G_STORE %ext(<4 x s64>), %ptr(p0) :: (store (<4 x s64>))
RET_ReallyLR
...
# Check that we don't propagate if the extend is used by a G_PTR_ADD, which on
# AArch64 has a good chance of folding in the extend.
---
name: sext_icst_through_phi_used_by_ptradd
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: sext_icst_through_phi_used_by_ptradd
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $w0, $w1, $x2
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
; CHECK-NEXT: %base:_(p0) = COPY $x2
; CHECK-NEXT: %one:_(s32) = G_CONSTANT i32 2
; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %cst32_4:_(s32) = G_CONSTANT i32 4
; CHECK-NEXT: G_BR %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %cst32_10:_(s32) = G_CONSTANT i32 10
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: %phi:_(s32) = G_PHI %cst32_4(s32), %bb.1, %cst32_10(s32), %bb.2
; CHECK-NEXT: %ext:_(s64) = G_SEXT %phi(s32)
; CHECK-NEXT: %ptr:_(p0) = G_PTR_ADD %base, %ext(s64)
; CHECK-NEXT: $x0 = COPY %ptr(p0)
; CHECK-NEXT: RET_ReallyLR implicit $x0
bb.1.entry:
liveins: $w0, $w1, $x2
%0:_(s32) = COPY $w0
%1:_(s32) = COPY $w1
%base:_(p0) = COPY $x2
%zero:_(s32) = G_CONSTANT i32 0
%one:_(s32) = G_CONSTANT i32 2
%cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%cst32_4:_(s32) = G_CONSTANT i32 4
G_BR %bb.4
bb.3:
%cst32_10:_(s32) = G_CONSTANT i32 10
bb.4:
%phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3
%ext:_(s64) = G_SEXT %phi
%ptr:_(p0) = G_PTR_ADD %base, %ext
$x0 = COPY %ptr(p0)
RET_ReallyLR implicit $x0
...
# Same as above but we do it here because the extend has multiple users, so the
# it probably won't cost extra instructions if we remove it.
---
name: sext_icst_through_phi_used_by_ptradd_multiuse
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: sext_icst_through_phi_used_by_ptradd_multiuse
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $w0, $w1, $x2
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
; CHECK-NEXT: %base:_(p0) = COPY $x2
; CHECK-NEXT: %one:_(s32) = G_CONSTANT i32 2
; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 4
; CHECK-NEXT: G_BR %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: %ext:_(s64) = G_PHI [[C]](s64), %bb.1, [[C1]](s64), %bb.2
; CHECK-NEXT: %ptr:_(p0) = G_PTR_ADD %base, %ext(s64)
; CHECK-NEXT: $x0 = COPY %ptr(p0)
; CHECK-NEXT: $x1 = COPY %ext(s64)
; CHECK-NEXT: RET_ReallyLR implicit $x0
bb.1.entry:
liveins: $w0, $w1, $x2
%0:_(s32) = COPY $w0
%1:_(s32) = COPY $w1
%base:_(p0) = COPY $x2
%zero:_(s32) = G_CONSTANT i32 0
%one:_(s32) = G_CONSTANT i32 2
%cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%cst32_4:_(s32) = G_CONSTANT i32 4
G_BR %bb.4
bb.3:
%cst32_10:_(s32) = G_CONSTANT i32 10
bb.4:
%phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3
%ext:_(s64) = G_SEXT %phi
%ptr:_(p0) = G_PTR_ADD %base, %ext
$x0 = COPY %ptr(p0)
$x1 = COPY %ext(s64)
RET_ReallyLR implicit $x0
...
# Check we don't propagate if there are more than 2 unique incoming values in the phi.
# Doing so might cause too much code bloat.
---
name: zext_icst_through_phi_too_many_incoming
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: zext_icst_through_phi_too_many_incoming
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $w0, $w1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
; CHECK-NEXT: %one:_(s32) = G_CONSTANT i32 2
; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x40000000), %bb.4(0x40000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %cst32_4:_(s32) = G_CONSTANT i32 4
; CHECK-NEXT: %cond:_(s1) = G_IMPLICIT_DEF
; CHECK-NEXT: G_BRCOND %cond(s1), %bb.3
; CHECK-NEXT: G_BR %bb.4
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.4(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %cst32_10:_(s32) = G_CONSTANT i32 10
; CHECK-NEXT: G_BR %bb.4
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: successors: %bb.4(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %cst32_42:_(s32) = G_CONSTANT i32 42
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.4:
; CHECK-NEXT: %phi:_(s32) = G_PHI %cst32_4(s32), %bb.1, %cst32_10(s32), %bb.2, %cst32_42(s32), %bb.3
; CHECK-NEXT: %ext:_(s64) = G_ZEXT %phi(s32)
; CHECK-NEXT: $x0 = COPY %ext(s64)
; CHECK-NEXT: RET_ReallyLR implicit $x0
bb.1.entry:
liveins: $w0, $w1
%0:_(s32) = COPY $w0
%1:_(s32) = COPY $w1
%zero:_(s32) = G_CONSTANT i32 0
%one:_(s32) = G_CONSTANT i32 2
%cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%cst32_4:_(s32) = G_CONSTANT i32 4
%cond:_(s1) = G_IMPLICIT_DEF
G_BRCOND %cond, %bb.5
G_BR %bb.4
bb.3:
%cst32_10:_(s32) = G_CONSTANT i32 10
G_BR %bb.4
bb.5:
%cst32_42:_(s32) = G_CONSTANT i32 42
bb.4:
%phi:_(s32) = G_PHI %cst32_4(s32), %bb.2, %cst32_10(s32), %bb.3, %cst32_42(s32), %bb.5
%ext:_(s64) = G_ZEXT %phi
$x0 = COPY %ext(s64)
RET_ReallyLR implicit $x0
...
# Check that we don't propagate if the extension would be of a non-allowed inst.
---
name: sext_add_through_phi
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: sext_add_through_phi
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $w0, $w1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
; CHECK-NEXT: %one:_(s32) = G_CONSTANT i32 2
; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %add:_(s32) = G_ADD [[COPY]], [[COPY1]]
; CHECK-NEXT: G_BR %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %cst32_10:_(s32) = G_CONSTANT i32 10
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: %phi:_(s32) = G_PHI %add(s32), %bb.1, %cst32_10(s32), %bb.2
; CHECK-NEXT: %ext:_(s64) = G_SEXT %phi(s32)
; CHECK-NEXT: $x0 = COPY %ext(s64)
; CHECK-NEXT: RET_ReallyLR implicit $x0
bb.1.entry:
liveins: $w0, $w1
%0:_(s32) = COPY $w0
%1:_(s32) = COPY $w1
%zero:_(s32) = G_CONSTANT i32 0
%one:_(s32) = G_CONSTANT i32 2
%cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%add:_(s32) = G_ADD %0, %1
G_BR %bb.4
bb.3:
%cst32_10:_(s32) = G_CONSTANT i32 10
bb.4:
%phi:_(s32) = G_PHI %add(s32), %bb.2, %cst32_10(s32), %bb.3
%ext:_(s64) = G_SEXT %phi
$x0 = COPY %ext(s64)
RET_ReallyLR implicit $x0
...
# Same as above but allowed with a G_ANYEXT.
---
name: anyext_add_through_phi
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: anyext_add_through_phi
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $w0, $w1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
; CHECK-NEXT: %one:_(s32) = G_CONSTANT i32 2
; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %add:_(s32) = G_ADD [[COPY]], [[COPY1]]
; CHECK-NEXT: [[ANYEXT:%[0-9]+]]:_(s64) = G_ANYEXT %add(s32)
; CHECK-NEXT: G_BR %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: %ext:_(s64) = G_PHI [[ANYEXT]](s64), %bb.1, [[C]](s64), %bb.2
; CHECK-NEXT: $x0 = COPY %ext(s64)
; CHECK-NEXT: RET_ReallyLR implicit $x0
bb.1.entry:
liveins: $w0, $w1
%0:_(s32) = COPY $w0
%1:_(s32) = COPY $w1
%zero:_(s32) = G_CONSTANT i32 0
%one:_(s32) = G_CONSTANT i32 2
%cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%add:_(s32) = G_ADD %0, %1
G_BR %bb.4
bb.3:
%cst32_10:_(s32) = G_CONSTANT i32 10
bb.4:
%phi:_(s32) = G_PHI %add(s32), %bb.2, %cst32_10(s32), %bb.3
%ext:_(s64) = G_ANYEXT %phi
$x0 = COPY %ext(s64)
RET_ReallyLR implicit $x0
...
# Same as above but with a source MI with multiple destination operands.
---
name: anyext_add_through_phi_multiple_operands
tracksRegLiveness: true
body: |
; CHECK-LABEL: name: anyext_add_through_phi_multiple_operands
; CHECK: bb.0.entry:
; CHECK-NEXT: successors: %bb.1(0x40000000), %bb.2(0x40000000)
; CHECK-NEXT: liveins: $w0, $w1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $w0
; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $w1
; CHECK-NEXT: %one:_(s32) = G_CONSTANT i32 2
; CHECK-NEXT: %cmp:_(s1) = G_ICMP intpred(sle), [[COPY]](s32), %one
; CHECK-NEXT: G_BRCOND %cmp(s1), %bb.2
; CHECK-NEXT: G_BR %bb.1
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.1:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: %big0:_(s64) = G_SEXT [[COPY]](s32)
; CHECK-NEXT: %big1:_(s64) = G_SEXT [[COPY1]](s32)
; CHECK-NEXT: %add:_(s64) = G_ADD %big0, %big1
; CHECK-NEXT: %first:_(s32), %second:_(s32) = G_UNMERGE_VALUES %add(s64)
; CHECK-NEXT: [[ANYEXT:%[0-9]+]]:_(s64) = G_ANYEXT %second(s32)
; CHECK-NEXT: G_BR %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.2:
; CHECK-NEXT: successors: %bb.3(0x80000000)
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 10
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
; CHECK-NEXT: %ext:_(s64) = G_PHI [[ANYEXT]](s64), %bb.1, [[C]](s64), %bb.2
; CHECK-NEXT: $x0 = COPY %ext(s64)
; CHECK-NEXT: RET_ReallyLR implicit $x0
bb.1.entry:
liveins: $w0, $w1
%0:_(s32) = COPY $w0
%1:_(s32) = COPY $w1
%zero:_(s32) = G_CONSTANT i32 0
%one:_(s32) = G_CONSTANT i32 2
%cmp:_(s1) = G_ICMP intpred(sgt), %0(s32), %one
G_BRCOND %cmp(s1), %bb.2
G_BR %bb.3
bb.2:
%big0:_(s64) = G_SEXT %0
%big1:_(s64) = G_SEXT %1
%add:_(s64) = G_ADD %big0, %big1
%first:_(s32), %second:_(s32) = G_UNMERGE_VALUES %add:_(s64)
G_BR %bb.4
bb.3:
%cst32_10:_(s32) = G_CONSTANT i32 10
bb.4:
%phi:_(s32) = G_PHI %second, %bb.2, %cst32_10, %bb.3
%ext:_(s64) = G_ANYEXT %phi
$x0 = COPY %ext(s64)
RET_ReallyLR implicit $x0
...
Codebase Browser
llvm