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

Pseudocode: Introduce pseudo-value analysis

Browse Source
This commit is contained in:
Alexey Sedunov
2014-05-12 17:42:44 +04:00
parent 3ce96671d9
commit d2c055e9da
103 changed files with 2417 additions and 1432 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/cfg/controlStructures/Finally.instructions
+199 -188
View File
@@ -13,17 +13,17 @@ L0:
mark(try { 1 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 })]
3 mark({ 1 })
r(1)
r(1) -> <v0>
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v1>
L5 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
r(2)
r(2) -> <v1>
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -49,33 +49,33 @@ L0:
mark(try { 1 if (2 > 3) { return } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return } })]
3 mark({ 1 if (2 > 3) { return } })
r(1)
r(1) -> <v0>
mark(if (2 > 3) { return })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L3) NEXT:[read (Unit), mark({ return })]
r(2) -> <v1>
r(3) -> <v2>
call(>, compareTo|<v1>, <v2>) -> <v3>
jf(L3|<v3>) NEXT:[read (Unit), mark({ return })]
4 mark({ return })
L4 [start finally]:
5 mark({ 2 })
r(2)
r(2) -> <v4>
L5 [finish finally]:
4 ret L1 NEXT:[<END>]
- 3 jmp(L6) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
L3:
read (Unit) PREV:[jf(L3)]
read (Unit) PREV:[jf(L3|<v3>)]
L6:
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
5 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v4>
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
5 mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
r(2)
r(2) -> <v4>
L1:
1 <END> NEXT:[<SINK>] PREV:[ret L1, r(2)]
1 <END> NEXT:[<SINK>] PREV:[ret L1, r(2) -> <v4>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -101,23 +101,23 @@ L0:
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 } } })]
3 mark({ 1 @l{ () -> if (2 > 3) { return@l } } })
r(1)
r(1) -> <v0>
mark(@l{ () -> if (2 > 3) { return@l } })
mark({ () -> if (2 > 3) { return@l } })
jmp?(L3) NEXT:[r({ () -> if (2 > 3) { return@l } }), 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:
r({ () -> if (2 > 3) { return@l } }) PREV:[jmp?(L3)]
r({ () -> if (2 > 3) { return@l } }) -> <v1> PREV:[jmp?(L3)]
2 jmp(L8 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L9 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v2>
L10 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L8 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])]
r(2)
r(2) -> <v2>
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -137,22 +137,22 @@ L4:
5 mark(if (2 > 3) { return@l })
mark(if (2 > 3) { return@l })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L6) NEXT:[read (Unit), mark({ return@l })]
r(2) -> <v0>
r(3) -> <v1>
call(>, compareTo|<v0>, <v1>) -> <v2>
jf(L6|<v2>) NEXT:[read (Unit), mark({ return@l })]
6 mark({ return@l })
ret L5 NEXT:[<END>]
- 5 jmp(L7) NEXT:[<END>] PREV:[]
ret L5 NEXT:[<END>]
- 5 jmp(L7) NEXT:[<END>] PREV:[]
L6:
read (Unit) PREV:[jf(L6)]
read (Unit) PREV:[jf(L6|<v2>)]
L5:
L7:
4 <END> NEXT:[<SINK>] PREV:[ret L5, read (Unit)]
4 <END> NEXT:[<SINK>] PREV:[ret L5, read (Unit)]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== t4 ==
fun t4() {
@@ -173,10 +173,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) NEXT:[r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }), 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:
r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) PREV:[jmp?(L2)]
r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0> PREV:[jmp?(L2)]
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -202,33 +202,33 @@ L3:
mark(try { 1 if (2 > 3) { return@l } } finally { 2 })
jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@l } })]
5 mark({ 1 if (2 > 3) { return@l } })
r(1)
r(1) -> <v0>
mark(if (2 > 3) { return@l })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L6) NEXT:[read (Unit), mark({ return@l })]
r(2) -> <v1>
r(3) -> <v2>
call(>, compareTo|<v1>, <v2>) -> <v3>
jf(L6|<v3>) NEXT:[read (Unit), mark({ return@l })]
6 mark({ return@l })
L7 [start finally]:
7 mark({ 2 })
r(2)
r(2) -> <v4>
L8 [finish finally]:
6 ret L4 NEXT:[<END>]
- 5 jmp(L9) NEXT:[jmp(L10 [skipFinallyToErrorBlock])] PREV:[]
L6:
read (Unit) PREV:[jf(L6)]
read (Unit) PREV:[jf(L6|<v3>)]
L9:
4 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L5 [onExceptionToFinallyBlock]:
7 mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v4>
4 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
r(2)
r(2) -> <v4>
L4:
3 <END> NEXT:[<SINK>] PREV:[ret L4, r(2)]
3 <END> NEXT:[<SINK>] PREV:[ret L4, r(2) -> <v4>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -255,38 +255,38 @@ L0:
mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } })
L2 [loop entry point]:
L5 [condition entry point]:
r(true) PREV:[mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2 [loop entry point])]
r(true) -> <v0> PREV:[mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2 [loop entry point])]
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?(L6 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { break @l } })]
4 mark({ 1 if (2 > 3) { break @l } })
r(1)
r(1) -> <v1>
mark(if (2 > 3) { break @l })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @l })]
r(2) -> <v2>
r(3) -> <v3>
call(>, compareTo|<v2>, <v3>) -> <v4>
jf(L7|<v4>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l })
L8 [start finally]:
6 mark({ 2 })
r(2)
r(2) -> <v5>
L9 [finish finally]:
5 jmp(L3 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
read (Unit) PREV:[jf(L7|<v4>)]
L10:
3 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L6 [onExceptionToFinallyBlock]:
6 mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v5>
3 jmp(error) NEXT:[<ERROR>]
L11 [skipFinallyToErrorBlock]:
6 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
r(2)
2 jmp(L2 [loop entry point]) NEXT:[r(true)]
r(2) -> <v5>
2 jmp(L2 [loop entry point]) NEXT:[r(true) -> <v0>]
L3 [loop exit point]:
read (Unit) PREV:[jmp(L3 [loop exit point])]
L1:
@@ -321,36 +321,36 @@ L0:
mark(while(true) { 1 if (2 > 3) { break @l } })
L3 [loop entry point]:
L6 [condition entry point]:
r(true) PREV:[mark(while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
r(true) -> <v0> PREV:[mark(while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
L5 [body entry point]:
4 mark({ 1 if (2 > 3) { break @l } })
r(1)
r(1) -> <v1>
mark(if (2 > 3) { break @l })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @l })]
r(2) -> <v2>
r(3) -> <v3>
call(>, compareTo|<v2>, <v3>) -> <v4>
jf(L7|<v4>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l })
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
read (Unit) PREV:[jf(L7|<v4>)]
L8:
3 jmp(L3 [loop entry point]) NEXT:[r(true)]
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>]
L4 [loop exit point]:
read (Unit) PREV:[jmp(L4 [loop exit point])]
r(5)
r(5) -> <v5>
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v6>
L11 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
r(2) -> <v6>
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -382,35 +382,35 @@ L0:
mark(while(true) { 1 if (2 > 3) { break @l } })
L3 [loop entry point]:
L6 [condition entry point]:
r(true) PREV:[mark(while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
r(true) -> <v0> PREV:[mark(while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
L5 [body entry point]:
4 mark({ 1 if (2 > 3) { break @l } })
r(1)
r(1) -> <v1>
mark(if (2 > 3) { break @l })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @l })]
r(2) -> <v2>
r(3) -> <v3>
call(>, compareTo|<v2>, <v3>) -> <v4>
jf(L7|<v4>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l })
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
read (Unit) PREV:[jf(L7|<v4>)]
L8:
3 jmp(L3 [loop entry point]) NEXT:[r(true)]
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>]
L4 [loop exit point]:
read (Unit) PREV:[jmp(L4 [loop exit point])]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v5>
L11 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
r(2) -> <v5>
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -435,50 +435,52 @@ fun t8(a : Int) {
L0:
1 <START>
v(a : Int)
w(a)
magic(a : Int) -> <v0>
w(a|<v0>)
2 mark({ @l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } })
mark(@l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } })
3 mark(for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } })
mark(1..a)
r(1)
r(a)
call(.., rangeTo)
r(1) -> <v1>
r(a) -> <v2>
call(.., rangeTo|<v1>, <v2>) -> <v3>
v(i)
L3:
jmp?(L2) NEXT:[read (Unit), w(i)]
jmp?(L2) NEXT:[read (Unit), magic(1..a|<v3>) -> <v4>]
L4 [loop entry point]:
L5 [body entry point]:
w(i) PREV:[jmp?(L2), jmp(L4 [loop entry point]), jmp?(L4 [loop entry point])]
magic(1..a|<v3>) -> <v4> PREV:[jmp?(L2), jmp(L4 [loop entry point]), jmp?(L4 [loop entry point])]
w(i|<v4>)
4 mark({ try { 1 if (2 > 3) { continue @l } } finally { 2 } })
mark(try { 1 if (2 > 3) { continue @l } } finally { 2 })
jmp?(L6 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue @l } })]
5 mark({ 1 if (2 > 3) { continue @l } })
r(1)
r(1) -> <v5>
mark(if (2 > 3) { continue @l })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @l })]
r(2) -> <v6>
r(3) -> <v7>
call(>, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l })
L8 [start finally]:
7 mark({ 2 })
r(2)
r(2) -> <v9>
L9 [finish finally]:
6 jmp(L4 [loop entry point]) NEXT:[w(i)]
6 jmp(L4 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>]
- 5 jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
read (Unit) PREV:[jf(L7|<v8>)]
L10:
4 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L6 [onExceptionToFinallyBlock]:
7 mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v9>
4 jmp(error) NEXT:[<ERROR>]
L11 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
r(2)
3 jmp?(L4 [loop entry point]) NEXT:[w(i), read (Unit)]
r(2) -> <v9>
3 jmp?(L4 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>, read (Unit)]
L2:
read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
L1:
@@ -506,7 +508,8 @@ fun t9(a : Int) {
L0:
1 <START>
v(a : Int)
w(a)
magic(a : Int) -> <v0>
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 })]
@@ -514,43 +517,44 @@ L0:
mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } })
4 mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
mark(1..a)
r(1)
r(a)
call(.., rangeTo)
r(1) -> <v1>
r(a) -> <v2>
call(.., rangeTo|<v1>, <v2>) -> <v3>
v(i)
L4:
jmp?(L3) NEXT:[read (Unit), w(i)]
jmp?(L3) NEXT:[read (Unit), magic(1..a|<v3>) -> <v4>]
L5 [loop entry point]:
L6 [body entry point]:
w(i) PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
magic(1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
w(i|<v4>)
5 mark({ 1 if (2 > 3) { continue @l } })
r(1)
r(1) -> <v5>
mark(if (2 > 3) { continue @l })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @l })]
r(2) -> <v6>
r(3) -> <v7>
call(>, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l })
jmp(L5 [loop entry point]) NEXT:[w(i)]
jmp(L5 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>]
- 5 jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
read (Unit) PREV:[jf(L7|<v8>)]
L8:
4 jmp?(L5 [loop entry point]) NEXT:[w(i), read (Unit)]
4 jmp?(L5 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>, read (Unit)]
L3:
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
3 r(5)
3 r(5) -> <v9>
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v10>
L11 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
r(2) -> <v10>
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -575,7 +579,8 @@ fun t10(a : Int) {
L0:
1 <START>
v(a : Int)
w(a)
magic(a : Int) -> <v0>
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 } } })]
@@ -583,42 +588,43 @@ L0:
mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } })
4 mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
mark(1..a)
r(1)
r(a)
call(.., rangeTo)
r(1) -> <v1>
r(a) -> <v2>
call(.., rangeTo|<v1>, <v2>) -> <v3>
v(i)
L4:
jmp?(L3) NEXT:[read (Unit), w(i)]
jmp?(L3) NEXT:[read (Unit), magic(1..a|<v3>) -> <v4>]
L5 [loop entry point]:
L6 [body entry point]:
w(i) PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
magic(1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
w(i|<v4>)
5 mark({ 1 if (2 > 3) { continue @l } })
r(1)
r(1) -> <v5>
mark(if (2 > 3) { continue @l })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @l })]
r(2) -> <v6>
r(3) -> <v7>
call(>, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l })
jmp(L5 [loop entry point]) NEXT:[w(i)]
jmp(L5 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>]
- 5 jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
read (Unit) PREV:[jf(L7|<v8>)]
L8:
4 jmp?(L5 [loop entry point]) NEXT:[w(i), read (Unit)]
4 jmp?(L5 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>, read (Unit)]
L3:
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
r(2) -> <v9>
L11 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
r(2) -> <v9>
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -642,25 +648,25 @@ L0:
mark(try { return 1 } finally { return 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return 2 }), mark({ return 1 })]
3 mark({ return 1 })
r(1)
r(1) -> <v0>
L3 [start finally]:
4 mark({ return 2 })
r(2)
ret(*) L1 NEXT:[<END>]
r(2) -> <v1>
ret(*|<v1>) L1 NEXT:[<END>]
L4 [finish finally]:
- 3 ret(*) L1 NEXT:[<END>] PREV:[]
- 3 ret(*|<v0>) L1 NEXT:[<END>] PREV:[]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ return 2 })] PREV:[]
L2 [onExceptionToFinallyBlock]:
4 mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
ret(*) L1 NEXT:[<END>]
r(2) -> <v1>
ret(*|<v1>) L1 NEXT:[<END>]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L5 [skipFinallyToErrorBlock]:
- 4 mark({ return 2 }) PREV:[]
- r(2) PREV:[]
- ret(*) L1 PREV:[]
- r(2) -> <v1> PREV:[]
- ret(*|<v1>) L1 PREV:[]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v1>) L1, ret(*|<v1>) L1]
error:
<ERROR> PREV:[]
sink:
@@ -682,28 +688,28 @@ L0:
mark(try { return 1 } finally { doSmth(3) })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 })
r(1)
r(1) -> <v0>
L3 [start finally]:
4 mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v1>
call(doSmth, doSmth|<v1>) -> <v2>
L4 [finish finally]:
3 ret(*) L1 NEXT:[<END>]
3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
L2 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v1>
call(doSmth, doSmth|<v1>) -> <v2>
2 jmp(error) NEXT:[<ERROR>]
L5 [skipFinallyToErrorBlock]:
- 4 mark({ doSmth(3) }) PREV:[]
- mark(doSmth(3)) PREV:[]
- r(3) PREV:[]
- call(doSmth, doSmth) PREV:[]
- r(3) -> <v1> PREV:[]
- call(doSmth, doSmth|<v1>) -> <v2> PREV:[]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v0>) L1]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -729,38 +735,39 @@ L0:
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 })
r(1)
r(1) -> <v0>
L4 [start finally]:
4 mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v1>
call(doSmth, doSmth|<v1>) -> <v2>
L5 [finish finally]:
3 ret(*) L1 NEXT:[<END>]
3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
magic(e: UnsupportedOperationException) -> <v3>
w(e|<v3>)
4 mark({ doSmth(2) })
mark(doSmth(2))
r(2)
call(doSmth, doSmth)
r(2) -> <v4>
call(doSmth, doSmth|<v4>) -> <v5>
3 jmp(L6 [afterCatches])
L6 [afterCatches]:
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })]
L3 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v1>
call(doSmth, doSmth|<v1>) -> <v2>
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
4 mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v1>
call(doSmth, doSmth|<v1>) -> <v2>
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, call(doSmth, doSmth)]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v0>) L1, call(doSmth, doSmth|<v1>) -> <v2>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -782,20 +789,21 @@ L0:
mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), mark({ return 1 })]
3 mark({ return 1 })
r(1)
ret(*) L1 NEXT:[<END>]
r(1) -> <v0>
ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L3 [afterCatches]) NEXT:[<END>] PREV:[]
L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
magic(e: UnsupportedOperationException) -> <v1>
w(e|<v1>)
4 mark({ doSmth(2) })
mark(doSmth(2))
r(2)
call(doSmth, doSmth)
r(2) -> <v2>
call(doSmth, doSmth|<v2>) -> <v3>
3 jmp(L3 [afterCatches])
L1:
L3 [afterCatches]:
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, jmp(L3 [afterCatches])]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v0>) L1, jmp(L3 [afterCatches])]
error:
<ERROR> PREV:[]
sink:
@@ -821,41 +829,42 @@ L0:
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 })
r(1)
r(1) -> <v0>
L4 [start finally]:
4 mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v1>
call(doSmth, doSmth|<v1>) -> <v2>
L5 [finish finally]:
3 ret(*) L1 NEXT:[<END>]
3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
magic(e: UnsupportedOperationException) -> <v3>
w(e|<v3>)
4 mark({ return 2 })
r(2)
r(2) -> <v4>
mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
ret(*) L1 NEXT:[<END>]
r(3) -> <v1>
call(doSmth, doSmth|<v1>) -> <v2>
ret(*|<v4>) L1 NEXT:[<END>]
- 3 jmp(L6 [afterCatches]) PREV:[]
L6 [afterCatches]:
- 2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
L3 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v1>
call(doSmth, doSmth|<v1>) -> <v2>
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
- 4 mark({ doSmth(3) }) PREV:[]
- mark(doSmth(3)) PREV:[]
- r(3) PREV:[]
- call(doSmth, doSmth) PREV:[]
- r(3) -> <v1> PREV:[]
- call(doSmth, doSmth|<v1>) -> <v2> PREV:[]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v0>) L1, ret(*|<v4>) L1]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -882,37 +891,38 @@ L0:
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ doSmth(1) })]
3 mark({ doSmth(1) })
mark(doSmth(1))
r(1)
call(doSmth, doSmth)
r(1) -> <v0>
call(doSmth, doSmth|<v0>) -> <v1>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])]
L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
magic(e: UnsupportedOperationException) -> <v2>
w(e|<v2>)
4 mark({ return 2 })
r(2)
r(2) -> <v3>
L5 [start finally]:
5 mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v4>
call(doSmth, doSmth|<v4>) -> <v5>
L6 [finish finally]:
4 ret(*) L1 NEXT:[<END>]
4 ret(*|<v3>) L1 NEXT:[<END>]
- 3 jmp(L4 [afterCatches]) PREV:[]
L4 [afterCatches]:
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4 [afterCatches])]
L3 [onExceptionToFinallyBlock]:
5 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v4>
call(doSmth, doSmth|<v4>) -> <v5>
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
5 mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
r(3) -> <v4>
call(doSmth, doSmth|<v4>) -> <v5>
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, call(doSmth, doSmth)]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v3>) L1, call(doSmth, doSmth|<v4>) -> <v5>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -925,13 +935,14 @@ fun doSmth(i: Int) {
L0:
1 <START>
v(i: Int)
w(i)
magic(i: Int) -> <v0>
w(i|<v0>)
2 mark({ })
read (Unit)
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
+105 -95
View File
@@ -74,46 +74,49 @@ 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 [onException]) NEXT:[jmp?(L5 [catch 0]), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ return 1 }), mark({ doSmth() })]
3 mark({ doSmth() })
mark(doSmth())
call(doSmth, doSmth)
2 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
call(doSmth, doSmth) -> <v0>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
L2 [onException]:
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])]
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])]
3 v(e: NullPointerException)
w(e)
magic(e: NullPointerException) -> <v1>
w(e|<v1>)
4 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1, doSmth1)
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
call(doSmth1, doSmth1) -> <v2>
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])]
w(e)
v(e: Exception) PREV:[jmp?(L5 [catch 0])]
magic(e: Exception) -> <v3>
w(e|<v3>)
4 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2, doSmth2)
call(doSmth2, doSmth2) -> <v4>
3 jmp(L4 [afterCatches])
L4 [afterCatches]:
2 jmp(L6 [skipFinallyToErrorBlock]) NEXT:[mark({ return 1 })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])]
2 jmp(L6 [skipFinallyToErrorBlock]) NEXT:[mark({ return 1 })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])]
L3 [onExceptionToFinallyBlock]:
L7 [start finally]:
3 mark({ return 1 }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
r(1)
ret(*) L1 NEXT:[<END>]
3 mark({ return 1 }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
r(1) -> <v5>
ret(*|<v5>) L1 NEXT:[<END>]
L8 [finish finally]:
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L6 [skipFinallyToErrorBlock]:
3 mark({ return 1 }) PREV:[jmp(L6 [skipFinallyToErrorBlock])]
r(1)
ret(*) L1
3 mark({ return 1 }) PREV:[jmp(L6 [skipFinallyToErrorBlock])]
r(1) -> <v5>
ret(*|<v5>) L1 NEXT:[<END>]
- 2 magic(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 }|<v0>, <v2>, <v4>) -> <v6> PREV:[]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v5>) L1, ret(*|<v5>) L1]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== testCopy2 ==
fun testCopy2() {
@@ -140,67 +143,70 @@ L0:
mark(while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
L2 [loop entry point]:
L5 [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(L2 [loop entry point]), jmp(L2 [loop entry point])]
call(cond, cond)
jf(L3 [loop exit point]) NEXT:[read (Unit), mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })]
mark(cond()) PREV:[mark(while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } }), jmp(L2 [loop entry point]), jmp(L2 [loop entry point])]
call(cond, cond) -> <v0>
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 } })]
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?(L6 [onException]) NEXT:[jmp?(L9 [catch 0]), jmp?(L7 [onExceptionToFinallyBlock])]
jmp?(L7 [onExceptionToFinallyBlock]) NEXT:[mark({ if (cond()) return else continue }), mark({ doSmth() })]
jmp?(L6 [onException]) NEXT:[jmp?(L9 [catch 0]), jmp?(L7 [onExceptionToFinallyBlock])]
jmp?(L7 [onExceptionToFinallyBlock]) NEXT:[mark({ if (cond()) return else continue }), mark({ doSmth() })]
4 mark({ doSmth() })
mark(doSmth())
call(doSmth, doSmth)
3 jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])]
call(doSmth, doSmth) -> <v1>
3 jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])]
L6 [onException]:
jmp?(L9 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L6 [onException])]
jmp?(L9 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L6 [onException])]
4 v(e: NullPointerException)
w(e)
magic(e: NullPointerException) -> <v2>
w(e|<v2>)
5 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1, doSmth1)
4 jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])]
call(doSmth1, doSmth1) -> <v3>
4 jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])]
L9 [catch 0]:
v(e: Exception) PREV:[jmp?(L9 [catch 0])]
w(e)
v(e: Exception) PREV:[jmp?(L9 [catch 0])]
magic(e: Exception) -> <v4>
w(e|<v4>)
5 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2, doSmth2)
call(doSmth2, doSmth2) -> <v5>
4 jmp(L8 [afterCatches])
L8 [afterCatches]:
3 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ if (cond()) return else continue })] PREV:[jmp(L8 [afterCatches]), jmp(L8 [afterCatches]), jmp(L8 [afterCatches])]
3 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ if (cond()) return else continue })] PREV:[jmp(L8 [afterCatches]), jmp(L8 [afterCatches]), jmp(L8 [afterCatches])]
L7 [onExceptionToFinallyBlock]:
L11 [start finally]:
4 mark({ if (cond()) return else continue }) PREV:[jmp?(L7 [onExceptionToFinallyBlock])]
4 mark({ if (cond()) return else continue }) PREV:[jmp?(L7 [onExceptionToFinallyBlock])]
mark(if (cond()) return else continue)
mark(cond())
call(cond, cond)
jf(L12) NEXT:[jmp(L2 [loop entry point]), ret L1]
ret L1 NEXT:[<END>]
- jmp(L13) NEXT:[jmp(error)] PREV:[]
call(cond, cond) -> <v6>
jf(L12|<v6>) NEXT:[jmp(L2 [loop entry point]), ret L1]
ret L1 NEXT:[<END>]
- jmp(L13) NEXT:[jmp(error)] PREV:[]
L12:
jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[jf(L12)]
jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[jf(L12|<v6>)]
L13:
L14 [finish finally]:
- 3 jmp(error) NEXT:[<ERROR>] PREV:[]
- 3 jmp(error) NEXT:[<ERROR>] PREV:[]
L10 [skipFinallyToErrorBlock]:
4 mark({ if (cond()) return else continue }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
4 mark({ if (cond()) return else continue }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
mark(if (cond()) return else continue)
mark(cond())
call(cond, cond)
jf(copy L12) NEXT:[jmp(L2 [loop entry point]), ret L1]
ret L1 NEXT:[<END>]
- jmp(copy L13) NEXT:[jmp(L2 [loop entry point])] PREV:[]
jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[jf(copy L12)]
- 2 jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[]
call(cond, cond) -> <v6>
jf(copy L12|<v6>) NEXT:[jmp(L2 [loop entry point]), ret L1]
ret L1 NEXT:[<END>]
- jmp(copy L13) NEXT:[magic(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }|<v1>, <v3>, <v5>) -> <v7>] PREV:[]
jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[jf(copy L12|<v6>)]
- 3 magic(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }|<v1>, <v3>, <v5>) -> <v7> PREV:[]
- 2 jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[]
L3 [loop exit point]:
read (Unit) PREV:[jf(L3 [loop exit point])]
read (Unit) PREV:[jf(L3 [loop exit point]|<v0>)]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== testCopy3 ==
fun testCopy3() {
@@ -222,58 +228,61 @@ 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 [onException]) NEXT:[jmp?(L5 [catch 0]), jmp?(L3 [onExceptionToFinallyBlock])]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ while (cond()); }), mark({ doSmth() })]
3 mark({ doSmth() })
mark(doSmth())
call(doSmth, doSmth)
2 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
call(doSmth, doSmth) -> <v0>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
L2 [onException]:
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])]
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])]
3 v(e: NullPointerException)
w(e)
magic(e: NullPointerException) -> <v1>
w(e|<v1>)
4 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1, doSmth1)
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
call(doSmth1, doSmth1) -> <v2>
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])]
w(e)
v(e: Exception) PREV:[jmp?(L5 [catch 0])]
magic(e: Exception) -> <v3>
w(e|<v3>)
4 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2, doSmth2)
call(doSmth2, doSmth2) -> <v4>
3 jmp(L4 [afterCatches])
L4 [afterCatches]:
2 jmp(L6 [skipFinallyToErrorBlock]) NEXT:[mark({ while (cond()); })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])]
2 jmp(L6 [skipFinallyToErrorBlock]) NEXT:[mark({ while (cond()); })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])]
L3 [onExceptionToFinallyBlock]:
L7 [start finally]:
3 mark({ while (cond()); }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
3 mark({ while (cond()); }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(while (cond()))
L8 [loop entry point]:
L11 [condition entry point]:
mark(cond()) PREV:[mark(while (cond())), jmp(L8 [loop entry point])]
call(cond, cond)
jf(L9 [loop exit point]) NEXT:[read (Unit), jmp(L8 [loop entry point])]
mark(cond()) PREV:[mark(while (cond())), jmp(L8 [loop entry point])]
call(cond, cond) -> <v5>
jf(L9 [loop exit point]|<v5>) NEXT:[read (Unit), jmp(L8 [loop entry point])]
L10 [body entry point]:
jmp(L8 [loop entry point]) NEXT:[mark(cond())]
jmp(L8 [loop entry point]) NEXT:[mark(cond())]
L9 [loop exit point]:
read (Unit) PREV:[jf(L9 [loop exit point])]
read (Unit) PREV:[jf(L9 [loop exit point]|<v5>)]
L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L6 [skipFinallyToErrorBlock]:
3 mark({ while (cond()); }) PREV:[jmp(L6 [skipFinallyToErrorBlock])]
3 mark({ while (cond()); }) PREV:[jmp(L6 [skipFinallyToErrorBlock])]
mark(while (cond()))
mark(cond()) PREV:[mark(while (cond())), jmp(copy L8 [loop entry point])]
call(cond, cond)
jf(copy L9 [loop exit point]) 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])]
mark(cond()) PREV:[mark(while (cond())), jmp(copy L8 [loop entry point])]
call(cond, cond) -> <v5>
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>)]
2 magic(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); }|<v0>, <v2>, <v4>) -> <v6>
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== doTestCopy4 ==
fun doTestCopy4(list: List<String>?) : Int {
@@ -289,28 +298,29 @@ fun doTestCopy4(list: List<String>?) : Int {
L0:
1 <START>
v(list: List<String>?)
w(list)
magic(list: List<String>?) -> <v0>
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() })]
3 mark({ doSmth() })
mark(doSmth())
call(doSmth, doSmth)
call(doSmth, doSmth) -> <v1>
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ if(list != null) { } })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
3 mark({ if(list != null) { } }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
mark(if(list != null) { })
mark(list != null)
r(list)
r(null)
call(!=, equals)
jf(L5) NEXT:[read (Unit), mark({ })]
r(list) -> <v2>
r(null) -> <v3>
call(!=, equals|<v2>, <v3>) -> <v4>
jf(L5|<v4>) NEXT:[read (Unit), mark({ })]
4 mark({ })
read (Unit)
3 jmp(L6) NEXT:[jmp(error)]
L5:
read (Unit) PREV:[jf(L5)]
read (Unit) PREV:[jf(L5|<v4>)]
L6:
L7 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] PREV:[jmp(L6), read (Unit)]
@@ -318,14 +328,14 @@ L3 [skipFinallyToErrorBlock]:
3 mark({ if(list != null) { } }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
mark(if(list != null) { })
mark(list != null)
r(list)
r(null)
call(!=, equals)
jf(copy L5) NEXT:[read (Unit), mark({ })]
r(list) -> <v2>
r(null) -> <v3>
call(!=, equals|<v2>, <v3>) -> <v4>
jf(copy L5|<v4>) NEXT:[read (Unit), mark({ })]
4 mark({ })
read (Unit)
3 jmp(copy L6) NEXT:[<END>]
read (Unit) PREV:[jf(copy L5)]
read (Unit) PREV:[jf(copy L5|<v4>)]
L1:
1 <END> NEXT:[<SINK>] PREV:[jmp(copy L6), read (Unit)]
error:
compiler/testData/cfg/controlStructures/For.instructions
+14 -12
View File
@@ -10,20 +10,21 @@ L0:
2 mark({ for (i in 1..2) { doSmth(i) } })
3 mark(for (i in 1..2) { doSmth(i) })
mark(1..2)
r(1)
r(2)
call(.., rangeTo)
r(1) -> <v0>
r(2) -> <v1>
call(.., rangeTo|<v0>, <v1>) -> <v2>
v(i)
L3:
jmp?(L2) NEXT:[read (Unit), w(i)]
jmp?(L2) NEXT:[read (Unit), magic(1..2|<v2>) -> <v3>]
L4 [loop entry point]:
L5 [body entry point]:
w(i) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
magic(1..2|<v2>) -> <v3> PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
w(i|<v3>)
4 mark({ doSmth(i) })
mark(doSmth(i))
r(i)
call(doSmth, doSmth)
3 jmp?(L4 [loop entry point]) NEXT:[w(i), read (Unit)]
r(i) -> <v4>
call(doSmth, doSmth|<v4>) -> <v5>
3 jmp?(L4 [loop entry point]) NEXT:[magic(1..2|<v2>) -> <v3>, read (Unit)]
L2:
read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
L1:
@@ -39,13 +40,14 @@ fun doSmth(i: Int) {}
L0:
1 <START>
v(i: Int)
w(i)
magic(i: Int) -> <v0>
w(i|<v0>)
2 mark({})
read (Unit)
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/controlStructures/If.instructions
+37 -33
View File
@@ -19,41 +19,42 @@ fun t1(b: Boolean) {
L0:
1 <START>
v(b: Boolean)
w(b)
magic(b: Boolean) -> <v0>
w(b|<v0>)
2 mark({ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) })
v(var u: String)
mark(if (b) { u = "s" })
r(b)
jf(L2) NEXT:[read (Unit), mark({ u = "s" })]
r(b) -> <v1>
jf(L2|<v1>) NEXT:[read (Unit), mark({ u = "s" })]
3 mark({ u = "s" })
mark("s")
r("s")
w(u)
r("s") -> <v2>
w(u|<v2>)
2 jmp(L3) NEXT:[mark(doSmth(u))]
L2:
read (Unit) PREV:[jf(L2)]
read (Unit) PREV:[jf(L2|<v1>)]
L3:
mark(doSmth(u)) PREV:[jmp(L3), read (Unit)]
r(u)
call(doSmth, doSmth)
r(u) -> <v3>
call(doSmth, doSmth|<v3>) -> <v4>
v(var r: String)
mark(if (b) { r = "s" } else { r = "t" })
r(b)
jf(L4) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
r(b) -> <v5>
jf(L4|<v5>) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
3 mark({ r = "s" })
mark("s")
r("s")
w(r)
r("s") -> <v6>
w(r|<v6>)
2 jmp(L5) NEXT:[mark(doSmth(r))]
L4:
3 mark({ r = "t" }) PREV:[jf(L4)]
3 mark({ r = "t" }) PREV:[jf(L4|<v5>)]
mark("t")
r("t")
w(r)
r("t") -> <v7>
w(r|<v7>)
L5:
2 mark(doSmth(r)) PREV:[jmp(L5), w(r)]
r(r)
call(doSmth, doSmth)
2 mark(doSmth(r)) PREV:[jmp(L5), w(r|<v7>)]
r(r) -> <v8>
call(doSmth, doSmth|<v8>) -> <v9>
L1:
1 <END> NEXT:[<SINK>]
error:
@@ -76,32 +77,34 @@ fun t2(b: Boolean) {
L0:
1 <START>
v(b: Boolean)
w(b)
magic(b: Boolean) -> <v0>
w(b|<v0>)
2 mark({ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } })
v(val i = 3)
r(3)
w(i)
r(3) -> <v1>
w(i|<v1>)
mark(if (b) { return; })
r(b)
jf(L2) NEXT:[read (Unit), mark({ return; })]
r(b) -> <v2>
jf(L2|<v2>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; })
ret L1 NEXT:[<END>]
- 2 jmp(L3) NEXT:[mark(doSmth(i))] PREV:[]
L2:
read (Unit) PREV:[jf(L2)]
read (Unit) PREV:[jf(L2|<v2>)]
L3:
mark(doSmth(i))
r(i)
call(doSmth, doSmth)
r(i) -> <v3>
call(doSmth, doSmth|<v3>) -> <v4>
mark(if (i is Int) { return; })
mark(i is Int)
r(i)
jf(L4) NEXT:[read (Unit), mark({ return; })]
r(i) -> <v5>
magic(i is Int|<v5>) -> <v6>
jf(L4|<v6>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; })
ret L1 NEXT:[<END>]
- 2 jmp(L5) NEXT:[<END>] PREV:[]
L4:
read (Unit) PREV:[jf(L4)]
read (Unit) PREV:[jf(L4|<v6>)]
L1:
L5:
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
@@ -116,13 +119,14 @@ fun doSmth(s: String) {}
L0:
1 <START>
v(s: String)
w(s)
magic(s: String) -> <v0>
w(s|<v0>)
2 mark({})
read (Unit)
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.instructions
+21 -21
View File
@@ -11,23 +11,23 @@ L0:
mark(while(0 > 1) { 2 })
L2 [loop entry point]:
L5 [condition entry point]:
mark(0 > 1) PREV:[mark(while(0 > 1) { 2 }), jmp(L2 [loop entry point])]
r(0)
r(1)
call(>, compareTo)
jf(L3 [loop exit point]) NEXT:[read (Unit), mark({ 2 })]
mark(0 > 1) PREV:[mark(while(0 > 1) { 2 }), jmp(L2 [loop entry point])]
r(0) -> <v0>
r(1) -> <v1>
call(>, compareTo|<v0>, <v1>) -> <v2>
jf(L3 [loop exit point]|<v2>) NEXT:[read (Unit), mark({ 2 })]
L4 [body entry point]:
3 mark({ 2 })
r(2)
2 jmp(L2 [loop entry point]) NEXT:[mark(0 > 1)]
r(2) -> <v3>
2 jmp(L2 [loop entry point]) NEXT:[mark(0 > 1)]
L3 [loop exit point]:
read (Unit) PREV:[jf(L3 [loop exit point])]
read (Unit) PREV:[jf(L3 [loop exit point]|<v2>)]
L1:
1 <END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
== dowhile ==
fun dowhile() {
@@ -42,19 +42,19 @@ L0:
L2 [loop entry point]:
L4 [body entry point]:
mark({return})
ret L1 NEXT:[<END>]
ret L1 NEXT:[<END>]
L5 [condition entry point]:
- mark(0 > 1) PREV:[]
- r(0) PREV:[]
- r(1) PREV:[]
- call(>, compareTo) PREV:[]
- jt(L2 [loop entry point]) NEXT:[read (Unit), mark({return})] PREV:[]
- mark(0 > 1) PREV:[]
- r(0) -> <v0> PREV:[]
- r(1) -> <v1> PREV:[]
- call(>, compareTo|<v0>, <v1>) -> <v2> PREV:[]
- jt(L2 [loop entry point]|<v2>) NEXT:[read (Unit), mark({return})] PREV:[]
L3 [loop exit point]:
- read (Unit) PREV:[]
- read (Unit) PREV:[]
L1:
1 <END> NEXT:[<SINK>] PREV:[ret L1]
1 <END> NEXT:[<SINK>] PREV:[ret L1]
error:
<ERROR> PREV:[]
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/controlStructures/returnsInWhen.instructions
+8 -6
View File
@@ -8,20 +8,22 @@ fun illegalWhenBlock(a: Any): Any {
L0:
1 <START>
v(a: Any)
w(a)
magic(a: Any) -> <v0>
w(a|<v0>)
2 mark({ when(a) { is Int -> return a } })
mark(when(a) { is Int -> return a })
r(a)
r(a) -> <v1>
mark(is Int -> return a)
jmp?(L4) NEXT:[<END>, r(a)]
magic(is Int|<v1>) -> <v2>
jmp?(L4|<v2>) NEXT:[<END>, r(a) -> <v3>]
L3:
r(a)
ret(*) L1 NEXT:[<END>]
r(a) -> <v3>
ret(*|<v3>) L1 NEXT:[<END>]
- jmp(L2) PREV:[]
L1:
L2:
L4:
1 <END> NEXT:[<SINK>] PREV:[jmp?(L4), ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[jmp?(L4|<v2>), ret(*|<v3>) L1]
error:
<ERROR> PREV:[]
sink: