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

Update test data for rendered CFA results after optimizations

Browse Source
This commit is contained in:
Denis Zharkov
2017-09-27 14:07:28 +03:00
parent a51078fda6
commit 477aeef90c
23 changed files with 348 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/cfg-variables/bugs/initializationInLocalClass.instructions
Vendored
+7 -7
View File
@@ -10,18 +10,18 @@ fun foo() {
}
---------------------
L0:
1 <START> INIT: in: {} out: {} USE: in: {length=READ} out: {length=READ}
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
2 mark({ var x: String class A { init { x = "" } } x.length })
v(var x: String) INIT: in: {} out: {x=D}
jmp?(L2) INIT: in: {x=D} out: {x=D} USE: in: {length=READ, x=READ} out: {length=READ, x=READ}
jmp?(L2) INIT: in: {x=D} out: {x=D} USE: in: {x=READ} out: {x=READ}
3 mark({ x = "" })
mark("")
r("") -> <v0> USE: in: {length=READ, x=WRITTEN_AFTER_READ} out: {length=READ, x=WRITTEN_AFTER_READ}
w(x|<v0>) INIT: in: {x=D} out: {x=ID} USE: in: {length=READ, x=READ} out: {length=READ, x=WRITTEN_AFTER_READ}
r("") -> <v0> USE: in: {x=WRITTEN_AFTER_READ} out: {x=WRITTEN_AFTER_READ}
w(x|<v0>) INIT: in: {x=D} out: {x=ID} USE: in: {x=READ} out: {x=WRITTEN_AFTER_READ}
L2 [after local class]:
2 mark(x.length) INIT: in: {x=I?D} out: {x=I?D} USE: in: {length=READ, x=READ} out: {length=READ, x=READ}
r(x) -> <v2> USE: in: {length=READ} out: {length=READ, x=READ}
r(length|<v2>) -> <v3> USE: in: {} out: {length=READ}
2 mark(x.length) INIT: in: {x=I?D} out: {x=I?D} USE: in: {x=READ} out: {x=READ}
r(x) -> <v2> USE: in: {} out: {x=READ}
r(length|<v2>) -> <v3>
L1:
1 <END> INIT: in: {} out: {}
error:
compiler/testData/cfg-variables/bugs/kt10243.instructions
Vendored
+18 -18
View File
@@ -32,66 +32,66 @@ L0:
mark(try { if (f) { x = 0 } } finally { fun bar() {} })
jmp?(L2)
3 mark({ if (f) { x = 0 } })
mark(if (f) { x = 0 }) USE: in: {f=READ, x=ONLY_WRITTEN_NEVER_READ} out: {f=READ, x=ONLY_WRITTEN_NEVER_READ}
r(f) -> <v1> USE: in: {x=ONLY_WRITTEN_NEVER_READ} out: {f=READ, x=ONLY_WRITTEN_NEVER_READ}
mark(if (f) { x = 0 })
r(f) -> <v1>
jf(L3|<v1>)
4 mark({ x = 0 })
r(0) -> <v2> USE: in: {x=ONLY_WRITTEN_NEVER_READ} out: {x=ONLY_WRITTEN_NEVER_READ}
w(x|<v2>) INIT: in: {f=ID} out: {f=ID, x=I} USE: in: {} out: {x=ONLY_WRITTEN_NEVER_READ}
3 jmp(L4) INIT: in: {f=ID, x=I} out: {f=ID, x=I}
r(0) -> <v2>
w(x|<v2>)
3 jmp(L4)
L3 [else branch]:
read (Unit) INIT: in: {f=ID} out: {f=ID}
read (Unit)
L4 ['if' expression result]:
merge(if (f) { x = 0 }|!<v3>) -> <v4> INIT: in: {f=ID, x=I} out: {f=ID, x=I}
merge(if (f) { x = 0 }|!<v3>) -> <v4>
2 jmp?(L2)
jmp(L5)
L2 [onExceptionToFinallyBlock]:
L6 [start finally]:
3 mark({ fun bar() {} })
jmp?(L7)
d(fun bar() {}) INIT: in: {f=I, x=I} out: {f=I, x=I}
d(fun bar() {})
L7 [after local declaration]:
L10 [finish finally]:
2 jmp(error) INIT: in: {f=ID, x=I} out: {f=ID, x=I}
2 jmp(error)
L5 [skipFinallyToErrorBlock]:
L11 [copy of L2, onExceptionToFinallyBlock]:
3 mark({ fun bar() {} })
jmp?(L12)
d(fun bar() {}) INIT: in: {f=I, x=I} out: {f=I, x=I}
d(fun bar() {})
L12 [copy of L7, after local declaration]:
2 merge(try { if (f) { x = 0 } } finally { fun bar() {} }|<v4>) -> <v5> INIT: in: {f=ID, x=I} out: {f=ID, x=I}
2 merge(try { if (f) { x = 0 } } finally { fun bar() {} }|<v4>) -> <v5>
L1:
1 <END>
error:
<ERROR>
sink:
<SINK> INIT: in: {f=I, x=I} out: {f=I, x=I} USE: in: {} out: {}
<SINK> USE: in: {f=READ} out: {f=READ}
=====================
== bar ==
fun bar() {}
---------------------
L8:
4 <START> INIT: in: {f=ID, x=I} out: {f=ID, x=I}
4 <START> INIT: in: {f=ID} out: {f=ID}
5 mark({})
read (Unit)
L9:
4 <END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {f=I, x=I} out: {f=I, x=I} USE: in: {} out: {}
<SINK> USE: in: {f=READ} out: {f=READ}
=====================
== bar ==
fun bar() {}
---------------------
L2 [copy of L8, null]:
4 <START> INIT: in: {f=ID, x=I} out: {f=ID, x=I}
4 <START> INIT: in: {f=ID} out: {f=ID}
5 mark({})
read (Unit)
L3 [copy of L9, null]:
4 <END>
L0 [copy of error, null]:
<ERROR> INIT: in: {} out: {}
<ERROR>
L1 [copy of sink, null]:
<SINK> INIT: in: {f=I, x=I} out: {f=I, x=I} USE: in: {} out: {}
<SINK> USE: in: {f=READ} out: {f=READ}
=====================
compiler/testData/cfg-variables/bugs/kt4764.instructions
Vendored
+6 -6
View File
@@ -78,27 +78,27 @@ L12 [start finally]:
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v10>, !<v11>) -> <v12>
L13 [finish finally]:
5 mark({}) INIT: in: {} out: {}
5 mark({}) INIT: in: {e=ID} out: {e=ID}
read (Unit)
8 ret(*|<v9>) L1 USE: in: {} out: {}
- 7 jmp(L11)
L11 [afterCatches]:
6 jmp(L14) INIT: in: {foo=ID} out: {foo=ID}
6 jmp(L14) INIT: in: {e=ID, foo=ID} out: {e=ID, 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}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v10>, !<v11>) -> <v12>
5 mark({}) INIT: in: {} out: {}
5 mark({}) INIT: in: {e=ID} out: {e=ID}
read (Unit)
6 jmp(error) USE: in: {} out: {}
L14 [skipFinallyToErrorBlock]:
9 mark({ println(foo) // Variable 'foo' must be initialized }) INIT: in: {foo=ID} out: {foo=ID} USE: in: {foo=READ} out: {foo=READ}
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}
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: {} out: {}
5 jmp(L15) INIT: in: {e=ID} out: {e=ID}
L8 [else branch]:
read (Unit)
L15 ['if' expression result]:
@@ -111,7 +111,7 @@ L15 ['if' expression result]:
ret(*|<v16>) L1 USE: in: {} out: {}
- 4 jmp(L16)
L7 [else branch]:
read (Unit) INIT: in: {} out: {}
read (Unit) INIT: in: {e=ID} out: {e=ID}
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]:
compiler/testData/cfg-variables/bugs/kt5469.instructions
Vendored
+2 -2
View File
@@ -37,9 +37,9 @@ L2 [onException]:
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> INIT: in: {foo=ID} out: {foo=ID}
2 merge(try { foo = 2 throw RuntimeException() } catch (e: Throwable) { println(foo) }|!<v3>, <v7>) -> <v8>
L1:
1 <END> INIT: in: {} out: {}
1 <END> INIT: in: {e=ID} out: {e=ID}
error:
<ERROR>
sink:
compiler/testData/cfg-variables/bugs/localObjectInConstructor.instructions
Vendored
+74 -74
View File
@@ -11,9 +11,9 @@ L0:
L1:
1 <END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {obj=I?} out: {obj=I?} USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== Demo0 ==
class Demo0 {
@@ -31,9 +31,9 @@ L0:
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}
jmp?(L2)
d(fun foo() { println(state) // Ok }) INIT: in: {some=I?} out: {some=I?} 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> INIT: in: {some=D} out: {some=D}
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}
@@ -41,9 +41,9 @@ L2 [after local declaration]:
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR> INIT: in: {some=ID} out: {some=ID}
sink:
<SINK> INIT: in: {some=I?, state=I?} out: {some=I?, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -53,16 +53,16 @@ fun foo() {
L3:
2 <START> INIT: in: {some=D} out: {some=D}
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:
2 <END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {some=I?} out: {some=I?} USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== Demo1 ==
class Demo1 {
@@ -83,7 +83,7 @@ L0:
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}
jmp?(L2)
d(fun foo() { if (state) state = true println(state) // must be initialized }) INIT: in: {some=I?, state=I} out: {some=I?, state=I} USE: in: {state=READ} out: {state=READ}
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}
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}
@@ -93,9 +93,9 @@ L2 [after local declaration]:
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR> INIT: in: {some=ID} out: {some=ID}
sink:
<SINK> INIT: in: {some=I?, state=I?} out: {some=I?, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -111,25 +111,25 @@ L3:
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}
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}
L5 [else branch]:
read (Unit) INIT: in: {some=D} out: {some=D}
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}
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: {} out: {}
<ERROR> INIT: in: {some=D} out: {some=D}
sink:
<SINK> INIT: in: {some=I?, state=I} out: {some=I?, state=I} USE: in: {} out: {}
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
=====================
== Demo1A ==
class Demo1A {
@@ -169,25 +169,25 @@ L0:
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L2|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L2|<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: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L3) INIT: in: {state=I} out: {state=I}
r(true) -> <v3>
w(state|<v2>, <v3>)
jmp(L3)
L2 [else branch]:
read (Unit) INIT: in: {} out: {}
read (Unit)
L3 ['if' expression result]:
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}
merge(if (state) state = true|!<v4>) -> <v5>
magic[IMPLICIT_RECEIVER](state) -> <v6>
r(state|<v6>) -> <v7>
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L1:
1 <END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== Demo2 ==
class Demo2 {
@@ -210,7 +210,7 @@ L0:
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}
jmp?(L2)
d(fun foo() { if (state) state = true else state = false println(state) // OK }) INIT: in: {some=I?, state=I} out: {some=I?, state=I} USE: in: {state=READ} out: {state=READ}
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}
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}
@@ -220,9 +220,9 @@ L2 [after local declaration]:
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR> INIT: in: {some=ID} out: {some=ID}
sink:
<SINK> INIT: in: {some=I?, state=I?} out: {some=I?, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -238,29 +238,29 @@ L3:
2 <START> INIT: in: {some=D} out: {some=D}
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: {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}
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}
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}
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}
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: {} out: {}
<ERROR> INIT: in: {some=D} out: {some=D}
sink:
<SINK> INIT: in: {some=I?, state=I} out: {some=I?, state=I} USE: in: {} out: {}
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
=====================
== Demo3 ==
class Demo3 {
@@ -280,9 +280,9 @@ L0:
magic[IMPLICIT_RECEIVER](run { if (state) state = true println(state) // OK }) -> <v0> INIT: in: {some=D} out: {some=D}
mark({ if (state) state = true println(state) // OK })
jmp?(L2)
d({ if (state) state = true println(state) // OK }) INIT: in: {some=I?} out: {some=I?} 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> INIT: in: {some=D} out: {some=D}
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}
@@ -292,9 +292,9 @@ L2 [after local declaration]:
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR> INIT: in: {some=ID} out: {some=ID}
sink:
<SINK> INIT: in: {some=I?, state=I?} out: {some=I?, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
=====================
== anonymous_0 ==
{
@@ -310,25 +310,25 @@ L3:
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: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {some=I?} out: {some=I?} USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== exec ==
fun <T> exec(f: () -> T): T = f()
@@ -337,17 +337,17 @@ 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} USE: in: {f=READ} out: {f=READ}
r(f) -> <v1> INIT: in: {f=ID} out: {f=ID} USE: in: {} out: {f=READ}
w(f|<v0>) INIT: in: {f=D} out: {f=ID}
r(f) -> <v1> INIT: in: {f=ID} out: {f=ID}
mark(f())
call(f(), invoke|<v1>) -> <v2>
ret(*|<v2>) L1
L1:
<END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {f=I?} out: {f=I?} USE: in: {} out: {}
<SINK> USE: in: {f=READ} out: {f=READ}
=====================
== Demo4 ==
class Demo4 {
@@ -366,7 +366,7 @@ L0:
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}
jmp?(L2)
d({ if (state) state = true println(state) // must be initialized }) INIT: in: {some=I?, state=I} out: {some=I?, state=I} USE: in: {state=READ} out: {state=READ}
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}
L2 [after local declaration]:
r({ if (state) state = true println(state) // must be initialized }) -> <v0> INIT: in: {some=D} out: {some=D}
mark(exec { if (state) state = true println(state) // must be initialized })
@@ -378,9 +378,9 @@ L2 [after local declaration]:
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR> INIT: in: {some=ID} out: {some=ID}
sink:
<SINK> INIT: in: {some=I?, state=I?} out: {some=I?, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
=====================
== anonymous_1 ==
{
@@ -396,25 +396,25 @@ L3:
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}
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}
L5 [else branch]:
read (Unit) INIT: in: {some=D} out: {some=D}
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}
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: {} out: {}
<ERROR> INIT: in: {some=D} out: {some=D}
sink:
<SINK> INIT: in: {some=I?, state=I} out: {some=I?, state=I} USE: in: {} out: {}
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
=====================
== Demo5 ==
class Demo5 {
@@ -438,16 +438,16 @@ L0:
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}
jmp?(L2)
d(fun foo() { if (state) state = true println(state) // OK }) INIT: in: {some=I?, state=I} out: {some=I?, state=I} USE: in: {state=READ} out: {state=READ}
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}
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}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR> INIT: in: {some=ID} out: {some=ID}
sink:
<SINK> INIT: in: {some=I?, state=I?} out: {some=I?, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -479,7 +479,7 @@ L6 ['if' expression result]:
L4:
2 <END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR> INIT: in: {some=D} out: {some=D}
sink:
<SINK> INIT: in: {some=I?, state=I} out: {some=I?, state=I} USE: in: {} out: {}
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
Vendored
+33 -33
View File
@@ -10,16 +10,16 @@ L0:
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}
jmp?(L2)
d({ x: Int -> sum(x - 1) + x }) INIT: in: {sum=I?} out: {sum=I?} USE: in: {sum=READ} out: {sum=READ}
d({ x: Int -> sum(x - 1) + x }) INIT: in: {sum=D, x=ID} out: {sum=D, x=ID}
L2 [after local declaration]:
r({ x: Int -> sum(x - 1) + x }) -> <v0> INIT: in: {sum=D} out: {sum=D}
w(sum|<v0>) INIT: in: {sum=D} out: {sum=ID}
r({ x: Int -> sum(x - 1) + x }) -> <v0>
w(sum|<v0>) INIT: in: {sum=D, x=ID} out: {sum=ID, x=ID}
L1:
<END> INIT: in: {sum=ID} out: {sum=ID}
<END> INIT: in: {sum=ID, x=ID} out: {sum=ID, x=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {sum=I?} out: {sum=I?} USE: in: {} out: {}
<SINK> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
=====================
== anonymous_0 ==
{ x: Int ->
@@ -32,24 +32,24 @@ L3:
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}
magic[IMPLICIT_RECEIVER](sum) -> <v1> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
r(sum|<v1>) -> <v2> USE: in: {x=READ} out: {sum=READ, x=READ}
magic[IMPLICIT_RECEIVER](sum) -> <v1>
r(sum|<v1>) -> <v2>
r(x) -> <v3>
r(1) -> <v4>
mark(x - 1)
call(x - 1, minus|<v3>, <v4>) -> <v5>
mark(sum(x - 1))
call(sum(x - 1), invoke|<v2>, <v5>) -> <v6> USE: in: {x=READ} out: {x=READ}
r(x) -> <v7> USE: in: {} out: {x=READ}
call(sum(x - 1), invoke|<v2>, <v5>) -> <v6>
r(x) -> <v7>
mark(sum(x - 1) + x)
call(sum(x - 1) + x, plus|<v6>, <v7>) -> <v8>
2 ret(*|<v8>) L4
L4:
<END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {sum=I?, x=I?} out: {sum=I?, x=I?} USE: in: {} out: {}
<SINK> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
=====================
== A ==
open class A(val a: A)
@@ -62,9 +62,9 @@ L0:
L1:
<END> INIT: in: {a=ID} out: {a=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {a=I?} out: {a=I?} USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== TestObjectLiteral ==
class TestObjectLiteral {
@@ -91,17 +91,17 @@ L0:
magic[IMPLICIT_RECEIVER](obj) -> <v3> INIT: in: {obj=D, x=D} out: {obj=D, x=D}
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} out: {obj=D}
d(fun foo() { val y = obj }) INIT: in: {obj=I?} out: {obj=I?} USE: in: {obj=READ} out: {obj=READ}
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}
L2 [after local declaration]:
r(object: A(obj) { init { val x = obj } fun foo() { val y = obj } }) -> <v5> INIT: in: {obj=D} out: {obj=D}
w(obj|<v5>) INIT: in: {obj=D} out: {obj=ID}
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}
L1:
<END> INIT: in: {obj=ID} out: {obj=ID}
<END> INIT: in: {obj=ID, x=ID, y=ID} out: {obj=ID, x=ID, y=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {obj=I?} out: {obj=I?} USE: in: {} out: {}
<SINK> USE: in: {obj=READ} out: {obj=READ}
=====================
== foo ==
fun foo() {
@@ -109,18 +109,18 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {obj=D} out: {obj=D}
2 <START> INIT: in: {obj=D, x=ID} out: {obj=D, x=ID}
3 mark({ val y = obj })
v(val y = obj) INIT: in: {obj=D} out: {obj=D, y=D}
magic[IMPLICIT_RECEIVER](obj) -> <v0> INIT: in: {obj=D, y=D} out: {obj=D, y=D} USE: in: {obj=READ} out: {obj=READ}
r(obj|<v0>) -> <v1> USE: in: {} out: {obj=READ}
w(y|<v1>) INIT: in: {obj=D, y=D} out: {obj=D, y=ID}
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}
r(obj|<v0>) -> <v1>
w(y|<v1>) INIT: in: {obj=D, x=ID, y=D} out: {obj=D, x=ID, y=ID}
L4:
2 <END> INIT: in: {obj=D} out: {obj=D}
2 <END> INIT: in: {obj=D, x=ID, y=ID} out: {obj=D, x=ID, y=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {obj=I?} out: {obj=I?} USE: in: {} out: {}
<SINK> USE: in: {obj=READ} out: {obj=READ}
=====================
== TestOther ==
class TestOther {
@@ -130,8 +130,8 @@ 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} USE: in: {x=READ} out: {x=READ}
r(x|<v0>) -> <v1> USE: in: {} out: {x=READ}
magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {x=D} out: {x=D}
r(x|<v0>) -> <v1>
r(1) -> <v2>
mark(x + 1)
call(x + 1, plus|<v1>, <v2>) -> <v3>
@@ -139,7 +139,7 @@ L0:
L1:
<END> INIT: in: {x=ID} out: {x=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {x=I?} out: {x=I?} USE: in: {} out: {}
<SINK> USE: in: {x=READ} out: {x=READ}
=====================
compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions
Vendored
+21 -21
View File
@@ -18,21 +18,21 @@ L0:
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} USE: in: {numbers=READ} out: {numbers=READ}
3 r(numbers) -> <v1> USE: in: {} out: {numbers=READ}
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}
3 r(numbers) -> <v1>
mark(numbers)
call(numbers, iterator|<v1>) -> <v2>
v(i) INIT: in: {numbers=ID} out: {i=D, numbers=ID}
L2 [loop entry point]:
L6 [condition entry point]:
mark(numbers) INIT: in: {i=I?D, numbers=ID} out: {i=I?D, numbers=ID}
mark(numbers) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID}
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=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: {} out: {}
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}
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}
@@ -43,29 +43,29 @@ L4 [body entry point]:
call(1 < 2, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>)
5 mark({ b = false })
r(false) -> <v9> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
w(b|<v9>) INIT: in: {b=D, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
4 jmp(L8) INIT: in: {b=ID, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ} out: {b=READ}
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}
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} out: {b=WRITTEN_AFTER_READ}
w(b|<v11>) INIT: in: {b=D, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
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}
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} out: {b=READ}
r(b) -> <v14> USE: in: {} out: {b=READ}
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}
mark(use(b))
call(use(b), use|<v14>) -> <v15>
jmp(L6) USE: in: {} out: {}
jmp(L6) USE: in: {numbers=READ} out: {numbers=READ}
- 3 jmp(L2)
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) INIT: in: {i=I?D, numbers=ID} out: {i=I?D, numbers=ID}
read (Unit) INIT: in: {i=ID, numbers=ID} out: {i=ID, numbers=ID}
L1:
1 <END> INIT: in: {numbers=ID} out: {numbers=ID}
1 <END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {numbers=I?} out: {numbers=I?} USE: in: {} out: {}
<SINK> USE: in: {numbers=READ} out: {numbers=READ}
=====================
== use ==
fun use(vararg a: Any?) = a
@@ -74,13 +74,13 @@ 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} USE: in: {a=READ} out: {a=READ}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID}
ret(*|<v1>) L1
L1:
<END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {a=I?} out: {a=I?} USE: in: {} out: {}
<SINK> USE: in: {a=READ} out: {a=READ}
=====================