azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Pseudocode: Generate merge instruction regardless of number of branches

Browse Source
This commit is contained in:
Alexey Sedunov
2014-07-25 20:59:00 +04:00
parent d008cb8c21
commit 9f3ebe5f3b
21 changed files with 525 additions and 500 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+1 -11
View File
@@ -220,17 +220,7 @@ public class JetControlFlowProcessor {
}
private void mergeValues(@NotNull List<JetExpression> from, @NotNull JetExpression to) {
List<PseudoValue> values = elementsToValues(from);
switch (values.size()) {
case 0:
break;
case 1:
builder.bindValue(values.get(0), to);
break;
default:
builder.merge(to, values);
break;
}
builder.merge(to, elementsToValues(from));
}
private void copyValue(@Nullable JetElement from, @NotNull JetElement to) {
compiler/testData/cfg/controlStructures/Finally.instructions
+172 -151
View File
@@ -11,25 +11,26 @@ L0:
1 <START>
2 mark({ try { 1 } finally { 2 } })
mark(try { 1 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 })]
3 mark({ 1 })
r(1) -> <v0>
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v1>
L5 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
r(2) -> <v1>
2 merge(try { 1 } finally { 2 }|<v0>) -> <v2>
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t2 ==
fun t2() {
@@ -47,7 +48,7 @@ L0:
1 <START>
2 mark({ try { 1 if (2 > 3) { return } } finally { 2 } })
mark(try { 1 if (2 > 3) { return } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return } })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return } })]
3 mark({ 1 if (2 > 3) { return } })
r(1) -> <v0>
mark(if (2 > 3) { return })
@@ -55,31 +56,33 @@ L0:
r(3) -> <v2>
mark(2 > 3)
call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
jf(L3|<v3>) NEXT:[read (Unit), mark({ return })]
jf(L3|<v3>) NEXT:[read (Unit), mark({ return })]
4 mark({ return })
L4 [start finally]:
5 mark({ 2 })
r(2) -> <v4>
L5 [finish finally]:
4 ret L1 NEXT:[<END>]
- 3 jmp(L6) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
4 ret L1 NEXT:[<END>]
- 3 jmp(L6) NEXT:[merge(if (2 > 3) { return }|!<v5>) -> <v6>] PREV:[]
L3:
read (Unit) PREV:[jf(L3|<v3>)]
read (Unit) PREV:[jf(L3|<v3>)]
L6:
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
merge(if (2 > 3) { return }|!<v5>) -> <v6>
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
5 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
5 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v4>
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
5 mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
5 mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
r(2) -> <v4>
2 merge(try { 1 if (2 > 3) { return } } finally { 2 }|<v6>) -> <v7>
L1:
1 <END> NEXT:[<SINK>] PREV:[ret L1, r(2) -> <v4>]
1 <END> NEXT:[<SINK>] PREV:[ret L1, merge(try { 1 if (2 > 3) { return } } finally { 2 }|<v6>) -> <v7>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t3 ==
fun t3() {
@@ -99,31 +102,32 @@ L0:
1 <START>
2 mark({ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } })
mark(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 @l{ () -> if (2 > 3) { return@l } } })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 @l{ () -> if (2 > 3) { return@l } } })]
3 mark({ 1 @l{ () -> if (2 > 3) { return@l } } })
r(1) -> <v0>
mark(@l{ () -> if (2 > 3) { return@l } })
mark({ () -> if (2 > 3) { return@l } })
jmp?(L3) NEXT:[r({ () -> if (2 > 3) { return@l } }) -> <v1>, d({ () -> if (2 > 3) { return@l } })]
d({ () -> if (2 > 3) { return@l } }) NEXT:[<SINK>]
jmp?(L3) NEXT:[r({ () -> if (2 > 3) { return@l } }) -> <v1>, d({ () -> if (2 > 3) { return@l } })]
d({ () -> if (2 > 3) { return@l } }) NEXT:[<SINK>]
L3:
r({ () -> if (2 > 3) { return@l } }) -> <v1> PREV:[jmp?(L3)]
2 jmp(L8 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
r({ () -> if (2 > 3) { return@l } }) -> <v1> PREV:[jmp?(L3)]
2 jmp(L8 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L9 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v2>
L10 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L8 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])]
r(2) -> <v2>
2 merge(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }|<v1>) -> <v3>
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>, d({ () -> if (2 > 3) { return@l } })]
<SINK> PREV:[<ERROR>, <END>, d({ () -> if (2 > 3) { return@l } })]
=====================
== anonymous_0 ==
{ () ->
@@ -140,20 +144,21 @@ L4:
r(3) -> <v1>
mark(2 > 3)
call(2 > 3, compareTo|<v0>, <v1>) -> <v2>
jf(L6|<v2>) NEXT:[read (Unit), mark({ return@l })]
jf(L6|<v2>) NEXT:[read (Unit), mark({ return@l })]
6 mark({ return@l })
ret L5 NEXT:[<END>]
- 5 jmp(L7) NEXT:[ret(*|!<v3>) L5] PREV:[]
ret L5 NEXT:[<END>]
- 5 jmp(L7) NEXT:[merge(if (2 > 3) { return@l }|!<v3>) -> <v4>] PREV:[]
L6:
read (Unit) PREV:[jf(L6|<v2>)]
read (Unit) PREV:[jf(L6|<v2>)]
L7:
4 ret(*|!<v3>) L5
merge(if (2 > 3) { return@l }|!<v3>) -> <v4>
4 ret(*|<v4>) L5
L5:
<END> NEXT:[<SINK>] PREV:[ret L5, ret(*|!<v3>) L5]
<END> NEXT:[<SINK>] PREV:[ret L5, ret(*|<v4>) L5]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t4 ==
fun t4() {
@@ -201,7 +206,7 @@ L3:
3 <START>
4 mark(try { 1 if (2 > 3) { return@l } } finally { 2 })
mark(try { 1 if (2 > 3) { return@l } } finally { 2 })
jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@l } })]
jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@l } })]
5 mark({ 1 if (2 > 3) { return@l } })
r(1) -> <v0>
mark(if (2 > 3) { return@l })
@@ -209,32 +214,34 @@ L3:
r(3) -> <v2>
mark(2 > 3)
call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
jf(L6|<v3>) NEXT:[read (Unit), mark({ return@l })]
jf(L6|<v3>) NEXT:[read (Unit), mark({ return@l })]
6 mark({ return@l })
L7 [start finally]:
7 mark({ 2 })
r(2) -> <v4>
L8 [finish finally]:
6 ret L4 NEXT:[<END>]
- 5 jmp(L9) NEXT:[jmp(L10 [skipFinallyToErrorBlock])] PREV:[]
6 ret L4 NEXT:[<END>]
- 5 jmp(L9) NEXT:[merge(if (2 > 3) { return@l }|!<v5>) -> <v6>] PREV:[]
L6:
read (Unit) PREV:[jf(L6|<v3>)]
read (Unit) PREV:[jf(L6|<v3>)]
L9:
4 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
merge(if (2 > 3) { return@l }|!<v5>) -> <v6>
4 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L5 [onExceptionToFinallyBlock]:
7 mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
7 mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
r(2) -> <v4>
4 jmp(error) NEXT:[<ERROR>]
4 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
7 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
r(2) -> <v4>
3 ret(*|!<v5>) L4
4 merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|<v6>) -> <v7>
3 ret(*|<v7>) L4
L4:
<END> NEXT:[<SINK>] PREV:[ret L4, ret(*|!<v5>) L4]
<END> NEXT:[<SINK>] PREV:[ret L4, ret(*|<v7>) L4]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t5 ==
fun t5() {
@@ -277,10 +284,11 @@ L8 [start finally]:
r(2) -> <v6>
L9 [finish finally]:
5 jmp(L3 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
- 4 jmp(L10) NEXT:[merge(if (2 > 3) { break @l }|!<v7>) -> <v8>] PREV:[]
L7:
read (Unit) PREV:[jf(L7|<v5>)]
L10:
merge(if (2 > 3) { break @l }|!<v7>) -> <v8>
3 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L6 [onExceptionToFinallyBlock]:
6 mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
@@ -289,6 +297,7 @@ L6 [onExceptionToFinallyBlock]:
L11 [skipFinallyToErrorBlock]:
6 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
r(2) -> <v6>
3 merge(try { 1 if (2 > 3) { break @l } } finally { 2 }|<v8>) -> <v9>
2 jmp(L2 [loop entry point]) NEXT:[r(true) -> <v0>]
L3 [loop exit point]:
read (Unit) PREV:[jmp(L3 [loop exit point])]
@@ -318,12 +327,12 @@ L0:
1 <START>
2 mark({ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } })
mark(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })]
3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })
mark(@l while(true) { 1 if (2 > 3) { break @l } })
L3 [loop entry point]:
L6 [condition entry point]:
r(true) -> <v0> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
r(true) -> <v0> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
mark(while(true) { 1 if (2 > 3) { break @l } })
magic[VALUE_CONSUMER](true|<v0>) -> <v1>
L5 [body entry point]:
@@ -334,33 +343,35 @@ L5 [body entry point]:
r(3) -> <v4>
mark(2 > 3)
call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
jf(L7|<v5>) NEXT:[read (Unit), mark({ break @l })]
jf(L7|<v5>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l })
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L8) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[]
L7:
read (Unit) PREV:[jf(L7|<v5>)]
read (Unit) PREV:[jf(L7|<v5>)]
L8:
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>]
merge(if (2 > 3) { break @l }|!<v6>) -> <v7>
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>]
L4 [loop exit point]:
read (Unit) PREV:[jmp(L4 [loop exit point])]
r(5) -> <v8>
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
read (Unit) PREV:[jmp(L4 [loop exit point])]
r(5) -> <v9>
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v9>
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v10>
L11 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2) -> <v9>
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2) -> <v10>
2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }|<v9>) -> <v11>
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t7 ==
fun t7() {
@@ -380,12 +391,12 @@ L0:
1 <START>
2 mark({ try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } })
mark(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } })]
3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } })
mark(@l while(true) { 1 if (2 > 3) { break @l } })
L3 [loop entry point]:
L6 [condition entry point]:
r(true) -> <v0> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
r(true) -> <v0> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
mark(while(true) { 1 if (2 > 3) { break @l } })
magic[VALUE_CONSUMER](true|<v0>) -> <v1>
L5 [body entry point]:
@@ -396,32 +407,34 @@ L5 [body entry point]:
r(3) -> <v4>
mark(2 > 3)
call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
jf(L7|<v5>) NEXT:[read (Unit), mark({ break @l })]
jf(L7|<v5>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l })
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L8) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[]
L7:
read (Unit) PREV:[jf(L7|<v5>)]
read (Unit) PREV:[jf(L7|<v5>)]
L8:
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>]
merge(if (2 > 3) { break @l }|!<v6>) -> <v7>
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>]
L4 [loop exit point]:
read (Unit) PREV:[jmp(L4 [loop exit point])]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
read (Unit) PREV:[jmp(L4 [loop exit point])]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v8>
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v9>
L11 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2) -> <v8>
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2) -> <v9>
2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 }|!<v8>) -> <v10>
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t8 ==
fun t8(a : Int) {
@@ -473,10 +486,11 @@ L8 [start finally]:
r(2) -> <v9>
L9 [finish finally]:
6 jmp(L4 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
- 5 jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
- 5 jmp(L10) NEXT:[merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>] PREV:[]
L7:
read (Unit) PREV:[jf(L7|<v8>)]
L10:
merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>
4 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L6 [onExceptionToFinallyBlock]:
7 mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
@@ -485,6 +499,7 @@ L6 [onExceptionToFinallyBlock]:
L11 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
r(2) -> <v9>
4 merge(try { 1 if (2 > 3) { continue @l } } finally { 2 }|<v11>) -> <v12>
3 jmp?(L4 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>, read (Unit)]
L2:
read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
@@ -517,7 +532,7 @@ L0:
w(a|<v0>)
2 mark({ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } })
mark(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })]
3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })
mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } })
4 r(1) -> <v1>
@@ -526,10 +541,10 @@ L0:
call(1..a, rangeTo|<v1>, <v2>) -> <v3>
v(i)
L4:
jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
L5 [loop entry point]:
L6 [body entry point]:
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
w(i|<v4>)
mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
5 mark({ 1 if (2 > 3) { continue @l } })
@@ -539,33 +554,35 @@ L6 [body entry point]:
r(3) -> <v7>
mark(2 > 3)
call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l })
jmp(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
- 5 jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
jmp(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
- 5 jmp(L8) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[]
L7:
read (Unit) PREV:[jf(L7|<v8>)]
read (Unit) PREV:[jf(L7|<v8>)]
L8:
4 jmp?(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>, read (Unit)]
merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>
4 jmp?(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>, read (Unit)]
L3:
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
3 r(5) -> <v11>
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
3 r(5) -> <v12>
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v12>
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v13>
L11 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2) -> <v12>
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2) -> <v13>
2 merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }|<v12>) -> <v14>
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t10 ==
fun t10(a : Int) {
@@ -588,7 +605,7 @@ L0:
w(a|<v0>)
2 mark({ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } })
mark(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })]
3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })
mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } })
4 r(1) -> <v1>
@@ -597,10 +614,10 @@ L0:
call(1..a, rangeTo|<v1>, <v2>) -> <v3>
v(i)
L4:
jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
L5 [loop entry point]:
L6 [body entry point]:
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
w(i|<v4>)
mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
5 mark({ 1 if (2 > 3) { continue @l } })
@@ -610,32 +627,34 @@ L6 [body entry point]:
r(3) -> <v7>
mark(2 > 3)
call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l })
jmp(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
- 5 jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
jmp(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
- 5 jmp(L8) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[]
L7:
read (Unit) PREV:[jf(L7|<v8>)]
read (Unit) PREV:[jf(L7|<v8>)]
L8:
4 jmp?(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>, read (Unit)]
merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>
4 jmp?(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>, read (Unit)]
L3:
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v11>
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v12>
L11 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2) -> <v11>
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2) -> <v12>
2 merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 }|!<v11>) -> <v13>
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t11 ==
fun t11() {
@@ -651,31 +670,32 @@ L0:
1 <START>
2 mark({ try { return 1 } finally { return 2 } })
mark(try { return 1 } finally { return 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return 2 }), mark({ return 1 })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return 2 }), mark({ return 1 })]
3 mark({ return 1 })
r(1) -> <v0>
L3 [start finally]:
4 mark({ return 2 })
r(2) -> <v1>
ret(*|<v1>) L1 NEXT:[<END>]
ret(*|<v1>) L1 NEXT:[<END>]
L4 [finish finally]:
- 3 ret(*|<v0>) L1 NEXT:[<END>] PREV:[]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ return 2 })] PREV:[]
- 3 ret(*|<v0>) L1 NEXT:[<END>] PREV:[]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ return 2 })] PREV:[]
L2 [onExceptionToFinallyBlock]:
4 mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
4 mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2) -> <v1>
ret(*|<v1>) L1 NEXT:[<END>]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
ret(*|<v1>) L1 NEXT:[<END>]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L5 [skipFinallyToErrorBlock]:
- 4 mark({ return 2 }) PREV:[]
- r(2) -> <v1> PREV:[]
- ret(*|<v1>) L1 PREV:[]
- 4 mark({ return 2 }) PREV:[]
- r(2) -> <v1> PREV:[]
- ret(*|<v1>) L1 NEXT:[<END>] PREV:[]
- 2 merge(try { return 1 } finally { return 2 }|!<v3>) -> <v4> PREV:[]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v1>) L1, ret(*|<v1>) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v1>) L1, ret(*|<v1>) L1]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t12 ==
fun t12() : Int {
@@ -691,7 +711,7 @@ L0:
1 <START>
2 mark({ try { return 1 } finally { doSmth(3) } })
mark(try { return 1 } finally { doSmth(3) })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 })
r(1) -> <v0>
L3 [start finally]:
@@ -700,25 +720,26 @@ L3 [start finally]:
mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2>
L4 [finish finally]:
3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
L2 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
4 mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(3) -> <v1>
mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2>
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L5 [skipFinallyToErrorBlock]:
- 4 mark({ doSmth(3) }) PREV:[]
- r(3) -> <v1> PREV:[]
- mark(doSmth(3)) PREV:[]
- call(doSmth(3), doSmth|<v1>) -> <v2> PREV:[]
- 4 mark({ doSmth(3) }) PREV:[]
- r(3) -> <v1> PREV:[]
- mark(doSmth(3)) PREV:[]
- call(doSmth(3), doSmth|<v1>) -> <v2> PREV:[]
- 2 merge(try { return 1 } finally { doSmth(3) }|!<v3>) -> <v4> PREV:[]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v0>) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v0>) L1]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t13 ==
fun t13() : Int {
compiler/testData/cfg/controlStructures/Finally.values
+174 -174
View File
@@ -7,12 +7,12 @@ fun t1() {
}
}
---------------------
1 <v0>: * NEW: r(1) -> <v0>
{ 1 } <v0>: * COPY
2 <v1>: * NEW: r(2) -> <v1>
{ 2 } <v1>: * COPY
try { 1 } finally { 2 } <v0>: * COPY
{ try { 1 } finally { 2 } } <v0>: * COPY
1 <v0>: * NEW: r(1) -> <v0>
{ 1 } <v0>: * COPY
2 <v1>: * NEW: r(2) -> <v1>
{ 2 } <v1>: * COPY
try { 1 } finally { 2 } <v2>: * NEW: merge(try { 1 } finally { 2 }|<v0>) -> <v2>
{ try { 1 } finally { 2 } } <v2>: * COPY
=====================
== t2 ==
fun t2() {
@@ -26,18 +26,18 @@ fun t2() {
}
}
---------------------
1 <v0>: * NEW: r(1) -> <v0>
2 <v1>: {<: Comparable<Int>} NEW: r(2) -> <v1>
3 <v2>: Int NEW: r(3) -> <v2>
2 > 3 <v3>: Boolean NEW: call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
return !<v5>: *
{ return } !<v5>: * COPY
if (2 > 3) { return } !<v5>: * COPY
{ 1 if (2 > 3) { return } } !<v5>: * COPY
2 <v4>: * NEW: r(2) -> <v4>
{ 2 } <v4>: * COPY
try { 1 if (2 > 3) { return } } finally { 2 } !<v5>: * COPY
{ try { 1 if (2 > 3) { return } } finally { 2 } } !<v5>: * COPY
1 <v0>: * NEW: r(1) -> <v0>
2 <v1>: {<: Comparable<Int>} NEW: r(2) -> <v1>
3 <v2>: Int NEW: r(3) -> <v2>
2 > 3 <v3>: Boolean NEW: call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
return !<v5>: *
{ return } !<v5>: * COPY
if (2 > 3) { return } <v6>: * NEW: merge(if (2 > 3) { return }|!<v5>) -> <v6>
{ 1 if (2 > 3) { return } } <v6>: * COPY
2 <v4>: * NEW: r(2) -> <v4>
{ 2 } <v4>: * COPY
try { 1 if (2 > 3) { return } } finally { 2 } <v7>: * NEW: merge(try { 1 if (2 > 3) { return } } finally { 2 }|<v6>) -> <v7>
{ try { 1 if (2 > 3) { return } } finally { 2 } } <v7>: * COPY
=====================
== t3 ==
fun t3() {
@@ -53,14 +53,14 @@ fun t3() {
}
}
---------------------
1 <v0>: * NEW: r(1) -> <v0>
{ () -> if (2 > 3) { return@l } } <v1>: * NEW: r({ () -> if (2 > 3) { return@l } }) -> <v1>
@l{ () -> if (2 > 3) { return@l } } <v1>: * COPY
{ 1 @l{ () -> if (2 > 3) { return@l } } } <v1>: * COPY
2 <v2>: * NEW: r(2) -> <v2>
{ 2 } <v2>: * COPY
try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } <v1>: * COPY
{ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } } <v1>: * COPY
1 <v0>: * NEW: r(1) -> <v0>
{ () -> if (2 > 3) { return@l } } <v1>: * NEW: r({ () -> if (2 > 3) { return@l } }) -> <v1>
@l{ () -> if (2 > 3) { return@l } } <v1>: * COPY
{ 1 @l{ () -> if (2 > 3) { return@l } } } <v1>: * COPY
2 <v2>: * NEW: r(2) -> <v2>
{ 2 } <v2>: * COPY
try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } <v3>: * NEW: merge(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }|<v1>) -> <v3>
{ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } } <v3>: * COPY
=====================
== anonymous_0 ==
{ () ->
@@ -69,13 +69,13 @@ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } <v1>: * COPY
}
}
---------------------
2 <v0>: {<: Comparable<Int>} NEW: r(2) -> <v0>
3 <v1>: Int NEW: r(3) -> <v1>
2 > 3 <v2>: Boolean NEW: call(2 > 3, compareTo|<v0>, <v1>) -> <v2>
return@l !<v3>: *
{ return@l } !<v3>: * COPY
if (2 > 3) { return@l } !<v3>: * COPY
if (2 > 3) { return@l } !<v3>: * COPY
2 <v0>: {<: Comparable<Int>} NEW: r(2) -> <v0>
3 <v1>: Int NEW: r(3) -> <v1>
2 > 3 <v2>: Boolean NEW: call(2 > 3, compareTo|<v0>, <v1>) -> <v2>
return@l !<v3>: *
{ return@l } !<v3>: * COPY
if (2 > 3) { return@l } <v4>: Unit NEW: merge(if (2 > 3) { return@l }|!<v3>) -> <v4>
if (2 > 3) { return@l } <v4>: Unit COPY
=====================
== t4 ==
fun t4() {
@@ -107,18 +107,18 @@ fun t4() {
}
}
---------------------
1 <v0>: * NEW: r(1) -> <v0>
2 <v1>: {<: Comparable<Int>} NEW: r(2) -> <v1>
3 <v2>: Int NEW: r(3) -> <v2>
2 > 3 <v3>: Boolean NEW: call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
return@l !<v5>: *
{ return@l } !<v5>: * COPY
if (2 > 3) { return@l } !<v5>: * COPY
{ 1 if (2 > 3) { return@l } } !<v5>: * COPY
2 <v4>: * NEW: r(2) -> <v4>
{ 2 } <v4>: * COPY
try { 1 if (2 > 3) { return@l } } finally { 2 } !<v5>: * COPY
try { 1 if (2 > 3) { return@l } } finally { 2 } !<v5>: * COPY
1 <v0>: * NEW: r(1) -> <v0>
2 <v1>: {<: Comparable<Int>} NEW: r(2) -> <v1>
3 <v2>: Int NEW: r(3) -> <v2>
2 > 3 <v3>: Boolean NEW: call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
return@l !<v5>: *
{ return@l } !<v5>: * COPY
if (2 > 3) { return@l } <v6>: Unit NEW: merge(if (2 > 3) { return@l }|!<v5>) -> <v6>
{ 1 if (2 > 3) { return@l } } <v6>: Unit COPY
2 <v4>: * NEW: r(2) -> <v4>
{ 2 } <v4>: * COPY
try { 1 if (2 > 3) { return@l } } finally { 2 } <v7>: Unit NEW: merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|<v6>) -> <v7>
try { 1 if (2 > 3) { return@l } } finally { 2 } <v7>: Unit COPY
=====================
== t5 ==
fun t5() {
@@ -134,23 +134,23 @@ fun t5() {
}
}
---------------------
<v1>: * NEW: magic[VALUE_CONSUMER](true|<v0>) -> <v1>
true <v0>: Boolean NEW: r(true) -> <v0>
1 <v2>: * NEW: r(1) -> <v2>
2 <v3>: {<: Comparable<Int>} NEW: r(2) -> <v3>
3 <v4>: Int NEW: r(3) -> <v4>
2 > 3 <v5>: Boolean NEW: call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
break @l !<v7>: *
{ break @l } !<v7>: * COPY
if (2 > 3) { break @l } !<v7>: * COPY
{ 1 if (2 > 3) { break @l } } !<v7>: * COPY
2 <v6>: * NEW: r(2) -> <v6>
{ 2 } <v6>: * COPY
try { 1 if (2 > 3) { break @l } } finally { 2 } !<v7>: * COPY
{ try { 1 if (2 > 3) { break @l } } finally { 2 } } !<v7>: * COPY
while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } !<v8>: *
@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } !<v8>: * COPY
{ @l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } } !<v8>: * COPY
<v1>: * NEW: magic[VALUE_CONSUMER](true|<v0>) -> <v1>
true <v0>: Boolean NEW: r(true) -> <v0>
1 <v2>: * NEW: r(1) -> <v2>
2 <v3>: {<: Comparable<Int>} NEW: r(2) -> <v3>
3 <v4>: Int NEW: r(3) -> <v4>
2 > 3 <v5>: Boolean NEW: call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
break @l !<v7>: *
{ break @l } !<v7>: * COPY
if (2 > 3) { break @l } <v8>: * NEW: merge(if (2 > 3) { break @l }|!<v7>) -> <v8>
{ 1 if (2 > 3) { break @l } } <v8>: * COPY
2 <v6>: * NEW: r(2) -> <v6>
{ 2 } <v6>: * COPY
try { 1 if (2 > 3) { break @l } } finally { 2 } <v9>: * NEW: merge(try { 1 if (2 > 3) { break @l } } finally { 2 }|<v8>) -> <v9>
{ try { 1 if (2 > 3) { break @l } } finally { 2 } } <v9>: * COPY
while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } !<v10>: *
@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } !<v10>: * COPY
{ @l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } } !<v10>: * COPY
=====================
== t6 ==
fun t6() {
@@ -167,24 +167,24 @@ fun t6() {
}
}
---------------------
<v1>: * NEW: magic[VALUE_CONSUMER](true|<v0>) -> <v1>
true <v0>: Boolean NEW: r(true) -> <v0>
1 <v2>: * NEW: r(1) -> <v2>
2 <v3>: {<: Comparable<Int>} NEW: r(2) -> <v3>
3 <v4>: Int NEW: r(3) -> <v4>
2 > 3 <v5>: Boolean NEW: call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
break @l !<v6>: *
{ break @l } !<v6>: * COPY
if (2 > 3) { break @l } !<v6>: * COPY
{ 1 if (2 > 3) { break @l } } !<v6>: * COPY
while(true) { 1 if (2 > 3) { break @l } } !<v7>: *
@l while(true) { 1 if (2 > 3) { break @l } } !<v7>: * COPY
5 <v8>: * NEW: r(5) -> <v8>
{ @l while(true) { 1 if (2 > 3) { break @l } } 5 } <v8>: * COPY
2 <v9>: * NEW: r(2) -> <v9>
{ 2 } <v9>: * COPY
try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } <v8>: * COPY
{ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } } <v8>: * COPY
<v1>: * NEW: magic[VALUE_CONSUMER](true|<v0>) -> <v1>
true <v0>: Boolean NEW: r(true) -> <v0>
1 <v2>: * NEW: r(1) -> <v2>
2 <v3>: {<: Comparable<Int>} NEW: r(2) -> <v3>
3 <v4>: Int NEW: r(3) -> <v4>
2 > 3 <v5>: Boolean NEW: call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
break @l !<v6>: *
{ break @l } !<v6>: * COPY
if (2 > 3) { break @l } <v7>: * NEW: merge(if (2 > 3) { break @l }|!<v6>) -> <v7>
{ 1 if (2 > 3) { break @l } } <v7>: * COPY
while(true) { 1 if (2 > 3) { break @l } } !<v8>: *
@l while(true) { 1 if (2 > 3) { break @l } } !<v8>: * COPY
5 <v9>: * NEW: r(5) -> <v9>
{ @l while(true) { 1 if (2 > 3) { break @l } } 5 } <v9>: * COPY
2 <v10>: * NEW: r(2) -> <v10>
{ 2 } <v10>: * COPY
try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } <v11>: * NEW: merge(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }|<v9>) -> <v11>
{ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } } <v11>: * COPY
=====================
== t7 ==
fun t7() {
@@ -200,23 +200,23 @@ fun t7() {
}
}
---------------------
<v1>: * NEW: magic[VALUE_CONSUMER](true|<v0>) -> <v1>
true <v0>: Boolean NEW: r(true) -> <v0>
1 <v2>: * NEW: r(1) -> <v2>
2 <v3>: {<: Comparable<Int>} NEW: r(2) -> <v3>
3 <v4>: Int NEW: r(3) -> <v4>
2 > 3 <v5>: Boolean NEW: call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
break @l !<v6>: *
{ break @l } !<v6>: * COPY
if (2 > 3) { break @l } !<v6>: * COPY
{ 1 if (2 > 3) { break @l } } !<v6>: * COPY
while(true) { 1 if (2 > 3) { break @l } } !<v7>: *
@l while(true) { 1 if (2 > 3) { break @l } } !<v7>: * COPY
{ @l while(true) { 1 if (2 > 3) { break @l } } } !<v7>: * COPY
2 <v8>: * NEW: r(2) -> <v8>
{ 2 } <v8>: * COPY
try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } !<v7>: * COPY
{ try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } } !<v7>: * COPY
<v1>: * NEW: magic[VALUE_CONSUMER](true|<v0>) -> <v1>
true <v0>: Boolean NEW: r(true) -> <v0>
1 <v2>: * NEW: r(1) -> <v2>
2 <v3>: {<: Comparable<Int>} NEW: r(2) -> <v3>
3 <v4>: Int NEW: r(3) -> <v4>
2 > 3 <v5>: Boolean NEW: call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
break @l !<v6>: *
{ break @l } !<v6>: * COPY
if (2 > 3) { break @l } <v7>: * NEW: merge(if (2 > 3) { break @l }|!<v6>) -> <v7>
{ 1 if (2 > 3) { break @l } } <v7>: * COPY
while(true) { 1 if (2 > 3) { break @l } } !<v8>: *
@l while(true) { 1 if (2 > 3) { break @l } } !<v8>: * COPY
{ @l while(true) { 1 if (2 > 3) { break @l } } } !<v8>: * COPY
2 <v9>: * NEW: r(2) -> <v9>
{ 2 } <v9>: * COPY
try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } <v10>: * NEW: merge(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 }|!<v8>) -> <v10>
{ try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } } <v10>: * COPY
=====================
== t8 ==
fun t8(a : Int) {
@@ -232,26 +232,26 @@ fun t8(a : Int) {
}
}
---------------------
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
1 <v5>: * NEW: r(1) -> <v5>
2 <v6>: {<: Comparable<Int>} NEW: r(2) -> <v6>
3 <v7>: Int NEW: r(3) -> <v7>
2 > 3 <v8>: Boolean NEW: call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
continue @l !<v10>: *
{ continue @l } !<v10>: * COPY
if (2 > 3) { continue @l } !<v10>: * COPY
{ 1 if (2 > 3) { continue @l } } !<v10>: * COPY
2 <v9>: * NEW: r(2) -> <v9>
{ 2 } <v9>: * COPY
try { 1 if (2 > 3) { continue @l } } finally { 2 } !<v10>: * COPY
{ try { 1 if (2 > 3) { continue @l } } finally { 2 } } !<v10>: * COPY
for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } !<v11>: *
@l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } !<v11>: * COPY
{ @l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } } !<v11>: * COPY
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
1 <v5>: * NEW: r(1) -> <v5>
2 <v6>: {<: Comparable<Int>} NEW: r(2) -> <v6>
3 <v7>: Int NEW: r(3) -> <v7>
2 > 3 <v8>: Boolean NEW: call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
continue @l !<v10>: *
{ continue @l } !<v10>: * COPY
if (2 > 3) { continue @l } <v11>: * NEW: merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>
{ 1 if (2 > 3) { continue @l } } <v11>: * COPY
2 <v9>: * NEW: r(2) -> <v9>
{ 2 } <v9>: * COPY
try { 1 if (2 > 3) { continue @l } } finally { 2 } <v12>: * NEW: merge(try { 1 if (2 > 3) { continue @l } } finally { 2 }|<v11>) -> <v12>
{ try { 1 if (2 > 3) { continue @l } } finally { 2 } } <v12>: * COPY
for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } !<v13>: *
@l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } !<v13>: * COPY
{ @l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } } !<v13>: * COPY
=====================
== t9 ==
fun t9(a : Int) {
@@ -268,27 +268,27 @@ fun t9(a : Int) {
}
}
---------------------
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
1 <v5>: * NEW: r(1) -> <v5>
2 <v6>: {<: Comparable<Int>} NEW: r(2) -> <v6>
3 <v7>: Int NEW: r(3) -> <v7>
2 > 3 <v8>: Boolean NEW: call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
continue @l !<v9>: *
{ continue @l } !<v9>: * COPY
if (2 > 3) { continue @l } !<v9>: * COPY
{ 1 if (2 > 3) { continue @l } } !<v9>: * COPY
for (i in 1..a) { 1 if (2 > 3) { continue @l } } !<v10>: *
@l for (i in 1..a) { 1 if (2 > 3) { continue @l } } !<v10>: * COPY
5 <v11>: * NEW: r(5) -> <v11>
{ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } <v11>: * COPY
2 <v12>: * NEW: r(2) -> <v12>
{ 2 } <v12>: * COPY
try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } <v11>: * COPY
{ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } } <v11>: * COPY
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
1 <v5>: * NEW: r(1) -> <v5>
2 <v6>: {<: Comparable<Int>} NEW: r(2) -> <v6>
3 <v7>: Int NEW: r(3) -> <v7>
2 > 3 <v8>: Boolean NEW: call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
continue @l !<v9>: *
{ continue @l } !<v9>: * COPY
if (2 > 3) { continue @l } <v10>: * NEW: merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>
{ 1 if (2 > 3) { continue @l } } <v10>: * COPY
for (i in 1..a) { 1 if (2 > 3) { continue @l } } !<v11>: *
@l for (i in 1..a) { 1 if (2 > 3) { continue @l } } !<v11>: * COPY
5 <v12>: * NEW: r(5) -> <v12>
{ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } <v12>: * COPY
2 <v13>: * NEW: r(2) -> <v13>
{ 2 } <v13>: * COPY
try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } <v14>: * NEW: merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }|<v12>) -> <v14>
{ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } } <v14>: * COPY
=====================
== t10 ==
fun t10(a : Int) {
@@ -304,26 +304,26 @@ fun t10(a : Int) {
}
}
---------------------
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
1 <v5>: * NEW: r(1) -> <v5>
2 <v6>: {<: Comparable<Int>} NEW: r(2) -> <v6>
3 <v7>: Int NEW: r(3) -> <v7>
2 > 3 <v8>: Boolean NEW: call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
continue @l !<v9>: *
{ continue @l } !<v9>: * COPY
if (2 > 3) { continue @l } !<v9>: * COPY
{ 1 if (2 > 3) { continue @l } } !<v9>: * COPY
for (i in 1..a) { 1 if (2 > 3) { continue @l } } !<v10>: *
@l for (i in 1..a) { 1 if (2 > 3) { continue @l } } !<v10>: * COPY
{ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } !<v10>: * COPY
2 <v11>: * NEW: r(2) -> <v11>
{ 2 } <v11>: * COPY
try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } !<v10>: * COPY
{ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } } !<v10>: * COPY
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
1 <v5>: * NEW: r(1) -> <v5>
2 <v6>: {<: Comparable<Int>} NEW: r(2) -> <v6>
3 <v7>: Int NEW: r(3) -> <v7>
2 > 3 <v8>: Boolean NEW: call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
continue @l !<v9>: *
{ continue @l } !<v9>: * COPY
if (2 > 3) { continue @l } <v10>: * NEW: merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>
{ 1 if (2 > 3) { continue @l } } <v10>: * COPY
for (i in 1..a) { 1 if (2 > 3) { continue @l } } !<v11>: *
@l for (i in 1..a) { 1 if (2 > 3) { continue @l } } !<v11>: * COPY
{ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } !<v11>: * COPY
2 <v12>: * NEW: r(2) -> <v12>
{ 2 } <v12>: * COPY
try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } <v13>: * NEW: merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 }|!<v11>) -> <v13>
{ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } } <v13>: * COPY
=====================
== t11 ==
fun t11() {
@@ -335,14 +335,14 @@ fun t11() {
}
}
---------------------
1 <v0>: Unit NEW: r(1) -> <v0>
return 1 !<v3>: *
{ return 1 } !<v3>: * COPY
2 <v1>: Unit NEW: r(2) -> <v1>
return 2 !<v2>: *
{ return 2 } !<v2>: * COPY
try { return 1 } finally { return 2 } !<v3>: * COPY
{ try { return 1 } finally { return 2 } } !<v3>: * COPY
1 <v0>: Unit NEW: r(1) -> <v0>
return 1 !<v3>: *
{ return 1 } !<v3>: * COPY
2 <v1>: Unit NEW: r(2) -> <v1>
return 2 !<v2>: *
{ return 2 } !<v2>: * COPY
try { return 1 } finally { return 2 } <v4>: * NEW: merge(try { return 1 } finally { return 2 }|!<v3>) -> <v4>
{ try { return 1 } finally { return 2 } } <v4>: * COPY
=====================
== t12 ==
fun t12() : Int {
@@ -354,14 +354,14 @@ fun t12() : Int {
}
}
---------------------
1 <v0>: Int NEW: r(1) -> <v0>
return 1 !<v3>: *
{ return 1 } !<v3>: * COPY
3 <v1>: Int NEW: r(3) -> <v1>
doSmth(3) <v2>: * NEW: call(doSmth(3), doSmth|<v1>) -> <v2>
{ doSmth(3) } <v2>: * COPY
try { return 1 } finally { doSmth(3) } !<v3>: * COPY
{ try { return 1 } finally { doSmth(3) } } !<v3>: * COPY
1 <v0>: Int NEW: r(1) -> <v0>
return 1 !<v3>: *
{ return 1 } !<v3>: * COPY
3 <v1>: Int NEW: r(3) -> <v1>
doSmth(3) <v2>: * NEW: call(doSmth(3), doSmth|<v1>) -> <v2>
{ doSmth(3) } <v2>: * COPY
try { return 1 } finally { doSmth(3) } <v4>: * NEW: merge(try { return 1 } finally { doSmth(3) }|!<v3>) -> <v4>
{ try { return 1 } finally { doSmth(3) } } <v4>: * COPY
=====================
== t13 ==
fun t13() : Int {
compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
+17 -14
View File
@@ -304,44 +304,47 @@ L0:
w(list|<v0>)
2 mark({ try { doSmth() } finally { if(list != null) { } } })
mark(try { doSmth() } finally { if(list != null) { } })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ if(list != null) { } }), mark({ doSmth() })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ if(list != null) { } }), mark({ doSmth() })]
3 mark({ doSmth() })
mark(doSmth())
call(doSmth(), doSmth) -> <v1>
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ if(list != null) { } })]
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ if(list != null) { } })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
3 mark({ if(list != null) { } }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ if(list != null) { } }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
mark(if(list != null) { })
r(list) -> <v2>
r(null) -> <v3>
mark(list != null)
call(list != null, equals|<v2>, <v3>) -> <v4>
jf(L5|<v4>) NEXT:[read (Unit), mark({ })]
jf(L5|<v4>) NEXT:[read (Unit), mark({ })]
4 mark({ })
read (Unit)
3 jmp(L6) NEXT:[jmp(error)]
3 jmp(L6) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>]
L5:
read (Unit) PREV:[jf(L5|<v4>)]
read (Unit) PREV:[jf(L5|<v4>)]
L6:
merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(L6), read (Unit)]
L7 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] PREV:[jmp(L6), read (Unit)]
2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]:
3 mark({ if(list != null) { } }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
3 mark({ if(list != null) { } }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
mark(if(list != null) { })
r(list) -> <v2>
r(null) -> <v3>
mark(list != null)
call(list != null, equals|<v2>, <v3>) -> <v4>
jf(copy L5|<v4>) NEXT:[read (Unit), mark({ })]
jf(copy L5|<v4>) NEXT:[read (Unit), mark({ })]
4 mark({ })
read (Unit)
3 jmp(copy L6) NEXT:[<END>]
read (Unit) PREV:[jf(copy L5|<v4>)]
3 jmp(copy L6) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>]
read (Unit) PREV:[jf(copy L5|<v4>)]
merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(copy L6), read (Unit)]
2 merge(try { doSmth() } finally { if(list != null) { } }|<v1>) -> <v7>
L1:
1 <END> NEXT:[<SINK>] PREV:[jmp(copy L6), read (Unit)]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/controlStructures/FinallyTestCopy.values
+11 -11
View File
@@ -123,15 +123,15 @@ fun doTestCopy4(list: List<String>?) : Int {
}
}
---------------------
<v0>: {<: List<String>?} NEW: magic[FAKE_INITIALIZER](list: List<String>?) -> <v0>
doSmth() <v1>: * NEW: call(doSmth(), doSmth) -> <v1>
{ doSmth() } <v1>: * COPY
list <v2>: * NEW: r(list) -> <v2>
null <v3>: * NEW: r(null) -> <v3>
list != null <v4>: Boolean NEW: call(list != null, equals|<v2>, <v3>) -> <v4>
{ } !<v5>: *
if(list != null) { } !<v5>: * COPY
{ if(list != null) { } } !<v5>: * COPY
try { doSmth() } finally { if(list != null) { } } <v1>: * COPY
{ try { doSmth() } finally { if(list != null) { } } } <v1>: * COPY
<v0>: {<: List<String>?} NEW: magic[FAKE_INITIALIZER](list: List<String>?) -> <v0>
doSmth() <v1>: * NEW: call(doSmth(), doSmth) -> <v1>
{ doSmth() } <v1>: * COPY
list <v2>: * NEW: r(list) -> <v2>
null <v3>: * NEW: r(null) -> <v3>
list != null <v4>: Boolean NEW: call(list != null, equals|<v2>, <v3>) -> <v4>
{ } !<v5>: *
if(list != null) { } <v6>: * NEW: merge(if(list != null) { }|!<v5>) -> <v6>
{ if(list != null) { } } <v6>: * COPY
try { doSmth() } finally { if(list != null) { } } <v7>: * NEW: merge(try { doSmth() } finally { if(list != null) { } }|<v1>) -> <v7>
{ try { doSmth() } finally { if(list != null) { } } } <v7>: * COPY
=====================
compiler/testData/cfg/controlStructures/If.instructions
+27 -24
View File
@@ -30,32 +30,33 @@ L0:
mark("s")
r("s") -> <v2>
w(u|<v2>)
2 jmp(L3) NEXT:[r(u) -> <v4>]
2 jmp(L3) NEXT:[merge(if (b) { u = "s" }|!<v3>) -> <v4>]
L2:
read (Unit) PREV:[jf(L2|<v1>)]
L3:
r(u) -> <v4> PREV:[jmp(L3), read (Unit)]
merge(if (b) { u = "s" }|!<v3>) -> <v4> PREV:[jmp(L3), read (Unit)]
r(u) -> <v5>
mark(doSmth(u))
call(doSmth(u), doSmth|<v4>) -> <v5>
call(doSmth(u), doSmth|<v5>) -> <v6>
v(var r: String)
mark(if (b) { r = "s" } else { r = "t" })
r(b) -> <v6>
jf(L4|<v6>) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
r(b) -> <v7>
jf(L4|<v7>) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
3 mark({ r = "s" })
mark("s")
r("s") -> <v7>
w(r|<v7>)
2 jmp(L5) NEXT:[merge(if (b) { r = "s" } else { r = "t" }|!<v8>, !<v10>) -> <v11>]
r("s") -> <v8>
w(r|<v8>)
2 jmp(L5) NEXT:[merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>]
L4:
3 mark({ r = "t" }) PREV:[jf(L4|<v6>)]
3 mark({ r = "t" }) PREV:[jf(L4|<v7>)]
mark("t")
r("t") -> <v9>
w(r|<v9>)
r("t") -> <v10>
w(r|<v10>)
L5:
2 merge(if (b) { r = "s" } else { r = "t" }|!<v8>, !<v10>) -> <v11> PREV:[jmp(L5), w(r|<v9>)]
r(r) -> <v12>
2 merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12> PREV:[jmp(L5), w(r|<v10>)]
r(r) -> <v13>
mark(doSmth(r))
call(doSmth(r), doSmth|<v12>) -> <v13>
call(doSmth(r), doSmth|<v13>) -> <v14>
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -89,26 +90,28 @@ L0:
jf(L2|<v2>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; })
ret L1 NEXT:[<END>]
- 2 jmp(L3) NEXT:[r(i) -> <v4>] PREV:[]
- 2 jmp(L3) NEXT:[merge(if (b) { return; }|!<v3>) -> <v4>] PREV:[]
L2:
read (Unit) PREV:[jf(L2|<v2>)]
L3:
r(i) -> <v4>
merge(if (b) { return; }|!<v3>) -> <v4>
r(i) -> <v5>
mark(doSmth(i))
call(doSmth(i), doSmth|<v4>) -> <v5>
call(doSmth(i), doSmth|<v5>) -> <v6>
mark(if (i is Int) { return; })
mark(i is Int)
r(i) -> <v6>
magic[IS](i is Int|<v6>) -> <v7>
jf(L4|<v7>) NEXT:[read (Unit), mark({ return; })]
r(i) -> <v7>
magic[IS](i is Int|<v7>) -> <v8>
jf(L4|<v8>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; })
ret L1 NEXT:[<END>]
- 2 jmp(L5) NEXT:[<END>] PREV:[]
- 2 jmp(L5) NEXT:[merge(if (i is Int) { return; }|!<v9>) -> <v10>] PREV:[]
L4:
read (Unit) PREV:[jf(L4|<v7>)]
L1:
read (Unit) PREV:[jf(L4|<v8>)]
L5:
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
merge(if (i is Int) { return; }|!<v9>) -> <v10>
L1:
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, merge(if (i is Int) { return; }|!<v9>) -> <v10>]
error:
<ERROR> PREV:[]
sink:
compiler/testData/cfg/controlStructures/If.values
+28 -28
View File
@@ -21,20 +21,20 @@ b
"s" <v2>: String NEW: r("s") -> <v2>
u = "s" !<v3>: *
{ u = "s" } !<v3>: * COPY
if (b) { u = "s" } !<v3>: * COPY
u <v4>: String NEW: r(u) -> <v4>
doSmth(u) <v5>: * NEW: call(doSmth(u), doSmth|<v4>) -> <v5>
b <v6>: Boolean NEW: r(b) -> <v6>
"s" <v7>: String NEW: r("s") -> <v7>
r = "s" !<v8>: *
{ r = "s" } !<v8>: * COPY
"t" <v9>: String NEW: r("t") -> <v9>
r = "t" !<v10>: *
{ r = "t" } !<v10>: * COPY
if (b) { r = "s" } else { r = "t" } <v11>: * NEW: merge(if (b) { r = "s" } else { r = "t" }|!<v8>, !<v10>) -> <v11>
r <v12>: String NEW: r(r) -> <v12>
doSmth(r) <v13>: * NEW: call(doSmth(r), doSmth|<v12>) -> <v13>
{ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) } <v13>: * COPY
if (b) { u = "s" } <v4>: * NEW: merge(if (b) { u = "s" }|!<v3>) -> <v4>
u <v5>: String NEW: r(u) -> <v5>
doSmth(u) <v6>: * NEW: call(doSmth(u), doSmth|<v5>) -> <v6>
b <v7>: Boolean NEW: r(b) -> <v7>
"s" <v8>: String NEW: r("s") -> <v8>
r = "s" !<v9>: *
{ r = "s" } !<v9>: * COPY
"t" <v10>: String NEW: r("t") -> <v10>
r = "t" !<v11>: *
{ r = "t" } !<v11>: * COPY
if (b) { r = "s" } else { r = "t" } <v12>: * NEW: merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>
r <v13>: String NEW: r(r) -> <v13>
doSmth(r) <v14>: * NEW: call(doSmth(r), doSmth|<v13>) -> <v14>
{ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) } <v14>: * COPY
=====================
== t2 ==
fun t2(b: Boolean) {
@@ -48,20 +48,20 @@ fun t2(b: Boolean) {
}
}
---------------------
<v0>: Boolean NEW: magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
3 <v1>: Int NEW: r(3) -> <v1>
b <v2>: Boolean NEW: r(b) -> <v2>
return !<v3>: *
{ return; } !<v3>: * COPY
if (b) { return; } !<v3>: * COPY
i <v4>: String NEW: r(i) -> <v4>
doSmth(i) <v5>: * NEW: call(doSmth(i), doSmth|<v4>) -> <v5>
i <v6>: * NEW: r(i) -> <v6>
i is Int <v7>: Boolean NEW: magic[IS](i is Int|<v6>) -> <v7>
return !<v8>: *
{ return; } !<v8>: * COPY
if (i is Int) { return; } !<v8>: * COPY
{ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } } !<v8>: * COPY
<v0>: Boolean NEW: magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
3 <v1>: Int NEW: r(3) -> <v1>
b <v2>: Boolean NEW: r(b) -> <v2>
return !<v3>: *
{ return; } !<v3>: * COPY
if (b) { return; } <v4>: * NEW: merge(if (b) { return; }|!<v3>) -> <v4>
i <v5>: String NEW: r(i) -> <v5>
doSmth(i) <v6>: * NEW: call(doSmth(i), doSmth|<v5>) -> <v6>
i <v7>: * NEW: r(i) -> <v7>
i is Int <v8>: Boolean NEW: magic[IS](i is Int|<v7>) -> <v8>
return !<v9>: *
{ return; } !<v9>: * COPY
if (i is Int) { return; } <v10>: * NEW: merge(if (i is Int) { return; }|!<v9>) -> <v10>
{ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } } <v10>: * COPY
=====================
== doSmth ==
fun doSmth(s: String) {}
compiler/testData/cfg/controlStructures/returnsInWhen.instructions
+8 -7
View File
@@ -16,17 +16,18 @@ L0:
mark(is Int -> return a)
mark(is Int)
magic[IS](is Int|<v1>) -> <v2>
jmp?(L4|<v2>) NEXT:[<END>, r(a) -> <v3>]
jmp?(L4|<v2>) NEXT:[merge(when(a) { is Int -> return a }|!<v4>) -> <v5>, r(a) -> <v3>]
L3:
r(a) -> <v3>
ret(*|<v3>) L1 NEXT:[<END>]
- jmp(L2) PREV:[]
L1:
ret(*|<v3>) L1 NEXT:[<END>]
- jmp(L2) PREV:[]
L2:
L4:
1 <END> NEXT:[<SINK>] PREV:[jmp?(L4|<v2>), ret(*|<v3>) L1]
merge(when(a) { is Int -> return a }|!<v4>) -> <v5> PREV:[jmp?(L4|<v2>)]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v3>) L1, merge(when(a) { is Int -> return a }|!<v4>) -> <v5>]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/controlStructures/returnsInWhen.values
+7 -7
View File
@@ -5,11 +5,11 @@ fun illegalWhenBlock(a: Any): Any {
}
}
---------------------
<v0>: {<: Any} NEW: magic[FAKE_INITIALIZER](a: Any) -> <v0>
a <v1>: * NEW: r(a) -> <v1>
is Int <v2>: * NEW: magic[IS](is Int|<v1>) -> <v2>
a <v3>: {<: Any} NEW: r(a) -> <v3>
return a !<v4>: *
when(a) { is Int -> return a } !<v4>: * COPY
{ when(a) { is Int -> return a } } !<v4>: * COPY
<v0>: {<: Any} NEW: magic[FAKE_INITIALIZER](a: Any) -> <v0>
a <v1>: * NEW: r(a) -> <v1>
is Int <v2>: * NEW: magic[IS](is Int|<v1>) -> <v2>
a <v3>: {<: Any} NEW: r(a) -> <v3>
return a !<v4>: *
when(a) { is Int -> return a } <v5>: * NEW: merge(when(a) { is Int -> return a }|!<v4>) -> <v5>
{ when(a) { is Int -> return a } } <v5>: * COPY
=====================
compiler/testData/cfg/conventions/equals.instructions
+4 -3
View File
@@ -21,12 +21,13 @@ L0:
jf(L2|<v4>) NEXT:[read (Unit), mark({ })]
3 mark({ })
read (Unit)
2 jmp(L3) NEXT:[<END>]
2 jmp(L3) NEXT:[merge(if (a == b) { }|!<v5>) -> <v6>]
L2:
read (Unit) PREV:[jf(L2|<v4>)]
L1:
L3:
1 <END> NEXT:[<SINK>] PREV:[jmp(L3), read (Unit)]
merge(if (a == b) { }|!<v5>) -> <v6> PREV:[jmp(L3), read (Unit)]
L1:
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
compiler/testData/cfg/conventions/equals.values
+2 -2
View File
@@ -10,6 +10,6 @@ a <v2>: OR{{<: Any}, {<: Any}} NEW: r(a) -> <v2>
b <v3>: * NEW: r(b) -> <v3>
a == b <v4>: Boolean NEW: call(a == b, equals|<v2>, <v3>) -> <v4>
{ } !<v5>: *
if (a == b) { } !<v5>: * COPY
{ if (a == b) { } } !<v5>: * COPY
if (a == b) { } <v6>: * NEW: merge(if (a == b) { }|!<v5>) -> <v6>
{ if (a == b) { } } <v6>: * COPY
=====================
compiler/testData/cfg/conventions/notEqual.instructions
+4 -3
View File
@@ -20,12 +20,13 @@ L0:
jf(L2|<v4>) NEXT:[read (Unit), mark({})]
3 mark({})
read (Unit)
2 jmp(L3) NEXT:[<END>]
2 jmp(L3) NEXT:[merge(if (a != b) {}|!<v5>) -> <v6>]
L2:
read (Unit) PREV:[jf(L2|<v4>)]
L1:
L3:
1 <END> NEXT:[<SINK>] PREV:[jmp(L3), read (Unit)]
merge(if (a != b) {}|!<v5>) -> <v6> PREV:[jmp(L3), read (Unit)]
L1:
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
compiler/testData/cfg/conventions/notEqual.values
+2 -2
View File
@@ -9,6 +9,6 @@ a <v2>: OR{{<: Any}, {<: Any}} NEW: r(a) -> <v2>
b <v3>: * NEW: r(b) -> <v3>
a != b <v4>: Boolean NEW: call(a != b, equals|<v2>, <v3>) -> <v4>
{} !<v5>: *
if (a != b) {} !<v5>: * COPY
{ if (a != b) {} } !<v5>: * COPY
if (a != b) {} <v6>: * NEW: merge(if (a != b) {}|!<v5>) -> <v6>
{ if (a != b) {} } <v6>: * COPY
=====================
compiler/testData/cfg/expressions/LazyBooleans.instructions
+9 -7
View File
@@ -70,20 +70,22 @@ L9:
r(a) -> <v21>
jf(L10|<v21>) NEXT:[read (Unit), r(11) -> <v22>]
r(11) -> <v22>
jmp(L11) NEXT:[r(12) -> <v23>]
jmp(L11) NEXT:[merge(if (a) 11|<v22>) -> <v23>]
L10:
read (Unit) PREV:[jf(L10|<v21>)]
L11:
r(12) -> <v23> PREV:[jmp(L11), read (Unit)]
merge(if (a) 11|<v22>) -> <v23> PREV:[jmp(L11), read (Unit)]
r(12) -> <v24>
mark(if (a) else 13)
r(a) -> <v24>
jf(L12|<v24>) NEXT:[r(13) -> <v25>, read (Unit)]
r(a) -> <v25>
jf(L12|<v25>) NEXT:[r(13) -> <v26>, read (Unit)]
read (Unit)
jmp(L13) NEXT:[r(14) -> <v26>]
jmp(L13) NEXT:[merge(if (a) else 13|<v26>) -> <v27>]
L12:
r(13) -> <v25> PREV:[jf(L12|<v24>)]
r(13) -> <v26> PREV:[jf(L12|<v25>)]
L13:
r(14) -> <v26> PREV:[jmp(L13), r(13) -> <v25>]
merge(if (a) else 13|<v26>) -> <v27> PREV:[jmp(L13), r(13) -> <v26>]
r(14) -> <v28>
L1:
1 <END> NEXT:[<SINK>]
error:
compiler/testData/cfg/expressions/LazyBooleans.values
+7 -7
View File
@@ -42,11 +42,11 @@ if (a || b) 8 else 9
10 <v20>: * NEW: r(10) -> <v20>
a <v21>: Boolean NEW: r(a) -> <v21>
11 <v22>: * NEW: r(11) -> <v22>
if (a) 11 <v22>: * COPY
12 <v23>: * NEW: r(12) -> <v23>
a <v24>: Boolean NEW: r(a) -> <v24>
13 <v25>: * NEW: r(13) -> <v25>
if (a) else 13 <v25>: * COPY
14 <v26>: * NEW: r(14) -> <v26>
{ if (a) { 1 } else { 2 } 3 if (a && b) 5 else 6 7 if (a || b) 8 else 9 10 if (a) 11 12 if (a) else 13 14 } <v26>: * COPY
if (a) 11 <v23>: * NEW: merge(if (a) 11|<v22>) -> <v23>
12 <v24>: * NEW: r(12) -> <v24>
a <v25>: Boolean NEW: r(a) -> <v25>
13 <v26>: * NEW: r(13) -> <v26>
if (a) else 13 <v27>: * NEW: merge(if (a) else 13|<v26>) -> <v27>
14 <v28>: * NEW: r(14) -> <v28>
{ if (a) { 1 } else { 2 } 3 if (a && b) 5 else 6 7 if (a || b) 8 else 9 10 if (a) 11 12 if (a) else 13 14 } <v28>: * COPY
=====================
compiler/testData/cfg/tailCalls/finally.instructions
+9 -8
View File
@@ -11,25 +11,26 @@ L0:
1 <START>
2 mark({ try { // do nothing } finally { test() } })
mark(try { // do nothing } finally { test() })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ test() }), mark({ // do nothing })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ test() }), mark({ // do nothing })]
3 mark({ // do nothing })
read (Unit)
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ test() })]
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ test() })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
3 mark({ test() }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ test() }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
mark(test())
call(test(), test) -> <v0>
L5 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]:
3 mark({ test() }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
3 mark({ test() }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
mark(test())
call(test(), test) -> <v0>
2 merge(try { // do nothing } finally { test() }|!<v1>) -> <v2>
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/tailCalls/finally.values
+5 -5
View File
@@ -7,9 +7,9 @@ tailRecursive fun test() : Int {
}
}
---------------------
{ // do nothing } !<v1>: *
test() <v0>: * NEW: call(test(), test) -> <v0>
{ test() } <v0>: * COPY
try { // do nothing } finally { test() } !<v1>: * COPY
{ try { // do nothing } finally { test() } } !<v1>: * COPY
{ // do nothing } !<v1>: *
test() <v0>: * NEW: call(test(), test) -> <v0>
{ test() } <v0>: * COPY
try { // do nothing } finally { test() } <v2>: * NEW: merge(try { // do nothing } finally { test() }|!<v1>) -> <v2>
{ try { // do nothing } finally { test() } } <v2>: * COPY
=====================
compiler/testData/cfg/tailCalls/finallyWithReturn.instructions
+11 -10
View File
@@ -11,27 +11,28 @@ L0:
1 <START>
2 mark({ try { // do nothing } finally { return test() } })
mark(try { // do nothing } finally { return test() })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return test() }), mark({ // do nothing })]
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return test() }), mark({ // do nothing })]
3 mark({ // do nothing })
read (Unit)
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ return test() })]
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ return test() })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
3 mark({ return test() }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ return test() }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
mark(test())
call(test(), test) -> <v0>
ret(*|<v0>) L1 NEXT:[<END>]
ret(*|<v0>) L1 NEXT:[<END>]
L5 [finish finally]:
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L3 [skipFinallyToErrorBlock]:
3 mark({ return test() }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
3 mark({ return test() }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
mark(test())
call(test(), test) -> <v0>
ret(*|<v0>) L1
ret(*|<v0>) L1 NEXT:[<END>]
- 2 merge(try { // do nothing } finally { return test() }|!<v2>) -> <v3> PREV:[]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v0>) L1, ret(*|<v0>) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v0>) L1, ret(*|<v0>) L1]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/tailCalls/finallyWithReturn.values
+6 -6
View File
@@ -7,10 +7,10 @@ tailRecursive fun test() : Int {
}
}
---------------------
{ // do nothing } !<v2>: *
test() <v0>: Int NEW: call(test(), test) -> <v0>
return test() !<v1>: *
{ return test() } !<v1>: * COPY
try { // do nothing } finally { return test() } !<v2>: * COPY
{ try { // do nothing } finally { return test() } } !<v2>: * COPY
{ // do nothing } !<v2>: *
test() <v0>: Int NEW: call(test(), test) -> <v0>
return test() !<v1>: *
{ return test() } !<v1>: * COPY
try { // do nothing } finally { return test() } <v3>: * NEW: merge(try { // do nothing } finally { return test() }|!<v2>) -> <v3>
{ try { // do nothing } finally { return test() } } <v3>: * COPY
=====================
compiler/testData/cfg/tailCalls/sum.instructions
+11 -10
View File
@@ -24,23 +24,24 @@ L0:
jf(L2|<v5>) NEXT:[read (Unit), r(sum) -> <v6>]
r(sum) -> <v6>
ret(*|<v6>) L1 NEXT:[<END>]
- jmp(L3) NEXT:[r(x) -> <v8>] PREV:[]
- jmp(L3) NEXT:[merge(if (x == 0.toLong()) return sum|!<v7>) -> <v8>] PREV:[]
L2:
read (Unit) PREV:[jf(L2|<v5>)]
L3:
r(x) -> <v8>
r(1) -> <v9>
merge(if (x == 0.toLong()) return sum|!<v7>) -> <v8>
r(x) -> <v9>
r(1) -> <v10>
mark(x - 1)
call(x - 1, minus|<v8>, <v9>) -> <v10>
r(sum) -> <v11>
r(x) -> <v12>
call(x - 1, minus|<v9>, <v10>) -> <v11>
r(sum) -> <v12>
r(x) -> <v13>
mark(sum + x)
call(sum + x, plus|<v11>, <v12>) -> <v13>
call(sum + x, plus|<v12>, <v13>) -> <v14>
mark(sum(x - 1, sum + x))
call(sum(x - 1, sum + x), sum|<v10>, <v13>) -> <v14>
ret(*|<v14>) L1
call(sum(x - 1, sum + x), sum|<v11>, <v14>) -> <v15>
ret(*|<v15>) L1
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v6>) L1, ret(*|<v14>) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v6>) L1, ret(*|<v15>) L1]
error:
<ERROR> PREV:[]
sink:
compiler/testData/cfg/tailCalls/sum.values
+10 -10
View File
@@ -13,14 +13,14 @@ toLong() <v4>: *
x == 0.toLong() <v5>: Boolean NEW: call(x == 0.toLong(), equals|<v2>, <v4>) -> <v5>
sum <v6>: Long NEW: r(sum) -> <v6>
return sum !<v7>: *
if (x == 0.toLong()) return sum !<v7>: * COPY
x <v8>: Long NEW: r(x) -> <v8>
1 <v9>: Int NEW: r(1) -> <v9>
x - 1 <v10>: Long NEW: call(x - 1, minus|<v8>, <v9>) -> <v10>
sum <v11>: Long NEW: r(sum) -> <v11>
x <v12>: Long NEW: r(x) -> <v12>
sum + x <v13>: Long NEW: call(sum + x, plus|<v11>, <v12>) -> <v13>
sum(x - 1, sum + x) <v14>: Long NEW: call(sum(x - 1, sum + x), sum|<v10>, <v13>) -> <v14>
return sum(x - 1, sum + x) !<v15>: *
{ if (x == 0.toLong()) return sum return sum(x - 1, sum + x) } !<v15>: * COPY
if (x == 0.toLong()) return sum <v8>: * NEW: merge(if (x == 0.toLong()) return sum|!<v7>) -> <v8>
x <v9>: Long NEW: r(x) -> <v9>
1 <v10>: Int NEW: r(1) -> <v10>
x - 1 <v11>: Long NEW: call(x - 1, minus|<v9>, <v10>) -> <v11>
sum <v12>: Long NEW: r(sum) -> <v12>
x <v13>: Long NEW: r(x) -> <v13>
sum + x <v14>: Long NEW: call(sum + x, plus|<v12>, <v13>) -> <v14>
sum(x - 1, sum + x) <v15>: Long NEW: call(sum(x - 1, sum + x), sum|<v11>, <v14>) -> <v15>
return sum(x - 1, sum + x) !<v16>: *
{ if (x == 0.toLong()) return sum return sum(x - 1, sum + x) } !<v16>: * COPY
=====================