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/lexicalScopes/forScope.instructions
Vendored
+7 -7
View File
@@ -11,7 +11,7 @@ L0:
1 <START> INIT: in: {} out: {}
2 mark({ "before" for (i in 1..10) { val a = i } "after" })
mark("before")
r("before") -> <v0> USE: in: {} out: {}
r("before") -> <v0>
3 r(1) -> <v1>
r(10) -> <v2>
mark(1..10)
@@ -21,29 +21,29 @@ L0:
v(i) INIT: in: {} out: {i=D}
L2 [loop entry point]:
L6 [condition entry point]:
mark(1..10) INIT: in: {i=I?D} out: {i=I?D}
mark(1..10) INIT: in: {i=D} out: {i=D}
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=I?D} out: {i=ID}
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}
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: {i=ID} out: {i=ID} USE: in: {i=READ} out: {i=READ}
3 jmp(L2) INIT: in: {a=ID, i=ID} out: {a=ID, i=ID}
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) INIT: in: {i=I?D} out: {i=I?D}
2 mark("after") INIT: in: {} out: {}
read (Unit)
2 mark("after")
r("after") -> <v9>
L1:
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {i=READ} out: {i=READ}
=====================
compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions
Vendored
+13 -13
View File
@@ -9,7 +9,7 @@ fun foo() {
}
---------------------
L0:
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
1 <START> INIT: in: {} out: {}
2 mark({ "before" val b = 1 val f = { x: Int -> val a = x + b } "after" })
mark("before")
r("before") -> <v0>
@@ -19,18 +19,18 @@ L0:
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}
jmp?(L2)
d({ x: Int -> val a = x + b }) INIT: in: {b=I, f=I?} out: {b=I, f=I?} USE: in: {b=READ} out: {b=READ}
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}
L2 [after local declaration]:
r({ x: Int -> val a = x + b }) -> <v2> INIT: in: {b=ID, f=D} out: {b=ID, f=D}
w(f|<v2>) INIT: in: {b=ID, f=D} out: {b=ID, f=ID}
mark("after") INIT: in: {b=ID, f=ID} out: {b=ID, f=ID}
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}
r("after") -> <v3>
L1:
1 <END> INIT: in: {} out: {}
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
=====================
== anonymous_0 ==
{ x: Int ->
@@ -43,16 +43,16 @@ L3:
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} USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
r(x) -> <v1> INIT: in: {a=D, b=ID, f=D, x=ID} out: {a=D, b=ID, f=D, x=ID} USE: in: {b=READ} out: {b=READ, x=READ}
r(b) -> <v2> USE: in: {} out: {b=READ}
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}
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}
L4:
3 <END> INIT: in: {b=ID, f=D, x=ID} out: {b=ID, f=D, x=ID}
3 <END> INIT: in: {a=ID, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=D, x=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {b=I, f=I?, x=I?} out: {b=I, f=I?, x=I?} USE: in: {} out: {}
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
=====================
compiler/testData/cfg-variables/lexicalScopes/ifScope.instructions
Vendored
+7 -7
View File
@@ -22,14 +22,14 @@ L0:
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: {} out: {}
2 jmp(L3) INIT: in: {a=ID} out: {a=ID}
L2 [else branch]:
3 mark({ val b = 2 })
v(val b = 2) INIT: in: {} out: {b=D}
r(2) -> <v3> INIT: in: {b=D} out: {b=D}
w(b|<v3>) INIT: in: {b=D} out: {b=ID}
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}
L3 ['if' expression result]:
2 merge(if (true) { val a = 1 } else { val b = 2 }|!<v4>, !<v5>) -> <v6> INIT: in: {} out: {}
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}
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
+13 -13
View File
@@ -26,18 +26,18 @@ L0:
magic[IMPLICIT_RECEIVER](x) -> <v2> INIT: in: {a=D, x=ID} out: {a=D, x=ID}
r(x|<v2>) -> <v3>
w(a|<v3>) INIT: in: {a=D, x=ID} out: {a=ID, x=ID}
2 jmp?(L3) INIT: in: {x=ID} out: {x=ID}
d(fun foo() { val b = x }) INIT: in: {x=I} out: {x=I} USE: in: {x=READ} out: {x=READ}
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}
L2 [after local class]:
L3 [after local declaration]:
mark("after") INIT: in: {x=I?} out: {x=I?}
mark("after")
r("after") -> <v4>
L1:
1 <END> INIT: in: {} out: {}
1 <END>
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: {x=ID} out: {x=ID}
3 <START> INIT: in: {a=ID, x=ID} out: {a=ID, x=ID}
4 mark({ val b = x })
v(val b = x) INIT: in: {x=ID} out: {b=D, x=ID}
magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {b=D, x=ID} out: {b=D, x=ID} USE: in: {x=READ} out: {x=READ}
r(x|<v0>) -> <v1> USE: in: {} out: {x=READ}
w(b|<v1>) INIT: in: {b=D, x=ID} out: {b=ID, x=ID}
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}
r(x|<v0>) -> <v1>
w(b|<v1>) INIT: in: {a=ID, b=D, x=ID} out: {a=ID, b=ID, x=ID}
L5:
3 <END> INIT: in: {x=ID} out: {x=ID}
3 <END> INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {x=I} out: {x=I} USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions
Vendored
+12 -12
View File
@@ -9,7 +9,7 @@ fun foo() {
}
---------------------
L0:
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
1 <START> INIT: in: {} out: {}
2 mark({ "before" val b = 1 fun local(x: Int) { val a = x + b } "after" })
mark("before")
r("before") -> <v0>
@@ -17,16 +17,16 @@ L0:
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: {b=I} out: {b=I} USE: in: {b=READ} out: {b=READ}
d(fun local(x: Int) { val a = x + b }) INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID}
L2 [after local declaration]:
mark("after") INIT: in: {b=ID} out: {b=ID}
mark("after")
r("after") -> <v2>
L1:
1 <END> INIT: in: {} out: {}
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
=====================
== local ==
fun local(x: Int) {
@@ -39,16 +39,16 @@ L3:
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} USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
r(x) -> <v1> INIT: in: {a=D, b=ID, x=ID} out: {a=D, b=ID, x=ID} USE: in: {b=READ} out: {b=READ, x=READ}
r(b) -> <v2> USE: in: {} out: {b=READ}
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}
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}
L4:
3 <END> INIT: in: {b=ID, x=ID} out: {b=ID, x=ID}
3 <END> INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {b=I, x=I?} out: {b=I, x=I?} USE: in: {} out: {}
=====================
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
=====================
compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions
Vendored
+11 -11
View File
@@ -7,7 +7,7 @@ fun foo() {
}
---------------------
L0:
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
1 <START> INIT: in: {} out: {}
2 mark({ "before" val b = 1 fun local(x: Int) = x + b "after" })
mark("before")
r("before") -> <v0>
@@ -15,16 +15,16 @@ L0:
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=I} out: {b=I} USE: in: {b=READ} out: {b=READ}
d(fun local(x: Int) = x + b) INIT: in: {b=ID, x=ID} out: {b=ID, x=ID}
L2 [after local declaration]:
mark("after") INIT: in: {b=ID} out: {b=ID}
mark("after")
r("after") -> <v2>
L1:
1 <END> INIT: in: {} out: {}
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
=====================
== local ==
fun local(x: Int) = x + b
@@ -33,16 +33,16 @@ 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} USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
r(x) -> <v1> INIT: in: {b=ID, x=ID} out: {b=ID, x=ID} USE: in: {b=READ} out: {b=READ, x=READ}
r(b) -> <v2> USE: in: {} out: {b=READ}
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}
r(b) -> <v2>
mark(x + b)
call(x + b, plus|<v1>, <v2>) -> <v3>
ret(*|<v3>) L4
L4:
<END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {b=I, x=I?} out: {b=I, x=I?} USE: in: {} out: {}
=====================
<SINK> USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
=====================
compiler/testData/cfg-variables/lexicalScopes/localObject.instructions
Vendored
+9 -9
View File
@@ -22,8 +22,8 @@ L0:
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: {} out: {}
d(fun foo() { val b = 2 })
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}
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: {} out: {}
3 <START> INIT: in: {a=ID} out: {a=ID}
4 mark({ val b = 2 })
v(val b = 2) INIT: in: {} out: {b=D}
r(2) -> <v0> INIT: in: {b=D} out: {b=D}
w(b|<v0>) INIT: in: {b=D} out: {b=ID}
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}
L5:
3 <END> INIT: in: {} out: {}
3 <END> INIT: in: {a=ID, b=ID} out: {a=ID, b=ID}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.instructions
Vendored
+15 -15
View File
@@ -23,19 +23,19 @@ L0:
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} out: {bar=D}
d(fun foo() { val a = 2 }) INIT: in: {bar=I?} out: {bar=I?}
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}
L2 [after local declaration]:
r(object { init { val x = 1 } fun foo() { val a = 2 } }) -> <v2> INIT: in: {bar=D} out: {bar=D}
w(bar|<v2>) INIT: in: {bar=D} out: {bar=ID}
mark("after") INIT: in: {bar=ID} out: {bar=ID}
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}
r("after") -> <v3>
L1:
1 <END> INIT: in: {} out: {}
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} out: {bar=D}
3 <START> INIT: in: {bar=D, x=ID} out: {bar=D, x=ID}
4 mark({ val a = 2 })
v(val a = 2) INIT: in: {bar=D} out: {a=D, bar=D}
r(2) -> <v0> INIT: in: {a=D, bar=D} out: {a=D, bar=D}
w(a|<v0>) INIT: in: {a=D, bar=D} out: {a=ID, bar=D}
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}
L4:
3 <END> INIT: in: {bar=D} out: {bar=D}
3 <END> INIT: in: {a=ID, bar=D, x=ID} out: {a=ID, bar=D, x=ID}
error:
<ERROR> INIT: in: {} out: {}
<ERROR>
sink:
<SINK> INIT: in: {bar=I?} out: {bar=I?} USE: in: {} out: {}
=====================
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.instructions
Vendored
+14 -14
View File
@@ -16,19 +16,19 @@ L0:
2 mark({ class A { var a : Int get() { return field } set(v: Int) { field = v } } })
jmp?(L2)
v(var a : Int get() { return field } set(v: Int) { field = v }) INIT: in: {} out: {a=D}
jmp?(L3) INIT: in: {a=D} out: {a=D} USE: in: {field=ONLY_WRITTEN_NEVER_READ, field=READ} out: {field=ONLY_WRITTEN_NEVER_READ, field=READ}
d(get() { return field }) INIT: in: {a=I?} out: {a=I?} USE: in: {field=READ} out: {field=READ}
jmp?(L3) INIT: in: {a=D} out: {a=D}
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?, field=I} out: {a=I?, field=I} USE: in: {field=ONLY_WRITTEN_NEVER_READ} out: {field=ONLY_WRITTEN_NEVER_READ}
d(set(v: Int) { field = v }) INIT: in: {a=I?, v=ID} out: {a=I?, v=ID}
L1:
L2 [after local class]:
L6 [after local declaration]:
1 <END> INIT: in: {} out: {}
1 <END> INIT: in: {v=ID} out: {v=ID}
error:
<ERROR>
sink:
<SINK> INIT: in: {field=I} out: {field=I} USE: in: {} out: {}
<SINK> USE: in: {v=READ} out: {v=READ}
=====================
== get_a ==
get() {
@@ -37,15 +37,15 @@ get() {
---------------------
L4:
3 <START> INIT: in: {a=D} out: {a=D}
4 mark({ return field }) USE: in: {field=READ} out: {field=READ}
r(field) -> <v0> USE: in: {} out: {field=READ}
4 mark({ return field })
r(field) -> <v0>
ret(*|<v0>) L5
L5:
3 <END>
error:
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {a=I?} out: {a=I?} USE: in: {} out: {}
<SINK> INIT: in: {a=I?} out: {a=I?} USE: in: {v=READ} out: {v=READ}
=====================
== set_a ==
set(v: Int) {
@@ -57,13 +57,13 @@ L7:
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} USE: in: {field=ONLY_WRITTEN_NEVER_READ, v=READ} out: {field=ONLY_WRITTEN_NEVER_READ, v=READ}
r(v) -> <v1> USE: in: {field=ONLY_WRITTEN_NEVER_READ} out: {field=ONLY_WRITTEN_NEVER_READ, v=READ}
w(field|<v1>) INIT: in: {a=D, v=ID} out: {a=D, field=I, v=ID} USE: in: {} out: {field=ONLY_WRITTEN_NEVER_READ}
4 mark({ field = v }) INIT: in: {a=D, v=ID} out: {a=D, v=ID}
r(v) -> <v1>
w(field|<v1>)
L8:
3 <END> INIT: in: {a=D, field=I, v=ID} out: {a=D, field=I, v=ID}
3 <END>
error:
<ERROR> INIT: in: {} out: {}
<ERROR> INIT: in: {v=ID} out: {v=ID}
sink:
<SINK> INIT: in: {a=I?, field=I, v=I?} out: {a=I?, field=I, v=I?} USE: in: {} out: {}
<SINK> INIT: in: {a=I?, v=ID} out: {a=I?, v=ID} USE: in: {v=READ} out: {v=READ}
=====================
compiler/testData/cfg-variables/lexicalScopes/tryScope.instructions
Vendored
+14 -14
View File
@@ -26,33 +26,33 @@ L0:
call(foo(), foo) -> <v1>
2 jmp?(L2)
jmp?(L3)
jmp(L4) USE: in: {} out: {}
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} USE: in: {e=READ} out: {e=READ}
r(e) -> <v3> INIT: in: {a=D, e=ID} out: {a=D, e=ID} USE: in: {} out: {e=READ}
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: {e=ID} out: {e=ID}
3 jmp(L4) INIT: in: {a=ID, e=ID} out: {a=ID, e=ID}
L4 [afterCatches]:
2 jmp(L5) INIT: in: {} out: {}
2 jmp(L5)
L3 [onExceptionToFinallyBlock]:
L6 [start finally]:
3 mark({ val a = 1 })
v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v4> INIT: in: {a=D} out: {a=D}
w(a|<v4>) INIT: in: {a=D} out: {a=ID}
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}
L7 [finish finally]:
2 jmp(error) INIT: in: {} out: {}
2 jmp(error) INIT: in: {a=ID, a=ID, e=ID} out: {a=ID, a=ID, e=ID}
L5 [skipFinallyToErrorBlock]:
L8 [copy of L3, onExceptionToFinallyBlock]:
3 mark({ val a = 1 })
v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v4> INIT: in: {a=D} out: {a=D}
w(a|<v4>) INIT: in: {a=D} out: {a=ID}
2 merge(try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 }|<v1>, !<v5>) -> <v6> INIT: in: {} out: {}
v(val a = 1)
r(1) -> <v4>
w(a|<v4>)
2 merge(try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 }|<v1>, !<v5>) -> <v6>
mark("after")
r("after") -> <v7>
L1:
@@ -60,5 +60,5 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {e=READ} out: {e=READ}
=====================