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

Added/updated tests for LexicalScope.

Browse Source
This commit is contained in:
Svetlana Isakova
2014-03-05 19:32:10 +04:00
parent 2cfcd1783b
commit 006f3ccbe9
81 changed files with 1404 additions and 604 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/cfg/controlStructures/Finally.instructions
+201 -201
View File
@@ -8,24 +8,24 @@ fun t1() {
}
---------------------
L0:
<START>
mark({ try { 1 } finally { 2 } })
1 <START>
2 mark({ try { 1 } finally { 2 } })
mark(try { 1 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 })]
mark({ 1 })
3 mark({ 1 })
r(1)
jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L5 [finish finally]:
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])]
r(2)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -44,11 +44,11 @@ fun t2() {
}
---------------------
L0:
<START>
mark({ try { 1 if (2 > 3) { return } } finally { 2 } })
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 } })]
mark({ 1 if (2 > 3) { return } })
3 mark({ 1 if (2 > 3) { return } })
r(1)
mark(if (2 > 3) { return })
mark(2 > 3)
@@ -56,26 +56,26 @@ L0:
r(3)
call(>, compareTo)
jf(L3) NEXT:[read (Unit), mark({ return })]
mark({ return })
4 mark({ return })
L4 [start finally]:
mark({ 2 })
5 mark({ 2 })
r(2)
L5 [finish finally]:
ret L1 NEXT:[<END>]
- jmp(L6) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
4 ret L1 NEXT:[<END>]
- 3 jmp(L6) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
L3:
read (Unit) PREV:[jf(L3)]
L6:
jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
5 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
5 mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
r(2)
L1:
<END> NEXT:[<SINK>] PREV:[ret L1, r(2)]
1 <END> NEXT:[<SINK>] PREV:[ret L1, r(2)]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -96,11 +96,11 @@ fun t3() {
}
---------------------
L0:
<START>
mark({ try { 1 @{ () -> if (2 > 3) { return@ } } } finally { 2 } })
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@ } } })]
mark({ 1 @{ () -> if (2 > 3) { return@ } } })
3 mark({ 1 @{ () -> if (2 > 3) { return@ } } })
r(1)
mark(@{ () -> if (2 > 3) { return@ } })
mark({ () -> if (2 > 3) { return@ } })
@@ -108,18 +108,18 @@ L0:
d({ () -> if (2 > 3) { return@ } }) NEXT:[<SINK>]
L3:
r({ () -> if (2 > 3) { return@ } }) PREV:[jmp?(L3)]
jmp(L8 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
2 jmp(L8 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L9 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L10 [finish finally]:
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L8 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])]
r(2)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -133,22 +133,22 @@ sink:
}
---------------------
L4:
<START>
mark(if (2 > 3) { return@ })
4 <START>
5 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@ })
6 mark({ return@ })
ret L5 NEXT:[<END>]
- jmp(L7) NEXT:[<END>] PREV:[]
- 5 jmp(L7) NEXT:[<END>] PREV:[]
L6:
read (Unit) PREV:[jf(L6)]
L5:
L7:
<END> NEXT:[<SINK>] PREV:[ret L5, read (Unit)]
4 <END> NEXT:[<SINK>] PREV:[ret L5, read (Unit)]
error:
<ERROR> PREV:[]
sink:
@@ -169,8 +169,8 @@ fun t4() {
}
---------------------
L0:
<START>
mark({ @{ () -> try { 1 if (2 > 3) { return@ } } finally { 2 } } })
1 <START>
2 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 } })]
@@ -178,7 +178,7 @@ L0:
L2:
r({ () -> try { 1 if (2 > 3) { return@ } } finally { 2 } }) PREV:[jmp?(L2)]
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
@@ -197,11 +197,11 @@ sink:
}
---------------------
L3:
<START>
mark(try { 1 if (2 > 3) { return@ } } finally { 2 })
3 <START>
4 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@ } })
5 mark({ 1 if (2 > 3) { return@ } })
r(1)
mark(if (2 > 3) { return@ })
mark(2 > 3)
@@ -209,26 +209,26 @@ L3:
r(3)
call(>, compareTo)
jf(L6) NEXT:[read (Unit), mark({ return@ })]
mark({ return@ })
6 mark({ return@ })
L7 [start finally]:
mark({ 2 })
7 mark({ 2 })
r(2)
L8 [finish finally]:
ret L4 NEXT:[<END>]
- jmp(L9) NEXT:[jmp(L10 [skipFinallyToErrorBlock])] PREV:[]
6 ret L4 NEXT:[<END>]
- 5 jmp(L9) NEXT:[jmp(L10 [skipFinallyToErrorBlock])] PREV:[]
L6:
read (Unit) PREV:[jf(L6)]
L9:
jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
4 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L5 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
7 mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
4 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
7 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])]
r(2)
L4:
<END> NEXT:[<SINK>] PREV:[ret L4, r(2)]
3 <END> NEXT:[<SINK>] PREV:[ret L4, r(2)]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -249,18 +249,18 @@ fun t5() {
}
---------------------
L0:
<START>
mark({ @ while(true) { try { 1 if (2 > 3) { break @ } } finally { 2 } } })
1 <START>
2 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 } })
3 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 @ } })
4 mark({ 1 if (2 > 3) { break @ } })
r(1)
mark(if (2 > 3) { break @ })
mark(2 > 3)
@@ -268,29 +268,29 @@ L4 [body entry point]:
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @ })]
mark({ break @ })
5 mark({ break @ })
L8 [start finally]:
mark({ 2 })
6 mark({ 2 })
r(2)
L9 [finish finally]:
jmp(L3 [loop exit point]) NEXT:[read (Unit)]
- jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
5 jmp(L3 [loop exit point]) NEXT:[read (Unit)]
- 4 jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
L10:
jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
3 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L6 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
6 mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
3 jmp(error) NEXT:[<ERROR>]
L11 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
6 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
r(2)
jmp(L2 [loop entry point]) NEXT:[r(true)]
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>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -312,18 +312,18 @@ fun t6() {
}
---------------------
L0:
<START>
mark({ try { @ while(true) { 1 if (2 > 3) { break @ } } 5 } finally { 2 } })
1 <START>
2 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 })
3 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 @ } })
4 mark({ 1 if (2 > 3) { break @ } })
r(1)
mark(if (2 > 3) { break @ })
mark(2 > 3)
@@ -331,28 +331,28 @@ L5 [body entry point]:
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @ })]
mark({ break @ })
5 mark({ break @ })
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
- 4 jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
L8:
jmp(L3 [loop entry point]) NEXT:[r(true)]
3 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 })]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L11 [finish finally]:
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -373,18 +373,18 @@ fun t7() {
}
---------------------
L0:
<START>
mark({ try { @ while(true) { 1 if (2 > 3) { break @ } } } finally { 2 } })
1 <START>
2 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 @ } } })
3 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 @ } })
4 mark({ 1 if (2 > 3) { break @ } })
r(1)
mark(if (2 > 3) { break @ })
mark(2 > 3)
@@ -392,27 +392,27 @@ L5 [body entry point]:
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ break @ })]
mark({ break @ })
5 mark({ break @ })
jmp(L4 [loop exit point]) NEXT:[read (Unit)]
- jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
- 4 jmp(L8) NEXT:[jmp(L3 [loop entry point])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
L8:
jmp(L3 [loop entry point]) NEXT:[r(true)]
3 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 })]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L11 [finish finally]:
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -433,12 +433,12 @@ fun t8(a : Int) {
}
---------------------
L0:
<START>
1 <START>
v(a : Int)
w(a)
mark({ @ for (i in 1..a) { try { 1 if (2 > 3) { continue @ } } finally { 2 } } })
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(for (i in 1..a) { try { 1 if (2 > 3) { continue @ } } finally { 2 } })
3 mark(for (i in 1..a) { try { 1 if (2 > 3) { continue @ } } finally { 2 } })
mark(1..a)
r(1)
r(a)
@@ -449,10 +449,10 @@ 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])]
4 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 @ } })
5 mark({ 1 if (2 > 3) { continue @ } })
r(1)
mark(if (2 > 3) { continue @ })
mark(2 > 3)
@@ -460,29 +460,29 @@ L5 [body entry point]:
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @ })]
mark({ continue @ })
6 mark({ continue @ })
L8 [start finally]:
mark({ 2 })
7 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:[]
6 jmp(L4 [loop entry point]) NEXT:[mark({ try { 1 if (2 > 3) { continue @ } } finally { 2 } })]
- 5 jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
L7:
read (Unit) PREV:[jf(L7)]
L10:
jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
4 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L6 [onExceptionToFinallyBlock]:
mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
7 mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
r(2)
jmp(error) NEXT:[<ERROR>]
4 jmp(error) NEXT:[<ERROR>]
L11 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
7 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)]
3 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>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -504,15 +504,15 @@ fun t9(a : Int) {
}
---------------------
L0:
<START>
1 <START>
v(a : Int)
w(a)
mark({ try { @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } 5 } finally { 2 } })
2 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 })
3 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 @ } })
4 mark(for (i in 1..a) { 1 if (2 > 3) { continue @ } })
mark(1..a)
r(1)
r(a)
@@ -523,7 +523,7 @@ 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])]
5 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)
@@ -531,28 +531,28 @@ L6 [body entry point]:
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @ })]
mark({ continue @ })
6 mark({ continue @ })
jmp(L5 [loop entry point]) NEXT:[mark({ 1 if (2 > 3) { continue @ } })]
- jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
- 5 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)]
4 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 })]
3 r(5)
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L11 [finish finally]:
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -573,15 +573,15 @@ fun t10(a : Int) {
}
---------------------
L0:
<START>
1 <START>
v(a : Int)
w(a)
mark({ try { @ for (i in 1..a) { 1 if (2 > 3) { continue @ } } } finally { 2 } })
2 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 @ } } })
3 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 @ } })
4 mark(for (i in 1..a) { 1 if (2 > 3) { continue @ } })
mark(1..a)
r(1)
r(a)
@@ -592,7 +592,7 @@ 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])]
5 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)
@@ -600,27 +600,27 @@ L6 [body entry point]:
r(3)
call(>, compareTo)
jf(L7) NEXT:[read (Unit), mark({ continue @ })]
mark({ continue @ })
6 mark({ continue @ })
jmp(L5 [loop entry point]) NEXT:[mark({ 1 if (2 > 3) { continue @ } })]
- jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
- 5 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)]
4 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 })]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]:
L10 [start finally]:
mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
L11 [finish finally]:
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L9 [skipFinallyToErrorBlock]:
mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])]
r(2)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -637,30 +637,30 @@ fun t11() {
}
---------------------
L0:
<START>
mark({ try { return 1 } finally { return 2 } })
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 })]
mark({ return 1 })
3 mark({ return 1 })
r(1)
L3 [start finally]:
mark({ return 2 })
4 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:[]
- 3 ret(*) L1 NEXT:[<END>] PREV:[]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ return 2 })] PREV:[]
L2 [onExceptionToFinallyBlock]:
mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
4 mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
r(2)
ret(*) L1 NEXT:[<END>]
- jmp(error) NEXT:[<ERROR>] PREV:[]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L5 [skipFinallyToErrorBlock]:
- mark({ return 2 }) PREV:[]
- 4 mark({ return 2 }) PREV:[]
- r(2) PREV:[]
- ret(*) L1 PREV:[]
L1:
<END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
error:
<ERROR> PREV:[]
sink:
@@ -677,33 +677,33 @@ fun t12() : Int {
}
---------------------
L0:
<START>
mark({ try { return 1 } finally { doSmth(3) } })
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 })]
mark({ return 1 })
3 mark({ return 1 })
r(1)
L3 [start finally]:
mark({ doSmth(3) })
4 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:[]
3 ret(*) L1 NEXT:[<END>]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
L2 [onExceptionToFinallyBlock]:
mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
4 mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L5 [skipFinallyToErrorBlock]:
- mark({ doSmth(3) }) PREV:[]
- 4 mark({ doSmth(3) }) PREV:[]
- mark(doSmth(3)) PREV:[]
- r(3) PREV:[]
- call(doSmth, doSmth) PREV:[]
L1:
<END> NEXT:[<SINK>] PREV:[ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -723,44 +723,44 @@ fun t13() : Int {
}
---------------------
L0:
<START>
mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } })
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 })]
mark({ return 1 })
3 mark({ return 1 })
r(1)
L4 [start finally]:
mark({ doSmth(3) })
4 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:[]
3 ret(*) L1 NEXT:[<END>]
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
L2 [onException]:
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
mark({ doSmth(2) })
4 mark({ doSmth(2) })
mark(doSmth(2))
r(2)
call(doSmth, doSmth)
jmp(L6 [afterCatches])
3 jmp(L6 [afterCatches])
L6 [afterCatches]:
jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })]
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })]
L3 [onExceptionToFinallyBlock]:
mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
4 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)]
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, call(doSmth, doSmth)]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -777,25 +777,25 @@ fun t14() : Int {
}
---------------------
L0:
<START>
mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } })
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 })]
mark({ return 1 })
3 mark({ return 1 })
r(1)
ret(*) L1 NEXT:[<END>]
- jmp(L3 [afterCatches]) NEXT:[<END>] PREV:[]
- 2 jmp(L3 [afterCatches]) NEXT:[<END>] PREV:[]
L2 [onException]:
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
mark({ doSmth(2) })
4 mark({ doSmth(2) })
mark(doSmth(2))
r(2)
call(doSmth, doSmth)
jmp(L3 [afterCatches])
3 jmp(L3 [afterCatches])
L1:
L3 [afterCatches]:
<END> NEXT:[<SINK>] PREV:[ret(*) L1, jmp(L3 [afterCatches])]
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, jmp(L3 [afterCatches])]
error:
<ERROR> PREV:[]
sink:
@@ -815,47 +815,47 @@ fun t15() : Int {
}
---------------------
L0:
<START>
mark({ try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } })
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 })]
mark({ return 1 })
3 mark({ return 1 })
r(1)
L4 [start finally]:
mark({ doSmth(3) })
4 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:[]
3 ret(*) L1 NEXT:[<END>]
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
L2 [onException]:
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
mark({ return 2 })
4 mark({ return 2 })
r(2)
mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
ret(*) L1 NEXT:[<END>]
- jmp(L6 [afterCatches]) PREV:[]
- 3 jmp(L6 [afterCatches]) PREV:[]
L6 [afterCatches]:
- jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
- 2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[]
L3 [onExceptionToFinallyBlock]:
mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
- mark({ doSmth(3) }) PREV:[]
- 4 mark({ doSmth(3) }) PREV:[]
- mark(doSmth(3)) PREV:[]
- r(3) PREV:[]
- call(doSmth, doSmth) PREV:[]
L1:
<END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -875,44 +875,44 @@ fun t16() : Int {
}
---------------------
L0:
<START>
mark({ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } })
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) })]
mark({ doSmth(1) })
3 mark({ doSmth(1) })
mark(doSmth(1))
r(1)
call(doSmth, doSmth)
jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])]
2 jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])]
L2 [onException]:
v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
w(e)
mark({ return 2 })
4 mark({ return 2 })
r(2)
L5 [start finally]:
mark({ doSmth(3) })
5 mark({ doSmth(3) })
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
L6 [finish finally]:
ret(*) L1 NEXT:[<END>]
- jmp(L4 [afterCatches]) PREV:[]
4 ret(*) L1 NEXT:[<END>]
- 3 jmp(L4 [afterCatches]) PREV:[]
L4 [afterCatches]:
jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4 [afterCatches])]
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4 [afterCatches])]
L3 [onExceptionToFinallyBlock]:
mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
5 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
mark(doSmth(3))
r(3)
call(doSmth, doSmth)
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]:
mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])]
5 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)]
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, call(doSmth, doSmth)]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -923,13 +923,13 @@ fun doSmth(i: Int) {
}
---------------------
L0:
<START>
1 <START>
v(i: Int)
w(i)
mark({ })
2 mark({ })
read (Unit)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
+68 -68
View File
@@ -2,11 +2,11 @@
fun doSmth() {}
---------------------
L0:
<START>
mark({})
1 <START>
2 mark({})
read (Unit)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
@@ -16,11 +16,11 @@ sink:
fun doSmth1() {}
---------------------
L0:
<START>
mark({})
1 <START>
2 mark({})
read (Unit)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
@@ -30,11 +30,11 @@ sink:
fun doSmth2() {}
---------------------
L0:
<START>
mark({})
1 <START>
2 mark({})
read (Unit)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
@@ -44,11 +44,11 @@ sink:
fun cond() {}
---------------------
L0:
<START>
mark({})
1 <START>
2 mark({})
read (Unit)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
@@ -71,45 +71,45 @@ fun testCopy1() : Int {
}
---------------------
L0:
<START>
mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 } })
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() })]
mark({ doSmth() })
3 mark({ doSmth() })
mark(doSmth())
call(doSmth, doSmth)
jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
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])]
v(e: NullPointerException)
3 v(e: NullPointerException)
w(e)
mark({ doSmth1() })
4 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1, doSmth1)
jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])]
w(e)
mark({ doSmth2() })
4 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2, doSmth2)
jmp(L4 [afterCatches])
3 jmp(L4 [afterCatches])
L4 [afterCatches]:
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]:
mark({ return 1 }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
3 mark({ return 1 }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
r(1)
ret(*) L1 NEXT:[<END>]
L8 [finish finally]:
- jmp(error) NEXT:[<ERROR>] PREV:[]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L6 [skipFinallyToErrorBlock]:
mark({ return 1 }) PREV:[jmp(L6 [skipFinallyToErrorBlock])]
3 mark({ return 1 }) PREV:[jmp(L6 [skipFinallyToErrorBlock])]
r(1)
ret(*) L1
L1:
<END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[ret(*) L1, ret(*) L1]
error:
<ERROR> PREV:[]
sink:
@@ -135,8 +135,8 @@ fun testCopy2() {
}
---------------------
L0:
<START>
mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } })
1 <START>
2 mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } })
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]:
@@ -144,34 +144,34 @@ L5 [condition 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 } })]
L4 [body entry point]:
mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
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() })]
mark({ doSmth() })
4 mark({ doSmth() })
mark(doSmth())
call(doSmth, doSmth)
jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])]
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])]
v(e: NullPointerException)
4 v(e: NullPointerException)
w(e)
mark({ doSmth1() })
5 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1, doSmth1)
jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])]
4 jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])]
L9 [catch 0]:
v(e: Exception) PREV:[jmp?(L9 [catch 0])]
w(e)
mark({ doSmth2() })
5 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2, doSmth2)
jmp(L8 [afterCatches])
4 jmp(L8 [afterCatches])
L8 [afterCatches]:
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]:
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)
@@ -182,9 +182,9 @@ L12:
jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[jf(L12)]
L13:
L14 [finish finally]:
- jmp(error) NEXT:[<ERROR>] PREV:[]
- 3 jmp(error) NEXT:[<ERROR>] PREV:[]
L10 [skipFinallyToErrorBlock]:
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)
@@ -192,11 +192,11 @@ L10 [skipFinallyToErrorBlock]:
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)]
- jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[]
- 2 jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[]
L3 [loop exit point]:
read (Unit) PREV:[jf(L3 [loop exit point])]
L1:
<END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
error:
<ERROR> PREV:[]
sink:
@@ -219,35 +219,35 @@ fun testCopy3() {
}
---------------------
L0:
<START>
mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); } })
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() })]
mark({ doSmth() })
3 mark({ doSmth() })
mark(doSmth())
call(doSmth, doSmth)
jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
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])]
v(e: NullPointerException)
3 v(e: NullPointerException)
w(e)
mark({ doSmth1() })
4 mark({ doSmth1() })
mark(doSmth1())
call(doSmth1, doSmth1)
jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])]
w(e)
mark({ doSmth2() })
4 mark({ doSmth2() })
mark(doSmth2())
call(doSmth2, doSmth2)
jmp(L4 [afterCatches])
3 jmp(L4 [afterCatches])
L4 [afterCatches]:
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]:
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]:
@@ -259,9 +259,9 @@ L10 [body entry point]:
L9 [loop exit point]:
read (Unit) PREV:[jf(L9 [loop exit point])]
L12 [finish finally]:
jmp(error) NEXT:[<ERROR>]
2 jmp(error) NEXT:[<ERROR>]
L6 [skipFinallyToErrorBlock]:
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)
@@ -269,7 +269,7 @@ L6 [skipFinallyToErrorBlock]:
jmp(copy L8 [loop entry point]) NEXT:[mark(cond())]
read (Unit) PREV:[jf(copy L9 [loop exit point])]
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[jmp(error)]
sink:
@@ -287,47 +287,47 @@ fun doTestCopy4(list: List<String>?) : Int {
}
---------------------
L0:
<START>
1 <START>
v(list: List<String>?)
w(list)
mark({ try { doSmth() } finally { if(list != null) { } } })
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() })]
mark({ doSmth() })
3 mark({ doSmth() })
mark(doSmth())
call(doSmth, doSmth)
jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ if(list != null) { } })]
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ if(list != null) { } })]
L2 [onExceptionToFinallyBlock]:
L4 [start finally]:
mark({ if(list != null) { } }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
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({ })]
mark({ })
4 mark({ })
read (Unit)
jmp(L6) NEXT:[jmp(error)]
3 jmp(L6) NEXT:[jmp(error)]
L5:
read (Unit) PREV:[jf(L5)]
L6:
L7 [finish finally]:
jmp(error) NEXT:[<ERROR>] PREV:[jmp(L6), read (Unit)]
2 jmp(error) NEXT:[<ERROR>] PREV:[jmp(L6), read (Unit)]
L3 [skipFinallyToErrorBlock]:
mark({ if(list != null) { } }) PREV:[jmp(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({ })]
mark({ })
4 mark({ })
read (Unit)
jmp(copy L6) NEXT:[<END>]
3 jmp(copy L6) NEXT:[<END>]
read (Unit) PREV:[jf(copy L5)]
L1:
<END> NEXT:[<SINK>] PREV:[jmp(copy L6), read (Unit)]
1 <END> NEXT:[<SINK>] PREV:[jmp(copy L6), read (Unit)]
error:
<ERROR> PREV:[jmp(error)]
sink:
compiler/testData/cfg/controlStructures/For.instructions
+9 -9
View File
@@ -6,9 +6,9 @@ fun t1() {
}
---------------------
L0:
<START>
mark({ for (i in 1..2) { doSmth(i) } })
mark(for (i in 1..2) { doSmth(i) })
1 <START>
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)
@@ -19,15 +19,15 @@ L3:
jmp?(L2) NEXT:[read (Unit), mark({ doSmth(i) })]
L4 [loop entry point]:
L5 [body entry point]:
mark({ doSmth(i) }) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
4 mark({ doSmth(i) }) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
mark(doSmth(i))
r(i)
call(doSmth, doSmth)
jmp?(L4 [loop entry point]) NEXT:[mark({ doSmth(i) }), read (Unit)]
3 jmp?(L4 [loop entry point]) NEXT:[mark({ doSmth(i) }), read (Unit)]
L2:
read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
@@ -37,13 +37,13 @@ sink:
fun doSmth(i: Int) {}
---------------------
L0:
<START>
1 <START>
v(i: Int)
w(i)
mark({})
2 mark({})
read (Unit)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
compiler/testData/cfg/controlStructures/If.instructions
+19 -19
View File
@@ -17,19 +17,19 @@ fun t1(b: Boolean) {
}
---------------------
L0:
<START>
1 <START>
v(b: Boolean)
w(b)
mark({ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) })
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" })]
mark({ u = "s" })
3 mark({ u = "s" })
mark("s")
r("s")
w(u)
jmp(L3) NEXT:[mark(doSmth(u))]
2 jmp(L3) NEXT:[mark(doSmth(u))]
L2:
read (Unit) PREV:[jf(L2)]
L3:
@@ -40,22 +40,22 @@ L3:
mark(if (b) { r = "s" } else { r = "t" })
r(b)
jf(L4) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
mark({ r = "s" })
3 mark({ r = "s" })
mark("s")
r("s")
w(r)
jmp(L5) NEXT:[mark(doSmth(r))]
2 jmp(L5) NEXT:[mark(doSmth(r))]
L4:
mark({ r = "t" }) PREV:[jf(L4)]
3 mark({ r = "t" }) PREV:[jf(L4)]
mark("t")
r("t")
w(r)
L5:
mark(doSmth(r)) PREV:[jmp(L5), w(r)]
2 mark(doSmth(r)) PREV:[jmp(L5), w(r)]
r(r)
call(doSmth, doSmth)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
@@ -74,19 +74,19 @@ fun t2(b: Boolean) {
}
---------------------
L0:
<START>
1 <START>
v(b: Boolean)
w(b)
mark({ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } })
2 mark({ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } })
v(val i = 3)
r(3)
w(i)
mark(if (b) { return; })
r(b)
jf(L2) NEXT:[read (Unit), mark({ return; })]
mark({ return; })
3 mark({ return; })
ret L1 NEXT:[<END>]
- jmp(L3) NEXT:[mark(doSmth(i))] PREV:[]
- 2 jmp(L3) NEXT:[mark(doSmth(i))] PREV:[]
L2:
read (Unit) PREV:[jf(L2)]
L3:
@@ -97,14 +97,14 @@ L3:
mark(i is Int)
r(i)
jf(L4) NEXT:[read (Unit), mark({ return; })]
mark({ return; })
3 mark({ return; })
ret L1 NEXT:[<END>]
- jmp(L5) NEXT:[<END>] PREV:[]
- 2 jmp(L5) NEXT:[<END>] PREV:[]
L4:
read (Unit) PREV:[jf(L4)]
L1:
L5:
<END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
error:
<ERROR> PREV:[]
sink:
@@ -114,13 +114,13 @@ sink:
fun doSmth(s: String) {}
---------------------
L0:
<START>
1 <START>
v(s: String)
w(s)
mark({})
2 mark({})
read (Unit)
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.instructions
+9 -9
View File
@@ -6,8 +6,8 @@ fun main() {
}
---------------------
L0:
<START>
mark({ while(1 > 0) { 2 } })
1 <START>
2 mark({ while(1 > 0) { 2 } })
mark(while(1 > 0) { 2 })
L2 [loop entry point]:
L5 [condition entry point]:
@@ -17,13 +17,13 @@ L5 [condition entry point]:
call(>, compareTo)
jf(L3 [loop exit point]) NEXT:[read (Unit), mark({ 2 })]
L4 [body entry point]:
mark({ 2 })
3 mark({ 2 })
r(2)
jmp(L2 [loop entry point]) NEXT:[mark(1 > 0)]
2 jmp(L2 [loop entry point]) NEXT:[mark(1 > 0)]
L3 [loop exit point]:
read (Unit) PREV:[jf(L3 [loop exit point])]
L1:
<END> NEXT:[<SINK>]
1 <END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
@@ -36,9 +36,9 @@ fun dowhile() {
}
---------------------
L0:
<START>
mark({ do {return} while(1 > 0) })
mark(do {return} while(1 > 0))
1 <START>
2 mark({ do {return} while(1 > 0) })
3 mark(do {return} while(1 > 0))
L2 [loop entry point]:
L4 [body entry point]:
mark({return})
@@ -52,7 +52,7 @@ L5 [condition entry point]:
L3 [loop exit point]:
- read (Unit) PREV:[]
L1:
<END> NEXT:[<SINK>] PREV:[ret L1]
1 <END> NEXT:[<SINK>] PREV:[ret L1]
error:
<ERROR> PREV:[]
sink:
compiler/testData/cfg/controlStructures/returnsInWhen.instructions
+3 -3
View File
@@ -6,10 +6,10 @@ fun illegalWhenBlock(a: Any): Any {
}
---------------------
L0:
<START>
1 <START>
v(a: Any)
w(a)
mark({ when(a) { is Int -> return a } })
2 mark({ when(a) { is Int -> return a } })
mark(when(a) { is Int -> return a })
r(a)
mark(is Int -> return a)
@@ -21,7 +21,7 @@ L3:
L1:
L2:
L4:
<END> NEXT:[<SINK>] PREV:[jmp?(L4), ret(*) L1]
1 <END> NEXT:[<SINK>] PREV:[jmp?(L4), ret(*) L1]
error:
<ERROR> PREV:[]
sink: