Fix incorrect coroutines codegen behavior
If all the suspension calls in a suspend function were "hidden" under the for-convention (iterator/next/hasNext) calls, control-flow didn't find them, thus supposing that there is no suspension points and there is no need to generate a coroutine state machine The solution is to add relevant calls to CFG #KT-15824 Fixed
This commit is contained in:
Denis Zharkov
+68
-50
@@ -476,48 +476,54 @@ L0:
|
||||
r(a) -> <v2>
|
||||
mark(1..a)
|
||||
call(1..a, rangeTo|<v1>, <v2>) -> <v3>
|
||||
mark(1..a)
|
||||
call(1..a, iterator|<v3>) -> <v4>
|
||||
v(i)
|
||||
L2 [loop entry point]:
|
||||
L6 [condition entry point]:
|
||||
jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L6), jmp(L2)]
|
||||
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
|
||||
w(i|<v4>)
|
||||
mark(1..a) PREV:[v(i), jmp(L6), jmp(L2)]
|
||||
call(1..a, hasNext) -> <v5>
|
||||
jmp?(L3) NEXT:[read (Unit), mark(1..a)]
|
||||
mark(1..a)
|
||||
call(1..a, next) -> <v6>
|
||||
magic[LOOP_RANGE_ITERATION](1..a|<v6>) -> <v7>
|
||||
w(i|<v7>)
|
||||
mark(for (i in 1..a) { try { 1 if (2 > 3) { continue@l } } finally { 2 } })
|
||||
L4 [body entry point]:
|
||||
4 mark({ try { 1 if (2 > 3) { continue@l } } finally { 2 } })
|
||||
mark(try { 1 if (2 > 3) { continue@l } } finally { 2 })
|
||||
jmp?(L7) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue@l } })]
|
||||
5 mark({ 1 if (2 > 3) { continue@l } })
|
||||
r(1) -> <v5>
|
||||
r(1) -> <v8>
|
||||
mark(if (2 > 3) { continue@l })
|
||||
r(2) -> <v6>
|
||||
r(3) -> <v7>
|
||||
r(2) -> <v9>
|
||||
r(3) -> <v10>
|
||||
mark(2 > 3)
|
||||
call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
|
||||
jf(L8|<v8>) NEXT:[read (Unit), mark({ continue@l })]
|
||||
call(2 > 3, compareTo|<v9>, <v10>) -> <v11>
|
||||
jf(L8|<v11>) NEXT:[read (Unit), mark({ continue@l })]
|
||||
6 mark({ continue@l })
|
||||
jmp?(L7) NEXT:[mark({ 2 }), mark({ 2 })]
|
||||
L9 [start finally]:
|
||||
7 mark({ 2 })
|
||||
r(2) -> <v9>
|
||||
r(2) -> <v12>
|
||||
L10 [finish finally]:
|
||||
6 jmp(L6) NEXT:[jmp?(L3)]
|
||||
- 5 jmp(L11) NEXT:[merge(if (2 > 3) { continue@l }|!<v10>) -> <v11>] PREV:[]
|
||||
6 jmp(L6) NEXT:[mark(1..a)]
|
||||
- 5 jmp(L11) NEXT:[merge(if (2 > 3) { continue@l }|!<v13>) -> <v14>] PREV:[]
|
||||
L8 [else branch]:
|
||||
read (Unit) PREV:[jf(L8|<v8>)]
|
||||
read (Unit) PREV:[jf(L8|<v11>)]
|
||||
L11 ['if' expression result]:
|
||||
merge(if (2 > 3) { continue@l }|!<v10>) -> <v11>
|
||||
merge(if (2 > 3) { continue@l }|!<v13>) -> <v14>
|
||||
4 jmp?(L7) NEXT:[mark({ 2 }), jmp(L12)]
|
||||
jmp(L12) NEXT:[mark({ 2 })]
|
||||
L7 [onExceptionToFinallyBlock]:
|
||||
7 mark({ 2 }) PREV:[jmp?(L7), jmp?(L7), jmp?(L7)]
|
||||
r(2) -> <v9>
|
||||
r(2) -> <v12>
|
||||
4 jmp(error) NEXT:[<ERROR>]
|
||||
L12 [skipFinallyToErrorBlock]:
|
||||
7 mark({ 2 }) PREV:[jmp(L12)]
|
||||
r(2) -> <v9>
|
||||
4 merge(try { 1 if (2 > 3) { continue@l } } finally { 2 }|<v11>) -> <v12>
|
||||
3 jmp(L2) NEXT:[jmp?(L3)]
|
||||
r(2) -> <v12>
|
||||
4 merge(try { 1 if (2 > 3) { continue@l } } finally { 2 }|<v14>) -> <v15>
|
||||
3 jmp(L2) NEXT:[mark(1..a)]
|
||||
L3 [loop exit point]:
|
||||
L5 [body exit point]:
|
||||
read (Unit) PREV:[jmp?(L3)]
|
||||
@@ -557,47 +563,53 @@ L0:
|
||||
r(a) -> <v2>
|
||||
mark(1..a)
|
||||
call(1..a, rangeTo|<v1>, <v2>) -> <v3>
|
||||
mark(1..a)
|
||||
call(1..a, iterator|<v3>) -> <v4>
|
||||
v(i)
|
||||
L3 [loop entry point]:
|
||||
L7 [condition entry point]:
|
||||
jmp?(L4) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L7), jmp(L3)]
|
||||
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
|
||||
w(i|<v4>)
|
||||
mark(1..a) PREV:[v(i), jmp(L7), jmp(L3)]
|
||||
call(1..a, hasNext) -> <v5>
|
||||
jmp?(L4) NEXT:[read (Unit), mark(1..a)]
|
||||
mark(1..a)
|
||||
call(1..a, next) -> <v6>
|
||||
magic[LOOP_RANGE_ITERATION](1..a|<v6>) -> <v7>
|
||||
w(i|<v7>)
|
||||
mark(for (i in 1..a) { 1 if (2 > 3) { continue@l } })
|
||||
L5 [body entry point]:
|
||||
5 mark({ 1 if (2 > 3) { continue@l } })
|
||||
r(1) -> <v5>
|
||||
r(1) -> <v8>
|
||||
mark(if (2 > 3) { continue@l })
|
||||
r(2) -> <v6>
|
||||
r(3) -> <v7>
|
||||
r(2) -> <v9>
|
||||
r(3) -> <v10>
|
||||
mark(2 > 3)
|
||||
call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
|
||||
jf(L8|<v8>) NEXT:[read (Unit), mark({ continue@l })]
|
||||
call(2 > 3, compareTo|<v9>, <v10>) -> <v11>
|
||||
jf(L8|<v11>) NEXT:[read (Unit), mark({ continue@l })]
|
||||
6 mark({ continue@l })
|
||||
jmp(L7) NEXT:[jmp?(L4)]
|
||||
- 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue@l }|!<v9>) -> <v10>] PREV:[]
|
||||
jmp(L7) NEXT:[mark(1..a)]
|
||||
- 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue@l }|!<v12>) -> <v13>] PREV:[]
|
||||
L8 [else branch]:
|
||||
read (Unit) PREV:[jf(L8|<v8>)]
|
||||
read (Unit) PREV:[jf(L8|<v11>)]
|
||||
L9 ['if' expression result]:
|
||||
merge(if (2 > 3) { continue@l }|!<v9>) -> <v10>
|
||||
4 jmp(L3) NEXT:[jmp?(L4)]
|
||||
merge(if (2 > 3) { continue@l }|!<v12>) -> <v13>
|
||||
4 jmp(L3) NEXT:[mark(1..a)]
|
||||
L4 [loop exit point]:
|
||||
L6 [body exit point]:
|
||||
read (Unit) PREV:[jmp?(L4)]
|
||||
3 r(5) -> <v12>
|
||||
3 r(5) -> <v15>
|
||||
2 jmp?(L2) NEXT:[mark({ 2 }), jmp(L10)]
|
||||
jmp(L10) NEXT:[mark({ 2 })]
|
||||
L2 [onExceptionToFinallyBlock]:
|
||||
L11 [start finally]:
|
||||
3 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2)]
|
||||
r(2) -> <v13>
|
||||
r(2) -> <v16>
|
||||
L12 [finish finally]:
|
||||
2 jmp(error) NEXT:[<ERROR>]
|
||||
L10 [skipFinallyToErrorBlock]:
|
||||
L13 [copy of L2, onExceptionToFinallyBlock]:
|
||||
3 mark({ 2 }) PREV:[jmp(L10)]
|
||||
r(2) -> <v13>
|
||||
2 merge(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 }|<v12>) -> <v14>
|
||||
r(2) -> <v16>
|
||||
2 merge(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 }|<v15>) -> <v17>
|
||||
L1:
|
||||
1 <END> NEXT:[<SINK>]
|
||||
error:
|
||||
@@ -633,30 +645,36 @@ L0:
|
||||
r(a) -> <v2>
|
||||
mark(1..a)
|
||||
call(1..a, rangeTo|<v1>, <v2>) -> <v3>
|
||||
mark(1..a)
|
||||
call(1..a, iterator|<v3>) -> <v4>
|
||||
v(i)
|
||||
L3 [loop entry point]:
|
||||
L7 [condition entry point]:
|
||||
jmp?(L4) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L7), jmp(L3)]
|
||||
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
|
||||
w(i|<v4>)
|
||||
mark(1..a) PREV:[v(i), jmp(L7), jmp(L3)]
|
||||
call(1..a, hasNext) -> <v5>
|
||||
jmp?(L4) NEXT:[read (Unit), mark(1..a)]
|
||||
mark(1..a)
|
||||
call(1..a, next) -> <v6>
|
||||
magic[LOOP_RANGE_ITERATION](1..a|<v6>) -> <v7>
|
||||
w(i|<v7>)
|
||||
mark(for (i in 1..a) { 1 if (2 > 3) { continue@l } })
|
||||
L5 [body entry point]:
|
||||
5 mark({ 1 if (2 > 3) { continue@l } })
|
||||
r(1) -> <v5>
|
||||
r(1) -> <v8>
|
||||
mark(if (2 > 3) { continue@l })
|
||||
r(2) -> <v6>
|
||||
r(3) -> <v7>
|
||||
r(2) -> <v9>
|
||||
r(3) -> <v10>
|
||||
mark(2 > 3)
|
||||
call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
|
||||
jf(L8|<v8>) NEXT:[read (Unit), mark({ continue@l })]
|
||||
call(2 > 3, compareTo|<v9>, <v10>) -> <v11>
|
||||
jf(L8|<v11>) NEXT:[read (Unit), mark({ continue@l })]
|
||||
6 mark({ continue@l })
|
||||
jmp(L7) NEXT:[jmp?(L4)]
|
||||
- 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue@l }|!<v9>) -> <v10>] PREV:[]
|
||||
jmp(L7) NEXT:[mark(1..a)]
|
||||
- 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue@l }|!<v12>) -> <v13>] PREV:[]
|
||||
L8 [else branch]:
|
||||
read (Unit) PREV:[jf(L8|<v8>)]
|
||||
read (Unit) PREV:[jf(L8|<v11>)]
|
||||
L9 ['if' expression result]:
|
||||
merge(if (2 > 3) { continue@l }|!<v9>) -> <v10>
|
||||
4 jmp(L3) NEXT:[jmp?(L4)]
|
||||
merge(if (2 > 3) { continue@l }|!<v12>) -> <v13>
|
||||
4 jmp(L3) NEXT:[mark(1..a)]
|
||||
L4 [loop exit point]:
|
||||
L6 [body exit point]:
|
||||
read (Unit) PREV:[jmp?(L4)]
|
||||
@@ -665,14 +683,14 @@ L6 [body exit point]:
|
||||
L2 [onExceptionToFinallyBlock]:
|
||||
L11 [start finally]:
|
||||
3 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2)]
|
||||
r(2) -> <v12>
|
||||
r(2) -> <v15>
|
||||
L12 [finish finally]:
|
||||
2 jmp(error) NEXT:[<ERROR>]
|
||||
L10 [skipFinallyToErrorBlock]:
|
||||
L13 [copy of L2, onExceptionToFinallyBlock]:
|
||||
3 mark({ 2 }) PREV:[jmp(L10)]
|
||||
r(2) -> <v12>
|
||||
2 merge(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 }|!<v11>) -> <v13>
|
||||
r(2) -> <v15>
|
||||
2 merge(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 }|!<v14>) -> <v16>
|
||||
L1:
|
||||
1 <END> NEXT:[<SINK>]
|
||||
error:
|
||||
|
||||
+82
-82
@@ -7,12 +7,12 @@ fun t1() {
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
1 <v0>: * NEW: r(1) -> <v0>
|
||||
{ 1 } <v0>: * COPY
|
||||
2 <v1>: * NEW: r(2) -> <v1>
|
||||
{ 2 } <v1>: * 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
|
||||
{ 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 } <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
|
||||
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
|
||||
{ try { 1 if (2 > 3) { return } } finally { 2 } } <v7>: * COPY
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
@@ -233,25 +233,25 @@ fun t8(a : Int) {
|
||||
}
|
||||
---------------------
|
||||
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
|
||||
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
|
||||
<v7>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v6>) -> <v7>
|
||||
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
|
||||
1..a <v6>: {<: Iterable<Int>} NEW: call(1..a, next) -> <v6>
|
||||
1 <v8>: * NEW: r(1) -> <v8>
|
||||
2 <v9>: {<: Comparable<Int>} NEW: r(2) -> <v9>
|
||||
3 <v10>: Int NEW: r(3) -> <v10>
|
||||
2 > 3 <v11>: Boolean NEW: call(2 > 3, compareTo|<v9>, <v10>) -> <v11>
|
||||
continue@l !<v13>: *
|
||||
{ continue@l } !<v13>: * COPY
|
||||
if (2 > 3) { continue@l } <v14>: * NEW: merge(if (2 > 3) { continue@l }|!<v13>) -> <v14>
|
||||
{ 1 if (2 > 3) { continue@l } } <v14>: * COPY
|
||||
2 <v12>: * NEW: r(2) -> <v12>
|
||||
{ 2 } <v12>: * COPY
|
||||
try { 1 if (2 > 3) { continue@l } } finally { 2 } <v15>: * NEW: merge(try { 1 if (2 > 3) { continue@l } } finally { 2 }|<v14>) -> <v15>
|
||||
{ try { 1 if (2 > 3) { continue@l } } finally { 2 } } <v15>: * COPY
|
||||
for (i in 1..a) { try { 1 if (2 > 3) { continue@l } } finally { 2 } } !<v16>: *
|
||||
l@ for (i in 1..a) { try { 1 if (2 > 3) { continue@l } } finally { 2 } } !<v16>: * COPY
|
||||
{ l@ for (i in 1..a) { try { 1 if (2 > 3) { continue@l } } finally { 2 } } } !<v16>: * COPY
|
||||
=====================
|
||||
== t9 ==
|
||||
fun t9(a : Int) {
|
||||
@@ -269,26 +269,26 @@ fun t9(a : Int) {
|
||||
}
|
||||
---------------------
|
||||
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
|
||||
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
|
||||
<v7>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v6>) -> <v7>
|
||||
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
|
||||
1..a <v6>: {<: Iterable<Int>} NEW: call(1..a, next) -> <v6>
|
||||
1 <v8>: * NEW: r(1) -> <v8>
|
||||
2 <v9>: {<: Comparable<Int>} NEW: r(2) -> <v9>
|
||||
3 <v10>: Int NEW: r(3) -> <v10>
|
||||
2 > 3 <v11>: Boolean NEW: call(2 > 3, compareTo|<v9>, <v10>) -> <v11>
|
||||
continue@l !<v12>: *
|
||||
{ continue@l } !<v12>: * COPY
|
||||
if (2 > 3) { continue@l } <v13>: * NEW: merge(if (2 > 3) { continue@l }|!<v12>) -> <v13>
|
||||
{ 1 if (2 > 3) { continue@l } } <v13>: * COPY
|
||||
for (i in 1..a) { 1 if (2 > 3) { continue@l } } !<v14>: *
|
||||
l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } !<v14>: * COPY
|
||||
5 <v15>: * NEW: r(5) -> <v15>
|
||||
{ l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } <v15>: * COPY
|
||||
2 <v16>: * NEW: r(2) -> <v16>
|
||||
{ 2 } <v16>: * COPY
|
||||
try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 } <v17>: * NEW: merge(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 }|<v15>) -> <v17>
|
||||
{ try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 } } <v17>: * COPY
|
||||
=====================
|
||||
== t10 ==
|
||||
fun t10(a : Int) {
|
||||
@@ -305,25 +305,25 @@ fun t10(a : Int) {
|
||||
}
|
||||
---------------------
|
||||
<v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
|
||||
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
|
||||
<v7>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v6>) -> <v7>
|
||||
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
|
||||
1..a <v6>: {<: Iterable<Int>} NEW: call(1..a, next) -> <v6>
|
||||
1 <v8>: * NEW: r(1) -> <v8>
|
||||
2 <v9>: {<: Comparable<Int>} NEW: r(2) -> <v9>
|
||||
3 <v10>: Int NEW: r(3) -> <v10>
|
||||
2 > 3 <v11>: Boolean NEW: call(2 > 3, compareTo|<v9>, <v10>) -> <v11>
|
||||
continue@l !<v12>: *
|
||||
{ continue@l } !<v12>: * COPY
|
||||
if (2 > 3) { continue@l } <v13>: * NEW: merge(if (2 > 3) { continue@l }|!<v12>) -> <v13>
|
||||
{ 1 if (2 > 3) { continue@l } } <v13>: * COPY
|
||||
for (i in 1..a) { 1 if (2 > 3) { continue@l } } !<v14>: *
|
||||
l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } !<v14>: * COPY
|
||||
{ l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } !<v14>: * COPY
|
||||
2 <v15>: * NEW: r(2) -> <v15>
|
||||
{ 2 } <v15>: * COPY
|
||||
try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 } <v16>: * NEW: merge(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 }|!<v14>) -> <v16>
|
||||
{ try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 } } <v16>: * 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
|
||||
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
|
||||
{ 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
|
||||
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
|
||||
{ try { return 1 } finally { doSmth(3) } } <v4>: * COPY
|
||||
=====================
|
||||
== t13 ==
|
||||
fun t13() : Int {
|
||||
|
||||
+13
-7
@@ -12,19 +12,25 @@ L0:
|
||||
r(2) -> <v1>
|
||||
mark(1..2)
|
||||
call(1..2, rangeTo|<v0>, <v1>) -> <v2>
|
||||
mark(1..2)
|
||||
call(1..2, iterator|<v2>) -> <v3>
|
||||
v(i)
|
||||
L2 [loop entry point]:
|
||||
L6 [condition entry point]:
|
||||
jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>] PREV:[v(i), jmp(L2)]
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>
|
||||
w(i|<v3>)
|
||||
mark(1..2) PREV:[v(i), jmp(L2)]
|
||||
call(1..2, hasNext) -> <v4>
|
||||
jmp?(L3) NEXT:[read (Unit), mark(1..2)]
|
||||
mark(1..2)
|
||||
call(1..2, next) -> <v5>
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v5>) -> <v6>
|
||||
w(i|<v6>)
|
||||
mark(for (i in 1..2) { doSmth(i) })
|
||||
L4 [body entry point]:
|
||||
4 mark({ doSmth(i) })
|
||||
r(i) -> <v4>
|
||||
r(i) -> <v7>
|
||||
mark(doSmth(i))
|
||||
call(doSmth(i), doSmth|<v4>) -> <v5>
|
||||
3 jmp(L2) NEXT:[jmp?(L3)]
|
||||
call(doSmth(i), doSmth|<v7>) -> <v8>
|
||||
3 jmp(L2) NEXT:[mark(1..2)]
|
||||
L3 [loop exit point]:
|
||||
L5 [body exit point]:
|
||||
read (Unit) PREV:[jmp?(L3)]
|
||||
@@ -51,4 +57,4 @@ error:
|
||||
<ERROR> PREV:[]
|
||||
sink:
|
||||
<SINK> PREV:[<ERROR>, <END>]
|
||||
=====================
|
||||
=====================
|
||||
|
||||
+9
-9
@@ -5,15 +5,15 @@ fun t1() {
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
<v3>: Int NEW: magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>
|
||||
1 <v0>: Int NEW: r(1) -> <v0>
|
||||
2 <v1>: Int NEW: r(2) -> <v1>
|
||||
1..2 <v2>: {<: Iterable<Int>} NEW: call(1..2, rangeTo|<v0>, <v1>) -> <v2>
|
||||
i <v4>: Int NEW: r(i) -> <v4>
|
||||
doSmth(i) <v5>: * NEW: call(doSmth(i), doSmth|<v4>) -> <v5>
|
||||
{ doSmth(i) } <v5>: * COPY
|
||||
for (i in 1..2) { doSmth(i) } !<v6>: *
|
||||
{ for (i in 1..2) { doSmth(i) } } !<v6>: * COPY
|
||||
<v6>: Int NEW: magic[LOOP_RANGE_ITERATION](1..2|<v5>) -> <v6>
|
||||
1 <v0>: Int NEW: r(1) -> <v0>
|
||||
2 <v1>: Int NEW: r(2) -> <v1>
|
||||
1..2 <v5>: {<: Iterable<Int>} NEW: call(1..2, next) -> <v5>
|
||||
i <v7>: Int NEW: r(i) -> <v7>
|
||||
doSmth(i) <v8>: * NEW: call(doSmth(i), doSmth|<v7>) -> <v8>
|
||||
{ doSmth(i) } <v8>: * COPY
|
||||
for (i in 1..2) { doSmth(i) } !<v9>: *
|
||||
{ for (i in 1..2) { doSmth(i) } } !<v9>: * COPY
|
||||
=====================
|
||||
== doSmth ==
|
||||
fun doSmth(i: Int) {}
|
||||
|
||||
@@ -16,26 +16,32 @@ L0:
|
||||
r(10) -> <v2>
|
||||
mark(1..10)
|
||||
call(1..10, rangeTo|<v1>, <v2>) -> <v3>
|
||||
mark(1..10)
|
||||
call(1..10, iterator|<v3>) -> <v4>
|
||||
v(i)
|
||||
L2 [loop entry point]:
|
||||
L6 [condition entry point]:
|
||||
jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>] PREV:[v(i), jmp(L6)]
|
||||
magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>
|
||||
w(i|<v4>)
|
||||
mark(1..10) PREV:[v(i), jmp(L6)]
|
||||
call(1..10, hasNext) -> <v5>
|
||||
jmp?(L3) NEXT:[read (Unit), mark(1..10)]
|
||||
mark(1..10)
|
||||
call(1..10, next) -> <v6>
|
||||
magic[LOOP_RANGE_ITERATION](1..10|<v6>) -> <v7>
|
||||
w(i|<v7>)
|
||||
mark(for (i in 1..10) { if (b) break; continue; })
|
||||
L4 [body entry point]:
|
||||
4 mark({ if (b) break; continue; })
|
||||
mark(if (b) break)
|
||||
r(b) -> <v5>
|
||||
jf(L7|<v5>) NEXT:[read (Unit), jmp(L3)]
|
||||
r(b) -> <v8>
|
||||
jf(L7|<v8>) NEXT:[read (Unit), jmp(L3)]
|
||||
jmp(L3) NEXT:[read (Unit)]
|
||||
- jmp(L8) NEXT:[merge(if (b) break|!<v6>) -> <v7>] PREV:[]
|
||||
- jmp(L8) NEXT:[merge(if (b) break|!<v9>) -> <v10>] PREV:[]
|
||||
L7 [else branch]:
|
||||
read (Unit) PREV:[jf(L7|<v5>)]
|
||||
read (Unit) PREV:[jf(L7|<v8>)]
|
||||
L8 ['if' expression result]:
|
||||
merge(if (b) break|!<v6>) -> <v7>
|
||||
jmp(L6) NEXT:[jmp?(L3)]
|
||||
- 3 jmp(L2) NEXT:[jmp?(L3)] PREV:[]
|
||||
merge(if (b) break|!<v9>) -> <v10>
|
||||
jmp(L6) NEXT:[mark(1..10)]
|
||||
- 3 jmp(L2) NEXT:[mark(1..10)] PREV:[]
|
||||
L3 [loop exit point]:
|
||||
L5 [body exit point]:
|
||||
read (Unit) PREV:[jmp?(L3), jmp(L3)]
|
||||
@@ -45,4 +51,4 @@ error:
|
||||
<ERROR> PREV:[]
|
||||
sink:
|
||||
<SINK> PREV:[<ERROR>, <END>]
|
||||
=====================
|
||||
=====================
|
||||
|
||||
+10
-10
@@ -7,15 +7,15 @@ fun test(b: Boolean) {
|
||||
}
|
||||
---------------------
|
||||
<v0>: Boolean NEW: magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
|
||||
<v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>
|
||||
<v7>: Int NEW: magic[LOOP_RANGE_ITERATION](1..10|<v6>) -> <v7>
|
||||
1 <v1>: Int NEW: r(1) -> <v1>
|
||||
10 <v2>: Int NEW: r(10) -> <v2>
|
||||
1..10 <v3>: {<: Iterable<Int>} NEW: call(1..10, rangeTo|<v1>, <v2>) -> <v3>
|
||||
b <v5>: Boolean NEW: r(b) -> <v5>
|
||||
break !<v6>: *
|
||||
if (b) break <v7>: * NEW: merge(if (b) break|!<v6>) -> <v7>
|
||||
continue !<v8>: *
|
||||
{ if (b) break; continue; } !<v8>: * COPY
|
||||
for (i in 1..10) { if (b) break; continue; } !<v9>: *
|
||||
{ for (i in 1..10) { if (b) break; continue; } } !<v9>: * COPY
|
||||
=====================
|
||||
1..10 <v6>: {<: Iterable<Int>} NEW: call(1..10, next) -> <v6>
|
||||
b <v8>: Boolean NEW: r(b) -> <v8>
|
||||
break !<v9>: *
|
||||
if (b) break <v10>: * NEW: merge(if (b) break|!<v9>) -> <v10>
|
||||
continue !<v11>: *
|
||||
{ if (b) break; continue; } !<v11>: * COPY
|
||||
for (i in 1..10) { if (b) break; continue; } !<v12>: *
|
||||
{ for (i in 1..10) { if (b) break; continue; } } !<v12>: * COPY
|
||||
=====================
|
||||
|
||||
+62
-38
@@ -67,39 +67,45 @@ L4 [start finally]:
|
||||
r(2) -> <v6>
|
||||
mark(1..2)
|
||||
call(1..2, rangeTo|<v5>, <v6>) -> <v7>
|
||||
mark(1..2)
|
||||
call(1..2, iterator|<v7>) -> <v8>
|
||||
v(i)
|
||||
L5 [loop entry point]:
|
||||
L9 [condition entry point]:
|
||||
jmp?(L6) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>] PREV:[v(i), jmp(L5)]
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>
|
||||
w(i|<v8>)
|
||||
mark(1..2) PREV:[v(i), jmp(L5)]
|
||||
call(1..2, hasNext) -> <v9>
|
||||
jmp?(L6) NEXT:[read (Unit), mark(1..2)]
|
||||
mark(1..2)
|
||||
call(1..2, next) -> <v10>
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v10>) -> <v11>
|
||||
w(i|<v11>)
|
||||
mark(for (i in 1..2) { })
|
||||
L7 [body entry point]:
|
||||
6 mark({ })
|
||||
read (Unit)
|
||||
5 jmp(L5) NEXT:[jmp?(L6)]
|
||||
5 jmp(L5) NEXT:[mark(1..2)]
|
||||
L6 [loop exit point]:
|
||||
L8 [body exit point]:
|
||||
read (Unit) PREV:[jmp?(L6)]
|
||||
4 mark(bar())
|
||||
call(bar(), bar) -> <v9>
|
||||
ret(*|<v9>) L1 NEXT:[<END>]
|
||||
call(bar(), bar) -> <v12>
|
||||
ret(*|<v12>) L1 NEXT:[<END>]
|
||||
L10 [finish finally]:
|
||||
- 3 ret(*|<v4>) L1 NEXT:[<END>] PREV:[]
|
||||
- jmp(L11) NEXT:[merge(if (n < 0) return 0|!<v11>) -> <v12>] PREV:[]
|
||||
- jmp(L11) NEXT:[merge(if (n < 0) return 0|!<v14>) -> <v15>] PREV:[]
|
||||
L3 [else branch]:
|
||||
read (Unit) PREV:[jf(L3|<v3>)]
|
||||
L11 ['if' expression result]:
|
||||
merge(if (n < 0) return 0|!<v11>) -> <v12>
|
||||
merge(if (n < 0) return 0|!<v14>) -> <v15>
|
||||
mark(n.let { return it })
|
||||
r(n) -> <v13>
|
||||
r(n) -> <v16>
|
||||
mark({ return it })
|
||||
jmp?(L12) NEXT:[r({ return it }) -> <v14>, d({ return it })]
|
||||
jmp?(L12) NEXT:[r({ return it }) -> <v17>, d({ return it })]
|
||||
d({ return it }) NEXT:[<SINK>]
|
||||
L12 [after local declaration]:
|
||||
r({ return it }) -> <v14> PREV:[jmp?(L12)]
|
||||
r({ return it }) -> <v17> PREV:[jmp?(L12)]
|
||||
mark(let { return it })
|
||||
call(let { return it }, let|<v13>, <v14>) -> <v15>
|
||||
call(let { return it }, let|<v16>, <v17>) -> <v18>
|
||||
2 jmp?(L2) NEXT:[mark({ for (i in 1..2) { } return bar() }), jmp(L20)]
|
||||
jmp(L20) NEXT:[mark({ for (i in 1..2) { } return bar() })]
|
||||
L2 [onExceptionToFinallyBlock]:
|
||||
@@ -108,23 +114,29 @@ L2 [onExceptionToFinallyBlock]:
|
||||
r(2) -> <v6>
|
||||
mark(1..2)
|
||||
call(1..2, rangeTo|<v5>, <v6>) -> <v7>
|
||||
mark(1..2)
|
||||
call(1..2, iterator|<v7>) -> <v8>
|
||||
v(i)
|
||||
L21 [copy of L5, loop entry point]:
|
||||
L25 [copy of L9, condition entry point]:
|
||||
jmp?(L22) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>] PREV:[v(i), jmp(L21)]
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>
|
||||
w(i|<v8>)
|
||||
mark(1..2) PREV:[v(i), jmp(L21)]
|
||||
call(1..2, hasNext) -> <v9>
|
||||
jmp?(L22) NEXT:[read (Unit), mark(1..2)]
|
||||
mark(1..2)
|
||||
call(1..2, next) -> <v10>
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v10>) -> <v11>
|
||||
w(i|<v11>)
|
||||
mark(for (i in 1..2) { })
|
||||
L23 [copy of L7, body entry point]:
|
||||
6 mark({ })
|
||||
read (Unit)
|
||||
5 jmp(L21) NEXT:[jmp?(L22)]
|
||||
5 jmp(L21) NEXT:[mark(1..2)]
|
||||
L22 [copy of L6, loop exit point]:
|
||||
L24 [copy of L8, body exit point]:
|
||||
read (Unit) PREV:[jmp?(L22)]
|
||||
4 mark(bar())
|
||||
call(bar(), bar) -> <v9>
|
||||
ret(*|<v9>) L1 NEXT:[<END>]
|
||||
call(bar(), bar) -> <v12>
|
||||
ret(*|<v12>) L1 NEXT:[<END>]
|
||||
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
|
||||
L20 [skipFinallyToErrorBlock]:
|
||||
4 mark({ for (i in 1..2) { } return bar() }) PREV:[jmp(L20)]
|
||||
@@ -132,26 +144,32 @@ L20 [skipFinallyToErrorBlock]:
|
||||
r(2) -> <v6>
|
||||
mark(1..2)
|
||||
call(1..2, rangeTo|<v5>, <v6>) -> <v7>
|
||||
mark(1..2)
|
||||
call(1..2, iterator|<v7>) -> <v8>
|
||||
v(i)
|
||||
L26 [copy of L5, loop entry point]:
|
||||
L30 [copy of L9, condition entry point]:
|
||||
jmp?(L27) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>] PREV:[v(i), jmp(L26)]
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>
|
||||
w(i|<v8>)
|
||||
mark(1..2) PREV:[v(i), jmp(L26)]
|
||||
call(1..2, hasNext) -> <v9>
|
||||
jmp?(L27) NEXT:[read (Unit), mark(1..2)]
|
||||
mark(1..2)
|
||||
call(1..2, next) -> <v10>
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v10>) -> <v11>
|
||||
w(i|<v11>)
|
||||
mark(for (i in 1..2) { })
|
||||
L28 [copy of L7, body entry point]:
|
||||
6 mark({ })
|
||||
read (Unit)
|
||||
5 jmp(L26) NEXT:[jmp?(L27)]
|
||||
5 jmp(L26) NEXT:[mark(1..2)]
|
||||
L27 [copy of L6, loop exit point]:
|
||||
L29 [copy of L8, body exit point]:
|
||||
read (Unit) PREV:[jmp?(L27)]
|
||||
4 mark(bar())
|
||||
call(bar(), bar) -> <v9>
|
||||
ret(*|<v9>) L1 NEXT:[<END>]
|
||||
- 2 merge(try { if (n < 0) return 0 n.let { return it } } finally { for (i in 1..2) { } return bar() }|<v15>) -> <v16> PREV:[]
|
||||
call(bar(), bar) -> <v12>
|
||||
ret(*|<v12>) L1 NEXT:[<END>]
|
||||
- 2 merge(try { if (n < 0) return 0 n.let { return it } } finally { for (i in 1..2) { } return bar() }|<v18>) -> <v19> PREV:[]
|
||||
L1:
|
||||
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v9>) L1, ret(*|<v9>) L1, ret(*|<v9>) L1, ret(*|<v9>) L1]
|
||||
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v12>) L1, ret(*|<v12>) L1, ret(*|<v12>) L1, ret(*|<v12>) L1]
|
||||
error:
|
||||
<ERROR> PREV:[]
|
||||
sink:
|
||||
@@ -169,29 +187,35 @@ L13:
|
||||
r(2) -> <v6>
|
||||
mark(1..2)
|
||||
call(1..2, rangeTo|<v5>, <v6>) -> <v7>
|
||||
mark(1..2)
|
||||
call(1..2, iterator|<v7>) -> <v8>
|
||||
v(i)
|
||||
L15 [copy of L5, loop entry point]:
|
||||
L19 [copy of L9, condition entry point]:
|
||||
jmp?(L16) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>] PREV:[v(i), jmp(L15)]
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>
|
||||
w(i|<v8>)
|
||||
mark(1..2) PREV:[v(i), jmp(L15)]
|
||||
call(1..2, hasNext) -> <v9>
|
||||
jmp?(L16) NEXT:[read (Unit), mark(1..2)]
|
||||
mark(1..2)
|
||||
call(1..2, next) -> <v10>
|
||||
magic[LOOP_RANGE_ITERATION](1..2|<v10>) -> <v11>
|
||||
w(i|<v11>)
|
||||
mark(for (i in 1..2) { })
|
||||
L17 [copy of L7, body entry point]:
|
||||
6 mark({ })
|
||||
read (Unit)
|
||||
5 jmp(L15) NEXT:[jmp?(L16)]
|
||||
5 jmp(L15) NEXT:[mark(1..2)]
|
||||
L16 [copy of L6, loop exit point]:
|
||||
L18 [copy of L8, body exit point]:
|
||||
read (Unit) PREV:[jmp?(L16)]
|
||||
read (Unit) PREV:[jmp?(L16)]
|
||||
4 mark(bar())
|
||||
call(bar(), bar) -> <v9>
|
||||
ret(*|<v9>) L1 NEXT:[<END>]
|
||||
- 5 ret(*|<v0>) L1 NEXT:[<END>] PREV:[]
|
||||
- 4 ret(*|!<v1>) L14 PREV:[]
|
||||
call(bar(), bar) -> <v12>
|
||||
ret(*|<v12>) L1 NEXT:[<END>]
|
||||
- 5 ret(*|<v0>) L1 NEXT:[<END>] PREV:[]
|
||||
- 4 ret(*|!<v1>) L14 PREV:[]
|
||||
L14:
|
||||
<END> NEXT:[<SINK>] PREV:[]
|
||||
<END> NEXT:[<SINK>] PREV:[]
|
||||
error:
|
||||
<ERROR> PREV:[]
|
||||
<ERROR> PREV:[]
|
||||
sink:
|
||||
<SINK> PREV:[<ERROR>, <END>]
|
||||
<SINK> PREV:[<ERROR>, <END>]
|
||||
=====================
|
||||
|
||||
+17
-17
@@ -25,32 +25,32 @@ fun foo(n: Int): Int {
|
||||
}
|
||||
---------------------
|
||||
<v0>: Int NEW: magic[FAKE_INITIALIZER](n: Int) -> <v0>
|
||||
<v8>: Int NEW: magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>
|
||||
<v11>: Int NEW: magic[LOOP_RANGE_ITERATION](1..2|<v10>) -> <v11>
|
||||
n <v1>: {<: Comparable<Int>} NEW: r(n) -> <v1>
|
||||
0 <v2>: Int NEW: r(0) -> <v2>
|
||||
n < 0 <v3>: Boolean NEW: call(n < 0, compareTo|<v1>, <v2>) -> <v3>
|
||||
0 <v4>: Int NEW: r(0) -> <v4>
|
||||
return 0 !<v11>: *
|
||||
if (n < 0) return 0 <v12>: * NEW: merge(if (n < 0) return 0|!<v11>) -> <v12>
|
||||
n <v13>: Int NEW: r(n) -> <v13>
|
||||
{ return it } <v14>: {<: (Int) -> ???} NEW: r({ return it }) -> <v14>
|
||||
let { return it } <v15>: * NEW: call(let { return it }, let|<v13>, <v14>) -> <v15>
|
||||
n.let { return it } <v15>: * COPY
|
||||
{ if (n < 0) return 0 n.let { return it } } <v15>: * COPY
|
||||
return 0 !<v14>: *
|
||||
if (n < 0) return 0 <v15>: * NEW: merge(if (n < 0) return 0|!<v14>) -> <v15>
|
||||
n <v16>: Int NEW: r(n) -> <v16>
|
||||
{ return it } <v17>: {<: (Int) -> ???} NEW: r({ return it }) -> <v17>
|
||||
let { return it } <v18>: * NEW: call(let { return it }, let|<v16>, <v17>) -> <v18>
|
||||
n.let { return it } <v18>: * COPY
|
||||
{ if (n < 0) return 0 n.let { return it } } <v18>: * COPY
|
||||
1 <v5>: Int NEW: r(1) -> <v5>
|
||||
2 <v6>: Int NEW: r(2) -> <v6>
|
||||
1..2 <v7>: {<: Iterable<Int>} NEW: call(1..2, rangeTo|<v5>, <v6>) -> <v7>
|
||||
bar() <v9>: Int NEW: call(bar(), bar) -> <v9>
|
||||
return bar() !<v10>: *
|
||||
{ for (i in 1..2) { } return bar() } !<v10>: * COPY
|
||||
try { if (n < 0) return 0 n.let { return it } } finally { for (i in 1..2) { } return bar() } <v16>: * NEW: merge(try { if (n < 0) return 0 n.let { return it } } finally { for (i in 1..2) { } return bar() }|<v15>) -> <v16>
|
||||
{ try { if (n < 0) return 0 n.let { return it } } finally { for (i in 1..2) { } return bar() } } <v16>: * COPY
|
||||
1..2 <v10>: {<: Iterable<Int>} NEW: call(1..2, next) -> <v10>
|
||||
bar() <v12>: Int NEW: call(bar(), bar) -> <v12>
|
||||
return bar() !<v13>: *
|
||||
{ for (i in 1..2) { } return bar() } !<v13>: * COPY
|
||||
try { if (n < 0) return 0 n.let { return it } } finally { for (i in 1..2) { } return bar() } <v19>: * NEW: merge(try { if (n < 0) return 0 n.let { return it } } finally { for (i in 1..2) { } return bar() }|<v18>) -> <v19>
|
||||
{ try { if (n < 0) return 0 n.let { return it } } finally { for (i in 1..2) { } return bar() } } <v19>: * COPY
|
||||
=====================
|
||||
== anonymous_0 ==
|
||||
{ return it }
|
||||
---------------------
|
||||
<v8>: Int NEW: magic[LOOP_RANGE_ITERATION](1..2|<v7>) -> <v8>
|
||||
it <v0>: Int NEW: r(it) -> <v0>
|
||||
<v11>: Int NEW: magic[LOOP_RANGE_ITERATION](1..2|<v10>) -> <v11>
|
||||
it <v0>: Int NEW: r(it) -> <v0>
|
||||
return it !<v1>: *
|
||||
return it !<v1>: * COPY
|
||||
return it !<v1>: * COPY
|
||||
=====================
|
||||
|
||||
Reference in New Issue
Block a user