azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ec478215677258cb46710c3cb400ee2e09598cfb
kotlin-fork/compiler/testData/cfg/controlStructures/Finally.instructions
T
Svetlana Isakova ec47821567 restructured control flow tests
2014-03-07 21:08:14 +04:00

996 lines
41 KiB
Plaintext
Raw Blame History

== t1 ==
fun t1() {
try {
1
} finally {
2
}
}
---------------------
L0:
<START>
mark({ try { 1 } finally { 2 } })
mark(try { 1 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 })]
mark({ 1 })
r(1)
jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L5 [finish finally]:
jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
r(2)
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>
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 } })]
mark({ 1 if (2 > 3) { return } })
r(1)
mark(if (2 > 3) { return })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L3) NEXT:[read (Unit), mark({ return })]
mark({ return })
L4 [start finally]:
mark({ 2 })
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:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
r(2)
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>
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@ } } })]
mark({ 1 @{ () -> if (2 > 3) { return@ } } })
r(1)
mark(@{ () -> if (2 > 3) { return@ } })
mark({ () -> if (2 > 3) { return@ } })
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:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L9 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L10 [finish finally]:
jmp(error) NEXT:[<ERROR>]
L8 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])]
r(2)
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
<SINK> PREV:[<ERROR>, <END>, d({ () -> if (2 > 3) { return@ } })]
L4:
<START>
mark(if (2 > 3) { return@ })
mark(if (2 > 3) { return@ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L6) NEXT:[read (Unit), mark({ return@ })]
mark({ return@ })
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>
mark(if (2 > 3) { return@ })
mark(if (2 > 3) { return@ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L6) NEXT:[read (Unit), mark({ return@ })]
mark({ return@ })
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>
mark({ @{ () -> try { 1 if (2 > 3) { return@ } } finally { 2 } } })
mark(@{ () -> try { 1 if (2 > 3) { return@ } } finally { 2 } })
mark({ () -> try { 1 if (2 > 3) { return@ } } finally { 2 } })
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>
mark(try { 1 if (2 > 3) { return@ } } finally { 2 })
mark(try { 1 if (2 > 3) { return@ } } finally { 2 })
jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@ } })]
mark({ 1 if (2 > 3) { return@ } })
r(1)
mark(if (2 > 3) { return@ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L6) NEXT:[read (Unit), mark({ return@ })]
mark({ return@ })
L7 [start finally]:
mark({ 2 })
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:[mark({ 2 })]
L5 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
r(2)
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>
mark(try { 1 if (2 > 3) { return@ } } finally { 2 })
mark(try { 1 if (2 > 3) { return@ } } finally { 2 })
jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@ } })]
mark({ 1 if (2 > 3) { return@ } })
r(1)
mark(if (2 > 3) { return@ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L6) NEXT:[read (Unit), mark({ return@ })]
mark({ return@ })
L7 [start finally]:
mark({ 2 })
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:[mark({ 2 })]
L5 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
r(2)
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>
mark({ @ while(true) { try { 1 if (2 > 3) { break @ } } finally { 2 } } })
mark(@ while(true) { try { 1 if (2 > 3) { break @ } } finally { 2 } })
mark(while(true) { try { 1 if (2 > 3) { break @ } } finally { 2 } })
L2 [loop entry point]:
L5 [condition entry point]:
r(true) PREV:[mark(while(true) { try { 1 if (2 > 3) { break @ } } finally { 2 } }), jmp(L2 [loop entry point])]
L4 [body entry point]:
mark({ try { 1 if (2 > 3) { break @ } } finally { 2 } })
mark(try { 1 if (2 > 3) { break @ } } finally { 2 })
jmp?(L6 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { break @ } })]
mark({ 1 if (2 > 3) { break @ } })
r(1)
mark(if (2 > 3) { break @ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @ })]
mark({ break @ })
L8 [start finally]:
mark({ 2 })
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:[mark({ 2 })]
L6 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
L11 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
r(2)
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>
mark({ try { @ while(true) { 1 if (2 > 3) { break @ } } 5 } finally { 2 } })
mark(try { @ while(true) { 1 if (2 > 3) { break @ } } 5 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @ while(true) { 1 if (2 > 3) { break @ } } 5 })]
mark({ @ while(true) { 1 if (2 > 3) { break @ } } 5 })
mark(@ while(true) { 1 if (2 > 3) { break @ } })
mark(while(true) { 1 if (2 > 3) { break @ } })
L3 [loop entry point]:
L6 [condition entry point]:
r(true) PREV:[mark(while(true) { 1 if (2 > 3) { break @ } }), jmp(L3 [loop entry point])]
L5 [body entry point]:
mark({ 1 if (2 > 3) { break @ } })
r(1)
mark(if (2 > 3) { break @ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @ })]
mark({ break @ })
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:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L11 [finish finally]:
jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
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>
mark({ try { @ while(true) { 1 if (2 > 3) { break @ } } } finally { 2 } })
mark(try { @ while(true) { 1 if (2 > 3) { break @ } } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @ while(true) { 1 if (2 > 3) { break @ } } })]
mark({ @ while(true) { 1 if (2 > 3) { break @ } } })
mark(@ while(true) { 1 if (2 > 3) { break @ } })
mark(while(true) { 1 if (2 > 3) { break @ } })
L3 [loop entry point]:
L6 [condition entry point]:
r(true) PREV:[mark(while(true) { 1 if (2 > 3) { break @ } }), jmp(L3 [loop entry point])]
L5 [body entry point]:
mark({ 1 if (2 > 3) { break @ } })
r(1)
mark(if (2 > 3) { break @ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @ })]
mark({ break @ })
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:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L11 [finish finally]:
jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
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)
mark({ @ for (i in 1..a) { try { 1 if (2 > 3) { continue @ } } finally { 2 } } })
mark(@ for (i in 1..a) { try { 1 if (2 > 3) { continue @ } } finally { 2 } })
mark(for (i in 1..a) { try { 1 if (2 > 3) { continue @ } } finally { 2 } })
mark(1..a)
r(1)
r(a)
call(.., rangeTo)
v(i)
w(i)
L3:
jmp?(L2) NEXT:[read (Unit), mark({ try { 1 if (2 > 3) { continue @ } } finally { 2 } })]
L4 [loop entry point]:
L5 [body entry point]:
mark({ try { 1 if (2 > 3) { continue @ } } finally { 2 } }) PREV:[jmp?(L2), jmp(L4 [loop entry point]), jmp?(L4 [loop entry point])]
mark(try { 1 if (2 > 3) { continue @ } } finally { 2 })
jmp?(L6 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue @ } })]
mark({ 1 if (2 > 3) { continue @ } })
r(1)
mark(if (2 > 3) { continue @ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @ })]
mark({ continue @ })
L8 [start finally]:
mark({ 2 })
r(2)
L9 [finish finally]:
jmp(L4 [loop entry point]) NEXT:[mark({ try { 1 if (2 > 3) { continue @ } } finally { 2 } })]
- jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
L10:
jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L6 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
L11 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
r(2)
jmp?(L4 [loop entry point]) NEXT:[mark({ try { 1 if (2 > 3) { continue @ } } finally { 2 } }), 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)
mark({ try { @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } 5 } finally { 2 } })
mark(try { @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } 5 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } 5 })]
mark({ @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } 5 })
mark(@ for (i in 1..a) { 1 if (2 > 3) { continue @ } })
mark(for (i in 1..a) { 1 if (2 > 3) { continue @ } })
mark(1..a)
r(1)
r(a)
call(.., rangeTo)
v(i)
w(i)
L4:
jmp?(L3) NEXT:[read (Unit), mark({ 1 if (2 > 3) { continue @ } })]
L5 [loop entry point]:
L6 [body entry point]:
mark({ 1 if (2 > 3) { continue @ } }) PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
r(1)
mark(if (2 > 3) { continue @ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @ })]
mark({ continue @ })
jmp(L5 [loop entry point]) NEXT:[mark({ 1 if (2 > 3) { continue @ } })]
- jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
L8:
jmp?(L5 [loop entry point]) NEXT:[mark({ 1 if (2 > 3) { continue @ } }), read (Unit)]
L3:
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
r(5)
jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L11 [finish finally]:
jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
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)
mark({ try { @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } } finally { 2 } })
mark(try { @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } })]
mark({ @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } })
mark(@ for (i in 1..a) { 1 if (2 > 3) { continue @ } })
mark(for (i in 1..a) { 1 if (2 > 3) { continue @ } })
mark(1..a)
r(1)
r(a)
call(.., rangeTo)
v(i)
w(i)
L4:
jmp?(L3) NEXT:[read (Unit), mark({ 1 if (2 > 3) { continue @ } })]
L5 [loop entry point]:
L6 [body entry point]:
mark({ 1 if (2 > 3) { continue @ } }) PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
r(1)
mark(if (2 > 3) { continue @ })
mark(2 > 3)
r(2)
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @ })]
mark({ continue @ })
jmp(L5 [loop entry point]) NEXT:[mark({ 1 if (2 > 3) { continue @ } })]
- jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
L8:
jmp?(L5 [loop entry point]) NEXT:[mark({ 1 if (2 > 3) { continue @ } }), read (Unit)]
L3:
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L11 [finish finally]:
jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
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>
mark({ try { return 1 } finally { return 2 } })
mark(try { return 1 } finally { return 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return 2 }), mark({ return 1 })]
mark({ return 1 })
r(1)
L3 [start finally]:
mark({ return 2 })
r(2)
ret(*) L1 NEXT:[<END>]
L4 [finish finally]:
- ret(*) L1 NEXT:[<END>] PREV:[]
- jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ return 2 })] PREV:[]
L2 [onExceptionToFinallyBlock]:
mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
ret(*) L1 NEXT:[<END>]
- jmp(error) NEXT:[<ERROR>] PREV:[]
L5 [skipFinallyToErrorBlock]:
- mark({ return 2 }) PREV:[]
- 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>
mark({ try { return 1 } finally { doSmth(3) } })
mark(try { return 1 } finally { doSmth(3) })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
mark({ return 1 })
r(1)
L3 [start finally]:
mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
L4 [finish finally]:
ret(*) L1 NEXT:[<END>]
- jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
L2 [onExceptionToFinallyBlock]:
mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
jmp(error) NEXT:[<ERROR>]
L5 [skipFinallyToErrorBlock]:
- mark({ doSmth(3) }) PREV:[]
- mark(doSmth(3)) PREV:[]
- 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>
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 })]
mark({ return 1 })
r(1)
L4 [start finally]:
mark({ doSmth(3) })
mark(doSmth(3))
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)
mark({ doSmth(2) })
mark(doSmth(2))
r(2)
call(doSmth, doSmth)
jmp(L6 [afterCatches])
L6 [afterCatches]:
jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })]
L3 [onExceptionToFinallyBlock]:
mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
mark(doSmth(3))
r(3)
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>
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 })]
mark({ return 1 })
r(1)
ret(*) L1 NEXT:[<END>]
- jmp(L3 [afterCatches]) NEXT:[<END>] PREV:[]
L2 [onException]:
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
mark({ doSmth(2) })
mark(doSmth(2))
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>
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 })]
mark({ return 1 })
r(1)
L4 [start finally]:
mark({ doSmth(3) })
mark(doSmth(3))
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)
mark({ return 2 })
r(2)
mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
ret(*) L1 NEXT:[<END>]
- jmp(L6 [afterCatches]) PREV:[]
L6 [afterCatches]:
- jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
L3 [onExceptionToFinallyBlock]:
mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
- mark({ doSmth(3) }) PREV:[]
- mark(doSmth(3)) PREV:[]
- 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>
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) })]
mark({ doSmth(1) })
mark(doSmth(1))
r(1)
call(doSmth, doSmth)
jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])]
L2 [onException]:
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
mark({ return 2 })
r(2)
L5 [start finally]:
mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
L6 [finish finally]:
ret(*) L1 NEXT:[<END>]
- jmp(L4 [afterCatches]) PREV:[]
L4 [afterCatches]:
jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4 [afterCatches])]
L3 [onExceptionToFinallyBlock]:
mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
mark(doSmth(3))
r(3)
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)
mark({ })
read (Unit)
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
Reference in New Issue View Git Blame Copy Permalink