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

Do not render trivial variables in DataFlow tests

Browse Source 
The reason is that while there are optimizations for them
definition of their state is both rather simple and may be
confusing in testData
This commit is contained in:
Denis Zharkov
2017-09-29 16:42:41 +03:00
parent 477aeef90c
commit edbf360852
24 changed files with 479 additions and 464 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.kt
+3
View File
@@ -67,6 +67,9 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon
fun getDeclaredVariables(pseudocode: Pseudocode, includeInsideLocalDeclarations: Boolean): Set<VariableDescriptor> =
getAllDeclaredVariables(pseudocode, includeInsideLocalDeclarations).allVars
fun isVariableWithTrivialInitializer(variableDescriptor: VariableDescriptor) =
variableDescriptor in rootVariables.valsWithTrivialInitializer
private fun getAllDeclaredVariables(pseudocode: Pseudocode, includeInsideLocalDeclarations: Boolean): VariablesForDeclaration {
if (!includeInsideLocalDeclarations) {
return getUpperLevelDeclaredVariables(pseudocode)
compiler/testData/cfg-variables/basic/ExhaustiveInitialization.instructions
Vendored
+30 -30
View File
@@ -38,66 +38,66 @@ fun foo(dir: Direction): Int {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(dir: Direction) INIT: in: {} out: {dir=D}
magic[FAKE_INITIALIZER](dir: Direction) -> <v0> INIT: in: {dir=D} out: {dir=D}
w(dir|<v0>) INIT: in: {dir=D} out: {dir=ID} USE: in: {dir=READ} out: {dir=READ}
2 mark({ val res: Int when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 } return res }) INIT: in: {dir=ID} out: {dir=ID}
v(val res: Int) INIT: in: {dir=ID} out: {dir=ID, res=D}
mark(when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }) INIT: in: {dir=ID, res=D} out: {dir=ID, res=D}
v(dir: Direction) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](dir: Direction) -> <v0> INIT: in: {} out: {}
w(dir|<v0>) INIT: in: {} out: {} USE: in: {} out: {}
2 mark({ val res: Int when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 } return res }) INIT: in: {} out: {}
v(val res: Int) INIT: in: {} out: {res=D}
mark(when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }) INIT: in: {res=D} out: {res=D}
r(dir) -> <v1>
mark(Direction.NORTH -> res = 1)
mark(Direction.NORTH)
mark(Direction.NORTH)
r(NORTH) -> <v2>
magic[EQUALS_IN_WHEN_CONDITION](Direction.NORTH|<v1>, <v2>) -> <v3>
jmp?(L4|<v3>) USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ}
jmp?(L4|<v3>) USE: in: {res=READ} out: {res=READ}
L3 ['when' entry body]:
r(1) -> <v4> USE: in: {dir=READ, res=WRITTEN_AFTER_READ} out: {dir=READ, res=WRITTEN_AFTER_READ}
w(res|<v4>) INIT: in: {dir=ID, res=D} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=WRITTEN_AFTER_READ}
jmp(L2) INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID}
r(1) -> <v4> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ}
w(res|<v4>) INIT: in: {res=D} out: {res=ID} USE: in: {res=READ} out: {res=WRITTEN_AFTER_READ}
jmp(L2) INIT: in: {res=ID} out: {res=ID}
L4 [next 'when' entry]:
mark(Direction.SOUTH -> res = 2) INIT: in: {dir=ID, res=D} out: {dir=ID, res=D}
mark(Direction.SOUTH -> res = 2) INIT: in: {res=D} out: {res=D}
mark(Direction.SOUTH)
mark(Direction.SOUTH)
r(SOUTH) -> <v5>
magic[EQUALS_IN_WHEN_CONDITION](Direction.SOUTH|<v1>, <v5>) -> <v6>
jmp?(L6|<v6>) USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ}
jmp?(L6|<v6>) USE: in: {res=READ} out: {res=READ}
L5 ['when' entry body]:
r(2) -> <v7> USE: in: {dir=READ, res=WRITTEN_AFTER_READ} out: {dir=READ, res=WRITTEN_AFTER_READ}
w(res|<v7>) INIT: in: {dir=ID, res=D} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=WRITTEN_AFTER_READ}
jmp(L2) INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID}
r(2) -> <v7> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ}
w(res|<v7>) INIT: in: {res=D} out: {res=ID} USE: in: {res=READ} out: {res=WRITTEN_AFTER_READ}
jmp(L2) INIT: in: {res=ID} out: {res=ID}
L6 [next 'when' entry]:
mark(Direction.WEST -> res = 3) INIT: in: {dir=ID, res=D} out: {dir=ID, res=D}
mark(Direction.WEST -> res = 3) INIT: in: {res=D} out: {res=D}
mark(Direction.WEST)
mark(Direction.WEST)
r(WEST) -> <v8>
magic[EQUALS_IN_WHEN_CONDITION](Direction.WEST|<v1>, <v8>) -> <v9>
jmp?(L8|<v9>) USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ}
jmp?(L8|<v9>) USE: in: {res=READ} out: {res=READ}
L7 ['when' entry body]:
r(3) -> <v10> USE: in: {dir=READ, res=WRITTEN_AFTER_READ} out: {dir=READ, res=WRITTEN_AFTER_READ}
w(res|<v10>) INIT: in: {dir=ID, res=D} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=WRITTEN_AFTER_READ}
jmp(L2) INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID}
r(3) -> <v10> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ}
w(res|<v10>) INIT: in: {res=D} out: {res=ID} USE: in: {res=READ} out: {res=WRITTEN_AFTER_READ}
jmp(L2) INIT: in: {res=ID} out: {res=ID}
L8 [next 'when' entry]:
mark(Direction.EAST -> res = 4) INIT: in: {dir=ID, res=D} out: {dir=ID, res=D}
mark(Direction.EAST -> res = 4) INIT: in: {res=D} out: {res=D}
mark(Direction.EAST)
mark(Direction.EAST)
r(EAST) -> <v11>
magic[EQUALS_IN_WHEN_CONDITION](Direction.EAST|<v1>, <v11>) -> <v12>
jmp?(L10|<v12>) USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ}
jmp?(L10|<v12>) USE: in: {res=READ} out: {res=READ}
L9 ['when' entry body]:
r(4) -> <v13> USE: in: {dir=READ, res=WRITTEN_AFTER_READ} out: {dir=READ, res=WRITTEN_AFTER_READ}
w(res|<v13>) INIT: in: {dir=ID, res=D} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=WRITTEN_AFTER_READ}
jmp(L2) INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID}
r(4) -> <v13> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ}
w(res|<v13>) INIT: in: {res=D} out: {res=ID} USE: in: {res=READ} out: {res=WRITTEN_AFTER_READ}
jmp(L2) INIT: in: {res=ID} out: {res=ID}
L10 [next 'when' entry]:
magic[EXHAUSTIVE_WHEN_ELSE](when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }) -> <v14> INIT: in: {dir=ID, res=D} out: {dir=ID, res=IED}
magic[EXHAUSTIVE_WHEN_ELSE](when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }) -> <v14> INIT: in: {res=D} out: {res=IED}
L2 [after 'when' expression]:
merge(when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }|!<v15>, !<v16>, !<v17>, !<v18>) -> <v19> INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ}
r(res) -> <v20> USE: in: {dir=READ} out: {dir=READ, res=READ}
merge(when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }|!<v15>, !<v16>, !<v17>, !<v18>) -> <v19> INIT: in: {res=ID} out: {res=ID} USE: in: {res=READ} out: {res=READ}
r(res) -> <v20> USE: in: {} out: {res=READ}
ret(*|<v20>) L1
L1:
1 <END> INIT: in: {dir=ID} out: {dir=ID}
1 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {dir=READ} out: {dir=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions
Vendored
+5 -5
View File
@@ -42,15 +42,15 @@ fun use(vararg a: Any?) = a
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(vararg a: Any?) INIT: in: {} out: {a=D}
magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID}
v(vararg a: Any?) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
r(a) -> <v1> INIT: in: {} out: {}
ret(*|<v1>) L1
L1:
<END>
error:
<ERROR>
sink:
<SINK> USE: in: {a=READ} out: {a=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions
Vendored
+24 -24
View File
@@ -10,22 +10,22 @@ fun foo() {
L0:
1 <START> INIT: in: {} out: {}
2 mark({ val a = 1 val f = { x: Int -> val y = x + a use(a) } })
v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
v(val f = { x: Int -> val y = x + a use(a) }) INIT: in: {a=ID} out: {a=ID, f=D}
mark({ x: Int -> val y = x + a use(a) }) INIT: in: {a=ID, f=D} out: {a=ID, f=D}
v(val a = 1) INIT: in: {} out: {}
r(1) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
v(val f = { x: Int -> val y = x + a use(a) }) INIT: in: {} out: {}
mark({ x: Int -> val y = x + a use(a) }) INIT: in: {} out: {}
jmp?(L2)
d({ x: Int -> val y = x + a use(a) }) INIT: in: {a=ID, f=D, x=ID, y=ID} out: {a=ID, f=D, x=ID, y=ID}
d({ x: Int -> val y = x + a use(a) }) INIT: in: {} out: {}
L2 [after local declaration]:
r({ x: Int -> val y = x + a use(a) }) -> <v1>
w(f|<v1>) INIT: in: {a=ID, f=D, x=ID, y=ID} out: {a=ID, f=ID, x=ID, y=ID}
w(f|<v1>) INIT: in: {} out: {}
L1:
1 <END> INIT: in: {a=ID, f=ID, x=ID, y=ID} out: {a=ID, f=ID, x=ID, y=ID}
1 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {a=READ, x=READ} out: {a=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== anonymous_0 ==
{ x: Int ->
@@ -34,18 +34,18 @@ sink:
}
---------------------
L3:
3 <START> INIT: in: {a=ID, f=D} out: {a=ID, f=D}
v(x: Int) INIT: in: {a=ID, f=D} out: {a=ID, f=D, x=D}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {a=ID, f=D, x=D} out: {a=ID, f=D, x=D}
w(x|<v0>) INIT: in: {a=ID, f=D, x=D} out: {a=ID, f=D, x=ID}
4 mark(val y = x + a use(a)) INIT: in: {a=ID, f=D, x=ID} out: {a=ID, f=D, x=ID}
v(val y = x + a) INIT: in: {a=ID, f=D, x=ID} out: {a=ID, f=D, x=ID, y=D}
r(x) -> <v1> INIT: in: {a=ID, f=D, x=ID, y=D} out: {a=ID, f=D, x=ID, y=D}
3 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {} out: {}
w(x|<v0>) INIT: in: {} out: {}
4 mark(val y = x + a use(a)) INIT: in: {} out: {}
v(val y = x + a) INIT: in: {} out: {}
r(x) -> <v1> INIT: in: {} out: {}
r(a) -> <v2>
mark(x + a)
call(x + a, plus|<v1>, <v2>) -> <v3>
w(y|<v3>) INIT: in: {a=ID, f=D, x=ID, y=D} out: {a=ID, f=D, x=ID, y=ID}
r(a) -> <v4> INIT: in: {a=ID, f=D, x=ID, y=ID} out: {a=ID, f=D, x=ID, y=ID}
w(y|<v3>) INIT: in: {} out: {}
r(a) -> <v4> INIT: in: {} out: {}
mark(use(a))
call(use(a), use|<v4>) -> <v5>
3 ret(*|<v5>) L4
@@ -54,22 +54,22 @@ L4:
error:
<ERROR>
sink:
<SINK> USE: in: {a=READ, x=READ} out: {a=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== use ==
fun use(vararg a: Any?) = a
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(vararg a: Any?) INIT: in: {} out: {a=D}
magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID}
v(vararg a: Any?) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
r(a) -> <v1> INIT: in: {} out: {}
ret(*|<v1>) L1
L1:
<END>
error:
<ERROR>
sink:
<SINK> USE: in: {a=READ} out: {a=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/basic/UseUninitializedInLambda.instructions
Vendored
+5 -5
View File
@@ -3,10 +3,10 @@ fun bar(f: () -> Unit) = f()
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(f: () -> Unit) INIT: in: {} out: {f=D}
magic[FAKE_INITIALIZER](f: () -> Unit) -> <v0> INIT: in: {f=D} out: {f=D}
w(f|<v0>) INIT: in: {f=D} out: {f=ID}
r(f) -> <v1> INIT: in: {f=ID} out: {f=ID}
v(f: () -> Unit) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](f: () -> Unit) -> <v0> INIT: in: {} out: {}
w(f|<v0>) INIT: in: {} out: {}
r(f) -> <v1> INIT: in: {} out: {}
mark(f())
call(f(), invoke|<v1>) -> <v2>
ret(*|<v2>) L1
@@ -15,7 +15,7 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
== foo ==
fun foo() {
compiler/testData/cfg-variables/basic/VariablesInitialization.instructions
Vendored
+18 -18
View File
@@ -7,21 +7,21 @@ fun foo() {
}
---------------------
L0:
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
2 mark({ val a = 1 val b: Int b = 2 42 })
v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
v(val b: Int) INIT: in: {a=ID} out: {a=ID, b=D}
r(2) -> <v1> INIT: in: {a=ID, b=D} out: {a=ID, b=D} USE: in: {b=ONLY_WRITTEN_NEVER_READ} out: {b=ONLY_WRITTEN_NEVER_READ}
w(b|<v1>) INIT: in: {a=ID, b=D} out: {a=ID, b=ID} USE: in: {} out: {b=ONLY_WRITTEN_NEVER_READ}
r(42) -> <v2> INIT: in: {a=ID, b=ID} out: {a=ID, b=ID}
v(val a = 1) INIT: in: {} out: {}
r(1) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
v(val b: Int) INIT: in: {} out: {b=D}
r(2) -> <v1> INIT: in: {b=D} out: {b=D} USE: in: {b=ONLY_WRITTEN_NEVER_READ} out: {b=ONLY_WRITTEN_NEVER_READ}
w(b|<v1>) INIT: in: {b=D} out: {b=ID} USE: in: {} out: {b=ONLY_WRITTEN_NEVER_READ}
r(42) -> <v2> INIT: in: {b=ID} out: {b=ID}
L1:
1 <END> INIT: in: {a=ID} out: {a=ID}
1 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== bar ==
fun bar(foo: Foo) {
@@ -32,10 +32,10 @@ fun bar(foo: Foo) {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(foo: Foo) INIT: in: {} out: {foo=D}
magic[FAKE_INITIALIZER](foo: Foo) -> <v0> INIT: in: {foo=D} out: {foo=D}
w(foo|<v0>) INIT: in: {foo=D} out: {foo=ID}
2 mark({ foo.c foo.c = 2 42 }) INIT: in: {foo=ID} out: {foo=ID}
v(foo: Foo) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](foo: Foo) -> <v0> INIT: in: {} out: {}
w(foo|<v0>) INIT: in: {} out: {}
2 mark({ foo.c foo.c = 2 42 }) INIT: in: {} out: {}
mark(foo.c)
r(foo) -> <v1>
r(c|<v1>) -> <v2>
@@ -48,7 +48,7 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {foo=READ} out: {foo=READ}
<SINK> USE: in: {} out: {}
=====================
== Foo ==
interface Foo {
@@ -57,11 +57,11 @@ interface Foo {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(var c: Int) INIT: in: {} out: {c=D}
v(var c: Int) INIT: in: {} out: {}
L1:
<END> INIT: in: {c=D} out: {c=D}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/basic/VariablesUsage.instructions
Vendored
+5 -5
View File
@@ -51,15 +51,15 @@ fun use(a: Int) = a
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(a: Int) INIT: in: {} out: {a=D}
magic[FAKE_INITIALIZER](a: Int) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID}
v(a: Int) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](a: Int) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
r(a) -> <v1> INIT: in: {} out: {}
ret(*|<v1>) L1
L1:
<END>
error:
<ERROR>
sink:
<SINK> USE: in: {a=READ} out: {a=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/kt10243.instructions
Vendored
+9 -9
View File
@@ -25,10 +25,10 @@ fun foo(f: Boolean) {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(f: Boolean) INIT: in: {} out: {f=D}
magic[FAKE_INITIALIZER](f: Boolean) -> <v0> INIT: in: {f=D} out: {f=D}
w(f|<v0>) INIT: in: {f=D} out: {f=ID}
2 mark({ try { if (f) { x = 0 } } finally { fun bar() {} } }) INIT: in: {f=ID} out: {f=ID}
v(f: Boolean) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](f: Boolean) -> <v0> INIT: in: {} out: {}
w(f|<v0>) INIT: in: {} out: {}
2 mark({ try { if (f) { x = 0 } } finally { fun bar() {} } }) INIT: in: {} out: {}
mark(try { if (f) { x = 0 } } finally { fun bar() {} })
jmp?(L2)
3 mark({ if (f) { x = 0 } })
@@ -65,13 +65,13 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
== bar ==
fun bar() {}
---------------------
L8:
4 <START> INIT: in: {f=ID} out: {f=ID}
4 <START> INIT: in: {} out: {}
5 mark({})
read (Unit)
L9:
@@ -79,13 +79,13 @@ L9:
error:
<ERROR>
sink:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
== bar ==
fun bar() {}
---------------------
L2 [copy of L8, null]:
4 <START> INIT: in: {f=ID} out: {f=ID}
4 <START> INIT: in: {} out: {}
5 mark({})
read (Unit)
L3 [copy of L9, null]:
@@ -93,5 +93,5 @@ L3 [copy of L9, null]:
L0 [copy of error, null]:
<ERROR>
L1 [copy of sink, null]:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/kt4764.instructions
Vendored
+24 -24
View File
@@ -39,7 +39,7 @@ L4 [start finally]:
5 mark({})
read (Unit)
L5 [finish finally]:
4 ret(*|<v1>) L1 USE: in: {} out: {}
4 ret(*|<v1>) L1 USE: in: {} out: {}
- 3 jmp(L6)
L3 [else branch]:
4 mark({ if (false) { if (false) { var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } } return "fail" } }) INIT: in: {} out: {}
@@ -49,56 +49,56 @@ L3 [else branch]:
5 mark({ if (false) { var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } } return "fail" })
mark(if (false) { var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } })
r(false) -> <v4>
jf(L8|<v4>) USE: in: {} out: {}
jf(L8|<v4>) USE: in: {} out: {}
6 mark({ var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } })
v(var foo: String? = null) INIT: in: {} out: {foo=D}
r(null) -> <v5> INIT: in: {foo=D} out: {foo=D}
w(foo|<v5>) INIT: in: {foo=D} out: {foo=ID}
mark(try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized }) INIT: in: {foo=ID} out: {foo=ID}
jmp?(L9)
jmp?(L10) USE: in: {foo=READ} out: {foo=READ}
jmp?(L10) USE: in: {foo=READ} out: {foo=READ}
7 mark({ foo = "test" })
mark("test")
r("test") -> <v6> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ}
w(foo|<v6>) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ}
r("test") -> <v6> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ}
w(foo|<v6>) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ}
6 jmp?(L9)
jmp?(L10)
jmp(L11)
L9 [onException]:
7 v(e: Exception) INIT: in: {foo=ID} out: {e=D, foo=ID}
magic[FAKE_INITIALIZER](e: Exception) -> <v8> INIT: in: {e=D, foo=ID} out: {e=D, foo=ID}
w(e|<v8>) INIT: in: {e=D, foo=ID} out: {e=ID, foo=ID}
8 mark({ return "fail" }) INIT: in: {e=ID, foo=ID} out: {e=ID, foo=ID}
7 v(e: Exception) INIT: in: {foo=ID} out: {foo=ID}
magic[FAKE_INITIALIZER](e: Exception) -> <v8> INIT: in: {foo=ID} out: {foo=ID}
w(e|<v8>) INIT: in: {foo=ID} out: {foo=ID}
8 mark({ return "fail" }) INIT: in: {foo=ID} out: {foo=ID}
jmp?(L2)
mark("fail")
r("fail") -> <v9>
L12 [start finally]:
9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v10>, !<v11>) -> <v12>
L13 [finish finally]:
5 mark({}) INIT: in: {e=ID} out: {e=ID}
5 mark({}) INIT: in: {} out: {}
read (Unit)
8 ret(*|<v9>) L1 USE: in: {} out: {}
8 ret(*|<v9>) L1 USE: in: {} out: {}
- 7 jmp(L11)
L11 [afterCatches]:
6 jmp(L14) INIT: in: {e=ID, foo=ID} out: {e=ID, foo=ID}
6 jmp(L14) INIT: in: {foo=ID} out: {foo=ID}
L10 [onExceptionToFinallyBlock]:
9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v10>, !<v11>) -> <v12>
5 mark({}) INIT: in: {e=ID} out: {e=ID}
5 mark({}) INIT: in: {} out: {}
read (Unit)
6 jmp(error) USE: in: {} out: {}
6 jmp(error) USE: in: {} out: {}
L14 [skipFinallyToErrorBlock]:
9 mark({ println(foo) // Variable 'foo' must be initialized }) INIT: in: {e=ID, foo=ID} out: {e=ID, foo=ID} USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
9 mark({ println(foo) // Variable 'foo' must be initialized }) INIT: in: {foo=ID} out: {foo=ID} USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v10>, !<v11>) -> <v12>
6 merge(try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized }|!<v7>, !<v13>) -> <v14>
5 jmp(L15) INIT: in: {e=ID} out: {e=ID}
5 jmp(L15) INIT: in: {} out: {}
L8 [else branch]:
read (Unit)
L15 ['if' expression result]:
@@ -108,10 +108,10 @@ L15 ['if' expression result]:
r("fail") -> <v16>
mark({})
read (Unit)
ret(*|<v16>) L1 USE: in: {} out: {}
ret(*|<v16>) L1 USE: in: {} out: {}
- 4 jmp(L16)
L7 [else branch]:
read (Unit) INIT: in: {e=ID} out: {e=ID}
read (Unit) INIT: in: {} out: {}
L16 ['if' expression result]:
merge(if (false) { if (false) { var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } } return "fail" }|!<v17>) -> <v18>
L6 ['if' expression result]:
@@ -133,5 +133,5 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/kt5469.instructions
Vendored
+13 -13
View File
@@ -10,38 +10,38 @@ fun f() {
}
---------------------
L0:
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
2 mark({ var foo = 1 try { foo = 2 throw RuntimeException() } catch (e: Throwable) { println(foo) } })
v(var foo = 1) INIT: in: {} out: {foo=D}
r(1) -> <v0> INIT: in: {foo=D} out: {foo=D}
w(foo|<v0>) INIT: in: {foo=D} out: {foo=ID}
mark(try { foo = 2 throw RuntimeException() } catch (e: Throwable) { println(foo) }) INIT: in: {foo=ID} out: {foo=ID}
jmp?(L2) USE: in: {foo=READ} out: {foo=READ}
jmp?(L2) USE: in: {foo=READ} out: {foo=READ}
3 mark({ foo = 2 throw RuntimeException() })
r(2) -> <v1> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ}
w(foo|<v1>) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ}
r(2) -> <v1> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ}
w(foo|<v1>) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ}
mark(throw RuntimeException())
jmp?(L2) USE: in: {foo=READ} out: {foo=READ}
jmp?(L2) USE: in: {foo=READ} out: {foo=READ}
mark(RuntimeException())
call(RuntimeException(), <init>) -> <v2>
throw (throw RuntimeException()|<v2>) USE: in: {} out: {}
throw (throw RuntimeException()|<v2>) USE: in: {} out: {}
- 2 jmp?(L2)
- jmp(L3)
L2 [onException]:
3 v(e: Throwable) INIT: in: {foo=ID} out: {e=D, foo=ID}
magic[FAKE_INITIALIZER](e: Throwable) -> <v4> INIT: in: {e=D, foo=ID} out: {e=D, foo=ID}
w(e|<v4>) INIT: in: {e=D, foo=ID} out: {e=ID, foo=ID}
4 mark({ println(foo) }) INIT: in: {e=ID, foo=ID} out: {e=ID, foo=ID} USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v5> USE: in: {} out: {foo=READ}
3 v(e: Throwable) INIT: in: {foo=ID} out: {foo=ID}
magic[FAKE_INITIALIZER](e: Throwable) -> <v4> INIT: in: {foo=ID} out: {foo=ID}
w(e|<v4>) INIT: in: {foo=ID} out: {foo=ID}
4 mark({ println(foo) }) INIT: in: {foo=ID} out: {foo=ID} USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v5> USE: in: {} out: {foo=READ}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v5>, !<v6>) -> <v7>
3 jmp(L3)
L3 [afterCatches]:
2 merge(try { foo = 2 throw RuntimeException() } catch (e: Throwable) { println(foo) }|!<v3>, <v7>) -> <v8>
L1:
1 <END> INIT: in: {e=ID} out: {e=ID}
1 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/localObjectInConstructor.instructions
Vendored
+126 -126
View File
@@ -3,17 +3,17 @@ fun println(obj: Any?) {}
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(obj: Any?) INIT: in: {} out: {obj=D}
magic[FAKE_INITIALIZER](obj: Any?) -> <v0> INIT: in: {obj=D} out: {obj=D}
w(obj|<v0>) INIT: in: {obj=D} out: {obj=ID}
2 mark({}) INIT: in: {obj=ID} out: {obj=ID}
v(obj: Any?) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](obj: Any?) -> <v0> INIT: in: {} out: {}
w(obj|<v0>) INIT: in: {} out: {}
2 mark({}) INIT: in: {} out: {}
read (Unit)
L1:
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== Demo0 ==
class Demo0 {
@@ -28,22 +28,22 @@ class Demo0 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = object { fun foo() { println(state) // Ok } }) INIT: in: {} out: {some=D}
mark(object { fun foo() { println(state) // Ok } }) INIT: in: {some=D} out: {some=D}
v(private val some = object { fun foo() { println(state) // Ok } }) INIT: in: {} out: {}
mark(object { fun foo() { println(state) // Ok } }) INIT: in: {} out: {}
jmp?(L2)
d(fun foo() { println(state) // Ok }) USE: in: {state=READ} out: {state=READ}
d(fun foo() { println(state) // Ok }) USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r(object { fun foo() { println(state) // Ok } }) -> <v0>
w(some|<v0>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v1> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v1>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
w(some|<v0>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v1> INIT: in: {state=D} out: {state=D}
w(state|<v1>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -51,10 +51,10 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark({ println(state) // Ok })
magic[IMPLICIT_RECEIVER](state) -> <v0> USE: in: {state=READ} out: {state=READ}
r(state|<v0>) -> <v1> USE: in: {} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v0> USE: in: {state=READ} out: {state=READ}
r(state|<v0>) -> <v1> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v1>) -> <v2>
L4:
@@ -62,7 +62,7 @@ L4:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== Demo1 ==
class Demo1 {
@@ -80,22 +80,22 @@ class Demo1 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = object { fun foo() { if (state) state = true println(state) // must be initialized } }) INIT: in: {} out: {some=D}
mark(object { fun foo() { if (state) state = true println(state) // must be initialized } }) INIT: in: {some=D} out: {some=D}
v(private val some = object { fun foo() { if (state) state = true println(state) // must be initialized } }) INIT: in: {} out: {}
mark(object { fun foo() { if (state) state = true println(state) // must be initialized } }) INIT: in: {} out: {}
jmp?(L2)
d(fun foo() { if (state) state = true println(state) // must be initialized }) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
d(fun foo() { if (state) state = true println(state) // must be initialized }) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r(object { fun foo() { if (state) state = true println(state) // must be initialized } }) -> <v0> INIT: in: {some=D} out: {some=D}
w(some|<v0>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v1> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v1>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
r(object { fun foo() { if (state) state = true println(state) // must be initialized } }) -> <v0> INIT: in: {} out: {}
w(some|<v0>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v1> INIT: in: {state=D} out: {state=D}
w(state|<v1>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -106,30 +106,30 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark({ if (state) state = true println(state) // must be initialized })
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {some=D, state=I} out: {some=D, state=I}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {state=I} out: {state=I}
L5 [else branch]:
read (Unit) INIT: in: {some=D} out: {some=D}
read (Unit) INIT: in: {} out: {}
L6 ['if' expression result]:
merge(if (state) state = true|!<v4>) -> <v5> INIT: in: {some=D, state=I} out: {some=D, state=I}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
merge(if (state) state = true|!<v4>) -> <v5> INIT: in: {state=I} out: {state=I}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L4:
2 <END>
error:
<ERROR> INIT: in: {some=D} out: {some=D}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
=====================
== Demo1A ==
class Demo1A {
@@ -207,22 +207,22 @@ class Demo2 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = object { fun foo() { if (state) state = true else state = false println(state) // OK } }) INIT: in: {} out: {some=D}
mark(object { fun foo() { if (state) state = true else state = false println(state) // OK } }) INIT: in: {some=D} out: {some=D}
v(private val some = object { fun foo() { if (state) state = true else state = false println(state) // OK } }) INIT: in: {} out: {}
mark(object { fun foo() { if (state) state = true else state = false println(state) // OK } }) INIT: in: {} out: {}
jmp?(L2)
d(fun foo() { if (state) state = true else state = false println(state) // OK }) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
d(fun foo() { if (state) state = true else state = false println(state) // OK }) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r(object { fun foo() { if (state) state = true else state = false println(state) // OK } }) -> <v0> INIT: in: {some=D} out: {some=D}
w(some|<v0>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v1> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v1>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
r(object { fun foo() { if (state) state = true else state = false println(state) // OK } }) -> <v0> INIT: in: {} out: {}
w(some|<v0>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v1> INIT: in: {state=D} out: {state=D}
w(state|<v1>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -235,32 +235,32 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark({ if (state) state = true else state = false println(state) // OK })
mark(if (state) state = true else state = false)
magic[IMPLICIT_RECEIVER](state) -> <v0> USE: in: {state=READ} out: {state=READ}
r(state|<v0>) -> <v1> USE: in: {state=WRITTEN_AFTER_READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v0> USE: in: {state=READ} out: {state=READ}
r(state|<v0>) -> <v1> USE: in: {state=WRITTEN_AFTER_READ} out: {state=READ}
jf(L5|<v1>)
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L5 [else branch]:
magic[IMPLICIT_RECEIVER](state) -> <v4> INIT: in: {some=D} out: {some=D}
r(false) -> <v5> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v4>, <v5>) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
magic[IMPLICIT_RECEIVER](state) -> <v4> INIT: in: {} out: {}
r(false) -> <v5> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v4>, <v5>) INIT: in: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
L6 ['if' expression result]:
merge(if (state) state = true else state = false|!<v6>, !<v7>) -> <v8> INIT: in: {some=D, state=I} out: {some=D, state=I}
magic[IMPLICIT_RECEIVER](state) -> <v9> USE: in: {state=READ} out: {state=READ}
r(state|<v9>) -> <v10> USE: in: {} out: {state=READ}
merge(if (state) state = true else state = false|!<v6>, !<v7>) -> <v8> INIT: in: {state=I} out: {state=I}
magic[IMPLICIT_RECEIVER](state) -> <v9> USE: in: {state=READ} out: {state=READ}
r(state|<v9>) -> <v10> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v10>) -> <v11>
L4:
2 <END>
error:
<ERROR> INIT: in: {some=D} out: {some=D}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
=====================
== Demo3 ==
class Demo3 {
@@ -276,25 +276,25 @@ class Demo3 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = run { if (state) state = true println(state) // OK }) INIT: in: {} out: {some=D}
magic[IMPLICIT_RECEIVER](run { if (state) state = true println(state) // OK }) -> <v0> INIT: in: {some=D} out: {some=D}
v(private val some = run { if (state) state = true println(state) // OK }) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](run { if (state) state = true println(state) // OK }) -> <v0> INIT: in: {} out: {}
mark({ if (state) state = true println(state) // OK })
jmp?(L2)
d({ if (state) state = true println(state) // OK }) USE: in: {state=READ} out: {state=READ}
d({ if (state) state = true println(state) // OK }) USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r({ if (state) state = true println(state) // OK }) -> <v1>
mark(run { if (state) state = true println(state) // OK })
call(run { if (state) state = true println(state) // OK }, run|<v0>, <v1>) -> <v2>
w(some|<v2>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v3> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v3>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
w(some|<v2>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v3> INIT: in: {state=D} out: {state=D}
w(state|<v3>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== anonymous_0 ==
{
@@ -305,22 +305,22 @@ sink:
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark(if (state) state = true println(state) // OK)
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6)
L5 [else branch]:
read (Unit)
L6 ['if' expression result]:
merge(if (state) state = true|!<v4>) -> <v5>
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L4:
@@ -328,17 +328,17 @@ L4:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== exec ==
fun <T> exec(f: () -> T): T = f()
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(f: () -> T) INIT: in: {} out: {f=D}
magic[FAKE_INITIALIZER](f: () -> T) -> <v0> INIT: in: {f=D} out: {f=D}
w(f|<v0>) INIT: in: {f=D} out: {f=ID}
r(f) -> <v1> INIT: in: {f=ID} out: {f=ID}
v(f: () -> T) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](f: () -> T) -> <v0> INIT: in: {} out: {}
w(f|<v0>) INIT: in: {} out: {}
r(f) -> <v1> INIT: in: {} out: {}
mark(f())
call(f(), invoke|<v1>) -> <v2>
ret(*|<v2>) L1
@@ -347,7 +347,7 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
== Demo4 ==
class Demo4 {
@@ -363,24 +363,24 @@ class Demo4 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = exec { if (state) state = true println(state) // must be initialized }) INIT: in: {} out: {some=D}
mark({ if (state) state = true println(state) // must be initialized }) INIT: in: {some=D} out: {some=D}
v(private val some = exec { if (state) state = true println(state) // must be initialized }) INIT: in: {} out: {}
mark({ if (state) state = true println(state) // must be initialized }) INIT: in: {} out: {}
jmp?(L2)
d({ if (state) state = true println(state) // must be initialized }) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
d({ if (state) state = true println(state) // must be initialized }) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r({ if (state) state = true println(state) // must be initialized }) -> <v0> INIT: in: {some=D} out: {some=D}
r({ if (state) state = true println(state) // must be initialized }) -> <v0> INIT: in: {} out: {}
mark(exec { if (state) state = true println(state) // must be initialized })
call(exec { if (state) state = true println(state) // must be initialized }, exec|<v0>) -> <v1>
w(some|<v1>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v2> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v2>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
w(some|<v1>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v2> INIT: in: {state=D} out: {state=D}
w(state|<v2>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== anonymous_1 ==
{
@@ -391,30 +391,30 @@ sink:
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark(if (state) state = true println(state) // must be initialized)
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {some=D, state=I} out: {some=D, state=I}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {state=I} out: {state=I}
L5 [else branch]:
read (Unit) INIT: in: {some=D} out: {some=D}
read (Unit) INIT: in: {} out: {}
L6 ['if' expression result]:
merge(if (state) state = true|!<v4>) -> <v5> INIT: in: {some=D, state=I} out: {some=D, state=I}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
merge(if (state) state = true|!<v4>) -> <v5> INIT: in: {state=I} out: {state=I}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L4:
2 <END>
error:
<ERROR> INIT: in: {some=D} out: {some=D}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
=====================
== Demo5 ==
class Demo5 {
@@ -435,19 +435,19 @@ L0:
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v0> INIT: in: {state=D} out: {state=D}
w(state|<v0>) INIT: in: {state=D} out: {state=ID}
v(private val some = object { fun foo() { if (state) state = true println(state) // OK } }) INIT: in: {state=ID} out: {some=D, state=ID}
mark(object { fun foo() { if (state) state = true println(state) // OK } }) INIT: in: {some=D, state=ID} out: {some=D, state=ID}
v(private val some = object { fun foo() { if (state) state = true println(state) // OK } }) INIT: in: {state=ID} out: {state=ID}
mark(object { fun foo() { if (state) state = true println(state) // OK } }) INIT: in: {state=ID} out: {state=ID}
jmp?(L2)
d(fun foo() { if (state) state = true println(state) // OK }) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
d(fun foo() { if (state) state = true println(state) // OK }) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r(object { fun foo() { if (state) state = true println(state) // OK } }) -> <v1> INIT: in: {some=D, state=ID} out: {some=D, state=ID}
w(some|<v1>) INIT: in: {some=D, state=ID} out: {some=ID, state=ID}
r(object { fun foo() { if (state) state = true println(state) // OK } }) -> <v1> INIT: in: {state=ID} out: {state=ID}
w(some|<v1>) INIT: in: {state=ID} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -458,28 +458,28 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {some=D, state=ID} out: {some=D, state=ID}
2 <START> INIT: in: {state=ID} out: {state=ID}
3 mark({ if (state) state = true println(state) // OK })
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6)
L5 [else branch]:
read (Unit)
L6 ['if' expression result]:
merge(if (state) state = true|!<v4>) -> <v5>
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L4:
2 <END>
error:
<ERROR> INIT: in: {some=D} out: {some=D}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
Vendored
+38 -38
View File
@@ -7,19 +7,19 @@ class TestFunctionLiteral {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(val sum: (Int)->Int = { x: Int -> sum(x - 1) + x }) INIT: in: {} out: {sum=D}
mark({ x: Int -> sum(x - 1) + x }) INIT: in: {sum=D} out: {sum=D}
v(val sum: (Int)->Int = { x: Int -> sum(x - 1) + x }) INIT: in: {} out: {}
mark({ x: Int -> sum(x - 1) + x }) INIT: in: {} out: {}
jmp?(L2)
d({ x: Int -> sum(x - 1) + x }) INIT: in: {sum=D, x=ID} out: {sum=D, x=ID}
d({ x: Int -> sum(x - 1) + x }) INIT: in: {} out: {}
L2 [after local declaration]:
r({ x: Int -> sum(x - 1) + x }) -> <v0>
w(sum|<v0>) INIT: in: {sum=D, x=ID} out: {sum=ID, x=ID}
w(sum|<v0>) INIT: in: {} out: {}
L1:
<END> INIT: in: {sum=ID, x=ID} out: {sum=ID, x=ID}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== anonymous_0 ==
{ x: Int ->
@@ -27,11 +27,11 @@ sink:
}
---------------------
L3:
2 <START> INIT: in: {sum=D} out: {sum=D}
v(x: Int) INIT: in: {sum=D} out: {sum=D, x=D}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {sum=D, x=D} out: {sum=D, x=D}
w(x|<v0>) INIT: in: {sum=D, x=D} out: {sum=D, x=ID}
3 mark(sum(x - 1) + x) INIT: in: {sum=D, x=ID} out: {sum=D, x=ID}
2 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {} out: {}
w(x|<v0>) INIT: in: {} out: {}
3 mark(sum(x - 1) + x) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](sum) -> <v1>
r(sum|<v1>) -> <v2>
r(x) -> <v3>
@@ -49,22 +49,22 @@ L4:
error:
<ERROR>
sink:
<SINK> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== A ==
open class A(val a: A)
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(val a: A) INIT: in: {} out: {a=D}
magic[FAKE_INITIALIZER](val a: A) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
v(val a: A) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](val a: A) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
L1:
<END> INIT: in: {a=ID} out: {a=ID}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== TestObjectLiteral ==
class TestObjectLiteral {
@@ -80,28 +80,28 @@ class TestObjectLiteral {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(val obj: A = object: A(obj) { init { val x = obj } fun foo() { val y = obj } }) INIT: in: {} out: {obj=D}
mark(object: A(obj) { init { val x = obj } fun foo() { val y = obj } }) INIT: in: {obj=D} out: {obj=D}
v(val obj: A = object: A(obj) { init { val x = obj } fun foo() { val y = obj } }) INIT: in: {} out: {}
mark(object: A(obj) { init { val x = obj } fun foo() { val y = obj } }) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](obj) -> <v0>
r(obj|<v0>) -> <v1>
mark(A(obj))
call(A(obj), <init>|<v1>) -> <v2>
2 mark({ val x = obj })
v(val x = obj) INIT: in: {obj=D} out: {obj=D, x=D}
magic[IMPLICIT_RECEIVER](obj) -> <v3> INIT: in: {obj=D, x=D} out: {obj=D, x=D}
v(val x = obj) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](obj) -> <v3> INIT: in: {} out: {}
r(obj|<v3>) -> <v4>
w(x|<v4>) INIT: in: {obj=D, x=D} out: {obj=D, x=ID}
1 jmp?(L2) INIT: in: {obj=D, x=ID} out: {obj=D, x=ID}
d(fun foo() { val y = obj }) INIT: in: {obj=D, x=ID, y=ID} out: {obj=D, x=ID, y=ID}
w(x|<v4>) INIT: in: {} out: {}
1 jmp?(L2) INIT: in: {} out: {}
d(fun foo() { val y = obj }) INIT: in: {} out: {}
L2 [after local declaration]:
r(object: A(obj) { init { val x = obj } fun foo() { val y = obj } }) -> <v5>
w(obj|<v5>) INIT: in: {obj=D, x=ID, y=ID} out: {obj=ID, x=ID, y=ID}
w(obj|<v5>) INIT: in: {} out: {}
L1:
<END> INIT: in: {obj=ID, x=ID, y=ID} out: {obj=ID, x=ID, y=ID}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {obj=READ} out: {obj=READ}
<SINK> USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -109,18 +109,18 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {obj=D, x=ID} out: {obj=D, x=ID}
2 <START> INIT: in: {} out: {}
3 mark({ val y = obj })
v(val y = obj) INIT: in: {obj=D, x=ID} out: {obj=D, x=ID, y=D}
magic[IMPLICIT_RECEIVER](obj) -> <v0> INIT: in: {obj=D, x=ID, y=D} out: {obj=D, x=ID, y=D}
v(val y = obj) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](obj) -> <v0> INIT: in: {} out: {}
r(obj|<v0>) -> <v1>
w(y|<v1>) INIT: in: {obj=D, x=ID, y=D} out: {obj=D, x=ID, y=ID}
w(y|<v1>) INIT: in: {} out: {}
L4:
2 <END> INIT: in: {obj=D, x=ID, y=ID} out: {obj=D, x=ID, y=ID}
2 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {obj=READ} out: {obj=READ}
<SINK> USE: in: {} out: {}
=====================
== TestOther ==
class TestOther {
@@ -129,17 +129,17 @@ class TestOther {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(val x: Int = x + 1) INIT: in: {} out: {x=D}
magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {x=D} out: {x=D}
v(val x: Int = x + 1) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {} out: {}
r(x|<v0>) -> <v1>
r(1) -> <v2>
mark(x + 1)
call(x + 1, plus|<v1>, <v2>) -> <v3>
w(x|<v3>) INIT: in: {x=D} out: {x=ID}
w(x|<v3>) INIT: in: {} out: {}
L1:
<END> INIT: in: {x=ID} out: {x=ID}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {x=READ} out: {x=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions
Vendored
+26 -26
View File
@@ -15,72 +15,72 @@ fun foo(numbers: Collection<Int>) {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(numbers: Collection<Int>) INIT: in: {} out: {numbers=D}
magic[FAKE_INITIALIZER](numbers: Collection<Int>) -> <v0> INIT: in: {numbers=D} out: {numbers=D}
w(numbers|<v0>) INIT: in: {numbers=D} out: {numbers=ID}
2 mark({ for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue } }) INIT: in: {numbers=ID} out: {numbers=ID}
v(numbers: Collection<Int>) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](numbers: Collection<Int>) -> <v0> INIT: in: {} out: {}
w(numbers|<v0>) INIT: in: {} out: {}
2 mark({ for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue } }) INIT: in: {} out: {}
3 r(numbers) -> <v1>
mark(numbers)
call(numbers, iterator|<v1>) -> <v2>
v(i) INIT: in: {numbers=ID} out: {i=D, numbers=ID}
v(i) INIT: in: {} out: {}
L2 [loop entry point]:
L6 [condition entry point]:
mark(numbers) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID}
mark(numbers) INIT: in: {} out: {}
call(numbers, hasNext) -> <v3>
jmp?(L3)
mark(numbers)
call(numbers, next) -> <v4>
magic[LOOP_RANGE_ITERATION](numbers|<v4>) -> <v5>
w(i|<v5>) INIT: in: {i=D, numbers=ID} out: {i=ID, numbers=ID}
mark(for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue }) INIT: in: {i=ID, numbers=ID} out: {i=ID, numbers=ID} USE: in: {numbers=READ} out: {numbers=READ}
w(i|<v5>) INIT: in: {} out: {}
mark(for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue }) INIT: in: {} out: {} USE: in: {} out: {}
L4 [body entry point]:
4 mark({ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue })
v(val b: Boolean) INIT: in: {i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
mark(if (1 < 2) { b = false } else { b = true }) INIT: in: {b=D, i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
v(val b: Boolean) INIT: in: {} out: {b=D}
mark(if (1 < 2) { b = false } else { b = true }) INIT: in: {b=D} out: {b=D}
r(1) -> <v6>
r(2) -> <v7>
mark(1 < 2)
call(1 < 2, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>)
5 mark({ b = false })
r(false) -> <v9> USE: in: {b=WRITTEN_AFTER_READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ}
w(b|<v9>) INIT: in: {b=D, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ}
4 jmp(L8) INIT: in: {b=ID, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ, numbers=READ} out: {b=READ, numbers=READ}
r(false) -> <v9> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
w(b|<v9>) INIT: in: {b=D} out: {b=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
4 jmp(L8) INIT: in: {b=ID} out: {b=ID} USE: in: {b=READ} out: {b=READ}
L7 [else branch]:
5 mark({ b = true }) INIT: in: {b=D, i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
r(true) -> <v11> USE: in: {b=WRITTEN_AFTER_READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ}
w(b|<v11>) INIT: in: {b=D, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ}
5 mark({ b = true }) INIT: in: {b=D} out: {b=D}
r(true) -> <v11> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
w(b|<v11>) INIT: in: {b=D} out: {b=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
L8 ['if' expression result]:
4 merge(if (1 < 2) { b = false } else { b = true }|!<v10>, !<v12>) -> <v13> INIT: in: {b=ID, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ, numbers=READ} out: {b=READ, numbers=READ}
r(b) -> <v14> USE: in: {numbers=READ} out: {b=READ, numbers=READ}
4 merge(if (1 < 2) { b = false } else { b = true }|!<v10>, !<v12>) -> <v13> INIT: in: {b=ID} out: {b=ID} USE: in: {b=READ} out: {b=READ}
r(b) -> <v14> USE: in: {} out: {b=READ}
mark(use(b))
call(use(b), use|<v14>) -> <v15>
jmp(L6) USE: in: {numbers=READ} out: {numbers=READ}
jmp(L6) USE: in: {} out: {}
- 3 jmp(L2)
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) INIT: in: {i=ID, numbers=ID} out: {i=ID, numbers=ID}
read (Unit) INIT: in: {} out: {}
L1:
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {numbers=READ} out: {numbers=READ}
<SINK> USE: in: {} out: {}
=====================
== use ==
fun use(vararg a: Any?) = a
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(vararg a: Any?) INIT: in: {} out: {a=D}
magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID}
v(vararg a: Any?) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
r(a) -> <v1> INIT: in: {} out: {}
ret(*|<v1>) L1
L1:
<END>
error:
<ERROR>
sink:
<SINK> USE: in: {a=READ} out: {a=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/forScope.instructions
Vendored
+9 -9
View File
@@ -18,23 +18,23 @@ L0:
call(1..10, rangeTo|<v1>, <v2>) -> <v3>
mark(1..10)
call(1..10, iterator|<v3>) -> <v4>
v(i) INIT: in: {} out: {i=D}
v(i) INIT: in: {} out: {}
L2 [loop entry point]:
L6 [condition entry point]:
mark(1..10) INIT: in: {i=D} out: {i=D}
mark(1..10) INIT: in: {} out: {}
call(1..10, hasNext) -> <v5>
jmp?(L3)
mark(1..10)
call(1..10, next) -> <v6>
magic[LOOP_RANGE_ITERATION](1..10|<v6>) -> <v7>
w(i|<v7>) INIT: in: {i=D} out: {i=ID}
mark(for (i in 1..10) { val a = i }) INIT: in: {i=ID} out: {i=ID}
w(i|<v7>) INIT: in: {} out: {}
mark(for (i in 1..10) { val a = i }) INIT: in: {} out: {}
L4 [body entry point]:
4 mark({ val a = i })
v(val a = i) INIT: in: {i=ID} out: {a=D, i=ID}
r(i) -> <v8> INIT: in: {a=D, i=ID} out: {a=D, i=ID}
w(a|<v8>) INIT: in: {a=D, i=ID} out: {a=ID, i=ID}
3 jmp(L2) INIT: in: {a=ID, i=ID} out: {a=ID, i=ID}
v(val a = i) INIT: in: {} out: {}
r(i) -> <v8> INIT: in: {} out: {}
w(a|<v8>) INIT: in: {} out: {}
3 jmp(L2) INIT: in: {} out: {}
L3 [loop exit point]:
L5 [body exit point]:
read (Unit)
@@ -45,5 +45,5 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {i=READ} out: {i=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions
Vendored
+19 -19
View File
@@ -13,24 +13,24 @@ L0:
2 mark({ "before" val b = 1 val f = { x: Int -> val a = x + b } "after" })
mark("before")
r("before") -> <v0>
v(val b = 1) INIT: in: {} out: {b=D}
r(1) -> <v1> INIT: in: {b=D} out: {b=D}
w(b|<v1>) INIT: in: {b=D} out: {b=ID}
v(val f = { x: Int -> val a = x + b }) INIT: in: {b=ID} out: {b=ID, f=D}
mark({ x: Int -> val a = x + b }) INIT: in: {b=ID, f=D} out: {b=ID, f=D}
v(val b = 1) INIT: in: {} out: {}
r(1) -> <v1> INIT: in: {} out: {}
w(b|<v1>) INIT: in: {} out: {}
v(val f = { x: Int -> val a = x + b }) INIT: in: {} out: {}
mark({ x: Int -> val a = x + b }) INIT: in: {} out: {}
jmp?(L2)
d({ x: Int -> val a = x + b }) INIT: in: {a=ID, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=D, x=ID}
d({ x: Int -> val a = x + b }) INIT: in: {} out: {}
L2 [after local declaration]:
r({ x: Int -> val a = x + b }) -> <v2>
w(f|<v2>) INIT: in: {a=ID, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=ID, x=ID}
mark("after") INIT: in: {a=ID, b=ID, f=ID, x=ID} out: {a=ID, b=ID, f=ID, x=ID}
w(f|<v2>) INIT: in: {} out: {}
mark("after") INIT: in: {} out: {}
r("after") -> <v3>
L1:
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== anonymous_0 ==
{ x: Int ->
@@ -38,21 +38,21 @@ sink:
}
---------------------
L3:
3 <START> INIT: in: {b=ID, f=D} out: {b=ID, f=D}
v(x: Int) INIT: in: {b=ID, f=D} out: {b=ID, f=D, x=D}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {b=ID, f=D, x=D} out: {b=ID, f=D, x=D}
w(x|<v0>) INIT: in: {b=ID, f=D, x=D} out: {b=ID, f=D, x=ID}
4 mark(val a = x + b) INIT: in: {b=ID, f=D, x=ID} out: {b=ID, f=D, x=ID}
v(val a = x + b) INIT: in: {b=ID, f=D, x=ID} out: {a=D, b=ID, f=D, x=ID}
r(x) -> <v1> INIT: in: {a=D, b=ID, f=D, x=ID} out: {a=D, b=ID, f=D, x=ID}
3 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {} out: {}
w(x|<v0>) INIT: in: {} out: {}
4 mark(val a = x + b) INIT: in: {} out: {}
v(val a = x + b) INIT: in: {} out: {}
r(x) -> <v1> INIT: in: {} out: {}
r(b) -> <v2>
mark(x + b)
call(x + b, plus|<v1>, <v2>) -> <v3>
w(a|<v3>) INIT: in: {a=D, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=D, x=ID}
w(a|<v3>) INIT: in: {} out: {}
L4:
3 <END> INIT: in: {a=ID, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=D, x=ID}
3 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/ifScope.instructions
Vendored
+9 -9
View File
@@ -19,17 +19,17 @@ L0:
r(true) -> <v1>
jf(L2|<v1>)
3 mark({ val a = 1 })
v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v2> INIT: in: {a=D} out: {a=D}
w(a|<v2>) INIT: in: {a=D} out: {a=ID}
2 jmp(L3) INIT: in: {a=ID} out: {a=ID}
v(val a = 1) INIT: in: {} out: {}
r(1) -> <v2> INIT: in: {} out: {}
w(a|<v2>) INIT: in: {} out: {}
2 jmp(L3) INIT: in: {} out: {}
L2 [else branch]:
3 mark({ val b = 2 })
v(val b = 2) INIT: in: {a=ID} out: {a=ID, b=D}
r(2) -> <v3> INIT: in: {a=ID, b=D} out: {a=ID, b=D}
w(b|<v3>) INIT: in: {a=ID, b=D} out: {a=ID, b=ID}
v(val b = 2) INIT: in: {} out: {}
r(2) -> <v3> INIT: in: {} out: {}
w(b|<v3>) INIT: in: {} out: {}
L3 ['if' expression result]:
2 merge(if (true) { val a = 1 } else { val b = 2 }|!<v4>, !<v5>) -> <v6> INIT: in: {a=ID, b=ID} out: {a=ID, b=ID}
2 merge(if (true) { val a = 1 } else { val b = 2 }|!<v4>, !<v5>) -> <v6> INIT: in: {} out: {}
mark("after")
r("after") -> <v7>
L1:
@@ -37,5 +37,5 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/localClass.instructions
Vendored
+16 -16
View File
@@ -18,16 +18,16 @@ L0:
mark("before")
r("before") -> <v0>
jmp?(L2)
v(val x: Int) INIT: in: {} out: {x=D}
magic[FAKE_INITIALIZER](val x: Int) -> <v1> INIT: in: {x=D} out: {x=D}
w(x|<v1>) INIT: in: {x=D} out: {x=ID}
3 mark({ val a = x }) INIT: in: {x=ID} out: {x=ID}
v(val a = x) INIT: in: {x=ID} out: {a=D, x=ID}
magic[IMPLICIT_RECEIVER](x) -> <v2> INIT: in: {a=D, x=ID} out: {a=D, x=ID}
v(val x: Int) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](val x: Int) -> <v1> INIT: in: {} out: {}
w(x|<v1>) INIT: in: {} out: {}
3 mark({ val a = x }) INIT: in: {} out: {}
v(val a = x) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](x) -> <v2> INIT: in: {} out: {}
r(x|<v2>) -> <v3>
w(a|<v3>) INIT: in: {a=D, x=ID} out: {a=ID, x=ID}
2 jmp?(L3) INIT: in: {a=ID, x=ID} out: {a=ID, x=ID}
d(fun foo() { val b = x }) INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID}
w(a|<v3>) INIT: in: {} out: {}
2 jmp?(L3) INIT: in: {} out: {}
d(fun foo() { val b = x }) INIT: in: {} out: {}
L2 [after local class]:
L3 [after local declaration]:
mark("after")
@@ -37,7 +37,7 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -45,16 +45,16 @@ fun foo() {
}
---------------------
L4:
3 <START> INIT: in: {a=ID, x=ID} out: {a=ID, x=ID}
3 <START> INIT: in: {} out: {}
4 mark({ val b = x })
v(val b = x) INIT: in: {a=ID, x=ID} out: {a=ID, b=D, x=ID}
magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {a=ID, b=D, x=ID} out: {a=ID, b=D, x=ID}
v(val b = x) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {} out: {}
r(x|<v0>) -> <v1>
w(b|<v1>) INIT: in: {a=ID, b=D, x=ID} out: {a=ID, b=ID, x=ID}
w(b|<v1>) INIT: in: {} out: {}
L5:
3 <END> INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID}
3 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions
Vendored
+16 -16
View File
@@ -13,11 +13,11 @@ L0:
2 mark({ "before" val b = 1 fun local(x: Int) { val a = x + b } "after" })
mark("before")
r("before") -> <v0>
v(val b = 1) INIT: in: {} out: {b=D}
r(1) -> <v1> INIT: in: {b=D} out: {b=D}
w(b|<v1>) INIT: in: {b=D} out: {b=ID}
jmp?(L2) INIT: in: {b=ID} out: {b=ID}
d(fun local(x: Int) { val a = x + b }) INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID}
v(val b = 1) INIT: in: {} out: {}
r(1) -> <v1> INIT: in: {} out: {}
w(b|<v1>) INIT: in: {} out: {}
jmp?(L2) INIT: in: {} out: {}
d(fun local(x: Int) { val a = x + b }) INIT: in: {} out: {}
L2 [after local declaration]:
mark("after")
r("after") -> <v2>
@@ -26,7 +26,7 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== local ==
fun local(x: Int) {
@@ -34,21 +34,21 @@ fun local(x: Int) {
}
---------------------
L3:
3 <START> INIT: in: {b=ID} out: {b=ID}
v(x: Int) INIT: in: {b=ID} out: {b=ID, x=D}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {b=ID, x=D} out: {b=ID, x=D}
w(x|<v0>) INIT: in: {b=ID, x=D} out: {b=ID, x=ID}
4 mark({ val a = x + b }) INIT: in: {b=ID, x=ID} out: {b=ID, x=ID}
v(val a = x + b) INIT: in: {b=ID, x=ID} out: {a=D, b=ID, x=ID}
r(x) -> <v1> INIT: in: {a=D, b=ID, x=ID} out: {a=D, b=ID, x=ID}
3 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {} out: {}
w(x|<v0>) INIT: in: {} out: {}
4 mark({ val a = x + b }) INIT: in: {} out: {}
v(val a = x + b) INIT: in: {} out: {}
r(x) -> <v1> INIT: in: {} out: {}
r(b) -> <v2>
mark(x + b)
call(x + b, plus|<v1>, <v2>) -> <v3>
w(a|<v3>) INIT: in: {a=D, b=ID, x=ID} out: {a=ID, b=ID, x=ID}
w(a|<v3>) INIT: in: {} out: {}
L4:
3 <END> INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID}
3 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions
Vendored
+12 -12
View File
@@ -11,11 +11,11 @@ L0:
2 mark({ "before" val b = 1 fun local(x: Int) = x + b "after" })
mark("before")
r("before") -> <v0>
v(val b = 1) INIT: in: {} out: {b=D}
r(1) -> <v1> INIT: in: {b=D} out: {b=D}
w(b|<v1>) INIT: in: {b=D} out: {b=ID}
jmp?(L2) INIT: in: {b=ID} out: {b=ID}
d(fun local(x: Int) = x + b) INIT: in: {b=ID, x=ID} out: {b=ID, x=ID}
v(val b = 1) INIT: in: {} out: {}
r(1) -> <v1> INIT: in: {} out: {}
w(b|<v1>) INIT: in: {} out: {}
jmp?(L2) INIT: in: {} out: {}
d(fun local(x: Int) = x + b) INIT: in: {} out: {}
L2 [after local declaration]:
mark("after")
r("after") -> <v2>
@@ -24,17 +24,17 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== local ==
fun local(x: Int) = x + b
---------------------
L3:
3 <START> INIT: in: {b=ID} out: {b=ID}
v(x: Int) INIT: in: {b=ID} out: {b=ID, x=D}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {b=ID, x=D} out: {b=ID, x=D}
w(x|<v0>) INIT: in: {b=ID, x=D} out: {b=ID, x=ID}
r(x) -> <v1> INIT: in: {b=ID, x=ID} out: {b=ID, x=ID}
3 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {} out: {}
w(x|<v0>) INIT: in: {} out: {}
r(x) -> <v1> INIT: in: {} out: {}
r(b) -> <v2>
mark(x + b)
call(x + b, plus|<v1>, <v2>) -> <v3>
@@ -44,5 +44,5 @@ L4:
error:
<ERROR>
sink:
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/localObject.instructions
Vendored
+12 -12
View File
@@ -19,11 +19,11 @@ L0:
r("before") -> <v0>
jmp?(L2)
3 mark({ val a = 1 })
v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v1> INIT: in: {a=D} out: {a=D}
w(a|<v1>) INIT: in: {a=D} out: {a=ID}
2 jmp?(L3) INIT: in: {a=ID} out: {a=ID}
d(fun foo() { val b = 2 }) INIT: in: {a=ID, b=ID} out: {a=ID, b=ID}
v(val a = 1) INIT: in: {} out: {}
r(1) -> <v1> INIT: in: {} out: {}
w(a|<v1>) INIT: in: {} out: {}
2 jmp?(L3) INIT: in: {} out: {}
d(fun foo() { val b = 2 }) INIT: in: {} out: {}
L2 [after local class]:
L3 [after local declaration]:
mark("after")
@@ -33,7 +33,7 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -41,15 +41,15 @@ fun foo() {
}
---------------------
L4:
3 <START> INIT: in: {a=ID} out: {a=ID}
3 <START> INIT: in: {} out: {}
4 mark({ val b = 2 })
v(val b = 2) INIT: in: {a=ID} out: {a=ID, b=D}
r(2) -> <v0> INIT: in: {a=ID, b=D} out: {a=ID, b=D}
w(b|<v0>) INIT: in: {a=ID, b=D} out: {a=ID, b=ID}
v(val b = 2) INIT: in: {} out: {}
r(2) -> <v0> INIT: in: {} out: {}
w(b|<v0>) INIT: in: {} out: {}
L5:
3 <END> INIT: in: {a=ID, b=ID} out: {a=ID, b=ID}
3 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.instructions
Vendored
+16 -16
View File
@@ -17,25 +17,25 @@ L0:
2 mark({ "before" val bar = object { init { val x = 1 } fun foo() { val a = 2 } } "after" })
mark("before")
r("before") -> <v0>
v(val bar = object { init { val x = 1 } fun foo() { val a = 2 } }) INIT: in: {} out: {bar=D}
mark(object { init { val x = 1 } fun foo() { val a = 2 } }) INIT: in: {bar=D} out: {bar=D}
v(val bar = object { init { val x = 1 } fun foo() { val a = 2 } }) INIT: in: {} out: {}
mark(object { init { val x = 1 } fun foo() { val a = 2 } }) INIT: in: {} out: {}
3 mark({ val x = 1 })
v(val x = 1) INIT: in: {bar=D} out: {bar=D, x=D}
r(1) -> <v1> INIT: in: {bar=D, x=D} out: {bar=D, x=D}
w(x|<v1>) INIT: in: {bar=D, x=D} out: {bar=D, x=ID}
2 jmp?(L2) INIT: in: {bar=D, x=ID} out: {bar=D, x=ID}
d(fun foo() { val a = 2 }) INIT: in: {a=ID, bar=D, x=ID} out: {a=ID, bar=D, x=ID}
v(val x = 1) INIT: in: {} out: {}
r(1) -> <v1> INIT: in: {} out: {}
w(x|<v1>) INIT: in: {} out: {}
2 jmp?(L2) INIT: in: {} out: {}
d(fun foo() { val a = 2 }) INIT: in: {} out: {}
L2 [after local declaration]:
r(object { init { val x = 1 } fun foo() { val a = 2 } }) -> <v2>
w(bar|<v2>) INIT: in: {a=ID, bar=D, x=ID} out: {a=ID, bar=ID, x=ID}
mark("after") INIT: in: {a=ID, bar=ID, x=ID} out: {a=ID, bar=ID, x=ID}
w(bar|<v2>) INIT: in: {} out: {}
mark("after") INIT: in: {} out: {}
r("after") -> <v3>
L1:
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -43,15 +43,15 @@ fun foo() {
}
---------------------
L3:
3 <START> INIT: in: {bar=D, x=ID} out: {bar=D, x=ID}
3 <START> INIT: in: {} out: {}
4 mark({ val a = 2 })
v(val a = 2) INIT: in: {bar=D, x=ID} out: {a=D, bar=D, x=ID}
r(2) -> <v0> INIT: in: {a=D, bar=D, x=ID} out: {a=D, bar=D, x=ID}
w(a|<v0>) INIT: in: {a=D, bar=D, x=ID} out: {a=ID, bar=D, x=ID}
v(val a = 2) INIT: in: {} out: {}
r(2) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
L4:
3 <END> INIT: in: {a=ID, bar=D, x=ID} out: {a=ID, bar=D, x=ID}
3 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.instructions
Vendored
+10 -10
View File
@@ -20,15 +20,15 @@ L0:
d(get() { return field }) INIT: in: {a=I?} out: {a=I?}
L3 [after local declaration]:
jmp?(L6) INIT: in: {a=D} out: {a=D}
d(set(v: Int) { field = v }) INIT: in: {a=I?, v=ID} out: {a=I?, v=ID}
d(set(v: Int) { field = v }) INIT: in: {a=I?} out: {a=I?}
L1:
L2 [after local class]:
L6 [after local declaration]:
1 <END> INIT: in: {v=ID} out: {v=ID}
1 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {v=READ} out: {v=READ}
<SINK> USE: in: {} out: {}
=====================
== get_a ==
get() {
@@ -45,7 +45,7 @@ L5:
error:
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {a=I?} out: {a=I?} USE: in: {v=READ} out: {v=READ}
<SINK> INIT: in: {a=I?} out: {a=I?} USE: in: {} out: {}
=====================
== set_a ==
set(v: Int) {
@@ -54,16 +54,16 @@ set(v: Int) {
---------------------
L7:
3 <START> INIT: in: {a=D} out: {a=D}
v(v: Int) INIT: in: {a=D} out: {a=D, v=D}
magic[FAKE_INITIALIZER](v: Int) -> <v0> INIT: in: {a=D, v=D} out: {a=D, v=D}
w(v|<v0>) INIT: in: {a=D, v=D} out: {a=D, v=ID}
4 mark({ field = v }) INIT: in: {a=D, v=ID} out: {a=D, v=ID}
v(v: Int) INIT: in: {a=D} out: {a=D}
magic[FAKE_INITIALIZER](v: Int) -> <v0> INIT: in: {a=D} out: {a=D}
w(v|<v0>) INIT: in: {a=D} out: {a=D}
4 mark({ field = v }) INIT: in: {a=D} out: {a=D}
r(v) -> <v1>
w(field|<v1>)
L8:
3 <END>
error:
<ERROR> INIT: in: {v=ID} out: {v=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {a=I?, v=ID} out: {a=I?, v=ID} USE: in: {v=READ} out: {v=READ}
<SINK> INIT: in: {a=I?} out: {a=I?} USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/tryScope.instructions
Vendored
+13 -13
View File
@@ -28,24 +28,24 @@ L0:
jmp?(L3)
jmp(L4)
L2 [onException]:
3 v(e: Exception) INIT: in: {} out: {e=D}
magic[FAKE_INITIALIZER](e: Exception) -> <v2> INIT: in: {e=D} out: {e=D}
w(e|<v2>) INIT: in: {e=D} out: {e=ID}
4 mark({ val a = e }) INIT: in: {e=ID} out: {e=ID}
v(val a = e) INIT: in: {e=ID} out: {a=D, e=ID}
r(e) -> <v3> INIT: in: {a=D, e=ID} out: {a=D, e=ID}
w(a|<v3>) INIT: in: {a=D, e=ID} out: {a=ID, e=ID}
3 jmp(L4) INIT: in: {a=ID, e=ID} out: {a=ID, e=ID}
3 v(e: Exception) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](e: Exception) -> <v2> INIT: in: {} out: {}
w(e|<v2>) INIT: in: {} out: {}
4 mark({ val a = e }) INIT: in: {} out: {}
v(val a = e) INIT: in: {} out: {}
r(e) -> <v3> INIT: in: {} out: {}
w(a|<v3>) INIT: in: {} out: {}
3 jmp(L4) INIT: in: {} out: {}
L4 [afterCatches]:
2 jmp(L5)
L3 [onExceptionToFinallyBlock]:
L6 [start finally]:
3 mark({ val a = 1 })
v(val a = 1) INIT: in: {a=ID, e=ID} out: {a=D, a=ID, e=ID}
r(1) -> <v4> INIT: in: {a=D, a=ID, e=ID} out: {a=D, a=ID, e=ID}
w(a|<v4>) INIT: in: {a=D, a=ID, e=ID} out: {a=ID, a=ID, e=ID}
v(val a = 1) INIT: in: {} out: {}
r(1) -> <v4> INIT: in: {} out: {}
w(a|<v4>) INIT: in: {} out: {}
L7 [finish finally]:
2 jmp(error) INIT: in: {a=ID, a=ID, e=ID} out: {a=ID, a=ID, e=ID}
2 jmp(error) INIT: in: {} out: {}
L5 [skipFinallyToErrorBlock]:
L8 [copy of L3, onExceptionToFinallyBlock]:
3 mark({ val a = 1 })
@@ -60,5 +60,5 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {e=READ} out: {e=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java
+21 -9
View File
@@ -45,7 +45,8 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest {
pseudocodeVariablesData.getVariableUseStatusData();
String initPrefix = " INIT:";
String usePrefix = " USE:";
int initializersColumnWidth = countDataColumnWidth(initPrefix, pseudocode.getInstructionsIncludingDeadCode(), variableInitializers);
int initializersColumnWidth = countDataColumnWidth(initPrefix, pseudocode.getInstructionsIncludingDeadCode(), variableInitializers,
pseudocodeVariablesData);
dumpInstructions(pseudocode, out, (instruction, next, prev) -> {
StringBuilder result = new StringBuilder();
@@ -53,14 +54,14 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest {
Edges<ReadOnlyInitControlFlowInfo> previousInitializersEdges = variableInitializers.get(prev);
String initializersData = "";
if (initializersEdges != null && !initializersEdges.equals(previousInitializersEdges)) {
initializersData = dumpEdgesData(initPrefix, initializersEdges);
initializersData = dumpEdgesData(initPrefix, initializersEdges, pseudocodeVariablesData);
}
result.append(String.format("%1$-" + initializersColumnWidth + "s", initializersData));
Edges<ReadOnlyControlFlowInfo<VariableUseState>> useStatusEdges = useStatusData.get(instruction);
Edges<ReadOnlyControlFlowInfo<VariableUseState>> nextUseStatusEdges = useStatusData.get(next);
if (useStatusEdges != null && !useStatusEdges.equals(nextUseStatusEdges)) {
result.append(dumpEdgesData(usePrefix, useStatusEdges));
result.append(dumpEdgesData(usePrefix, useStatusEdges, pseudocodeVariablesData));
}
return result.toString();
});
@@ -69,13 +70,14 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest {
private static int countDataColumnWidth(
@NotNull String prefix,
@NotNull List<Instruction> instructions,
@NotNull Map<Instruction, Edges<ReadOnlyInitControlFlowInfo>> data
@NotNull Map<Instruction, Edges<ReadOnlyInitControlFlowInfo>> data,
@NotNull PseudocodeVariablesData variablesData
) {
int maxWidth = 0;
for (Instruction instruction : instructions) {
Edges<ReadOnlyInitControlFlowInfo> edges = data.get(instruction);
if (edges == null) continue;
int length = dumpEdgesData(prefix, edges).length();
int length = dumpEdgesData(prefix, edges, variablesData).length();
if (maxWidth < length) {
maxWidth = length;
}
@@ -85,17 +87,27 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest {
}
@NotNull
private static <S, I extends ReadOnlyControlFlowInfo<S>> String dumpEdgesData(String prefix, @NotNull Edges<I> edges) {
private static <S, I extends ReadOnlyControlFlowInfo<S>> String dumpEdgesData(
String prefix,
@NotNull Edges<I> edges,
@NotNull PseudocodeVariablesData variablesData
) {
return prefix +
" in: " + renderVariableMap(edges.getIncoming().asMap()) +
" out: " + renderVariableMap(edges.getOutgoing().asMap());
" in: " + renderVariableMap(edges.getIncoming().asMap(), variablesData) +
" out: " + renderVariableMap(edges.getOutgoing().asMap(), variablesData);
}
private static <S> String renderVariableMap(javaslang.collection.Map<VariableDescriptor, S> map) {
private static <S> String renderVariableMap(
javaslang.collection.Map<VariableDescriptor, S> map,
PseudocodeVariablesData variablesData
) {
List<String> result = Lists.newArrayList();
for (Tuple2<VariableDescriptor, S> entry : map) {
VariableDescriptor variable = entry._1;
S state = entry._2;
if (variablesData.isVariableWithTrivialInitializer(variable)) continue;
result.add(variable.getName() + "=" + state);
}
Collections.sort(result);