Andrey Breslav
820 lines
32 KiB
Plaintext
820 lines
32 KiB
Plaintext
== t1 ==
|
|
fun t1() {
|
|
try {
|
|
1
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
jmp(L3 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
L4 [start finally]:
|
|
r(2) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
L5 [finish finally]:
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L3 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t2 ==
|
|
fun t2() {
|
|
try {
|
|
1
|
|
if (2 > 3) {
|
|
return
|
|
}
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L3) NEXT:[read (Unit), r(2)]
|
|
L4 [start finally]:
|
|
r(2)
|
|
L5 [finish finally]:
|
|
ret L1 NEXT:[<END>]
|
|
- jmp(L6) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
|
|
L3:
|
|
read (Unit) PREV:[jf(L3)]
|
|
L6:
|
|
jmp(L7 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
r(2) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L7 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
|
|
L1:
|
|
<END> NEXT:[<SINK>] PREV:[ret L1, r(2)]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t3 ==
|
|
fun t3() {
|
|
try {
|
|
1
|
|
@{ () =>
|
|
if (2 > 3) {
|
|
return@
|
|
}
|
|
}
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
jmp?(L3) NEXT:[r({ () => if (2 > 3) { return@ } }), d({ () => if (2 > 3) { return@ } })]
|
|
d({ () => if (2 > 3) { return@ } }) NEXT:[<SINK>]
|
|
L3:
|
|
r({ () => if (2 > 3) { return@ } }) PREV:[jmp?(L3)]
|
|
jmp(L8 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
L9 [start finally]:
|
|
r(2) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
L10 [finish finally]:
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L8 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L8 [skipFinallyToErrorBlock])]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>, d({ () => if (2 > 3) { return@ } })]
|
|
L4:
|
|
<START>
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L6) NEXT:[read (Unit), ret L5]
|
|
ret L5 NEXT:[<END>]
|
|
- jmp(L7) NEXT:[<END>] PREV:[]
|
|
L6:
|
|
read (Unit) PREV:[jf(L6)]
|
|
L5:
|
|
L7:
|
|
<END> NEXT:[<SINK>] PREV:[ret L5, read (Unit)]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== anonymous_0 ==
|
|
{ () =>
|
|
if (2 > 3) {
|
|
return@
|
|
}
|
|
}
|
|
---------------------
|
|
L4:
|
|
<START>
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L6) NEXT:[read (Unit), ret L5]
|
|
ret L5 NEXT:[<END>]
|
|
- jmp(L7) NEXT:[<END>] PREV:[]
|
|
L6:
|
|
read (Unit) PREV:[jf(L6)]
|
|
L5:
|
|
L7:
|
|
<END> NEXT:[<SINK>] PREV:[ret L5, read (Unit)]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t4 ==
|
|
fun t4() {
|
|
@{ () =>
|
|
try {
|
|
1
|
|
if (2 > 3) {
|
|
return@
|
|
}
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2) NEXT:[r({ () => try { 1 if (2 > 3) { return@ } } finally { 2 } }), d({ () => try { 1 if (2 > 3) { return@ } } finally { 2 } })]
|
|
d({ () => try { 1 if (2 > 3) { return@ } } finally { 2 } }) NEXT:[<SINK>]
|
|
L2:
|
|
r({ () => try { 1 if (2 > 3) { return@ } } finally { 2 } }) PREV:[jmp?(L2)]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>, d({ () => try { 1 if (2 > 3) { return@ } } finally { 2 } })]
|
|
L3:
|
|
<START>
|
|
jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L6) NEXT:[read (Unit), r(2)]
|
|
L7 [start finally]:
|
|
r(2)
|
|
L8 [finish finally]:
|
|
ret L4 NEXT:[<END>]
|
|
- jmp(L9) NEXT:[jmp(L10 [skipFinallyToErrorBlock])] PREV:[]
|
|
L6:
|
|
read (Unit) PREV:[jf(L6)]
|
|
L9:
|
|
jmp(L10 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L5 [onExceptionToFinallyBlock]:
|
|
r(2) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L10 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
|
|
L4:
|
|
<END> NEXT:[<SINK>] PREV:[ret L4, r(2)]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== anonymous_1 ==
|
|
{ () =>
|
|
try {
|
|
1
|
|
if (2 > 3) {
|
|
return@
|
|
}
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
---------------------
|
|
L3:
|
|
<START>
|
|
jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L6) NEXT:[read (Unit), r(2)]
|
|
L7 [start finally]:
|
|
r(2)
|
|
L8 [finish finally]:
|
|
ret L4 NEXT:[<END>]
|
|
- jmp(L9) NEXT:[jmp(L10 [skipFinallyToErrorBlock])] PREV:[]
|
|
L6:
|
|
read (Unit) PREV:[jf(L6)]
|
|
L9:
|
|
jmp(L10 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L5 [onExceptionToFinallyBlock]:
|
|
r(2) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L10 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
|
|
L4:
|
|
<END> NEXT:[<SINK>] PREV:[ret L4, r(2)]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t5 ==
|
|
fun t5() {
|
|
@ while(true) {
|
|
try {
|
|
1
|
|
if (2 > 3) {
|
|
break @
|
|
}
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
L2 [loop entry point]:
|
|
L5 [condition entry point]:
|
|
r(true) PREV:[<START>, jmp(L2 [loop entry point])]
|
|
L4 [body entry point]:
|
|
jmp?(L6 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L7) NEXT:[read (Unit), r(2)]
|
|
L8 [start finally]:
|
|
r(2)
|
|
L9 [finish finally]:
|
|
jmp(L3 [loop exit point]) NEXT:[read (Unit)]
|
|
- jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
|
|
L7:
|
|
read (Unit) PREV:[jf(L7)]
|
|
L10:
|
|
jmp(L11 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L6 [onExceptionToFinallyBlock]:
|
|
r(2) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L11 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
|
|
jmp(L2 [loop entry point]) NEXT:[r(true)]
|
|
L3 [loop exit point]:
|
|
read (Unit) PREV:[jmp(L3 [loop exit point])]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t6 ==
|
|
fun t6() {
|
|
try {
|
|
@ while(true) {
|
|
1
|
|
if (2 > 3) {
|
|
break @
|
|
}
|
|
}
|
|
5
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(2), r(true)]
|
|
L3 [loop entry point]:
|
|
L6 [condition entry point]:
|
|
r(true) PREV:[jmp?(L2 [onExceptionToFinallyBlock]), jmp(L3 [loop entry point])]
|
|
L5 [body entry point]:
|
|
r(1)
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L7) NEXT:[read (Unit), jmp(L4 [loop exit point])]
|
|
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
|
|
- jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
|
|
L7:
|
|
read (Unit) PREV:[jf(L7)]
|
|
L8:
|
|
jmp(L3 [loop entry point]) NEXT:[r(true)]
|
|
L4 [loop exit point]:
|
|
read (Unit) PREV:[jmp(L4 [loop exit point])]
|
|
r(5)
|
|
jmp(L9 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
L10 [start finally]:
|
|
r(2) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
L11 [finish finally]:
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L9 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t7 ==
|
|
fun t7() {
|
|
try {
|
|
@ while(true) {
|
|
1
|
|
if (2 > 3) {
|
|
break @
|
|
}
|
|
}
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(2), r(true)]
|
|
L3 [loop entry point]:
|
|
L6 [condition entry point]:
|
|
r(true) PREV:[jmp?(L2 [onExceptionToFinallyBlock]), jmp(L3 [loop entry point])]
|
|
L5 [body entry point]:
|
|
r(1)
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L7) NEXT:[read (Unit), jmp(L4 [loop exit point])]
|
|
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
|
|
- jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
|
|
L7:
|
|
read (Unit) PREV:[jf(L7)]
|
|
L8:
|
|
jmp(L3 [loop entry point]) NEXT:[r(true)]
|
|
L4 [loop exit point]:
|
|
read (Unit) PREV:[jmp(L4 [loop exit point])]
|
|
jmp(L9 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
L10 [start finally]:
|
|
r(2) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
L11 [finish finally]:
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L9 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t8 ==
|
|
fun t8(a : Int) {
|
|
@ for (i in 1..a) {
|
|
try {
|
|
1
|
|
if (2 > 3) {
|
|
continue @
|
|
}
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
v(a : Int)
|
|
w(a)
|
|
r(1)
|
|
r(a)
|
|
call(.., rangeTo)
|
|
v(i)
|
|
w(i)
|
|
L3:
|
|
jmp?(L2) NEXT:[read (Unit), jmp?(L6 [onExceptionToFinallyBlock])]
|
|
L4 [loop entry point]:
|
|
L5 [body entry point]:
|
|
jmp?(L6 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)] PREV:[jmp?(L2), jmp(L4 [loop entry point]), jmp?(L4 [loop entry point])]
|
|
r(1)
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L7) NEXT:[read (Unit), r(2)]
|
|
L8 [start finally]:
|
|
r(2)
|
|
L9 [finish finally]:
|
|
jmp(L4 [loop entry point]) NEXT:[jmp?(L6 [onExceptionToFinallyBlock])]
|
|
- jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
|
|
L7:
|
|
read (Unit) PREV:[jf(L7)]
|
|
L10:
|
|
jmp(L11 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L6 [onExceptionToFinallyBlock]:
|
|
r(2) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L11 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
|
|
jmp?(L4 [loop entry point]) NEXT:[jmp?(L6 [onExceptionToFinallyBlock]), read (Unit)]
|
|
L2:
|
|
read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t9 ==
|
|
fun t9(a : Int) {
|
|
try {
|
|
@ for (i in 1..a) {
|
|
1
|
|
if (2 > 3) {
|
|
continue @
|
|
}
|
|
}
|
|
5
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
v(a : Int)
|
|
w(a)
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
r(a)
|
|
call(.., rangeTo)
|
|
v(i)
|
|
w(i)
|
|
L4:
|
|
jmp?(L3) NEXT:[read (Unit), r(1)]
|
|
L5 [loop entry point]:
|
|
L6 [body entry point]:
|
|
r(1) PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L7) NEXT:[read (Unit), jmp(L5 [loop entry point])]
|
|
jmp(L5 [loop entry point]) NEXT:[r(1)]
|
|
- jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
|
|
L7:
|
|
read (Unit) PREV:[jf(L7)]
|
|
L8:
|
|
jmp?(L5 [loop entry point]) NEXT:[r(1), read (Unit)]
|
|
L3:
|
|
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
|
|
r(5)
|
|
jmp(L9 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
L10 [start finally]:
|
|
r(2) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
L11 [finish finally]:
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L9 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t10 ==
|
|
fun t10(a : Int) {
|
|
try {
|
|
@ for (i in 1..a) {
|
|
1
|
|
if (2 > 3) {
|
|
continue @
|
|
}
|
|
}
|
|
} finally {
|
|
2
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
v(a : Int)
|
|
w(a)
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
r(a)
|
|
call(.., rangeTo)
|
|
v(i)
|
|
w(i)
|
|
L4:
|
|
jmp?(L3) NEXT:[read (Unit), r(1)]
|
|
L5 [loop entry point]:
|
|
L6 [body entry point]:
|
|
r(1) PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
|
|
r(2)
|
|
r(3)
|
|
call(>, compareTo)
|
|
jf(L7) NEXT:[read (Unit), jmp(L5 [loop entry point])]
|
|
jmp(L5 [loop entry point]) NEXT:[r(1)]
|
|
- jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
|
|
L7:
|
|
read (Unit) PREV:[jf(L7)]
|
|
L8:
|
|
jmp?(L5 [loop entry point]) NEXT:[r(1), read (Unit)]
|
|
L3:
|
|
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
|
|
jmp(L9 [skipFinallyToErrorBlock]) NEXT:[r(2)]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
L10 [start finally]:
|
|
r(2) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
L11 [finish finally]:
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L9 [skipFinallyToErrorBlock]:
|
|
r(2) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t11 ==
|
|
fun t11() {
|
|
try {
|
|
return 1
|
|
}
|
|
finally {
|
|
return 2
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(2), r(1)]
|
|
r(1)
|
|
L3 [start finally]:
|
|
r(2)
|
|
ret(*) L1 NEXT:[<END>]
|
|
L4 [finish finally]:
|
|
- ret(*) L1 NEXT:[<END>] PREV:[]
|
|
- jmp(L5 [skipFinallyToErrorBlock]) NEXT:[r(2)] PREV:[]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
r(2) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
ret(*) L1 NEXT:[<END>]
|
|
- jmp(error) NEXT:[<ERROR>] PREV:[]
|
|
L5 [skipFinallyToErrorBlock]:
|
|
- r(2) PREV:[]
|
|
- ret(*) L1 PREV:[]
|
|
L1:
|
|
<END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t12 ==
|
|
fun t12() : Int {
|
|
try {
|
|
return 1
|
|
}
|
|
finally {
|
|
doSmth(3)
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[r(3), r(1)]
|
|
r(1)
|
|
L3 [start finally]:
|
|
r(3)
|
|
call(doSmth, doSmth)
|
|
L4 [finish finally]:
|
|
ret(*) L1 NEXT:[<END>]
|
|
- jmp(L5 [skipFinallyToErrorBlock]) NEXT:[r(3)] PREV:[]
|
|
L2 [onExceptionToFinallyBlock]:
|
|
r(3) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
|
|
call(doSmth, doSmth)
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L5 [skipFinallyToErrorBlock]:
|
|
- r(3) PREV:[]
|
|
- call(doSmth, doSmth) PREV:[]
|
|
L1:
|
|
<END> NEXT:[<SINK>] PREV:[ret(*) L1]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t13 ==
|
|
fun t13() : Int {
|
|
try {
|
|
return 1
|
|
}
|
|
catch (e: UnsupportedOperationException) {
|
|
doSmth(2)
|
|
}
|
|
finally {
|
|
doSmth(3)
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
|
|
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[r(3), r(1)]
|
|
r(1)
|
|
L4 [start finally]:
|
|
r(3)
|
|
call(doSmth, doSmth)
|
|
L5 [finish finally]:
|
|
ret(*) L1 NEXT:[<END>]
|
|
- jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
|
|
L2 [onException]:
|
|
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
|
|
w(e)
|
|
r(2)
|
|
call(doSmth, doSmth)
|
|
jmp(L6 [afterCatches])
|
|
L6 [afterCatches]:
|
|
jmp(L7 [skipFinallyToErrorBlock]) NEXT:[r(3)]
|
|
L3 [onExceptionToFinallyBlock]:
|
|
r(3) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
|
|
call(doSmth, doSmth)
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L7 [skipFinallyToErrorBlock]:
|
|
r(3) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
|
|
call(doSmth, doSmth)
|
|
L1:
|
|
<END> NEXT:[<SINK>] PREV:[ret(*) L1, call(doSmth, doSmth)]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t14 ==
|
|
fun t14() : Int {
|
|
try {
|
|
return 1
|
|
}
|
|
catch (e: UnsupportedOperationException) {
|
|
doSmth(2)
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), r(1)]
|
|
r(1)
|
|
ret(*) L1 NEXT:[<END>]
|
|
- jmp(L3 [afterCatches]) NEXT:[<END>] PREV:[]
|
|
L2 [onException]:
|
|
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
|
|
w(e)
|
|
r(2)
|
|
call(doSmth, doSmth)
|
|
jmp(L3 [afterCatches])
|
|
L1:
|
|
L3 [afterCatches]:
|
|
<END> NEXT:[<SINK>] PREV:[ret(*) L1, jmp(L3 [afterCatches])]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t15 ==
|
|
fun t15() : Int {
|
|
try {
|
|
return 1
|
|
}
|
|
catch (e: UnsupportedOperationException) {
|
|
return 2
|
|
}
|
|
finally {
|
|
doSmth(3)
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
|
|
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[r(3), r(1)]
|
|
r(1)
|
|
L4 [start finally]:
|
|
r(3)
|
|
call(doSmth, doSmth)
|
|
L5 [finish finally]:
|
|
ret(*) L1 NEXT:[<END>]
|
|
- jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
|
|
L2 [onException]:
|
|
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
|
|
w(e)
|
|
r(2)
|
|
r(3)
|
|
call(doSmth, doSmth)
|
|
ret(*) L1 NEXT:[<END>]
|
|
- jmp(L6 [afterCatches]) PREV:[]
|
|
L6 [afterCatches]:
|
|
- jmp(L7 [skipFinallyToErrorBlock]) NEXT:[r(3)] PREV:[]
|
|
L3 [onExceptionToFinallyBlock]:
|
|
r(3) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
|
|
call(doSmth, doSmth)
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L7 [skipFinallyToErrorBlock]:
|
|
- r(3) PREV:[]
|
|
- call(doSmth, doSmth) PREV:[]
|
|
L1:
|
|
<END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t16 ==
|
|
fun t16() : Int {
|
|
try {
|
|
doSmth(1)
|
|
}
|
|
catch (e: UnsupportedOperationException) {
|
|
return 2
|
|
}
|
|
finally {
|
|
doSmth(3)
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
|
|
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[r(3), r(1)]
|
|
r(1)
|
|
call(doSmth, doSmth)
|
|
jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])]
|
|
L2 [onException]:
|
|
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
|
|
w(e)
|
|
r(2)
|
|
L5 [start finally]:
|
|
r(3)
|
|
call(doSmth, doSmth)
|
|
L6 [finish finally]:
|
|
ret(*) L1 NEXT:[<END>]
|
|
- jmp(L4 [afterCatches]) PREV:[]
|
|
L4 [afterCatches]:
|
|
jmp(L7 [skipFinallyToErrorBlock]) NEXT:[r(3)] PREV:[jmp(L4 [afterCatches])]
|
|
L3 [onExceptionToFinallyBlock]:
|
|
r(3) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
|
|
call(doSmth, doSmth)
|
|
jmp(error) NEXT:[<ERROR>]
|
|
L7 [skipFinallyToErrorBlock]:
|
|
r(3) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
|
|
call(doSmth, doSmth)
|
|
L1:
|
|
<END> NEXT:[<SINK>] PREV:[ret(*) L1, call(doSmth, doSmth)]
|
|
error:
|
|
<ERROR> PREV:[jmp(error)]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== doSmth ==
|
|
fun doSmth(i: Int) {
|
|
}
|
|
---------------------
|
|
L0:
|
|
<START>
|
|
v(i: Int)
|
|
w(i)
|
|
read (Unit)
|
|
L1:
|
|
<END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|