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

Pseudocode: don't write full label name when jump on it

Browse Source
This commit is contained in:
Svetlana Isakova
2014-09-03 16:00:41 +04:00
parent 3a9b7bbade
commit 976d5ab030
89 changed files with 482 additions and 480 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/cfg/controlStructures/Finally.instructions
+129 -129
View File
@@ -11,18 +11,18 @@ L0:
1 <START>
2 mark({ try { 1 } finally { 2 } })
mark(try { 1 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 })]
jmp?(L2) NEXT:[mark({ 2 }), mark({ 1 })]
3 mark({ 1 })
r(1) -> <v0>
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
2 jmp(L3) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v1>
L5 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L3)]
r(2) -> <v1>
2 merge(try { 1 } finally { 2 }|<v0>) -> <v2>
L1:
@@ -48,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) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return } })]
3 mark({ 1 if (2 > 3) { return } })
r(1) -> <v0>
mark(if (2 > 3) { return })
@@ -56,25 +56,25 @@ L0:
r(3) -> <v2>
mark(2 > 3)
call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
jf(L3 [else branch]|<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 ['if' expression result]) NEXT:[merge(if (2 > 3) { return }|!<v5>) -> <v6>] PREV:[]
- 3 jmp(L6) NEXT:[merge(if (2 > 3) { return }|!<v5>) -> <v6>] PREV:[]
L3 [else branch]:
read (Unit) PREV:[jf(L3 [else branch]|<v3>)]
read (Unit) PREV:[jf(L3|<v3>)]
L6 ['if' expression result]:
merge(if (2 > 3) { return }|!<v5>) -> <v6>
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
2 jmp(L7) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
5 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
5 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v4>
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
5 mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
5 mark({ 2 }) PREV:[jmp(L7)]
r(2) -> <v4>
2 merge(try { 1 if (2 > 3) { return } } finally { 2 }|<v6>) -> <v7>
L1:
@@ -102,24 +102,24 @@ 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) 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 [after local declaration]) NEXT:[r({ () -> if (2 > 3) { return@l } }) -> <v1>, d({ () -> 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>]
L3 [after local declaration]:
r({ () -> if (2 > 3) { return@l } }) -> <v1> PREV:[jmp?(L3 [after local declaration])]
2 jmp(L8 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
r({ () -> if (2 > 3) { return@l } }) -> <v1> PREV:[jmp?(L3)]
2 jmp(L8) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L9 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v2>
L10 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L8 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L8)]
r(2) -> <v2>
2 merge(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }|<v1>) -> <v3>
L1:
@@ -144,12 +144,12 @@ L4:
r(3) -> <v1>
mark(2 > 3)
call(2 > 3, compareTo|<v0>, <v1>) -> <v2>
jf(L6 [else branch]|<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 ['if' expression result]) NEXT:[merge(if (2 > 3) { return@l }|!<v3>) -> <v4>] PREV:[]
- 5 jmp(L7) NEXT:[merge(if (2 > 3) { return@l }|!<v3>) -> <v4>] PREV:[]
L6 [else branch]:
read (Unit) PREV:[jf(L6 [else branch]|<v2>)]
read (Unit) PREV:[jf(L6|<v2>)]
L7 ['if' expression result]:
merge(if (2 > 3) { return@l }|!<v3>) -> <v4>
L5:
@@ -178,10 +178,10 @@ L0:
2 mark({ @l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } })
mark(@l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })
mark({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })
jmp?(L2 [after local declaration]) NEXT:[r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0>, d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })]
jmp?(L2) NEXT:[r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0>, d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })]
d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) NEXT:[<SINK>]
L2 [after local declaration]:
r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0> PREV:[jmp?(L2 [after local declaration])]
r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0> PREV:[jmp?(L2)]
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -205,7 +205,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) 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 })
@@ -213,25 +213,25 @@ L3:
r(3) -> <v2>
mark(2 > 3)
call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
jf(L6 [else branch]|<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 ['if' expression result]) NEXT:[merge(if (2 > 3) { return@l }|!<v5>) -> <v6>] PREV:[]
- 5 jmp(L9) NEXT:[merge(if (2 > 3) { return@l }|!<v5>) -> <v6>] PREV:[]
L6 [else branch]:
read (Unit) PREV:[jf(L6 [else branch]|<v3>)]
read (Unit) PREV:[jf(L6|<v3>)]
L9 ['if' expression result]:
merge(if (2 > 3) { return@l }|!<v5>) -> <v6>
4 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
4 jmp(L10) NEXT:[mark({ 2 })]
L5 [onExceptionToFinallyBlock]:
7 mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
7 mark({ 2 }) PREV:[jmp?(L5)]
r(2) -> <v4>
4 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
7 mark({ 2 }) PREV:[jmp(L10)]
r(2) -> <v4>
4 merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|<v6>) -> <v7>
L4:
@@ -261,13 +261,13 @@ L0:
mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } })
L2 [loop entry point]:
L6 [condition entry point]:
r(true) -> <v0> PREV:[mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2 [loop entry point])]
r(true) -> <v0> PREV:[mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2)]
mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } })
magic[VALUE_CONSUMER](true|<v0>) -> <v1>
L4 [body entry point]:
3 mark({ try { 1 if (2 > 3) { break @l } } finally { 2 } })
mark(try { 1 if (2 > 3) { break @l } } finally { 2 })
jmp?(L7 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { break @l } })]
jmp?(L7) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { break @l } })]
4 mark({ 1 if (2 > 3) { break @l } })
r(1) -> <v2>
mark(if (2 > 3) { break @l })
@@ -275,31 +275,31 @@ L4 [body entry point]:
r(3) -> <v4>
mark(2 > 3)
call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
jf(L8 [else branch]|<v5>) NEXT:[read (Unit), mark({ break @l })]
jf(L8|<v5>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l })
L9 [start finally]:
6 mark({ 2 })
r(2) -> <v6>
L10 [finish finally]:
5 jmp(L3 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L11 ['if' expression result]) NEXT:[merge(if (2 > 3) { break @l }|!<v7>) -> <v8>] PREV:[]
5 jmp(L3) NEXT:[read (Unit)]
- 4 jmp(L11) NEXT:[merge(if (2 > 3) { break @l }|!<v7>) -> <v8>] PREV:[]
L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v5>)]
read (Unit) PREV:[jf(L8|<v5>)]
L11 ['if' expression result]:
merge(if (2 > 3) { break @l }|!<v7>) -> <v8>
3 jmp(L12 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
3 jmp(L12) NEXT:[mark({ 2 })]
L7 [onExceptionToFinallyBlock]:
6 mark({ 2 }) PREV:[jmp?(L7 [onExceptionToFinallyBlock])]
6 mark({ 2 }) PREV:[jmp?(L7)]
r(2) -> <v6>
3 jmp(error) NEXT:[<ERROR>]
L12 [skipFinallyToErrorBlock]:
6 mark({ 2 }) PREV:[jmp(L12 [skipFinallyToErrorBlock])]
6 mark({ 2 }) PREV:[jmp(L12)]
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>]
2 jmp(L2) NEXT:[r(true) -> <v0>]
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) PREV:[jmp(L3 [loop exit point])]
read (Unit) PREV:[jmp(L3)]
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -326,12 +326,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) 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]:
L7 [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)]
mark(while(true) { 1 if (2 > 3) { break @l } })
magic[VALUE_CONSUMER](true|<v0>) -> <v1>
L5 [body entry point]:
@@ -342,28 +342,28 @@ L5 [body entry point]:
r(3) -> <v4>
mark(2 > 3)
call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
jf(L8 [else branch]|<v5>) NEXT:[read (Unit), mark({ break @l })]
jf(L8|<v5>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l })
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[]
jmp(L4) NEXT:[read (Unit)]
- 4 jmp(L9) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[]
L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v5>)]
read (Unit) PREV:[jf(L8|<v5>)]
L9 ['if' expression result]:
merge(if (2 > 3) { break @l }|!<v6>) -> <v7>
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>]
3 jmp(L3) NEXT:[r(true) -> <v0>]
L4 [loop exit point]:
L6 [body exit point]:
read (Unit) PREV:[jmp(L4 [loop exit point])]
read (Unit) PREV:[jmp(L4)]
r(5) -> <v9>
2 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
2 jmp(L10) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L11 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v10>
L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L10)]
r(2) -> <v10>
2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }|<v9>) -> <v11>
L1:
@@ -391,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) 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]:
L7 [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)]
mark(while(true) { 1 if (2 > 3) { break @l } })
magic[VALUE_CONSUMER](true|<v0>) -> <v1>
L5 [body entry point]:
@@ -407,27 +407,27 @@ L5 [body entry point]:
r(3) -> <v4>
mark(2 > 3)
call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
jf(L8 [else branch]|<v5>) NEXT:[read (Unit), mark({ break @l })]
jf(L8|<v5>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l })
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[]
jmp(L4) NEXT:[read (Unit)]
- 4 jmp(L9) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[]
L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v5>)]
read (Unit) PREV:[jf(L8|<v5>)]
L9 ['if' expression result]:
merge(if (2 > 3) { break @l }|!<v6>) -> <v7>
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>]
3 jmp(L3) NEXT:[r(true) -> <v0>]
L4 [loop exit point]:
L6 [body exit point]:
read (Unit) PREV:[jmp(L4 [loop exit point])]
2 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
read (Unit) PREV:[jmp(L4)]
2 jmp(L10) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L11 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v9>
L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L10)]
r(2) -> <v9>
2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 }|!<v8>) -> <v10>
L1:
@@ -465,14 +465,14 @@ L0:
v(i)
L2 [loop entry point]:
L6 [condition entry point]:
jmp?(L3 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L6 [condition entry point]), jmp(L2 [loop 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(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 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue @l } })]
jmp?(L7) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue @l } })]
5 mark({ 1 if (2 > 3) { continue @l } })
r(1) -> <v5>
mark(if (2 > 3) { continue @l })
@@ -480,31 +480,31 @@ L4 [body entry point]:
r(3) -> <v7>
mark(2 > 3)
call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L8 [else branch]|<v8>) NEXT:[read (Unit), mark({ continue @l })]
jf(L8|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l })
L9 [start finally]:
7 mark({ 2 })
r(2) -> <v9>
L10 [finish finally]:
6 jmp(L6 [condition entry point]) NEXT:[jmp?(L3 [loop exit point])]
- 5 jmp(L11 ['if' expression result]) NEXT:[merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>] PREV:[]
6 jmp(L6) NEXT:[jmp?(L3)]
- 5 jmp(L11) NEXT:[merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>] PREV:[]
L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v8>)]
read (Unit) PREV:[jf(L8|<v8>)]
L11 ['if' expression result]:
merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>
4 jmp(L12 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
4 jmp(L12) NEXT:[mark({ 2 })]
L7 [onExceptionToFinallyBlock]:
7 mark({ 2 }) PREV:[jmp?(L7 [onExceptionToFinallyBlock])]
7 mark({ 2 }) PREV:[jmp?(L7)]
r(2) -> <v9>
4 jmp(error) NEXT:[<ERROR>]
L12 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(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 [loop entry point]) NEXT:[jmp?(L3 [loop exit point])]
3 jmp(L2) NEXT:[jmp?(L3)]
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) PREV:[jmp?(L3 [loop exit point])]
read (Unit) PREV:[jmp?(L3)]
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -534,7 +534,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) 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>
@@ -544,7 +544,7 @@ L0:
v(i)
L3 [loop entry point]:
L7 [condition entry point]:
jmp?(L4 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L7 [condition entry point]), jmp(L3 [loop 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(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
@@ -556,28 +556,28 @@ L5 [body entry point]:
r(3) -> <v7>
mark(2 > 3)
call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L8 [else branch]|<v8>) NEXT:[read (Unit), mark({ continue @l })]
jf(L8|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l })
jmp(L7 [condition entry point]) NEXT:[jmp?(L4 [loop exit point])]
- 5 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[]
jmp(L7) NEXT:[jmp?(L4)]
- 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[]
L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v8>)]
read (Unit) PREV:[jf(L8|<v8>)]
L9 ['if' expression result]:
merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>
4 jmp(L3 [loop entry point]) NEXT:[jmp?(L4 [loop exit point])]
4 jmp(L3) NEXT:[jmp?(L4)]
L4 [loop exit point]:
L6 [body exit point]:
read (Unit) PREV:[jmp?(L4 [loop exit point])]
read (Unit) PREV:[jmp?(L4)]
3 r(5) -> <v12>
2 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
2 jmp(L10) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L11 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v13>
L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
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>
L1:
@@ -608,7 +608,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) 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>
@@ -618,7 +618,7 @@ L0:
v(i)
L3 [loop entry point]:
L7 [condition entry point]:
jmp?(L4 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L7 [condition entry point]), jmp(L3 [loop 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(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
@@ -630,27 +630,27 @@ L5 [body entry point]:
r(3) -> <v7>
mark(2 > 3)
call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L8 [else branch]|<v8>) NEXT:[read (Unit), mark({ continue @l })]
jf(L8|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l })
jmp(L7 [condition entry point]) NEXT:[jmp?(L4 [loop exit point])]
- 5 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[]
jmp(L7) NEXT:[jmp?(L4)]
- 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[]
L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v8>)]
read (Unit) PREV:[jf(L8|<v8>)]
L9 ['if' expression result]:
merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>
4 jmp(L3 [loop entry point]) NEXT:[jmp?(L4 [loop exit point])]
4 jmp(L3) NEXT:[jmp?(L4)]
L4 [loop exit point]:
L6 [body exit point]:
read (Unit) PREV:[jmp?(L4 [loop exit point])]
2 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
read (Unit) PREV:[jmp?(L4)]
2 jmp(L10) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L11 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v12>
L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
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>
L1:
@@ -674,7 +674,7 @@ 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) NEXT:[mark({ return 2 }), mark({ return 1 })]
3 mark({ return 1 })
r(1) -> <v0>
L3 [start finally]:
@@ -683,9 +683,9 @@ L3 [start finally]:
ret(*|<v1>) L1 NEXT:[<END>]
L4 [finish finally]:
- 3 ret(*|<v0>) L1 NEXT:[<END>] PREV:[]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ return 2 })] PREV:[]
- 2 jmp(L5) NEXT:[mark({ return 2 })] PREV:[]
L2 [onExceptionToFinallyBlock]:
4 mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
4 mark({ return 2 }) PREV:[jmp?(L2)]
r(2) -> <v1>
ret(*|<v1>) L1 NEXT:[<END>]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
@@ -715,7 +715,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) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 })
r(1) -> <v0>
L3 [start finally]:
@@ -725,9 +725,9 @@ L3 [start finally]:
call(doSmth(3), doSmth|<v1>) -> <v2>
L4 [finish finally]:
3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
- 2 jmp(L5) NEXT:[mark({ doSmth(3) })] PREV:[]
L2 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
4 mark({ doSmth(3) }) PREV:[jmp?(L2)]
r(3) -> <v1>
mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2>
@@ -762,8 +762,8 @@ L0:
1 <START>
2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } })
mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)]
jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 })
r(1) -> <v0>
L4 [start finally]:
@@ -773,26 +773,26 @@ L4 [start finally]:
call(doSmth(3), doSmth|<v1>) -> <v2>
L5 [finish finally]:
3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
- 2 jmp(L6) NEXT:[jmp(L7)] PREV:[]
L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v4>
w(e|<v4>)
4 mark({ doSmth(2) })
r(2) -> <v5>
mark(doSmth(2))
call(doSmth(2), doSmth|<v5>) -> <v6>
3 jmp(L6 [afterCatches])
3 jmp(L6)
L6 [afterCatches]:
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })]
2 jmp(L7) NEXT:[mark({ doSmth(3) })]
L3 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
4 mark({ doSmth(3) }) PREV:[jmp?(L3)]
r(3) -> <v1>
mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2>
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
4 mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
4 mark({ doSmth(3) }) PREV:[jmp(L7)]
r(3) -> <v1>
mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2>
@@ -818,20 +818,20 @@ L0:
1 <START>
2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } })
mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), mark({ return 1 })]
jmp?(L2) NEXT:[v(e: UnsupportedOperationException), mark({ return 1 })]
3 mark({ return 1 })
r(1) -> <v0>
ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L3 [afterCatches]) NEXT:[merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!<v1>, <v4>) -> <v5>] PREV:[]
- 2 jmp(L3) NEXT:[merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!<v1>, <v4>) -> <v5>] PREV:[]
L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v2>
w(e|<v2>)
4 mark({ doSmth(2) })
r(2) -> <v3>
mark(doSmth(2))
call(doSmth(2), doSmth|<v3>) -> <v4>
3 jmp(L3 [afterCatches])
3 jmp(L3)
L3 [afterCatches]:
2 merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!<v1>, <v4>) -> <v5>
L1:
@@ -858,8 +858,8 @@ L0:
1 <START>
2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } })
mark(try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)]
jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 })
r(1) -> <v0>
L4 [start finally]:
@@ -869,9 +869,9 @@ L4 [start finally]:
call(doSmth(3), doSmth|<v1>) -> <v2>
L5 [finish finally]:
3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
- 2 jmp(L6) NEXT:[jmp(L7)] PREV:[]
L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v4>
w(e|<v4>)
4 mark({ return 2 })
@@ -881,11 +881,11 @@ L2 [onException]:
mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2>
ret(*|<v5>) L1 NEXT:[<END>]
- 3 jmp(L6 [afterCatches]) PREV:[]
- 3 jmp(L6) PREV:[]
L6 [afterCatches]:
- 2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
- 2 jmp(L7) NEXT:[mark({ doSmth(3) })] PREV:[]
L3 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
4 mark({ doSmth(3) }) PREV:[jmp?(L3)]
r(3) -> <v1>
mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2>
@@ -920,15 +920,15 @@ L0:
1 <START>
2 mark({ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } })
mark(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ doSmth(1) })]
jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)]
jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ doSmth(1) })]
3 mark({ doSmth(1) })
r(1) -> <v0>
mark(doSmth(1))
call(doSmth(1), doSmth|<v0>) -> <v1>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])]
2 jmp(L4) NEXT:[jmp(L7)]
L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v2>
w(e|<v2>)
4 mark({ return 2 })
@@ -940,17 +940,17 @@ L5 [start finally]:
call(doSmth(3), doSmth|<v4>) -> <v5>
L6 [finish finally]:
4 ret(*|<v3>) L1 NEXT:[<END>]
- 3 jmp(L4 [afterCatches]) PREV:[]
- 3 jmp(L4) PREV:[]
L4 [afterCatches]:
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4 [afterCatches])]
2 jmp(L7) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4)]
L3 [onExceptionToFinallyBlock]:
5 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
5 mark({ doSmth(3) }) PREV:[jmp?(L3)]
r(3) -> <v4>
mark(doSmth(3))
call(doSmth(3), doSmth|<v4>) -> <v5>
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
5 mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
5 mark({ doSmth(3) }) PREV:[jmp(L7)]
r(3) -> <v4>
mark(doSmth(3))
call(doSmth(3), doSmth|<v4>) -> <v5>
@@ -979,4 +979,4 @@ error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
=====================
compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
+61 -61
View File
@@ -74,40 +74,40 @@ L0:
1 <START>
2 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 } })
mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 })
jmp?(L2 [onException]) NEXT:[jmp?(L5 [catch 0]), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ return 1 }), mark({ doSmth() })]
jmp?(L2) NEXT:[jmp?(L5), jmp?(L3)]
jmp?(L3) NEXT:[mark({ return 1 }), mark({ doSmth() })]
3 mark({ doSmth() })
mark(doSmth())
call(doSmth(), doSmth) -> <v0>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
2 jmp(L4) NEXT:[jmp(L6)]
L2 [onException]:
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])]
jmp?(L5) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2)]
3 v(e: NullPointerException)
magic[FAKE_INITIALIZER](e: NullPointerException) -> <v1>
w(e|<v1>)
4 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1(), doSmth1) -> <v2>
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
3 jmp(L4) NEXT:[jmp(L6)]
L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])]
v(e: Exception) PREV:[jmp?(L5)]
magic[FAKE_INITIALIZER](e: Exception) -> <v3>
w(e|<v3>)
4 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2(), doSmth2) -> <v4>
3 jmp(L4 [afterCatches])
3 jmp(L4)
L4 [afterCatches]:
2 jmp(L6 [skipFinallyToErrorBlock]) NEXT:[mark({ return 1 })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])]
2 jmp(L6) NEXT:[mark({ return 1 })] PREV:[jmp(L4), jmp(L4), jmp(L4)]
L3 [onExceptionToFinallyBlock]:
L7 [start finally]:
3 mark({ return 1 }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
3 mark({ return 1 }) PREV:[jmp?(L3)]
r(1) -> <v5>
ret(*|<v5>) L1 NEXT:[<END>]
L8 [finish finally]:
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L6 [skipFinallyToErrorBlock]:
3 mark({ return 1 }) PREV:[jmp(L6 [skipFinallyToErrorBlock])]
3 mark({ return 1 }) PREV:[jmp(L6)]
r(1) -> <v5>
ret(*|<v5>) L1 NEXT:[<END>]
- 2 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 }|<v0>, <v2>, <v4>) -> <v7> PREV:[]
@@ -142,68 +142,68 @@ L0:
2 mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } })
L2 [loop entry point]:
L6 [condition entry point]:
mark(cond()) PREV:[mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } }), jmp(L6 [condition entry point]), jmp(L6 [condition entry point])]
mark(cond()) PREV:[mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } }), jmp(L6), jmp(L6)]
call(cond(), cond) -> <v0>
mark(while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
jf(L3 [loop exit point]|<v0>) NEXT:[read (Unit), mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })]
jf(L3|<v0>) NEXT:[read (Unit), mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })]
L4 [body entry point]:
3 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue })
jmp?(L7 [onException]) NEXT:[jmp?(L10 [catch 0]), jmp?(L8 [onExceptionToFinallyBlock])]
jmp?(L8 [onExceptionToFinallyBlock]) NEXT:[mark({ if (cond()) return else continue }), mark({ doSmth() })]
jmp?(L7) NEXT:[jmp?(L10), jmp?(L8)]
jmp?(L8) NEXT:[mark({ if (cond()) return else continue }), mark({ doSmth() })]
4 mark({ doSmth() })
mark(doSmth())
call(doSmth(), doSmth) -> <v1>
3 jmp(L9 [afterCatches]) NEXT:[jmp(L11 [skipFinallyToErrorBlock])]
3 jmp(L9) NEXT:[jmp(L11)]
L7 [onException]:
jmp?(L10 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L7 [onException])]
jmp?(L10) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L7)]
4 v(e: NullPointerException)
magic[FAKE_INITIALIZER](e: NullPointerException) -> <v2>
w(e|<v2>)
5 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1(), doSmth1) -> <v3>
4 jmp(L9 [afterCatches]) NEXT:[jmp(L11 [skipFinallyToErrorBlock])]
4 jmp(L9) NEXT:[jmp(L11)]
L10 [catch 0]:
v(e: Exception) PREV:[jmp?(L10 [catch 0])]
v(e: Exception) PREV:[jmp?(L10)]
magic[FAKE_INITIALIZER](e: Exception) -> <v4>
w(e|<v4>)
5 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2(), doSmth2) -> <v5>
4 jmp(L9 [afterCatches])
4 jmp(L9)
L9 [afterCatches]:
3 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ if (cond()) return else continue })] PREV:[jmp(L9 [afterCatches]), jmp(L9 [afterCatches]), jmp(L9 [afterCatches])]
3 jmp(L11) NEXT:[mark({ if (cond()) return else continue })] PREV:[jmp(L9), jmp(L9), jmp(L9)]
L8 [onExceptionToFinallyBlock]:
L12 [start finally]:
4 mark({ if (cond()) return else continue }) PREV:[jmp?(L8 [onExceptionToFinallyBlock])]
4 mark({ if (cond()) return else continue }) PREV:[jmp?(L8)]
mark(if (cond()) return else continue)
mark(cond())
call(cond(), cond) -> <v6>
jf(L13 [else branch]|<v6>) NEXT:[jmp(L6 [condition entry point]), ret L1]
jf(L13|<v6>) NEXT:[jmp(L6), ret L1]
ret L1 NEXT:[<END>]
- jmp(L14 ['if' expression result]) NEXT:[merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9>] PREV:[]
- jmp(L14) NEXT:[merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9>] PREV:[]
L13 [else branch]:
jmp(L6 [condition entry point]) NEXT:[mark(cond())] PREV:[jf(L13 [else branch]|<v6>)]
jmp(L6) NEXT:[mark(cond())] PREV:[jf(L13|<v6>)]
L14 ['if' expression result]:
- merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9> PREV:[]
L15 [finish finally]:
- 3 jmp(error) NEXT:[<ERROR>] PREV:[]
L11 [skipFinallyToErrorBlock]:
4 mark({ if (cond()) return else continue }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
4 mark({ if (cond()) return else continue }) PREV:[jmp(L11)]
mark(if (cond()) return else continue)
mark(cond())
call(cond(), cond) -> <v6>
jf(copy L13 [else branch]|<v6>) NEXT:[jmp(L6 [condition entry point]), ret L1]
jf(L17|<v6>) NEXT:[jmp(L6), ret L1]
ret L1 NEXT:[<END>]
- jmp(copy L14 ['if' expression result]) NEXT:[merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9>] PREV:[]
jmp(L6 [condition entry point]) NEXT:[mark(cond())] PREV:[jf(copy L13 [else branch]|<v6>)]
- jmp(L18) NEXT:[merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9>] PREV:[]
jmp(L6) NEXT:[mark(cond())] PREV:[jf(L17|<v6>)]
- merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9> PREV:[]
- 3 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }|<v1>, <v3>, <v5>) -> <v10> PREV:[]
- 2 jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[]
- 2 jmp(L2) NEXT:[mark(cond())] PREV:[]
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) PREV:[jf(L3 [loop exit point]|<v0>)]
read (Unit) PREV:[jf(L3|<v0>)]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
error:
@@ -231,55 +231,55 @@ L0:
1 <START>
2 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); } })
mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); })
jmp?(L2 [onException]) NEXT:[jmp?(L5 [catch 0]), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ while (cond()); }), mark({ doSmth() })]
jmp?(L2) NEXT:[jmp?(L5), jmp?(L3)]
jmp?(L3) NEXT:[mark({ while (cond()); }), mark({ doSmth() })]
3 mark({ doSmth() })
mark(doSmth())
call(doSmth(), doSmth) -> <v0>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
2 jmp(L4) NEXT:[jmp(L6)]
L2 [onException]:
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])]
jmp?(L5) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2)]
3 v(e: NullPointerException)
magic[FAKE_INITIALIZER](e: NullPointerException) -> <v1>
w(e|<v1>)
4 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1(), doSmth1) -> <v2>
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
3 jmp(L4) NEXT:[jmp(L6)]
L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])]
v(e: Exception) PREV:[jmp?(L5)]
magic[FAKE_INITIALIZER](e: Exception) -> <v3>
w(e|<v3>)
4 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2(), doSmth2) -> <v4>
3 jmp(L4 [afterCatches])
3 jmp(L4)
L4 [afterCatches]:
2 jmp(L6 [skipFinallyToErrorBlock]) NEXT:[mark({ while (cond()); })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])]
2 jmp(L6) NEXT:[mark({ while (cond()); })] PREV:[jmp(L4), jmp(L4), jmp(L4)]
L3 [onExceptionToFinallyBlock]:
L7 [start finally]:
3 mark({ while (cond()); }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
3 mark({ while (cond()); }) PREV:[jmp?(L3)]
L8 [loop entry point]:
L12 [condition entry point]:
mark(cond()) PREV:[mark({ while (cond()); }), jmp(L8 [loop entry point])]
mark(cond()) PREV:[mark({ while (cond()); }), jmp(L8)]
call(cond(), cond) -> <v5>
mark(while (cond()))
jf(L9 [loop exit point]|<v5>) NEXT:[read (Unit), jmp(L8 [loop entry point])]
jf(L9|<v5>) NEXT:[read (Unit), jmp(L8)]
L10 [body entry point]:
jmp(L8 [loop entry point]) NEXT:[mark(cond())]
jmp(L8) NEXT:[mark(cond())]
L9 [loop exit point]:
L11 [body exit point]:
read (Unit) PREV:[jf(L9 [loop exit point]|<v5>)]
read (Unit) PREV:[jf(L9|<v5>)]
L13 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L6 [skipFinallyToErrorBlock]:
3 mark({ while (cond()); }) PREV:[jmp(L6 [skipFinallyToErrorBlock])]
mark(cond()) PREV:[mark({ while (cond()); }), jmp(copy L8 [loop entry point])]
3 mark({ while (cond()); }) PREV:[jmp(L6)]
mark(cond()) PREV:[mark({ while (cond()); }), jmp(L15)]
call(cond(), cond) -> <v5>
mark(while (cond()))
jf(copy L9 [loop exit point]|<v5>) NEXT:[read (Unit), jmp(copy L8 [loop entry point])]
jmp(copy L8 [loop entry point]) NEXT:[mark(cond())]
read (Unit) PREV:[jf(copy L9 [loop exit point]|<v5>)]
jf(L16|<v5>) NEXT:[read (Unit), jmp(L15)]
jmp(L15) NEXT:[mark(cond())]
read (Unit) PREV:[jf(L16|<v5>)]
2 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); }|<v0>, <v2>, <v4>) -> <v7>
L1:
1 <END> NEXT:[<SINK>]
@@ -306,42 +306,42 @@ 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) 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) 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)]
mark(if(list != null) { })
r(list) -> <v2>
r(null) -> <v3>
mark(list != null)
call(list != null, equals|<v2>, <v3>) -> <v4>
jf(L5 [else branch]|<v4>) NEXT:[read (Unit), mark({ })]
jf(L5|<v4>) NEXT:[read (Unit), mark({ })]
4 mark({ })
read (Unit)
3 jmp(L6 ['if' expression result]) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>]
3 jmp(L6) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>]
L5 [else branch]:
read (Unit) PREV:[jf(L5 [else branch]|<v4>)]
read (Unit) PREV:[jf(L5|<v4>)]
L6 ['if' expression result]:
merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(L6 ['if' expression result]), read (Unit)]
merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(L6), read (Unit)]
L7 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]:
3 mark({ if(list != null) { } }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
3 mark({ if(list != null) { } }) PREV:[jmp(L3)]
mark(if(list != null) { })
r(list) -> <v2>
r(null) -> <v3>
mark(list != null)
call(list != null, equals|<v2>, <v3>) -> <v4>
jf(copy L5 [else branch]|<v4>) NEXT:[read (Unit), mark({ })]
jf(L9|<v4>) NEXT:[read (Unit), mark({ })]
4 mark({ })
read (Unit)
3 jmp(copy L6 ['if' expression result]) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>]
read (Unit) PREV:[jf(copy L5 [else branch]|<v4>)]
merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(copy L6 ['if' expression result]), read (Unit)]
3 jmp(L10) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>]
read (Unit) PREV:[jf(L9|<v4>)]
merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(L10), read (Unit)]
2 merge(try { doSmth() } finally { if(list != null) { } }|<v1>) -> <v7>
L1:
1 <END> NEXT:[<SINK>]
@@ -349,4 +349,4 @@ error:
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
=====================
compiler/testData/cfg/controlStructures/For.instructions
+4 -4
View File
@@ -15,7 +15,7 @@ L0:
v(i)
L2 [loop entry point]:
L6 [condition entry point]:
jmp?(L3 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>] PREV:[v(i), jmp(L2 [loop 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(for (i in 1..2) { doSmth(i) })
@@ -24,10 +24,10 @@ L4 [body entry point]:
r(i) -> <v4>
mark(doSmth(i))
call(doSmth(i), doSmth|<v4>) -> <v5>
3 jmp(L2 [loop entry point]) NEXT:[jmp?(L3 [loop exit point])]
3 jmp(L2) NEXT:[jmp?(L3)]
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) PREV:[jmp?(L3 [loop exit point])]
read (Unit) PREV:[jmp?(L3)]
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -51,4 +51,4 @@ error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
=====================
compiler/testData/cfg/controlStructures/If.instructions
+14 -14
View File
@@ -25,35 +25,35 @@ L0:
v(var u: String)
mark(if (b) { u = "s" })
r(b) -> <v1>
jf(L2 [else branch]|<v1>) NEXT:[read (Unit), mark({ u = "s" })]
jf(L2|<v1>) NEXT:[read (Unit), mark({ u = "s" })]
3 mark({ u = "s" })
mark("s")
r("s") -> <v2>
w(u|<v2>)
2 jmp(L3 ['if' expression result]) NEXT:[merge(if (b) { u = "s" }|!<v3>) -> <v4>]
2 jmp(L3) NEXT:[merge(if (b) { u = "s" }|!<v3>) -> <v4>]
L2 [else branch]:
read (Unit) PREV:[jf(L2 [else branch]|<v1>)]
read (Unit) PREV:[jf(L2|<v1>)]
L3 ['if' expression result]:
merge(if (b) { u = "s" }|!<v3>) -> <v4> PREV:[jmp(L3 ['if' expression result]), read (Unit)]
merge(if (b) { u = "s" }|!<v3>) -> <v4> PREV:[jmp(L3), read (Unit)]
r(u) -> <v5>
mark(doSmth(u))
call(doSmth(u), doSmth|<v5>) -> <v6>
v(var r: String)
mark(if (b) { r = "s" } else { r = "t" })
r(b) -> <v7>
jf(L4 [else branch]|<v7>) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
jf(L4|<v7>) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
3 mark({ r = "s" })
mark("s")
r("s") -> <v8>
w(r|<v8>)
2 jmp(L5 ['if' expression result]) NEXT:[merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>]
2 jmp(L5) NEXT:[merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>]
L4 [else branch]:
3 mark({ r = "t" }) PREV:[jf(L4 [else branch]|<v7>)]
3 mark({ r = "t" }) PREV:[jf(L4|<v7>)]
mark("t")
r("t") -> <v10>
w(r|<v10>)
L5 ['if' expression result]:
2 merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12> PREV:[jmp(L5 ['if' expression result]), w(r|<v10>)]
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|<v13>) -> <v14>
@@ -87,12 +87,12 @@ L0:
w(i|<v1>)
mark(if (b) { return; })
r(b) -> <v2>
jf(L2 [else branch]|<v2>) NEXT:[read (Unit), mark({ return; })]
jf(L2|<v2>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; })
ret L1 NEXT:[<END>]
- 2 jmp(L3 ['if' expression result]) NEXT:[merge(if (b) { return; }|!<v3>) -> <v4>] PREV:[]
- 2 jmp(L3) NEXT:[merge(if (b) { return; }|!<v3>) -> <v4>] PREV:[]
L2 [else branch]:
read (Unit) PREV:[jf(L2 [else branch]|<v2>)]
read (Unit) PREV:[jf(L2|<v2>)]
L3 ['if' expression result]:
merge(if (b) { return; }|!<v3>) -> <v4>
r(i) -> <v5>
@@ -102,12 +102,12 @@ L3 ['if' expression result]:
mark(i is Int)
r(i) -> <v7>
magic[IS](i is Int|<v7>) -> <v8>
jf(L4 [else branch]|<v8>) NEXT:[read (Unit), mark({ return; })]
jf(L4|<v8>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; })
ret L1 NEXT:[<END>]
- 2 jmp(L5 ['if' expression result]) NEXT:[merge(if (i is Int) { return; }|!<v9>) -> <v10>] PREV:[]
- 2 jmp(L5) NEXT:[merge(if (i is Int) { return; }|!<v9>) -> <v10>] PREV:[]
L4 [else branch]:
read (Unit) PREV:[jf(L4 [else branch]|<v8>)]
read (Unit) PREV:[jf(L4|<v8>)]
L5 ['if' expression result]:
merge(if (i is Int) { return; }|!<v9>) -> <v10>
L1:
compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.instructions
+6 -6
View File
@@ -10,19 +10,19 @@ L0:
2 mark({ while(0 > 1) { 2 } })
L2 [loop entry point]:
L6 [condition entry point]:
r(0) -> <v0> PREV:[mark({ while(0 > 1) { 2 } }), jmp(L2 [loop entry point])]
r(0) -> <v0> PREV:[mark({ while(0 > 1) { 2 } }), jmp(L2)]
r(1) -> <v1>
mark(0 > 1)
call(0 > 1, compareTo|<v0>, <v1>) -> <v2>
mark(while(0 > 1) { 2 })
jf(L3 [loop exit point]|<v2>) NEXT:[read (Unit), mark({ 2 })]
jf(L3|<v2>) NEXT:[read (Unit), mark({ 2 })]
L4 [body entry point]:
3 mark({ 2 })
r(2) -> <v3>
2 jmp(L2 [loop entry point]) NEXT:[r(0) -> <v0>]
2 jmp(L2) NEXT:[r(0) -> <v0>]
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) PREV:[jf(L3 [loop exit point]|<v2>)]
read (Unit) PREV:[jf(L3|<v2>)]
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -50,7 +50,7 @@ L6 [condition entry point]:
- r(1) -> <v2> PREV:[]
- mark(0 > 1) PREV:[]
- call(0 > 1, compareTo|<v1>, <v2>) -> <v3> PREV:[]
- jt(L2 [loop entry point]|<v3>) NEXT:[read (Unit), mark({return})] PREV:[]
- jt(L2|<v3>) NEXT:[read (Unit), mark({return})] PREV:[]
L3 [loop exit point]:
- read (Unit) PREV:[]
L1:
@@ -59,4 +59,4 @@ error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
=====================
compiler/testData/cfg/controlStructures/continueInDoWhile.instructions
+9 -9
View File
@@ -15,27 +15,27 @@ L0:
3 mark(do { if (b) break; continue; } while (true))
L2 [loop entry point]:
L4 [body entry point]:
mark({ if (b) break; continue; }) PREV:[mark(do { if (b) break; continue; } while (true)), jt(L2 [loop entry point]|<v5>)]
mark({ if (b) break; continue; }) PREV:[mark(do { if (b) break; continue; } while (true)), jt(L2|<v5>)]
mark(if (b) break)
r(b) -> <v1>
jf(L7 [else branch]|<v1>) NEXT:[read (Unit), jmp(L3 [loop exit point])]
jmp(L3 [loop exit point]) NEXT:[read (Unit)]
- jmp(L8 ['if' expression result]) NEXT:[merge(if (b) break|!<v2>) -> <v3>] PREV:[]
jf(L7|<v1>) NEXT:[read (Unit), jmp(L3)]
jmp(L3) NEXT:[read (Unit)]
- jmp(L8) NEXT:[merge(if (b) break|!<v2>) -> <v3>] PREV:[]
L7 [else branch]:
read (Unit) PREV:[jf(L7 [else branch]|<v1>)]
read (Unit) PREV:[jf(L7|<v1>)]
L8 ['if' expression result]:
merge(if (b) break|!<v2>) -> <v3>
jmp(L6 [condition entry point])
jmp(L6)
L5 [body exit point]:
L6 [condition entry point]:
r(true) -> <v5>
jt(L2 [loop entry point]|<v5>) NEXT:[read (Unit), mark({ if (b) break; continue; })]
jt(L2|<v5>) NEXT:[read (Unit), mark({ if (b) break; continue; })]
L3 [loop exit point]:
read (Unit) PREV:[jmp(L3 [loop exit point]), jt(L2 [loop entry point]|<v5>)]
read (Unit) PREV:[jmp(L3), jt(L2|<v5>)]
L1:
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
=====================
compiler/testData/cfg/controlStructures/continueInFor.instructions
+9 -9
View File
@@ -19,7 +19,7 @@ L0:
v(i)
L2 [loop entry point]:
L6 [condition entry point]:
jmp?(L3 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>] PREV:[v(i), jmp(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(for (i in 1..10) { if (b) break; continue; })
@@ -27,22 +27,22 @@ L4 [body entry point]:
4 mark({ if (b) break; continue; })
mark(if (b) break)
r(b) -> <v5>
jf(L7 [else branch]|<v5>) NEXT:[read (Unit), jmp(L3 [loop exit point])]
jmp(L3 [loop exit point]) NEXT:[read (Unit)]
- jmp(L8 ['if' expression result]) NEXT:[merge(if (b) break|!<v6>) -> <v7>] PREV:[]
jf(L7|<v5>) NEXT:[read (Unit), jmp(L3)]
jmp(L3) NEXT:[read (Unit)]
- jmp(L8) NEXT:[merge(if (b) break|!<v6>) -> <v7>] PREV:[]
L7 [else branch]:
read (Unit) PREV:[jf(L7 [else branch]|<v5>)]
read (Unit) PREV:[jf(L7|<v5>)]
L8 ['if' expression result]:
merge(if (b) break|!<v6>) -> <v7>
jmp(L6 [condition entry point]) NEXT:[jmp?(L3 [loop exit point])]
- 3 jmp(L2 [loop entry point]) NEXT:[jmp?(L3 [loop exit point])] PREV:[]
jmp(L6) NEXT:[jmp?(L3)]
- 3 jmp(L2) NEXT:[jmp?(L3)] PREV:[]
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) PREV:[jmp?(L3 [loop exit point]), jmp(L3 [loop exit point])]
read (Unit) PREV:[jmp?(L3), jmp(L3)]
L1:
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
=====================
compiler/testData/cfg/controlStructures/continueInWhile.instructions
+9 -9
View File
@@ -14,29 +14,29 @@ L0:
2 mark({ while (true) { if (b) break; continue; } })
L2 [loop entry point]:
L6 [condition entry point]:
r(true) -> <v1> PREV:[mark({ while (true) { if (b) break; continue; } }), jmp(L6 [condition entry point])]
r(true) -> <v1> PREV:[mark({ while (true) { if (b) break; continue; } }), jmp(L6)]
mark(while (true) { if (b) break; continue; })
magic[VALUE_CONSUMER](true|<v1>) -> <v2>
L4 [body entry point]:
3 mark({ if (b) break; continue; })
mark(if (b) break)
r(b) -> <v3>
jf(L7 [else branch]|<v3>) NEXT:[read (Unit), jmp(L3 [loop exit point])]
jmp(L3 [loop exit point]) NEXT:[read (Unit)]
- jmp(L8 ['if' expression result]) NEXT:[merge(if (b) break|!<v4>) -> <v5>] PREV:[]
jf(L7|<v3>) NEXT:[read (Unit), jmp(L3)]
jmp(L3) NEXT:[read (Unit)]
- jmp(L8) NEXT:[merge(if (b) break|!<v4>) -> <v5>] PREV:[]
L7 [else branch]:
read (Unit) PREV:[jf(L7 [else branch]|<v3>)]
read (Unit) PREV:[jf(L7|<v3>)]
L8 ['if' expression result]:
merge(if (b) break|!<v4>) -> <v5>
jmp(L6 [condition entry point]) NEXT:[r(true) -> <v1>]
- 2 jmp(L2 [loop entry point]) NEXT:[r(true) -> <v1>] PREV:[]
jmp(L6) NEXT:[r(true) -> <v1>]
- 2 jmp(L2) NEXT:[r(true) -> <v1>] PREV:[]
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) PREV:[jmp(L3 [loop exit point])]
read (Unit) PREV:[jmp(L3)]
L1:
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
=====================
compiler/testData/cfg/controlStructures/returnsInWhen.instructions
+3 -3
View File
@@ -16,14 +16,14 @@ L0:
mark(is Int -> return a)
mark(is Int)
magic[IS](is Int|<v1>) -> <v2>
jmp?(L4 [next 'when' entry]|<v2>) NEXT:[merge(when(a) { is Int -> return a }|!<v4>) -> <v5>, r(a) -> <v3>]
jmp?(L4|<v2>) NEXT:[merge(when(a) { is Int -> return a }|!<v4>) -> <v5>, r(a) -> <v3>]
L3 ['when' entry body]:
r(a) -> <v3>
ret(*|<v3>) L1 NEXT:[<END>]
- jmp(L2 [after 'when' expression]) PREV:[]
- jmp(L2) PREV:[]
L2 [after 'when' expression]:
L4 [next 'when' entry]:
merge(when(a) { is Int -> return a }|!<v4>) -> <v5> PREV:[jmp?(L4 [next 'when' entry]|<v2>)]
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:
compiler/testData/cfg/controlStructures/whenConditions.instructions
+17 -17
View File
@@ -23,62 +23,62 @@ L0:
mark(1)
r(1) -> <v2>
magic[EQUALS_IN_WHEN_CONDITION](1|<v1>, <v2>) -> <v3>
jmp?(L4 [next 'when' entry]|<v3>) NEXT:[mark(in Collections.singleton(2) -> "2"), mark("1")]
jmp?(L4|<v3>) NEXT:[mark(in Collections.singleton(2) -> "2"), mark("1")]
L3 ['when' entry body]:
mark("1")
r("1") -> <v4>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L4 [next 'when' entry]:
mark(in Collections.singleton(2) -> "2") PREV:[jmp?(L4 [next 'when' entry]|<v3>)]
mark(in Collections.singleton(2) -> "2") PREV:[jmp?(L4|<v3>)]
mark(Collections.singleton(2))
r(2) -> <v5>
mark(singleton(2))
call(singleton(2), singleton|<v5>) -> <v6>
mark(in Collections.singleton(2))
call(in Collections.singleton(2), contains|<v6>, <v1>) -> <v7>
jmp?(L6 [next 'when' entry]|<v7>) NEXT:[mark(is Int -> "Int"), mark("2")]
jmp?(L6|<v7>) NEXT:[mark(is Int -> "Int"), mark("2")]
L5 ['when' entry body]:
mark("2")
r("2") -> <v8>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L6 [next 'when' entry]:
mark(is Int -> "Int") PREV:[jmp?(L6 [next 'when' entry]|<v7>)]
mark(is Int -> "Int") PREV:[jmp?(L6|<v7>)]
mark(is Int)
magic[IS](is Int|<v1>) -> <v9>
jmp?(L8 [next 'when' entry]|<v9>) NEXT:[mark(!in Collections.singleton(3) -> "!3"), mark("Int")]
jmp?(L8|<v9>) NEXT:[mark(!in Collections.singleton(3) -> "!3"), mark("Int")]
L7 ['when' entry body]:
mark("Int")
r("Int") -> <v10>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L8 [next 'when' entry]:
mark(!in Collections.singleton(3) -> "!3") PREV:[jmp?(L8 [next 'when' entry]|<v9>)]
mark(!in Collections.singleton(3) -> "!3") PREV:[jmp?(L8|<v9>)]
mark(Collections.singleton(3))
r(3) -> <v11>
mark(singleton(3))
call(singleton(3), singleton|<v11>) -> <v12>
mark(!in Collections.singleton(3))
call(!in Collections.singleton(3), contains|<v12>, <v1>) -> <v13>
jmp?(L10 [next 'when' entry]|<v13>) NEXT:[mark(!is Number -> "!Number"), mark("!3")]
jmp?(L10|<v13>) NEXT:[mark(!is Number -> "!Number"), mark("!3")]
L9 ['when' entry body]:
mark("!3")
r("!3") -> <v14>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L10 [next 'when' entry]:
mark(!is Number -> "!Number") PREV:[jmp?(L10 [next 'when' entry]|<v13>)]
mark(!is Number -> "!Number") PREV:[jmp?(L10|<v13>)]
mark(!is Number)
magic[IS](!is Number|<v1>) -> <v15>
jmp?(L12 [next 'when' entry]|<v15>) NEXT:[mark(else -> null), mark("!Number")]
jmp?(L12|<v15>) NEXT:[mark(else -> null), mark("!Number")]
L11 ['when' entry body]:
mark("!Number")
r("!Number") -> <v16>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L12 [next 'when' entry]:
mark(else -> null) PREV:[jmp?(L12 [next 'when' entry]|<v15>)]
mark(else -> null) PREV:[jmp?(L12|<v15>)]
L13 ['when' entry body]:
r(null) -> <v17>
jmp(L2 [after 'when' expression])
jmp(L2)
L2 [after 'when' expression]:
merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18> PREV:[jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression])]
merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18> PREV:[jmp(L2), jmp(L2), jmp(L2), jmp(L2), jmp(L2), jmp(L2)]
w(t|<v18>)
L1:
1 <END> NEXT:[<SINK>]