Svetlana Isakova
136 lines
5.3 KiB
Plaintext
Vendored
136 lines
5.3 KiB
Plaintext
Vendored
== t1 ==
|
|
fun t1(b: Boolean) {
|
|
var u: String
|
|
if (b) {
|
|
u = "s"
|
|
}
|
|
doSmth(u)
|
|
|
|
var r: String
|
|
if (b) {
|
|
r = "s"
|
|
}
|
|
else {
|
|
r = "t"
|
|
}
|
|
doSmth(r)
|
|
}
|
|
---------------------
|
|
L0:
|
|
1 <START>
|
|
v(b: Boolean)
|
|
magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
|
|
w(b|<v0>)
|
|
2 mark({ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) })
|
|
v(var u: String)
|
|
mark(if (b) { u = "s" })
|
|
r(b) -> <v1>
|
|
jf(L2|<v1>) NEXT:[read (Unit), mark({ u = "s" })]
|
|
3 mark({ u = "s" })
|
|
mark("s")
|
|
r("s") -> <v2>
|
|
w(u|<v2>)
|
|
2 jmp(L3) NEXT:[merge(if (b) { u = "s" }|!<v3>) -> <v4>]
|
|
L2 [else branch]:
|
|
read (Unit) PREV:[jf(L2|<v1>)]
|
|
L3 ['if' expression result]:
|
|
merge(if (b) { u = "s" }|!<v3>) -> <v4> PREV:[jmp(L3), read (Unit)]
|
|
r(u) -> <v5>
|
|
mark(doSmth(u))
|
|
call(doSmth(u), doSmth|<v5>) -> <v6>
|
|
v(var r: String)
|
|
mark(if (b) { r = "s" } else { r = "t" })
|
|
r(b) -> <v7>
|
|
jf(L4|<v7>) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
|
|
3 mark({ r = "s" })
|
|
mark("s")
|
|
r("s") -> <v8>
|
|
w(r|<v8>)
|
|
2 jmp(L5) NEXT:[merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>]
|
|
L4 [else branch]:
|
|
3 mark({ r = "t" }) PREV:[jf(L4|<v7>)]
|
|
mark("t")
|
|
r("t") -> <v10>
|
|
w(r|<v10>)
|
|
L5 ['if' expression result]:
|
|
2 merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12> PREV:[jmp(L5), w(r|<v10>)]
|
|
r(r) -> <v13>
|
|
mark(doSmth(r))
|
|
call(doSmth(r), doSmth|<v13>) -> <v14>
|
|
L1:
|
|
1 <END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== t2 ==
|
|
fun t2(b: Boolean) {
|
|
val i = 3
|
|
if (b) {
|
|
return;
|
|
}
|
|
doSmth(i)
|
|
if (i is Int) {
|
|
return;
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
1 <START>
|
|
v(b: Boolean)
|
|
magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
|
|
w(b|<v0>)
|
|
2 mark({ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } })
|
|
v(val i = 3)
|
|
r(3) -> <v1>
|
|
w(i|<v1>)
|
|
mark(if (b) { return; })
|
|
r(b) -> <v2>
|
|
jf(L2|<v2>) NEXT:[read (Unit), mark({ return; })]
|
|
3 mark({ return; })
|
|
ret L1 NEXT:[<END>]
|
|
- 2 jmp(L3) NEXT:[merge(if (b) { return; }|!<v3>) -> <v4>] PREV:[]
|
|
L2 [else branch]:
|
|
read (Unit) PREV:[jf(L2|<v2>)]
|
|
L3 ['if' expression result]:
|
|
merge(if (b) { return; }|!<v3>) -> <v4>
|
|
r(i) -> <v5>
|
|
mark(doSmth(i))
|
|
call(doSmth(i), doSmth|<v5>) -> <v6>
|
|
mark(if (i is Int) { return; })
|
|
mark(i is Int)
|
|
r(i) -> <v7>
|
|
magic[IS](i is Int|<v7>) -> <v8>
|
|
jf(L4|<v8>) NEXT:[read (Unit), mark({ return; })]
|
|
3 mark({ return; })
|
|
ret L1 NEXT:[<END>]
|
|
- 2 jmp(L5) NEXT:[merge(if (i is Int) { return; }|!<v9>) -> <v10>] PREV:[]
|
|
L4 [else branch]:
|
|
read (Unit) PREV:[jf(L4|<v8>)]
|
|
L5 ['if' expression result]:
|
|
merge(if (i is Int) { return; }|!<v9>) -> <v10>
|
|
L1:
|
|
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, merge(if (i is Int) { return; }|!<v9>) -> <v10>]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
=====================
|
|
== doSmth ==
|
|
fun doSmth(s: String) {}
|
|
---------------------
|
|
L0:
|
|
1 <START>
|
|
v(s: String)
|
|
magic[FAKE_INITIALIZER](s: String) -> <v0>
|
|
w(s|<v0>)
|
|
2 mark({})
|
|
read (Unit)
|
|
L1:
|
|
1 <END> NEXT:[<SINK>]
|
|
error:
|
|
<ERROR> PREV:[]
|
|
sink:
|
|
<SINK> PREV:[<ERROR>, <END>]
|
|
===================== |