; RUN: llc -O2 -ppc-reduce-cr-logicals -o - %s | FileCheck \
; RUN:   --check-prefix=CHECK --check-prefix=CHECK-O2 %s
; RUN: llc -O3 -ppc-reduce-cr-logicals -o - %s | FileCheck \
; RUN:   --check-prefix=CHECK --check-prefix=CHECK-O3 %s
target datalayout = "e-m:e-i64:64-n32:64"
target triple = "powerpc64le-grtev4-linux-gnu"

; Intended layout:
; The chain-based outlining produces the layout
; test1
; test2
; test3
; test4
; optional1
; optional2
; optional3
; optional4
; exit
; Tail duplication puts test n+1 at the end of optional n
; so optional1 includes a copy of test2 at the end, and branches
; to test3 (at the top) or falls through to optional 2.
; The CHECK statements check for the whole string of tests
; and then check that the correct test has been duplicated into the end of
; the optional blocks and that the optional blocks are in the correct order.
;CHECK-LABEL: straight_test:
; test1 may have been merged with entry
;CHECK: mr [[TAGREG:[0-9]+]], 3
;CHECK: andi. {{[0-9]+}}, [[TAGREG:[0-9]+]], 1
;CHECK-NEXT: bc 12, 1, .[[OPT1LABEL:[_0-9A-Za-z]+]]
;CHECK-NEXT: # %test2
;CHECK-NEXT: andi. {{[0-9]+}}, [[TAGREG]], 2
;CHECK-NEXT: bne 0, .[[OPT2LABEL:[_0-9A-Za-z]+]]
;CHECK-NEXT: .[[TEST3LABEL:[_0-9A-Za-z]+]]: # %test3
;CHECK-NEXT: andi. {{[0-9]+}}, [[TAGREG]], 4
;CHECK-NEXT: bne 0, .[[OPT3LABEL:[_0-9A-Za-z]+]]
;CHECK-NEXT: .[[TEST4LABEL:[_0-9A-Za-z]+]]: # %test4
;CHECK-NEXT: andi. {{[0-9]+}}, [[TAGREG]], 8
;CHECK-NEXT: bne 0, .[[OPT4LABEL:[_0-9A-Za-z]+]]
;CHECK-NEXT: .[[EXITLABEL:[_0-9A-Za-z]+]]: # %exit
;CHECK: blr
;CHECK-NEXT: .[[OPT1LABEL]]:
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 2
;CHECK-NEXT: beq 0, .[[TEST3LABEL]]
;CHECK-NEXT: .[[OPT2LABEL]]:
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 4
;CHECK-NEXT: beq 0, .[[TEST4LABEL]]
;CHECK-NEXT: .[[OPT3LABEL]]:
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 8
;CHECK-NEXT: beq 0, .[[EXITLABEL]]
;CHECK-NEXT: .[[OPT4LABEL]]:
;CHECK: b .[[EXITLABEL]]

define void @straight_test(i32 %tag) {
entry:
  br label %test1
test1:
  %tagbit1 = and i32 %tag, 1
  %tagbit1eq0 = icmp eq i32 %tagbit1, 0
  br i1 %tagbit1eq0, label %test2, label %optional1, !prof !1
optional1:
  call void @a()
  call void @a()
  call void @a()
  call void @a()
  br label %test2
test2:
  %tagbit2 = and i32 %tag, 2
  %tagbit2eq0 = icmp eq i32 %tagbit2, 0
  br i1 %tagbit2eq0, label %test3, label %optional2, !prof !1
optional2:
  call void @b()
  call void @b()
  call void @b()
  call void @b()
  br label %test3
test3:
  %tagbit3 = and i32 %tag, 4
  %tagbit3eq0 = icmp eq i32 %tagbit3, 0
  br i1 %tagbit3eq0, label %test4, label %optional3, !prof !1
optional3:
  call void @c()
  call void @c()
  call void @c()
  call void @c()
  br label %test4
test4:
  %tagbit4 = and i32 %tag, 8
  %tagbit4eq0 = icmp eq i32 %tagbit4, 0
  br i1 %tagbit4eq0, label %exit, label %optional4, !prof !1
optional4:
  call void @d()
  call void @d()
  call void @d()
  call void @d()
  br label %exit
exit:
  ret void
}

; Intended layout:
; The chain-of-triangles based duplicating produces the layout
; test1
; test2
; test3
; optional1
; optional2
; optional3
; exit
; even for 50/50 branches.
; Tail duplication puts test n+1 at the end of optional n
; so optional1 includes a copy of test2 at the end, and branches
; to test3 (at the top) or falls through to optional 2.
; The CHECK statements check for the whole string of tests
; and then check that the correct test has been duplicated into the end of
; the optional blocks and that the optional blocks are in the correct order.
;CHECK-LABEL: straight_test_50:
; test1 may have been merged with entry
;CHECK: mr [[TAGREG:[0-9]+]], 3
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 1
;CHECK-NEXT: bc 12, 1, .[[OPT1LABEL:[_0-9A-Za-z]+]]
;CHECK-NEXT: # %test2
;CHECK-NEXT: andi. {{[0-9]+}}, [[TAGREG]], 2
;CHECK-NEXT: bne 0, .[[OPT2LABEL:[_0-9A-Za-z]+]]
;CHECK-NEXT: .[[TEST3LABEL:[_0-9A-Za-z]+]]: # %test3
;CHECK-NEXT: andi. {{[0-9]+}}, [[TAGREG]], 4
;CHECK-NEXT: bne 0, .[[OPT3LABEL:[_0-9A-Za-z]+]]
;CHECK-NEXT: .[[EXITLABEL:[_0-9A-Za-z]+]]: # %exit
;CHECK: blr
;CHECK-NEXT: .[[OPT1LABEL]]:
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 2
;CHECK-NEXT: beq 0, .[[TEST3LABEL]]
;CHECK-NEXT: .[[OPT2LABEL]]:
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 4
;CHECK-NEXT: beq 0, .[[EXITLABEL]]
;CHECK-NEXT: .[[OPT3LABEL]]:
;CHECK: b .[[EXITLABEL]]

define void @straight_test_50(i32 %tag) {
entry:
  br label %test1
test1:
  %tagbit1 = and i32 %tag, 1
  %tagbit1eq0 = icmp eq i32 %tagbit1, 0
  br i1 %tagbit1eq0, label %test2, label %optional1, !prof !2
optional1:
  call void @a()
  br label %test2
test2:
  %tagbit2 = and i32 %tag, 2
  %tagbit2eq0 = icmp eq i32 %tagbit2, 0
  br i1 %tagbit2eq0, label %test3, label %optional2, !prof !2
optional2:
  call void @b()
  br label %test3
test3:
  %tagbit3 = and i32 %tag, 4
  %tagbit3eq0 = icmp eq i32 %tagbit3, 0
  br i1 %tagbit3eq0, label %exit, label %optional3, !prof !1
optional3:
  call void @c()
  br label %exit
exit:
  ret void
}

; Intended layout:
; The chain-of-triangles based duplicating produces the layout when 3
; instructions are allowed for tail-duplication.
; test1
; test2
; test3
; optional1
; optional2
; optional3
; exit
;
; Otherwise it produces the layout:
; test1
; optional1
; test2
; optional2
; test3
; optional3
; exit

;CHECK-LABEL: straight_test_3_instr_test:
; test1 may have been merged with entry
;CHECK: mr [[TAGREG:[0-9]+]], 3
;CHECK: clrlwi {{[0-9]+}}, [[TAGREG]], 30
;CHECK-NEXT: cmplwi {{[0-9]+}}, 2

;CHECK-O3-NEXT: bne 0, .[[OPT1LABEL:[_0-9A-Za-z]+]]
;CHECK-O3-NEXT: # %test2
;CHECK-O3-NEXT: rlwinm {{[0-9]+}}, [[TAGREG]], 0, 28, 29
;CHECK-O3-NEXT: cmplwi {{[0-9]+}}, 8
;CHECK-O3-NEXT: bne 0, .[[OPT2LABEL:[_0-9A-Za-z]+]]
;CHECK-O3-NEXT: .[[TEST3LABEL:[_0-9A-Za-z]+]]: # %test3
;CHECK-O3-NEXT: rlwinm {{[0-9]+}}, [[TAGREG]], 0, 26, 27
;CHECK-O3-NEXT: cmplwi {{[0-9]+}}, 32
;CHECK-O3-NEXT: bne 0, .[[OPT3LABEL:[_0-9A-Za-z]+]]
;CHECK-O3-NEXT: .[[EXITLABEL:[_0-9A-Za-z]+]]: # %exit
;CHECK-O3: blr
;CHECK-O3-NEXT: .[[OPT1LABEL]]:
;CHECK-O3: rlwinm {{[0-9]+}}, [[TAGREG]], 0, 28, 29
;CHECK-O3-NEXT: cmplwi {{[0-9]+}}, 8
;CHECK-O3-NEXT: beq 0, .[[TEST3LABEL]]
;CHECK-O3-NEXT: .[[OPT2LABEL]]:
;CHECK-O3: rlwinm {{[0-9]+}}, [[TAGREG]], 0, 26, 27
;CHECK-O3-NEXT: cmplwi {{[0-9]+}}, 32
;CHECK-O3-NEXT: beq 0, .[[EXITLABEL]]
;CHECK-O3-NEXT: .[[OPT3LABEL]]:
;CHECK-O3: b .[[EXITLABEL]]

;CHECK-O2-NEXT: beq 0, .[[TEST2LABEL:[_0-9A-Za-z]+]]
;CHECK-O2-NEXT: # %optional1
;CHECK-O2: .[[TEST2LABEL]]: # %test2
;CHECK-O2-NEXT: rlwinm {{[0-9]+}}, [[TAGREG]], 0, 28, 29
;CHECK-O2-NEXT: cmplwi {{[0-9]+}}, 8
;CHECK-O2-NEXT: beq 0, .[[TEST3LABEL:[_0-9A-Za-z]+]]
;CHECK-O2-NEXT: # %optional2
;CHECK-O2: .[[TEST3LABEL]]: # %test3
;CHECK-O2-NEXT: rlwinm {{[0-9]+}}, [[TAGREG]], 0, 26, 27
;CHECK-O2-NEXT: cmplwi {{[0-9]+}}, 32
;CHECK-O2-NEXT: beq 0, .[[EXITLABEL:[_0-9A-Za-z]+]]
;CHECK-O2-NEXT: # %optional3
;CHECK-O2: .[[EXITLABEL:[_0-9A-Za-z]+]]: # %exit
;CHECK-O2: blr


define void @straight_test_3_instr_test(i32 %tag) {
entry:
  br label %test1
test1:
  %tagbit1 = and i32 %tag, 3
  %tagbit1eq0 = icmp eq i32 %tagbit1, 2
  br i1 %tagbit1eq0, label %test2, label %optional1, !prof !2
optional1:
  call void @a()
  br label %test2
test2:
  %tagbit2 = and i32 %tag, 12
  %tagbit2eq0 = icmp eq i32 %tagbit2, 8
  br i1 %tagbit2eq0, label %test3, label %optional2, !prof !2
optional2:
  call void @b()
  br label %test3
test3:
  %tagbit3 = and i32 %tag, 48
  %tagbit3eq0 = icmp eq i32 %tagbit3, 32
  br i1 %tagbit3eq0, label %exit, label %optional3, !prof !1
optional3:
  call void @c()
  br label %exit
exit:
  ret void
}

; Intended layout:
; The chain-based outlining produces the layout
; entry
; --- Begin loop ---
; for.latch
; for.check
; test1
; test2
; test3
; test4
; optional1
; optional2
; optional3
; optional4
; --- End loop ---
; exit
; The CHECK statements check for the whole string of tests and exit block,
; and then check that the correct test has been duplicated into the end of
; the optional blocks and that the optional blocks are in the correct order.
;CHECK-LABEL: loop_test:
;CHECK: add [[TAGPTRREG:[0-9]+]], 3, 4
;CHECK: .[[LATCHLABEL:[._0-9A-Za-z]+]]: # %for.latch
;CHECK: addi
;CHECK-O2: .[[CHECKLABEL:[._0-9A-Za-z]+]]: # %for.check
;CHECK: lwz [[TAGREG:[0-9]+]], 0([[TAGPTRREG]])
;CHECK-O3: .[[CHECKLABEL:[._0-9A-Za-z]+]]: # %for.check
;CHECK: # %bb.{{[0-9]+}}: # %test1
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 1
;CHECK-NEXT: bc 12, 1, .[[OPT1LABEL:[._0-9A-Za-z]+]]
;CHECK-NEXT: # %test2
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 2
;CHECK-NEXT: bne 0, .[[OPT2LABEL:[._0-9A-Za-z]+]]
;CHECK-NEXT: .[[TEST3LABEL:[._0-9A-Za-z]+]]: # %test3
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 4
;CHECK-NEXT: bne 0, .[[OPT3LABEL:[._0-9A-Za-z]+]]
;CHECK-NEXT: .[[TEST4LABEL:[._0-9A-Za-z]+]]: # %{{(test4|optional3)}}
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 8
;CHECK-NEXT: beq 0, .[[LATCHLABEL]]
;CHECK-NEXT: b .[[OPT4LABEL:[._0-9A-Za-z]+]]
;CHECK: [[OPT1LABEL]]
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 2
;CHECK-NEXT: beq 0, .[[TEST3LABEL]]
;CHECK-NEXT: .[[OPT2LABEL]]
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 4
;CHECK-NEXT: beq 0, .[[TEST4LABEL]]
;CHECK-NEXT: .[[OPT3LABEL]]
;CHECK: andi. {{[0-9]+}}, [[TAGREG]], 8
;CHECK-NEXT: beq 0, .[[LATCHLABEL]]
;CHECK: [[OPT4LABEL]]:
;CHECK: b .[[LATCHLABEL]]
define void @loop_test(i32* %tags, i32 %count) {
entry:
  br label %for.check
for.check:
  %count.loop = phi i32 [%count, %entry], [%count.sub, %for.latch]
  %done.count = icmp ugt i32 %count.loop, 0
  %tag_ptr = getelementptr inbounds i32, i32* %tags, i32 %count
  %tag = load i32, i32* %tag_ptr
  %done.tag = icmp eq i32 %tag, 0
  %done = and i1 %done.count, %done.tag
  br i1 %done, label %test1, label %exit, !prof !1
test1:
  %tagbit1 = and i32 %tag, 1
  %tagbit1eq0 = icmp eq i32 %tagbit1, 0
  br i1 %tagbit1eq0, label %test2, label %optional1, !prof !1
optional1:
  call void @a()
  call void @a()
  call void @a()
  call void @a()
  br label %test2
test2:
  %tagbit2 = and i32 %tag, 2
  %tagbit2eq0 = icmp eq i32 %tagbit2, 0
  br i1 %tagbit2eq0, label %test3, label %optional2, !prof !1
optional2:
  call void @b()
  call void @b()
  call void @b()
  call void @b()
  br label %test3
test3:
  %tagbit3 = and i32 %tag, 4
  %tagbit3eq0 = icmp eq i32 %tagbit3, 0
  br i1 %tagbit3eq0, label %test4, label %optional3, !prof !1
optional3:
  call void @c()
  call void @c()
  call void @c()
  call void @c()
  br label %test4
test4:
  %tagbit4 = and i32 %tag, 8
  %tagbit4eq0 = icmp eq i32 %tagbit4, 0
  br i1 %tagbit4eq0, label %for.latch, label %optional4, !prof !1
optional4:
  call void @d()
  call void @d()
  call void @d()
  call void @d()
  br label %for.latch
for.latch:
  %count.sub = sub i32 %count.loop, 1
  br label %for.check
exit:
  ret void
}

; The block then2 is not unavoidable, meaning it does not dominate the exit.
; But since it can be tail-duplicated, it should be placed as a fallthrough from
; test2 and copied. The purpose here is to make sure that the tail-duplication
; code is independent of the outlining code, which works by choosing the
; "unavoidable" blocks.
; CHECK-LABEL: avoidable_test:
; CHECK: # %bb.{{[0-9]+}}: # %entry
; CHECK: andi.
; CHECK: # %bb.{{[0-9]+}}: # %test2
; Make sure then2 falls through from test2
; CHECK-NOT: # %{{[-_a-zA-Z0-9]+}}
; CHECK: # %bb.{{[0-9]+}}: # %then2
; CHECK: andi. {{[0-9]+}}, {{[0-9]+}}, 4
; CHECK: # %else1
; CHECK: bl a
; CHECK: bl a
; Make sure then2 was copied into else1
; CHECK: andi. {{[0-9]+}}, {{[0-9]+}}, 4
; CHECK: # %end1
; CHECK: bl d
; CHECK: # %else2
; CHECK: bl c
; CHECK: # %end2
define void @avoidable_test(i32 %tag) {
entry:
  br label %test1
test1:
  %tagbit1 = and i32 %tag, 1
  %tagbit1eq0 = icmp eq i32 %tagbit1, 0
  br i1 %tagbit1eq0, label %test2, label %else1, !prof !1 ; %test2 more likely
else1:
  call void @a()
  call void @a()
  br label %then2
test2:
  %tagbit2 = and i32 %tag, 2
  %tagbit2eq0 = icmp eq i32 %tagbit2, 0
  br i1 %tagbit2eq0, label %then2, label %else2, !prof !1 ; %then2 more likely
then2:
  %tagbit3 = and i32 %tag, 4
  %tagbit3eq0 = icmp eq i32 %tagbit3, 0
  br i1 %tagbit3eq0, label %end2, label %end1, !prof !1 ; %end2 more likely
else2:
  call void @c()
  br label %end2
end2:
  ret void
end1:
  call void @d()
  ret void
}

; CHECK-LABEL: trellis_test
; The number in the block labels is the expected block frequency given the
; probabilities annotated. There is a conflict in the b;c->d;e trellis that
; should be resolved as c->e;b->d.
; The d;e->f;g trellis should be resolved as e->g;d->f.
; The f;g->h;i trellis should be resolved as f->i;g->h.
; The h;i->j;ret trellis contains a triangle edge, and should be resolved as
; h->j->ret
; CHECK: # %bb.{{[0-9]+}}: # %entry
; CHECK: # %bb.{{[0-9]+}}: # %c10
; CHECK: # %e9
; CHECK: # %g10
; CHECK: # %h10
; CHECK: # %j8
; CHECK: # %ret
; CHECK: # %b6
; CHECK: # %d7
; CHECK: # %f6
; CHECK: # %i6
define void @trellis_test(i32 %tag) {
entry:
  br label %a16
a16:
  call void @a()
  call void @a()
  %tagbits.a = and i32 %tag, 3
  %tagbits.a.eq0 = icmp eq i32 %tagbits.a, 0
  br i1 %tagbits.a.eq0, label %c10, label %b6, !prof !1 ; 10 to 6
c10:
  call void @c()
  call void @c()
  %tagbits.c = and i32 %tag, 12
  %tagbits.c.eq0 = icmp eq i32 %tagbits.c, 0
  ; Both of these edges should be hotter than the other incoming edge
  ; for e9 or d7
  br i1 %tagbits.c.eq0, label %e9, label %d7, !prof !3 ; 6 to 4
e9:
  call void @e()
  call void @e()
  %tagbits.e = and i32 %tag, 48
  %tagbits.e.eq0 = icmp eq i32 %tagbits.e, 0
  br i1 %tagbits.e.eq0, label %g10, label %f6, !prof !4 ; 7 to 2
g10:
  call void @g()
  call void @g()
  %tagbits.g = and i32 %tag, 192
  %tagbits.g.eq0 = icmp eq i32 %tagbits.g, 0
  br i1 %tagbits.g.eq0, label %i6, label %h10, !prof !5 ; 2 to 8
i6:
  call void @i()
  call void @i()
  %tagbits.i = and i32 %tag, 768
  %tagbits.i.eq0 = icmp eq i32 %tagbits.i, 0
  br i1 %tagbits.i.eq0, label %ret, label %j8, !prof !2 ; balanced (3 to 3)
b6:
  call void @b()
  call void @b()
  %tagbits.b = and i32 %tag, 12
  %tagbits.b.eq1 = icmp eq i32 %tagbits.b, 8
  br i1 %tagbits.b.eq1, label %e9, label %d7, !prof !2 ; balanced (3 to 3)
d7:
  call void @d()
  call void @d()
  %tagbits.d = and i32 %tag, 48
  %tagbits.d.eq1 = icmp eq i32 %tagbits.d, 32
  br i1 %tagbits.d.eq1, label %g10, label %f6, !prof !6 ; 3 to 4
f6:
  call void @f()
  call void @f()
  %tagbits.f = and i32 %tag, 192
  %tagbits.f.eq1 = icmp eq i32 %tagbits.f, 128
  br i1 %tagbits.f.eq1, label %i6, label %h10, !prof !7 ; 4 to 2
h10:
  call void @h()
  call void @h()
  %tagbits.h = and i32 %tag, 768
  %tagbits.h.eq1 = icmp eq i32 %tagbits.h, 512
  br i1 %tagbits.h.eq1, label %ret, label %j8, !prof !2 ; balanced (5 to 5)
j8:
  call void @j()
  call void @j()
  br label %ret
ret:
  ret void
}

; Verify that we still consider tail-duplication opportunities if we find a
; triangle trellis. Here D->F->G is the triangle, and D;E are both predecessors
; of both F and G. The basic trellis algorithm picks the F->G edge, but after
; checking, it's profitable to duplicate G into F. The weights here are not
; really important. They are there to help make the test stable.
; CHECK-LABEL: trellis_then_dup_test
; CHECK: # %bb.{{[0-9]+}}: # %entry
; CHECK: # %bb.{{[0-9]+}}: # %b
; CHECK: # %d
; CHECK: # %g
; CHECK: # %ret1
; CHECK: # %c
; CHECK: # %e
; CHECK: # %f
; CHECK: # %ret2
; CHECK: # %ret
define void @trellis_then_dup_test(i32 %tag) {
entry:
  br label %a
a:
  call void @a()
  call void @a()
  %tagbits.a = and i32 %tag, 3
  %tagbits.a.eq0 = icmp eq i32 %tagbits.a, 0
  br i1 %tagbits.a.eq0, label %b, label %c, !prof !1 ; 5 to 3
b:
  call void @b()
  call void @b()
  %tagbits.b = and i32 %tag, 12
  %tagbits.b.eq1 = icmp eq i32 %tagbits.b, 8
  br i1 %tagbits.b.eq1, label %d, label %e, !prof !1 ; 5 to 3
d:
  call void @d()
  call void @d()
  %tagbits.d = and i32 %tag, 48
  %tagbits.d.eq1 = icmp eq i32 %tagbits.d, 32
  br i1 %tagbits.d.eq1, label %g, label %f, !prof !1 ; 5 to 3
f:
  call void @f()
  call void @f()
  br label %g
g:
  %tagbits.g = and i32 %tag, 192
  %tagbits.g.eq0 = icmp eq i32 %tagbits.g, 0
  br i1 %tagbits.g.eq0, label %ret1, label %ret2, !prof !2 ; balanced
c:
  call void @c()
  call void @c()
  %tagbits.c = and i32 %tag, 12
  %tagbits.c.eq0 = icmp eq i32 %tagbits.c, 0
  br i1 %tagbits.c.eq0, label %d, label %e, !prof !1 ; 5 to 3
e:
  call void @e()
  call void @e()
  %tagbits.e = and i32 %tag, 48
  %tagbits.e.eq0 = icmp eq i32 %tagbits.e, 0
  br i1 %tagbits.e.eq0, label %g, label %f, !prof !1 ; 5 to 3
ret1:
  call void @a()
  br label %ret
ret2:
  call void @b()
  br label %ret
ret:
  ret void
}

; Verify that we did not mis-identify triangle trellises if it is not
; really a triangle.
; CHECK-LABEL: trellis_no_triangle
; CHECK: # %bb.{{[0-9]+}}: # %entry
; CHECK: # %bb.{{[0-9]+}}: # %b
; CHECK: # %d
; CHECK: # %ret
; CHECK: # %c
; CHECK: # %e
define void @trellis_no_triangle(i32 %tag) {
entry:
  br label %a
a:
  call void @a()
  call void @a()
  %tagbits.a = and i32 %tag, 3
  %tagbits.a.eq0 = icmp eq i32 %tagbits.a, 0
  br i1 %tagbits.a.eq0, label %b, label %c, !prof !8 ; 98 to 2
b:
  call void @b()
  call void @b()
  %tagbits.b = and i32 %tag, 12
  %tagbits.b.eq1 = icmp eq i32 %tagbits.b, 8
  br i1 %tagbits.b.eq1, label %d, label %e, !prof !9 ; 97 to 1
d:
  call void @d()
  call void @d()
  %tagbits.d = and i32 %tag, 48
  %tagbits.d.eq1 = icmp eq i32 %tagbits.d, 32
  br i1 %tagbits.d.eq1, label %ret, label %e, !prof !10 ; 96 to 2
c:
  call void @c()
  call void @c()
  %tagbits.c = and i32 %tag, 12
  %tagbits.c.eq0 = icmp eq i32 %tagbits.c, 0
  br i1 %tagbits.c.eq0, label %d, label %e, !prof !2 ; 1 to 1
e:
  call void @e()
  call void @e()
  br label %ret
ret:
  call void @f()
  ret void
}

declare void @a()
declare void @b()
declare void @c()
declare void @d()
declare void @e()
declare void @f()
declare void @g()
declare void @h()
declare void @i()
declare void @j()

!1 = !{!"branch_weights", i32 5, i32 3}
!2 = !{!"branch_weights", i32 50, i32 50}
!3 = !{!"branch_weights", i32 6, i32 4}
!4 = !{!"branch_weights", i32 7, i32 2}
!5 = !{!"branch_weights", i32 2, i32 8}
!6 = !{!"branch_weights", i32 3, i32 4}
!7 = !{!"branch_weights", i32 4, i32 2}
!8 = !{!"branch_weights", i32 98, i32 2}
!9 = !{!"branch_weights", i32 97, i32 1}
!10 = !{!"branch_weights", i32 96, i32 2}
