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/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: {}
=====================