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

Pseudocode: don't write full label name when jump on it

Browse Source
This commit is contained in:
Svetlana Isakova
2014-09-03 16:00:41 +04:00
parent 3a9b7bbade
commit 976d5ab030
89 changed files with 482 additions and 480 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
+15 -15
View File
@@ -117,8 +117,8 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
private JetControlFlowInstructionsGeneratorWorker(@NotNull JetElement scopingElement, @NotNull JetElement returnSubroutine) { private JetControlFlowInstructionsGeneratorWorker(@NotNull JetElement scopingElement, @NotNull JetElement returnSubroutine) {
this.pseudocode = new PseudocodeImpl(scopingElement); this.pseudocode = new PseudocodeImpl(scopingElement);
this.error = pseudocode.createLabel("error"); this.error = pseudocode.createLabel("error", null);
this.sink = pseudocode.createLabel("sink"); this.sink = pseudocode.createLabel("sink", null);
this.returnSubroutine = returnSubroutine; this.returnSubroutine = returnSubroutine;
} }
@@ -133,29 +133,28 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
@NotNull @NotNull
@Override @Override
public final Label createUnboundLabel() { public final Label createUnboundLabel() {
return pseudocode.createLabel("L" + labelCount++); return pseudocode.createLabel("L" + labelCount++, null);
} }
@NotNull @NotNull
@Override @Override
public Label createUnboundLabel(@NotNull String name) { public Label createUnboundLabel(@NotNull String name) {
return pseudocode.createLabel("L" + labelCount++ + " [" + name + "]"); return pseudocode.createLabel("L" + labelCount++, name);
} }
@NotNull @NotNull
@Override @Override
public final LoopInfo enterLoop(@NotNull JetLoopExpression expression) { public final LoopInfo enterLoop(@NotNull JetLoopExpression expression) {
Label loopEntryLabel = createUnboundLabel("loop entry point"); LoopInfo info = new LoopInfo(
bindLabel(loopEntryLabel);
LoopInfo blockInfo = new LoopInfo(
expression, expression,
loopEntryLabel, createUnboundLabel("loop entry point"),
createUnboundLabel("loop exit point"), createUnboundLabel("loop exit point"),
createUnboundLabel("body entry point"), createUnboundLabel("body entry point"),
createUnboundLabel("body exit point"), createUnboundLabel("body exit point"),
createUnboundLabel("condition entry point")); createUnboundLabel("condition entry point"));
elementToBlockInfo.put(expression, blockInfo); bindLabel(info.getEntryPoint());
return blockInfo; elementToBlockInfo.put(expression, info);
return info;
} }
@Override @Override
@@ -181,12 +180,13 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
@Override @Override
public void enterSubroutine(@NotNull JetElement subroutine) { public void enterSubroutine(@NotNull JetElement subroutine) {
Label entryPoint = createUnboundLabel(); BreakableBlockInfo blockInfo = new BreakableBlockInfo(
BreakableBlockInfo blockInfo = new BreakableBlockInfo(subroutine, entryPoint, createUnboundLabel()); subroutine,
// subroutineInfo.push(blockInfo); /* entry point */ createUnboundLabel(),
/* exit point */ createUnboundLabel());
elementToBlockInfo.put(subroutine, blockInfo); elementToBlockInfo.put(subroutine, blockInfo);
allBlocks.push(blockInfo); allBlocks.push(blockInfo);
bindLabel(entryPoint); bindLabel(blockInfo.getEntryPoint());
add(new SubroutineEnterInstruction(subroutine, getCurrentScope())); add(new SubroutineEnterInstruction(subroutine, getCurrentScope()));
} }
@@ -408,7 +408,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
@Override @Override
public void repeatPseudocode(@NotNull Label startLabel, @NotNull Label finishLabel) { public void repeatPseudocode(@NotNull Label startLabel, @NotNull Label finishLabel) {
pseudocode.repeatPart(startLabel, finishLabel); labelCount = pseudocode.repeatPart(startLabel, finishLabel, labelCount);
} }
@NotNull @NotNull
compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/PseudocodeImpl.java
+11 -10
View File
@@ -23,7 +23,6 @@ import kotlin.KotlinPackage;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.cfg.Label; import org.jetbrains.jet.lang.cfg.Label;
import org.jetbrains.jet.lang.cfg.LoopInfo;
import org.jetbrains.jet.lang.cfg.pseudocode.instructions.*; import org.jetbrains.jet.lang.cfg.pseudocode.instructions.*;
import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.MergeInstruction; import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.MergeInstruction;
import org.jetbrains.jet.lang.cfg.pseudocode.instructions.jumps.AbstractJumpInstruction; import org.jetbrains.jet.lang.cfg.pseudocode.instructions.jumps.AbstractJumpInstruction;
@@ -35,7 +34,6 @@ import org.jetbrains.jet.lang.cfg.pseudocode.instructions.special.SubroutineExit
import org.jetbrains.jet.lang.cfg.pseudocode.instructions.special.SubroutineSinkInstruction; import org.jetbrains.jet.lang.cfg.pseudocode.instructions.special.SubroutineSinkInstruction;
import org.jetbrains.jet.lang.cfg.pseudocodeTraverser.PseudocodeTraverserPackage; import org.jetbrains.jet.lang.cfg.pseudocodeTraverser.PseudocodeTraverserPackage;
import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.psi.JetElement;
import org.jetbrains.jet.lang.psi.JetExpression;
import java.util.*; import java.util.*;
@@ -46,11 +44,13 @@ public class PseudocodeImpl implements Pseudocode {
public class PseudocodeLabel implements Label { public class PseudocodeLabel implements Label {
private final String name; private final String name;
private final String comment;
private Integer targetInstructionIndex; private Integer targetInstructionIndex;
private PseudocodeLabel(String name) { private PseudocodeLabel(@NotNull String name, @Nullable String comment) {
this.name = name; this.name = name;
this.comment = comment;
} }
@NotNull @NotNull
@@ -61,7 +61,7 @@ public class PseudocodeImpl implements Pseudocode {
@Override @Override
public String toString() { public String toString() {
return name; return comment == null ? name : (name + " [" + comment + "]");
} }
public Integer getTargetInstructionIndex() { public Integer getTargetInstructionIndex() {
@@ -83,8 +83,8 @@ public class PseudocodeImpl implements Pseudocode {
return mutableInstructionList.get(targetInstructionIndex); return mutableInstructionList.get(targetInstructionIndex);
} }
public Label copy() { public PseudocodeLabel copy(int newLabelIndex) {
return new PseudocodeLabel("copy " + name); return new PseudocodeLabel("L" + newLabelIndex, "copy of " + name + ", " + comment);
} }
} }
@@ -161,8 +161,8 @@ public class PseudocodeImpl implements Pseudocode {
return this; return this;
} }
/*package*/ PseudocodeLabel createLabel(String name) { /*package*/ PseudocodeLabel createLabel(@NotNull String name, @Nullable String comment) {
PseudocodeLabel label = new PseudocodeLabel(name); PseudocodeLabel label = new PseudocodeLabel(name, comment);
labels.add(label); labels.add(label);
return label; return label;
} }
@@ -454,7 +454,7 @@ public class PseudocodeImpl implements Pseudocode {
return mutableInstructionList.get(targetPosition); return mutableInstructionList.get(targetPosition);
} }
public void repeatPart(@NotNull Label startLabel, @NotNull Label finishLabel) { public int repeatPart(@NotNull Label startLabel, @NotNull Label finishLabel, int labelCount) {
Integer startIndex = ((PseudocodeLabel) startLabel).getTargetInstructionIndex(); Integer startIndex = ((PseudocodeLabel) startLabel).getTargetInstructionIndex();
assert startIndex != null; assert startIndex != null;
Integer finishIndex = ((PseudocodeLabel) finishLabel).getTargetInstructionIndex(); Integer finishIndex = ((PseudocodeLabel) finishLabel).getTargetInstructionIndex();
@@ -468,7 +468,7 @@ public class PseudocodeImpl implements Pseudocode {
if (label == startLabel || label == finishLabel) continue; if (label == startLabel || label == finishLabel) continue;
if (startIndex <= index && index <= finishIndex) { if (startIndex <= index && index <= finishIndex) {
originalToCopy.put(label, label.copy()); originalToCopy.put(label, label.copy(labelCount++));
originalLabelsForInstruction.put(getJumpTarget(label), label); originalLabelsForInstruction.put(getJumpTarget(label), label);
} }
} }
@@ -478,6 +478,7 @@ public class PseudocodeImpl implements Pseudocode {
addInstruction(copyInstruction(originalInstruction, originalToCopy)); addInstruction(copyInstruction(originalInstruction, originalToCopy));
} }
repeatLabelsBindingForInstruction(mutableInstructionList.get(finishIndex), originalToCopy, originalLabelsForInstruction); repeatLabelsBindingForInstruction(mutableInstructionList.get(finishIndex), originalToCopy, originalLabelsForInstruction);
return labelCount;
} }
private void repeatLabelsBindingForInstruction( private void repeatLabelsBindingForInstruction(
compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions
+2 -2
View File
@@ -18,12 +18,12 @@ L0:
r(2) -> <v1> r(2) -> <v1>
mark(1 < 2) mark(1 < 2)
call(1 < 2, compareTo|<v0>, <v1>) -> <v2> call(1 < 2, compareTo|<v0>, <v1>) -> <v2>
jf(L2 [else branch]|<v2>) jf(L2|<v2>)
3 mark({ use(b) }) USE: in: {b=READ} out: {b=READ} 3 mark({ use(b) }) USE: in: {b=READ} out: {b=READ}
r(b) -> <v3> USE: in: {} out: {b=READ} r(b) -> <v3> USE: in: {} out: {b=READ}
mark(use(b)) mark(use(b))
call(use(b), use|<v3>) -> <v4> call(use(b), use|<v3>) -> <v4>
2 jmp(L3 ['if' expression result]) USE: in: {} out: {} 2 jmp(L3) USE: in: {} out: {}
L2 [else branch]: L2 [else branch]:
3 mark({ b = true }) 3 mark({ b = true })
r(true) -> <v5> USE: in: {b=ONLY_WRITTEN_NEVER_READ} out: {b=ONLY_WRITTEN_NEVER_READ} r(true) -> <v5> USE: in: {b=ONLY_WRITTEN_NEVER_READ} out: {b=ONLY_WRITTEN_NEVER_READ}
compiler/testData/cfg-variables/basic/InitializedNotDeclared.instructions
+1 -1
View File
@@ -19,4 +19,4 @@ error:
<ERROR> INIT: in: {} out: {} <ERROR> INIT: in: {} out: {}
sink: sink:
<SINK> INIT: in: {x=ID} out: {x=ID} USE: in: {} out: {} <SINK> INIT: in: {x=ID} out: {x=ID} USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions
+2 -2
View File
@@ -15,7 +15,7 @@ L0:
w(a|<v0>) INIT: in: {a=D} out: {a=ID} 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} 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} mark({ (x: Int) -> val y = x + a use(a) }) INIT: in: {a=ID, f=D} out: {a=ID, f=D}
jmp?(L2 [after local declaration]) jmp?(L2)
d({ (x: Int) -> val y = x + a use(a) }) USE: in: {a=READ} out: {a=READ} d({ (x: Int) -> val y = x + a use(a) }) USE: in: {a=READ} out: {a=READ}
L2 [after local declaration]: L2 [after local declaration]:
r({ (x: Int) -> val y = x + a use(a) }) -> <v1> r({ (x: Int) -> val y = x + a use(a) }) -> <v1>
@@ -72,4 +72,4 @@ error:
<ERROR> INIT: in: {} out: {} <ERROR> INIT: in: {} out: {}
sink: sink:
<SINK> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {} <SINK> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/basic/VariablesInitialization.instructions
+1 -1
View File
@@ -64,4 +64,4 @@ error:
<ERROR> INIT: in: {} out: {} <ERROR> INIT: in: {} out: {}
sink: sink:
<SINK> INIT: in: {c=D} out: {c=D} USE: in: {} out: {} <SINK> INIT: in: {c=D} out: {c=D} USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/basic/VariablesUsage.instructions
+1 -1
View File
@@ -62,4 +62,4 @@ error:
<ERROR> INIT: in: {} out: {} <ERROR> INIT: in: {} out: {}
sink: sink:
<SINK> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {} <SINK> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
+2 -2
View File
@@ -9,7 +9,7 @@ L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(val sum: (Int)->Int = { (x: Int) -> sum(x - 1) + x }) INIT: in: {} out: {sum=D} 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} mark({ (x: Int) -> sum(x - 1) + x }) INIT: in: {sum=D} out: {sum=D}
jmp?(L2 [after local declaration]) jmp?(L2)
d({ (x: Int) -> sum(x - 1) + x }) USE: in: {sum=READ} out: {sum=READ} d({ (x: Int) -> sum(x - 1) + x }) USE: in: {sum=READ} out: {sum=READ}
L2 [after local declaration]: L2 [after local declaration]:
r({ (x: Int) -> sum(x - 1) + x }) -> <v0> r({ (x: Int) -> sum(x - 1) + x }) -> <v0>
@@ -91,7 +91,7 @@ L0:
magic[IMPLICIT_RECEIVER](obj) -> <v3> INIT: in: {obj=D, x=D} out: {obj=D, x=D} magic[IMPLICIT_RECEIVER](obj) -> <v3> INIT: in: {obj=D, x=D} out: {obj=D, x=D}
r(obj|<v3>) -> <v4> r(obj|<v3>) -> <v4>
w(x|<v4>) INIT: in: {obj=D, x=D} out: {obj=D, x=ID} w(x|<v4>) INIT: in: {obj=D, x=D} out: {obj=D, x=ID}
1 jmp?(L2 [after local declaration]) INIT: in: {obj=D} out: {obj=D} 1 jmp?(L2) INIT: in: {obj=D} out: {obj=D}
d(fun foo() { val y = obj }) USE: in: {obj=READ} out: {obj=READ} d(fun foo() { val y = obj }) USE: in: {obj=READ} out: {obj=READ}
L2 [after local declaration]: L2 [after local declaration]:
r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> <v5> r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> <v5>
compiler/testData/cfg-variables/bugs/varInitializationInIf.instructions
+2 -2
View File
@@ -19,11 +19,11 @@ L0:
r(2) -> <v1> r(2) -> <v1>
mark(1 < 2) mark(1 < 2)
call(1 < 2, compareTo|<v0>, <v1>) -> <v2> call(1 < 2, compareTo|<v0>, <v1>) -> <v2>
jf(L2 [else branch]|<v2>) jf(L2|<v2>)
3 mark({ b = false }) 3 mark({ b = false })
r(false) -> <v3> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ} r(false) -> <v3> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
w(b|<v3>) INIT: in: {b=D} out: {b=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ} w(b|<v3>) INIT: in: {b=D} out: {b=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
2 jmp(L3 ['if' expression result]) INIT: in: {b=ID} out: {b=ID} USE: in: {b=READ} out: {b=READ} 2 jmp(L3) INIT: in: {b=ID} out: {b=ID} USE: in: {b=READ} out: {b=READ}
L2 [else branch]: L2 [else branch]:
3 mark({ b = true }) INIT: in: {b=D} out: {b=D} 3 mark({ b = true }) INIT: in: {b=D} out: {b=D}
r(true) -> <v5> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ} r(true) -> <v5> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions
+6 -6
View File
@@ -23,7 +23,7 @@ L0:
v(i) INIT: in: {numbers=ID} out: {i=D, numbers=ID} v(i) INIT: in: {numbers=ID} out: {i=D, numbers=ID}
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
jmp?(L3 [loop exit point]) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID} jmp?(L3) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID}
magic[LOOP_RANGE_ITERATION](numbers|<v1>) -> <v2> magic[LOOP_RANGE_ITERATION](numbers|<v1>) -> <v2>
w(i|<v2>) INIT: in: {i=D, numbers=ID} out: {i=ID, numbers=ID} w(i|<v2>) 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: {} out: {} 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: {}
@@ -35,11 +35,11 @@ L4 [body entry point]:
r(2) -> <v4> r(2) -> <v4>
mark(1 < 2) mark(1 < 2)
call(1 < 2, compareTo|<v3>, <v4>) -> <v5> call(1 < 2, compareTo|<v3>, <v4>) -> <v5>
jf(L7 [else branch]|<v5>) jf(L7|<v5>)
5 mark({ b = false }) 5 mark({ b = false })
r(false) -> <v6> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ} r(false) -> <v6> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
w(b|<v6>) INIT: in: {b=D, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ} w(b|<v6>) 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 ['if' expression result]) INIT: in: {b=ID, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ} out: {b=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}
L7 [else branch]: L7 [else branch]:
5 mark({ b = true }) INIT: in: {b=D, i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID} 5 mark({ b = true }) INIT: in: {b=D, i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
r(true) -> <v8> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ} r(true) -> <v8> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
@@ -49,8 +49,8 @@ L8 ['if' expression result]:
r(b) -> <v11> USE: in: {} out: {b=READ} r(b) -> <v11> USE: in: {} out: {b=READ}
mark(use(b)) mark(use(b))
call(use(b), use|<v11>) -> <v12> call(use(b), use|<v11>) -> <v12>
jmp(L6 [condition entry point]) USE: in: {} out: {} jmp(L6) USE: in: {} out: {}
- 3 jmp(L2 [loop entry point]) - 3 jmp(L2)
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID} read (Unit) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID}
@@ -77,4 +77,4 @@ error:
<ERROR> INIT: in: {} out: {} <ERROR> INIT: in: {} out: {}
sink: sink:
<SINK> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {} <SINK> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/doWhileScope.instructions
+2 -2
View File
@@ -25,7 +25,7 @@ L6 [condition entry point]:
r(0) -> <v3> r(0) -> <v3>
mark(a > 0) mark(a > 0)
call(a > 0, compareTo|<v2>, <v3>) -> <v4> call(a > 0, compareTo|<v2>, <v3>) -> <v4>
jt(L2 [loop entry point]|<v4>) USE: in: {a=READ} out: {a=READ} jt(L2|<v4>) USE: in: {a=READ} out: {a=READ}
L3 [loop exit point]: L3 [loop exit point]:
read (Unit) read (Unit)
2 mark("after") INIT: in: {} out: {} 2 mark("after") INIT: in: {} out: {}
@@ -36,4 +36,4 @@ error:
<ERROR> <ERROR>
sink: sink:
<SINK> USE: in: {} out: {} <SINK> USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/forScope.instructions
+3 -3
View File
@@ -19,7 +19,7 @@ L0:
v(i) INIT: in: {} out: {i=D} v(i) INIT: in: {} out: {i=D}
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
jmp?(L3 [loop exit point]) INIT: in: {i=D} out: {i=D} jmp?(L3) INIT: in: {i=D} out: {i=D}
magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4> magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>
w(i|<v4>) INIT: in: {i=D} out: {i=ID} w(i|<v4>) INIT: in: {i=D} out: {i=ID}
mark(for (i in 1..10) { val a = i }) INIT: in: {i=ID} out: {i=ID} mark(for (i in 1..10) { val a = i }) INIT: in: {i=ID} out: {i=ID}
@@ -28,7 +28,7 @@ L4 [body entry point]:
v(val a = i) INIT: in: {i=ID} out: {a=D, i=ID} v(val a = i) INIT: in: {i=ID} out: {a=D, i=ID}
r(i) -> <v5> INIT: in: {a=D, i=ID} out: {a=D, i=ID} r(i) -> <v5> INIT: in: {a=D, i=ID} out: {a=D, i=ID}
w(a|<v5>) INIT: in: {a=D, i=ID} out: {a=ID, i=ID} w(a|<v5>) INIT: in: {a=D, i=ID} out: {a=ID, i=ID}
3 jmp(L2 [loop entry point]) INIT: in: {i=ID} out: {i=ID} USE: in: {i=READ} out: {i=READ} 3 jmp(L2) INIT: in: {i=ID} out: {i=ID} USE: in: {i=READ} out: {i=READ}
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) INIT: in: {i=D} out: {i=D} read (Unit) INIT: in: {i=D} out: {i=D}
@@ -40,4 +40,4 @@ error:
<ERROR> <ERROR>
sink: sink:
<SINK> USE: in: {} out: {} <SINK> USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions
+1 -1
View File
@@ -18,7 +18,7 @@ L0:
w(b|<v1>) INIT: in: {b=D} out: {b=ID} 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} 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} mark({ (x: Int) -> val a = x + b }) INIT: in: {b=ID, f=D} out: {b=ID, f=D}
jmp?(L2 [after local declaration]) jmp?(L2)
d({ (x: Int) -> val a = x + b }) USE: in: {b=READ} out: {b=READ} d({ (x: Int) -> val a = x + b }) USE: in: {b=READ} out: {b=READ}
L2 [after local declaration]: L2 [after local declaration]:
r({ (x: Int) -> val a = x + b }) -> <v2> r({ (x: Int) -> val a = x + b }) -> <v2>
compiler/testData/cfg-variables/lexicalScopes/ifScope.instructions
+2 -2
View File
@@ -17,12 +17,12 @@ L0:
r("before") -> <v0> r("before") -> <v0>
mark(if (true) { val a = 1 } else { val b = 2 }) mark(if (true) { val a = 1 } else { val b = 2 })
r(true) -> <v1> r(true) -> <v1>
jf(L2 [else branch]|<v1>) jf(L2|<v1>)
3 mark({ val a = 1 }) 3 mark({ val a = 1 })
v(val a = 1) INIT: in: {} out: {a=D} v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v2> INIT: in: {a=D} out: {a=D} r(1) -> <v2> INIT: in: {a=D} out: {a=D}
w(a|<v2>) INIT: in: {a=D} out: {a=ID} w(a|<v2>) INIT: in: {a=D} out: {a=ID}
2 jmp(L3 ['if' expression result]) INIT: in: {} out: {} 2 jmp(L3) INIT: in: {} out: {}
L2 [else branch]: L2 [else branch]:
3 mark({ val b = 2 }) 3 mark({ val b = 2 })
v(val b = 2) INIT: in: {} out: {b=D} v(val b = 2) INIT: in: {} out: {b=D}
compiler/testData/cfg-variables/lexicalScopes/localClass.instructions
+1 -1
View File
@@ -25,7 +25,7 @@ L0:
magic[IMPLICIT_RECEIVER](x) -> <v2> INIT: in: {a=D, x=ID} out: {a=D, x=ID} magic[IMPLICIT_RECEIVER](x) -> <v2> INIT: in: {a=D, x=ID} out: {a=D, x=ID}
r(x|<v2>) -> <v3> r(x|<v2>) -> <v3>
w(a|<v3>) INIT: in: {a=D, x=ID} out: {a=ID, x=ID} w(a|<v3>) INIT: in: {a=D, x=ID} out: {a=ID, x=ID}
2 jmp?(L2 [after local declaration]) INIT: in: {x=ID} out: {x=ID} 2 jmp?(L2) INIT: in: {x=ID} out: {x=ID}
d(fun foo() { val b = x }) USE: in: {x=READ} out: {x=READ} d(fun foo() { val b = x }) USE: in: {x=READ} out: {x=READ}
L2 [after local declaration]: L2 [after local declaration]:
mark("after") mark("after")
compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions
+1 -1
View File
@@ -16,7 +16,7 @@ L0:
v(val b = 1) INIT: in: {} out: {b=D} v(val b = 1) INIT: in: {} out: {b=D}
r(1) -> <v1> INIT: in: {b=D} out: {b=D} r(1) -> <v1> INIT: in: {b=D} out: {b=D}
w(b|<v1>) INIT: in: {b=D} out: {b=ID} w(b|<v1>) INIT: in: {b=D} out: {b=ID}
jmp?(L2 [after local declaration]) INIT: in: {b=ID} out: {b=ID} jmp?(L2) INIT: in: {b=ID} out: {b=ID}
d(fun local(x: Int) { val a = x + b }) USE: in: {b=READ} out: {b=READ} d(fun local(x: Int) { val a = x + b }) USE: in: {b=READ} out: {b=READ}
L2 [after local declaration]: L2 [after local declaration]:
mark("after") mark("after")
compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions
+1 -1
View File
@@ -14,7 +14,7 @@ L0:
v(val b = 1) INIT: in: {} out: {b=D} v(val b = 1) INIT: in: {} out: {b=D}
r(1) -> <v1> INIT: in: {b=D} out: {b=D} r(1) -> <v1> INIT: in: {b=D} out: {b=D}
w(b|<v1>) INIT: in: {b=D} out: {b=ID} w(b|<v1>) INIT: in: {b=D} out: {b=ID}
jmp?(L2 [after local declaration]) INIT: in: {b=ID} out: {b=ID} jmp?(L2) INIT: in: {b=ID} out: {b=ID}
d(fun local(x: Int) = x + b) USE: in: {b=READ} out: {b=READ} d(fun local(x: Int) = x + b) USE: in: {b=READ} out: {b=READ}
L2 [after local declaration]: L2 [after local declaration]:
mark("after") mark("after")
compiler/testData/cfg-variables/lexicalScopes/localObject.instructions
+1 -1
View File
@@ -21,7 +21,7 @@ L0:
v(val a = 1) INIT: in: {} out: {a=D} v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v1> INIT: in: {a=D} out: {a=D} r(1) -> <v1> INIT: in: {a=D} out: {a=D}
w(a|<v1>) INIT: in: {a=D} out: {a=ID} w(a|<v1>) INIT: in: {a=D} out: {a=ID}
2 jmp?(L2 [after local declaration]) INIT: in: {} out: {} 2 jmp?(L2) INIT: in: {} out: {}
d(fun foo() { val b = 2 }) d(fun foo() { val b = 2 })
L2 [after local declaration]: L2 [after local declaration]:
mark("after") mark("after")
compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.instructions
+1 -1
View File
@@ -23,7 +23,7 @@ L0:
v(val x = 1) INIT: in: {bar=D} out: {bar=D, x=D} 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} 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} w(x|<v1>) INIT: in: {bar=D, x=D} out: {bar=D, x=ID}
2 jmp?(L2 [after local declaration]) INIT: in: {bar=D} out: {bar=D} 2 jmp?(L2) INIT: in: {bar=D} out: {bar=D}
d(fun foo() { val a = 2 }) d(fun foo() { val a = 2 })
L2 [after local declaration]: L2 [after local declaration]:
r(object { { val x = 1 } fun foo() { val a = 2 } }) -> <v2> r(object { { val x = 1 } fun foo() { val a = 2 } }) -> <v2>
compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.instructions
+2 -2
View File
@@ -15,10 +15,10 @@ L0:
1 <START> INIT: in: {} out: {} USE: in: {} out: {} 1 <START> INIT: in: {} out: {} USE: in: {} out: {}
2 mark({ class A { var a : Int get() { return $a } set(v: Int) { $a = v } } }) 2 mark({ class A { var a : Int get() { return $a } set(v: Int) { $a = v } } })
v(var a : Int get() { return $a } set(v: Int) { $a = v }) INIT: in: {} out: {a=D} v(var a : Int get() { return $a } set(v: Int) { $a = v }) INIT: in: {} out: {a=D}
jmp?(L2 [after local declaration]) INIT: in: {a=D} out: {a=D} jmp?(L2) INIT: in: {a=D} out: {a=D}
d(get() { return $a }) USE: in: {a=READ} out: {a=READ} d(get() { return $a }) USE: in: {a=READ} out: {a=READ}
L2 [after local declaration]: L2 [after local declaration]:
jmp?(L5 [after local declaration]) jmp?(L5)
d(set(v: Int) { $a = v }) USE: in: {a=ONLY_WRITTEN_NEVER_READ} out: {a=ONLY_WRITTEN_NEVER_READ} d(set(v: Int) { $a = v }) USE: in: {a=ONLY_WRITTEN_NEVER_READ} out: {a=ONLY_WRITTEN_NEVER_READ}
L1: L1:
L5 [after local declaration]: L5 [after local declaration]:
compiler/testData/cfg-variables/lexicalScopes/tryScope.instructions
+7 -6
View File
@@ -19,12 +19,12 @@ L0:
mark("before") mark("before")
r("before") -> <v0> r("before") -> <v0>
mark(try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 }) mark(try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 })
jmp?(L2 [onException]) jmp?(L2)
jmp?(L3 [onExceptionToFinallyBlock]) jmp?(L3)
3 mark({ foo() }) 3 mark({ foo() })
mark(foo()) mark(foo())
call(foo(), foo) -> <v1> call(foo(), foo) -> <v1>
2 jmp(L4 [afterCatches]) USE: in: {} out: {} 2 jmp(L4) USE: in: {} out: {}
L2 [onException]: L2 [onException]:
3 v(e: Exception) INIT: in: {} out: {e=D} 3 v(e: Exception) INIT: in: {} out: {e=D}
magic[FAKE_INITIALIZER](e: Exception) -> <v2> INIT: in: {e=D} out: {e=D} magic[FAKE_INITIALIZER](e: Exception) -> <v2> INIT: in: {e=D} out: {e=D}
@@ -33,9 +33,9 @@ L2 [onException]:
v(val a = e) INIT: in: {e=ID} out: {a=D, e=ID} USE: in: {e=READ} out: {e=READ} 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} r(e) -> <v3> INIT: in: {a=D, e=ID} out: {a=D, e=ID} USE: in: {} out: {e=READ}
w(a|<v3>) INIT: in: {a=D, e=ID} out: {a=ID, e=ID} w(a|<v3>) INIT: in: {a=D, e=ID} out: {a=ID, e=ID}
3 jmp(L4 [afterCatches]) INIT: in: {e=ID} out: {e=ID} 3 jmp(L4) INIT: in: {e=ID} out: {e=ID}
L4 [afterCatches]: L4 [afterCatches]:
2 jmp(L5 [skipFinallyToErrorBlock]) INIT: in: {} out: {} 2 jmp(L5) INIT: in: {} out: {}
L3 [onExceptionToFinallyBlock]: L3 [onExceptionToFinallyBlock]:
L6 [start finally]: L6 [start finally]:
3 mark({ val a = 1 }) 3 mark({ val a = 1 })
@@ -45,6 +45,7 @@ L6 [start finally]:
L7 [finish finally]: L7 [finish finally]:
2 jmp(error) INIT: in: {} out: {} 2 jmp(error) INIT: in: {} out: {}
L5 [skipFinallyToErrorBlock]: L5 [skipFinallyToErrorBlock]:
L8 [copy of L3, onExceptionToFinallyBlock]:
3 mark({ val a = 1 }) 3 mark({ val a = 1 })
v(val a = 1) INIT: in: {} out: {a=D} v(val a = 1) INIT: in: {} out: {a=D}
r(1) -> <v4> INIT: in: {a=D} out: {a=D} r(1) -> <v4> INIT: in: {a=D} out: {a=D}
@@ -58,4 +59,4 @@ error:
<ERROR> <ERROR>
sink: sink:
<SINK> USE: in: {} out: {} <SINK> USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/whileScope.instructions
+2 -2
View File
@@ -20,7 +20,7 @@ L6 [condition entry point]:
L4 [body entry point]: L4 [body entry point]:
3 mark({ val a: Int }) 3 mark({ val a: Int })
v(val a: Int) INIT: in: {} out: {a=D} v(val a: Int) INIT: in: {} out: {a=D}
2 jmp(L2 [loop entry point]) INIT: in: {} out: {} USE: in: {} out: {} 2 jmp(L2) INIT: in: {} out: {} USE: in: {} out: {}
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
- read (Unit) - read (Unit)
@@ -32,4 +32,4 @@ error:
<ERROR> <ERROR>
sink: sink:
<SINK> USE: in: {} out: {} <SINK> USE: in: {} out: {}
===================== =====================
compiler/testData/cfg/arrays/ArrayAccess.instructions
+1 -1
View File
@@ -46,4 +46,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/arrays/ArrayOfFunctions.instructions
+1 -1
View File
@@ -23,4 +23,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/arrays/arrayAccessExpression.instructions
+1 -1
View File
@@ -49,4 +49,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/arrays/arrayInc.instructions
+1 -1
View File
@@ -25,4 +25,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/arrays/arraySet.instructions
+1 -1
View File
@@ -20,4 +20,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/arrays/arraySetPlusAssign.instructions
+1 -1
View File
@@ -26,4 +26,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/basic/Basic.instructions
+7 -7
View File
@@ -36,10 +36,10 @@ L0:
mark(genfun<Any>()) mark(genfun<Any>())
call(genfun<Any>(), genfun) -> <v8> call(genfun<Any>(), genfun) -> <v8>
mark({1}) mark({1})
jmp?(L2 [after local declaration]) NEXT:[r({1}) -> <v9>, d({1})] jmp?(L2) NEXT:[r({1}) -> <v9>, d({1})]
d({1}) NEXT:[<SINK>] d({1}) NEXT:[<SINK>]
L2 [after local declaration]: L2 [after local declaration]:
r({1}) -> <v9> PREV:[jmp?(L2 [after local declaration])] r({1}) -> <v9> PREV:[jmp?(L2)]
mark(flfun {1}) mark(flfun {1})
call(flfun {1}, flfun|<v9>) -> <v10> call(flfun {1}, flfun|<v9>) -> <v10>
mark(3.equals(4)) mark(3.equals(4))
@@ -56,15 +56,15 @@ L2 [after local declaration]:
mark(1 + 2) mark(1 + 2)
call(1 + 2, plus|<v17>, <v18>) -> <v19> call(1 + 2, plus|<v17>, <v18>) -> <v19>
r(a) -> <v20> r(a) -> <v20>
jf(L5 [result of boolean operation]|<v20>) NEXT:[magic[AND](a && true|<v20>, <v21>) -> <v22>, r(true) -> <v21>] jf(L5|<v20>) NEXT:[magic[AND](a && true|<v20>, <v21>) -> <v22>, r(true) -> <v21>]
r(true) -> <v21> r(true) -> <v21>
L5 [result of boolean operation]: L5 [result of boolean operation]:
magic[AND](a && true|<v20>, <v21>) -> <v22> PREV:[jf(L5 [result of boolean operation]|<v20>), r(true) -> <v21>] magic[AND](a && true|<v20>, <v21>) -> <v22> PREV:[jf(L5|<v20>), r(true) -> <v21>]
r(a) -> <v23> r(a) -> <v23>
jt(L6 [result of boolean operation]|<v23>) NEXT:[r(false) -> <v24>, magic[OR](a || false|<v23>, <v24>) -> <v25>] jt(L6|<v23>) NEXT:[r(false) -> <v24>, magic[OR](a || false|<v23>, <v24>) -> <v25>]
r(false) -> <v24> r(false) -> <v24>
L6 [result of boolean operation]: L6 [result of boolean operation]:
magic[OR](a || false|<v23>, <v24>) -> <v25> PREV:[jt(L6 [result of boolean operation]|<v23>), r(false) -> <v24>] magic[OR](a || false|<v23>, <v24>) -> <v25> PREV:[jt(L6|<v23>), r(false) -> <v24>]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
@@ -137,4 +137,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/basic/EmptyFunction.instructions
+1 -1
View File
@@ -11,4 +11,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/basic/ShortFunction.instructions
+1 -1
View File
@@ -11,4 +11,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/bugs/jumpToOuterScope.instructions
+11 -11
View File
@@ -17,21 +17,21 @@ L0:
v(e) v(e)
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
jmp?(L3 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](c|<v1>) -> <v2>] PREV:[v(e), jmp(L2 [loop entry point])] jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](c|<v1>) -> <v2>] PREV:[v(e), jmp(L2)]
magic[LOOP_RANGE_ITERATION](c|<v1>) -> <v2> magic[LOOP_RANGE_ITERATION](c|<v1>) -> <v2>
w(e|<v2>) w(e|<v2>)
mark(for (e in c) { { break } }) mark(for (e in c) { { break } })
L4 [body entry point]: L4 [body entry point]:
4 mark({ { break } }) 4 mark({ { break } })
mark({ break }) mark({ break })
jmp?(L7 [after local declaration]) NEXT:[r({ break }) -> <v3>, d({ break })] jmp?(L7) NEXT:[r({ break }) -> <v3>, d({ break })]
d({ break }) NEXT:[<SINK>] d({ break }) NEXT:[<SINK>]
L7 [after local declaration]: L7 [after local declaration]:
r({ break }) -> <v3> PREV:[jmp?(L7 [after local declaration])] r({ break }) -> <v3> PREV:[jmp?(L7)]
3 jmp(L2 [loop entry point]) NEXT:[jmp?(L3 [loop exit point])] 3 jmp(L2) NEXT:[jmp?(L3)]
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) PREV:[jmp?(L3 [loop exit point]), jmp(L3 [loop exit point])] read (Unit) PREV:[jmp?(L3), jmp(L3)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
@@ -47,12 +47,12 @@ sink:
L8: L8:
5 <START> 5 <START>
6 mark(break) 6 mark(break)
jmp(L3 [loop exit point]) NEXT:[read (Unit)] jmp(L3) NEXT:[read (Unit)]
- 5 ret(*|!<v0>) L9 PREV:[] - 5 ret(*|!<v0>) L9 PREV:[]
L9: L9:
<END> NEXT:[<SINK>] PREV:[] <END> NEXT:[<SINK>] PREV:[]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/controlStructures/Finally.instructions
+129 -129
View File
@@ -11,18 +11,18 @@ L0:
1 <START> 1 <START>
2 mark({ try { 1 } finally { 2 } }) 2 mark({ try { 1 } finally { 2 } })
mark(try { 1 } finally { 2 }) mark(try { 1 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 })] jmp?(L2) NEXT:[mark({ 2 }), mark({ 1 })]
3 mark({ 1 }) 3 mark({ 1 })
r(1) -> <v0> r(1) -> <v0>
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 2 jmp(L3) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L4 [start finally]: L4 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v1> r(2) -> <v1>
L5 [finish finally]: L5 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]: L3 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])] 3 mark({ 2 }) PREV:[jmp(L3)]
r(2) -> <v1> r(2) -> <v1>
2 merge(try { 1 } finally { 2 }|<v0>) -> <v2> 2 merge(try { 1 } finally { 2 }|<v0>) -> <v2>
L1: L1:
@@ -48,7 +48,7 @@ L0:
1 <START> 1 <START>
2 mark({ try { 1 if (2 > 3) { return } } finally { 2 } }) 2 mark({ try { 1 if (2 > 3) { return } } finally { 2 } })
mark(try { 1 if (2 > 3) { return } } finally { 2 }) mark(try { 1 if (2 > 3) { return } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return } })] jmp?(L2) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return } })]
3 mark({ 1 if (2 > 3) { return } }) 3 mark({ 1 if (2 > 3) { return } })
r(1) -> <v0> r(1) -> <v0>
mark(if (2 > 3) { return }) mark(if (2 > 3) { return })
@@ -56,25 +56,25 @@ L0:
r(3) -> <v2> r(3) -> <v2>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v1>, <v2>) -> <v3> call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
jf(L3 [else branch]|<v3>) NEXT:[read (Unit), mark({ return })] jf(L3|<v3>) NEXT:[read (Unit), mark({ return })]
4 mark({ return }) 4 mark({ return })
L4 [start finally]: L4 [start finally]:
5 mark({ 2 }) 5 mark({ 2 })
r(2) -> <v4> r(2) -> <v4>
L5 [finish finally]: L5 [finish finally]:
4 ret L1 NEXT:[<END>] 4 ret L1 NEXT:[<END>]
- 3 jmp(L6 ['if' expression result]) NEXT:[merge(if (2 > 3) { return }|!<v5>) -> <v6>] PREV:[] - 3 jmp(L6) NEXT:[merge(if (2 > 3) { return }|!<v5>) -> <v6>] PREV:[]
L3 [else branch]: L3 [else branch]:
read (Unit) PREV:[jf(L3 [else branch]|<v3>)] read (Unit) PREV:[jf(L3|<v3>)]
L6 ['if' expression result]: L6 ['if' expression result]:
merge(if (2 > 3) { return }|!<v5>) -> <v6> merge(if (2 > 3) { return }|!<v5>) -> <v6>
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 2 jmp(L7) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
5 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 5 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v4> r(2) -> <v4>
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]: L7 [skipFinallyToErrorBlock]:
5 mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])] 5 mark({ 2 }) PREV:[jmp(L7)]
r(2) -> <v4> r(2) -> <v4>
2 merge(try { 1 if (2 > 3) { return } } finally { 2 }|<v6>) -> <v7> 2 merge(try { 1 if (2 > 3) { return } } finally { 2 }|<v6>) -> <v7>
L1: L1:
@@ -102,24 +102,24 @@ L0:
1 <START> 1 <START>
2 mark({ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } }) 2 mark({ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } })
mark(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }) mark(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 @l{ () -> if (2 > 3) { return@l } } })] jmp?(L2) NEXT:[mark({ 2 }), mark({ 1 @l{ () -> if (2 > 3) { return@l } } })]
3 mark({ 1 @l{ () -> if (2 > 3) { return@l } } }) 3 mark({ 1 @l{ () -> if (2 > 3) { return@l } } })
r(1) -> <v0> r(1) -> <v0>
mark(@l{ () -> if (2 > 3) { return@l } }) mark(@l{ () -> if (2 > 3) { return@l } })
mark({ () -> if (2 > 3) { return@l } }) mark({ () -> if (2 > 3) { return@l } })
jmp?(L3 [after local declaration]) NEXT:[r({ () -> if (2 > 3) { return@l } }) -> <v1>, d({ () -> if (2 > 3) { return@l } })] jmp?(L3) NEXT:[r({ () -> if (2 > 3) { return@l } }) -> <v1>, d({ () -> if (2 > 3) { return@l } })]
d({ () -> if (2 > 3) { return@l } }) NEXT:[<SINK>] d({ () -> if (2 > 3) { return@l } }) NEXT:[<SINK>]
L3 [after local declaration]: L3 [after local declaration]:
r({ () -> if (2 > 3) { return@l } }) -> <v1> PREV:[jmp?(L3 [after local declaration])] r({ () -> if (2 > 3) { return@l } }) -> <v1> PREV:[jmp?(L3)]
2 jmp(L8 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 2 jmp(L8) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L9 [start finally]: L9 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v2> r(2) -> <v2>
L10 [finish finally]: L10 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L8 [skipFinallyToErrorBlock]: L8 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])] 3 mark({ 2 }) PREV:[jmp(L8)]
r(2) -> <v2> r(2) -> <v2>
2 merge(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }|<v1>) -> <v3> 2 merge(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }|<v1>) -> <v3>
L1: L1:
@@ -144,12 +144,12 @@ L4:
r(3) -> <v1> r(3) -> <v1>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v0>, <v1>) -> <v2> call(2 > 3, compareTo|<v0>, <v1>) -> <v2>
jf(L6 [else branch]|<v2>) NEXT:[read (Unit), mark({ return@l })] jf(L6|<v2>) NEXT:[read (Unit), mark({ return@l })]
6 mark({ return@l }) 6 mark({ return@l })
ret L5 NEXT:[<END>] ret L5 NEXT:[<END>]
- 5 jmp(L7 ['if' expression result]) NEXT:[merge(if (2 > 3) { return@l }|!<v3>) -> <v4>] PREV:[] - 5 jmp(L7) NEXT:[merge(if (2 > 3) { return@l }|!<v3>) -> <v4>] PREV:[]
L6 [else branch]: L6 [else branch]:
read (Unit) PREV:[jf(L6 [else branch]|<v2>)] read (Unit) PREV:[jf(L6|<v2>)]
L7 ['if' expression result]: L7 ['if' expression result]:
merge(if (2 > 3) { return@l }|!<v3>) -> <v4> merge(if (2 > 3) { return@l }|!<v3>) -> <v4>
L5: L5:
@@ -178,10 +178,10 @@ L0:
2 mark({ @l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } }) 2 mark({ @l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } })
mark(@l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) mark(@l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })
mark({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) mark({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })
jmp?(L2 [after local declaration]) NEXT:[r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0>, d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })] jmp?(L2) NEXT:[r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0>, d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })]
d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) NEXT:[<SINK>] d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) NEXT:[<SINK>]
L2 [after local declaration]: L2 [after local declaration]:
r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0> PREV:[jmp?(L2 [after local declaration])] r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> <v0> PREV:[jmp?(L2)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
@@ -205,7 +205,7 @@ L3:
3 <START> 3 <START>
4 mark(try { 1 if (2 > 3) { return@l } } finally { 2 }) 4 mark(try { 1 if (2 > 3) { return@l } } finally { 2 })
mark(try { 1 if (2 > 3) { return@l } } finally { 2 }) mark(try { 1 if (2 > 3) { return@l } } finally { 2 })
jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@l } })] jmp?(L5) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@l } })]
5 mark({ 1 if (2 > 3) { return@l } }) 5 mark({ 1 if (2 > 3) { return@l } })
r(1) -> <v0> r(1) -> <v0>
mark(if (2 > 3) { return@l }) mark(if (2 > 3) { return@l })
@@ -213,25 +213,25 @@ L3:
r(3) -> <v2> r(3) -> <v2>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v1>, <v2>) -> <v3> call(2 > 3, compareTo|<v1>, <v2>) -> <v3>
jf(L6 [else branch]|<v3>) NEXT:[read (Unit), mark({ return@l })] jf(L6|<v3>) NEXT:[read (Unit), mark({ return@l })]
6 mark({ return@l }) 6 mark({ return@l })
L7 [start finally]: L7 [start finally]:
7 mark({ 2 }) 7 mark({ 2 })
r(2) -> <v4> r(2) -> <v4>
L8 [finish finally]: L8 [finish finally]:
6 ret L4 NEXT:[<END>] 6 ret L4 NEXT:[<END>]
- 5 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { return@l }|!<v5>) -> <v6>] PREV:[] - 5 jmp(L9) NEXT:[merge(if (2 > 3) { return@l }|!<v5>) -> <v6>] PREV:[]
L6 [else branch]: L6 [else branch]:
read (Unit) PREV:[jf(L6 [else branch]|<v3>)] read (Unit) PREV:[jf(L6|<v3>)]
L9 ['if' expression result]: L9 ['if' expression result]:
merge(if (2 > 3) { return@l }|!<v5>) -> <v6> merge(if (2 > 3) { return@l }|!<v5>) -> <v6>
4 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 4 jmp(L10) NEXT:[mark({ 2 })]
L5 [onExceptionToFinallyBlock]: L5 [onExceptionToFinallyBlock]:
7 mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])] 7 mark({ 2 }) PREV:[jmp?(L5)]
r(2) -> <v4> r(2) -> <v4>
4 jmp(error) NEXT:[<ERROR>] 4 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]: L10 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])] 7 mark({ 2 }) PREV:[jmp(L10)]
r(2) -> <v4> r(2) -> <v4>
4 merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|<v6>) -> <v7> 4 merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|<v6>) -> <v7>
L4: L4:
@@ -261,13 +261,13 @@ L0:
mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }) mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } })
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
r(true) -> <v0> PREV:[mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2 [loop entry point])] r(true) -> <v0> PREV:[mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2)]
mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }) mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } })
magic[VALUE_CONSUMER](true|<v0>) -> <v1> magic[VALUE_CONSUMER](true|<v0>) -> <v1>
L4 [body entry point]: L4 [body entry point]:
3 mark({ try { 1 if (2 > 3) { break @l } } finally { 2 } }) 3 mark({ try { 1 if (2 > 3) { break @l } } finally { 2 } })
mark(try { 1 if (2 > 3) { break @l } } finally { 2 }) mark(try { 1 if (2 > 3) { break @l } } finally { 2 })
jmp?(L7 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { break @l } })] jmp?(L7) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { break @l } })]
4 mark({ 1 if (2 > 3) { break @l } }) 4 mark({ 1 if (2 > 3) { break @l } })
r(1) -> <v2> r(1) -> <v2>
mark(if (2 > 3) { break @l }) mark(if (2 > 3) { break @l })
@@ -275,31 +275,31 @@ L4 [body entry point]:
r(3) -> <v4> r(3) -> <v4>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v3>, <v4>) -> <v5> call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
jf(L8 [else branch]|<v5>) NEXT:[read (Unit), mark({ break @l })] jf(L8|<v5>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l }) 5 mark({ break @l })
L9 [start finally]: L9 [start finally]:
6 mark({ 2 }) 6 mark({ 2 })
r(2) -> <v6> r(2) -> <v6>
L10 [finish finally]: L10 [finish finally]:
5 jmp(L3 [loop exit point]) NEXT:[read (Unit)] 5 jmp(L3) NEXT:[read (Unit)]
- 4 jmp(L11 ['if' expression result]) NEXT:[merge(if (2 > 3) { break @l }|!<v7>) -> <v8>] PREV:[] - 4 jmp(L11) NEXT:[merge(if (2 > 3) { break @l }|!<v7>) -> <v8>] PREV:[]
L8 [else branch]: L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v5>)] read (Unit) PREV:[jf(L8|<v5>)]
L11 ['if' expression result]: L11 ['if' expression result]:
merge(if (2 > 3) { break @l }|!<v7>) -> <v8> merge(if (2 > 3) { break @l }|!<v7>) -> <v8>
3 jmp(L12 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 3 jmp(L12) NEXT:[mark({ 2 })]
L7 [onExceptionToFinallyBlock]: L7 [onExceptionToFinallyBlock]:
6 mark({ 2 }) PREV:[jmp?(L7 [onExceptionToFinallyBlock])] 6 mark({ 2 }) PREV:[jmp?(L7)]
r(2) -> <v6> r(2) -> <v6>
3 jmp(error) NEXT:[<ERROR>] 3 jmp(error) NEXT:[<ERROR>]
L12 [skipFinallyToErrorBlock]: L12 [skipFinallyToErrorBlock]:
6 mark({ 2 }) PREV:[jmp(L12 [skipFinallyToErrorBlock])] 6 mark({ 2 }) PREV:[jmp(L12)]
r(2) -> <v6> r(2) -> <v6>
3 merge(try { 1 if (2 > 3) { break @l } } finally { 2 }|<v8>) -> <v9> 3 merge(try { 1 if (2 > 3) { break @l } } finally { 2 }|<v8>) -> <v9>
2 jmp(L2 [loop entry point]) NEXT:[r(true) -> <v0>] 2 jmp(L2) NEXT:[r(true) -> <v0>]
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) PREV:[jmp(L3 [loop exit point])] read (Unit) PREV:[jmp(L3)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
@@ -326,12 +326,12 @@ L0:
1 <START> 1 <START>
2 mark({ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } }) 2 mark({ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } })
mark(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }) mark(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })] jmp?(L2) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })]
3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 }) 3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })
mark(@l while(true) { 1 if (2 > 3) { break @l } }) mark(@l while(true) { 1 if (2 > 3) { break @l } })
L3 [loop entry point]: L3 [loop entry point]:
L7 [condition entry point]: L7 [condition entry point]:
r(true) -> <v0> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])] r(true) -> <v0> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3)]
mark(while(true) { 1 if (2 > 3) { break @l } }) mark(while(true) { 1 if (2 > 3) { break @l } })
magic[VALUE_CONSUMER](true|<v0>) -> <v1> magic[VALUE_CONSUMER](true|<v0>) -> <v1>
L5 [body entry point]: L5 [body entry point]:
@@ -342,28 +342,28 @@ L5 [body entry point]:
r(3) -> <v4> r(3) -> <v4>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v3>, <v4>) -> <v5> call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
jf(L8 [else branch]|<v5>) NEXT:[read (Unit), mark({ break @l })] jf(L8|<v5>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l }) 5 mark({ break @l })
jmp(L4 [loop exit point]) NEXT:[read (Unit)] jmp(L4) NEXT:[read (Unit)]
- 4 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[] - 4 jmp(L9) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[]
L8 [else branch]: L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v5>)] read (Unit) PREV:[jf(L8|<v5>)]
L9 ['if' expression result]: L9 ['if' expression result]:
merge(if (2 > 3) { break @l }|!<v6>) -> <v7> merge(if (2 > 3) { break @l }|!<v6>) -> <v7>
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>] 3 jmp(L3) NEXT:[r(true) -> <v0>]
L4 [loop exit point]: L4 [loop exit point]:
L6 [body exit point]: L6 [body exit point]:
read (Unit) PREV:[jmp(L4 [loop exit point])] read (Unit) PREV:[jmp(L4)]
r(5) -> <v9> r(5) -> <v9>
2 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 2 jmp(L10) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L11 [start finally]: L11 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v10> r(2) -> <v10>
L12 [finish finally]: L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]: L10 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])] 3 mark({ 2 }) PREV:[jmp(L10)]
r(2) -> <v10> r(2) -> <v10>
2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }|<v9>) -> <v11> 2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }|<v9>) -> <v11>
L1: L1:
@@ -391,12 +391,12 @@ L0:
1 <START> 1 <START>
2 mark({ try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } }) 2 mark({ try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } })
mark(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 }) mark(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } })] jmp?(L2) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } })]
3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } }) 3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } })
mark(@l while(true) { 1 if (2 > 3) { break @l } }) mark(@l while(true) { 1 if (2 > 3) { break @l } })
L3 [loop entry point]: L3 [loop entry point]:
L7 [condition entry point]: L7 [condition entry point]:
r(true) -> <v0> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])] r(true) -> <v0> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3)]
mark(while(true) { 1 if (2 > 3) { break @l } }) mark(while(true) { 1 if (2 > 3) { break @l } })
magic[VALUE_CONSUMER](true|<v0>) -> <v1> magic[VALUE_CONSUMER](true|<v0>) -> <v1>
L5 [body entry point]: L5 [body entry point]:
@@ -407,27 +407,27 @@ L5 [body entry point]:
r(3) -> <v4> r(3) -> <v4>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v3>, <v4>) -> <v5> call(2 > 3, compareTo|<v3>, <v4>) -> <v5>
jf(L8 [else branch]|<v5>) NEXT:[read (Unit), mark({ break @l })] jf(L8|<v5>) NEXT:[read (Unit), mark({ break @l })]
5 mark({ break @l }) 5 mark({ break @l })
jmp(L4 [loop exit point]) NEXT:[read (Unit)] jmp(L4) NEXT:[read (Unit)]
- 4 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[] - 4 jmp(L9) NEXT:[merge(if (2 > 3) { break @l }|!<v6>) -> <v7>] PREV:[]
L8 [else branch]: L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v5>)] read (Unit) PREV:[jf(L8|<v5>)]
L9 ['if' expression result]: L9 ['if' expression result]:
merge(if (2 > 3) { break @l }|!<v6>) -> <v7> merge(if (2 > 3) { break @l }|!<v6>) -> <v7>
3 jmp(L3 [loop entry point]) NEXT:[r(true) -> <v0>] 3 jmp(L3) NEXT:[r(true) -> <v0>]
L4 [loop exit point]: L4 [loop exit point]:
L6 [body exit point]: L6 [body exit point]:
read (Unit) PREV:[jmp(L4 [loop exit point])] read (Unit) PREV:[jmp(L4)]
2 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 2 jmp(L10) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L11 [start finally]: L11 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v9> r(2) -> <v9>
L12 [finish finally]: L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]: L10 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])] 3 mark({ 2 }) PREV:[jmp(L10)]
r(2) -> <v9> r(2) -> <v9>
2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 }|!<v8>) -> <v10> 2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 }|!<v8>) -> <v10>
L1: L1:
@@ -465,14 +465,14 @@ L0:
v(i) v(i)
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
jmp?(L3 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L6 [condition entry point]), jmp(L2 [loop entry point])] jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L6), jmp(L2)]
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
w(i|<v4>) w(i|<v4>)
mark(for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } }) mark(for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } })
L4 [body entry point]: L4 [body entry point]:
4 mark({ try { 1 if (2 > 3) { continue @l } } finally { 2 } }) 4 mark({ try { 1 if (2 > 3) { continue @l } } finally { 2 } })
mark(try { 1 if (2 > 3) { continue @l } } finally { 2 }) mark(try { 1 if (2 > 3) { continue @l } } finally { 2 })
jmp?(L7 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue @l } })] jmp?(L7) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue @l } })]
5 mark({ 1 if (2 > 3) { continue @l } }) 5 mark({ 1 if (2 > 3) { continue @l } })
r(1) -> <v5> r(1) -> <v5>
mark(if (2 > 3) { continue @l }) mark(if (2 > 3) { continue @l })
@@ -480,31 +480,31 @@ L4 [body entry point]:
r(3) -> <v7> r(3) -> <v7>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v6>, <v7>) -> <v8> call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L8 [else branch]|<v8>) NEXT:[read (Unit), mark({ continue @l })] jf(L8|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l }) 6 mark({ continue @l })
L9 [start finally]: L9 [start finally]:
7 mark({ 2 }) 7 mark({ 2 })
r(2) -> <v9> r(2) -> <v9>
L10 [finish finally]: L10 [finish finally]:
6 jmp(L6 [condition entry point]) NEXT:[jmp?(L3 [loop exit point])] 6 jmp(L6) NEXT:[jmp?(L3)]
- 5 jmp(L11 ['if' expression result]) NEXT:[merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>] PREV:[] - 5 jmp(L11) NEXT:[merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>] PREV:[]
L8 [else branch]: L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v8>)] read (Unit) PREV:[jf(L8|<v8>)]
L11 ['if' expression result]: L11 ['if' expression result]:
merge(if (2 > 3) { continue @l }|!<v10>) -> <v11> merge(if (2 > 3) { continue @l }|!<v10>) -> <v11>
4 jmp(L12 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 4 jmp(L12) NEXT:[mark({ 2 })]
L7 [onExceptionToFinallyBlock]: L7 [onExceptionToFinallyBlock]:
7 mark({ 2 }) PREV:[jmp?(L7 [onExceptionToFinallyBlock])] 7 mark({ 2 }) PREV:[jmp?(L7)]
r(2) -> <v9> r(2) -> <v9>
4 jmp(error) NEXT:[<ERROR>] 4 jmp(error) NEXT:[<ERROR>]
L12 [skipFinallyToErrorBlock]: L12 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(L12 [skipFinallyToErrorBlock])] 7 mark({ 2 }) PREV:[jmp(L12)]
r(2) -> <v9> r(2) -> <v9>
4 merge(try { 1 if (2 > 3) { continue @l } } finally { 2 }|<v11>) -> <v12> 4 merge(try { 1 if (2 > 3) { continue @l } } finally { 2 }|<v11>) -> <v12>
3 jmp(L2 [loop entry point]) NEXT:[jmp?(L3 [loop exit point])] 3 jmp(L2) NEXT:[jmp?(L3)]
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) PREV:[jmp?(L3 [loop exit point])] read (Unit) PREV:[jmp?(L3)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
@@ -534,7 +534,7 @@ L0:
w(a|<v0>) w(a|<v0>)
2 mark({ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } }) 2 mark({ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } })
mark(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }) mark(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })] jmp?(L2) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })]
3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 }) 3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })
mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } }) mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } })
4 r(1) -> <v1> 4 r(1) -> <v1>
@@ -544,7 +544,7 @@ L0:
v(i) v(i)
L3 [loop entry point]: L3 [loop entry point]:
L7 [condition entry point]: L7 [condition entry point]:
jmp?(L4 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L7 [condition entry point]), jmp(L3 [loop entry point])] jmp?(L4) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L7), jmp(L3)]
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
w(i|<v4>) w(i|<v4>)
mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } }) mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
@@ -556,28 +556,28 @@ L5 [body entry point]:
r(3) -> <v7> r(3) -> <v7>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v6>, <v7>) -> <v8> call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L8 [else branch]|<v8>) NEXT:[read (Unit), mark({ continue @l })] jf(L8|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l }) 6 mark({ continue @l })
jmp(L7 [condition entry point]) NEXT:[jmp?(L4 [loop exit point])] jmp(L7) NEXT:[jmp?(L4)]
- 5 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[] - 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[]
L8 [else branch]: L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v8>)] read (Unit) PREV:[jf(L8|<v8>)]
L9 ['if' expression result]: L9 ['if' expression result]:
merge(if (2 > 3) { continue @l }|!<v9>) -> <v10> merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>
4 jmp(L3 [loop entry point]) NEXT:[jmp?(L4 [loop exit point])] 4 jmp(L3) NEXT:[jmp?(L4)]
L4 [loop exit point]: L4 [loop exit point]:
L6 [body exit point]: L6 [body exit point]:
read (Unit) PREV:[jmp?(L4 [loop exit point])] read (Unit) PREV:[jmp?(L4)]
3 r(5) -> <v12> 3 r(5) -> <v12>
2 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 2 jmp(L10) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L11 [start finally]: L11 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v13> r(2) -> <v13>
L12 [finish finally]: L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]: L10 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])] 3 mark({ 2 }) PREV:[jmp(L10)]
r(2) -> <v13> r(2) -> <v13>
2 merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }|<v12>) -> <v14> 2 merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }|<v12>) -> <v14>
L1: L1:
@@ -608,7 +608,7 @@ L0:
w(a|<v0>) w(a|<v0>)
2 mark({ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } }) 2 mark({ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } })
mark(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 }) mark(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })] jmp?(L2) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })]
3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } }) 3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })
mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } }) mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } })
4 r(1) -> <v1> 4 r(1) -> <v1>
@@ -618,7 +618,7 @@ L0:
v(i) v(i)
L3 [loop entry point]: L3 [loop entry point]:
L7 [condition entry point]: L7 [condition entry point]:
jmp?(L4 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L7 [condition entry point]), jmp(L3 [loop entry point])] jmp?(L4) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>] PREV:[v(i), jmp(L7), jmp(L3)]
magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
w(i|<v4>) w(i|<v4>)
mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } }) mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
@@ -630,27 +630,27 @@ L5 [body entry point]:
r(3) -> <v7> r(3) -> <v7>
mark(2 > 3) mark(2 > 3)
call(2 > 3, compareTo|<v6>, <v7>) -> <v8> call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L8 [else branch]|<v8>) NEXT:[read (Unit), mark({ continue @l })] jf(L8|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l }) 6 mark({ continue @l })
jmp(L7 [condition entry point]) NEXT:[jmp?(L4 [loop exit point])] jmp(L7) NEXT:[jmp?(L4)]
- 5 jmp(L9 ['if' expression result]) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[] - 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>] PREV:[]
L8 [else branch]: L8 [else branch]:
read (Unit) PREV:[jf(L8 [else branch]|<v8>)] read (Unit) PREV:[jf(L8|<v8>)]
L9 ['if' expression result]: L9 ['if' expression result]:
merge(if (2 > 3) { continue @l }|!<v9>) -> <v10> merge(if (2 > 3) { continue @l }|!<v9>) -> <v10>
4 jmp(L3 [loop entry point]) NEXT:[jmp?(L4 [loop exit point])] 4 jmp(L3) NEXT:[jmp?(L4)]
L4 [loop exit point]: L4 [loop exit point]:
L6 [body exit point]: L6 [body exit point]:
read (Unit) PREV:[jmp?(L4 [loop exit point])] read (Unit) PREV:[jmp?(L4)]
2 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 2 jmp(L10) NEXT:[mark({ 2 })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L11 [start finally]: L11 [start finally]:
3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ 2 }) PREV:[jmp?(L2)]
r(2) -> <v12> r(2) -> <v12>
L12 [finish finally]: L12 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L10 [skipFinallyToErrorBlock]: L10 [skipFinallyToErrorBlock]:
3 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])] 3 mark({ 2 }) PREV:[jmp(L10)]
r(2) -> <v12> r(2) -> <v12>
2 merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 }|!<v11>) -> <v13> 2 merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 }|!<v11>) -> <v13>
L1: L1:
@@ -674,7 +674,7 @@ L0:
1 <START> 1 <START>
2 mark({ try { return 1 } finally { return 2 } }) 2 mark({ try { return 1 } finally { return 2 } })
mark(try { return 1 } finally { return 2 }) mark(try { return 1 } finally { return 2 })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return 2 }), mark({ return 1 })] jmp?(L2) NEXT:[mark({ return 2 }), mark({ return 1 })]
3 mark({ return 1 }) 3 mark({ return 1 })
r(1) -> <v0> r(1) -> <v0>
L3 [start finally]: L3 [start finally]:
@@ -683,9 +683,9 @@ L3 [start finally]:
ret(*|<v1>) L1 NEXT:[<END>] ret(*|<v1>) L1 NEXT:[<END>]
L4 [finish finally]: L4 [finish finally]:
- 3 ret(*|<v0>) L1 NEXT:[<END>] PREV:[] - 3 ret(*|<v0>) L1 NEXT:[<END>] PREV:[]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ return 2 })] PREV:[] - 2 jmp(L5) NEXT:[mark({ return 2 })] PREV:[]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
4 mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 4 mark({ return 2 }) PREV:[jmp?(L2)]
r(2) -> <v1> r(2) -> <v1>
ret(*|<v1>) L1 NEXT:[<END>] ret(*|<v1>) L1 NEXT:[<END>]
- 2 jmp(error) NEXT:[<ERROR>] PREV:[] - 2 jmp(error) NEXT:[<ERROR>] PREV:[]
@@ -715,7 +715,7 @@ L0:
1 <START> 1 <START>
2 mark({ try { return 1 } finally { doSmth(3) } }) 2 mark({ try { return 1 } finally { doSmth(3) } })
mark(try { return 1 } finally { doSmth(3) }) mark(try { return 1 } finally { doSmth(3) })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] jmp?(L2) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 }) 3 mark({ return 1 })
r(1) -> <v0> r(1) -> <v0>
L3 [start finally]: L3 [start finally]:
@@ -725,9 +725,9 @@ L3 [start finally]:
call(doSmth(3), doSmth|<v1>) -> <v2> call(doSmth(3), doSmth|<v1>) -> <v2>
L4 [finish finally]: L4 [finish finally]:
3 ret(*|<v0>) L1 NEXT:[<END>] 3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[] - 2 jmp(L5) NEXT:[mark({ doSmth(3) })] PREV:[]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 4 mark({ doSmth(3) }) PREV:[jmp?(L2)]
r(3) -> <v1> r(3) -> <v1>
mark(doSmth(3)) mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2> call(doSmth(3), doSmth|<v1>) -> <v2>
@@ -762,8 +762,8 @@ L0:
1 <START> 1 <START>
2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } }) 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } })
mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }) mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 }) 3 mark({ return 1 })
r(1) -> <v0> r(1) -> <v0>
L4 [start finally]: L4 [start finally]:
@@ -773,26 +773,26 @@ L4 [start finally]:
call(doSmth(3), doSmth|<v1>) -> <v2> call(doSmth(3), doSmth|<v1>) -> <v2>
L5 [finish finally]: L5 [finish finally]:
3 ret(*|<v0>) L1 NEXT:[<END>] 3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[] - 2 jmp(L6) NEXT:[jmp(L7)] PREV:[]
L2 [onException]: L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v4> magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v4>
w(e|<v4>) w(e|<v4>)
4 mark({ doSmth(2) }) 4 mark({ doSmth(2) })
r(2) -> <v5> r(2) -> <v5>
mark(doSmth(2)) mark(doSmth(2))
call(doSmth(2), doSmth|<v5>) -> <v6> call(doSmth(2), doSmth|<v5>) -> <v6>
3 jmp(L6 [afterCatches]) 3 jmp(L6)
L6 [afterCatches]: L6 [afterCatches]:
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] 2 jmp(L7) NEXT:[mark({ doSmth(3) })]
L3 [onExceptionToFinallyBlock]: L3 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] 4 mark({ doSmth(3) }) PREV:[jmp?(L3)]
r(3) -> <v1> r(3) -> <v1>
mark(doSmth(3)) mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2> call(doSmth(3), doSmth|<v1>) -> <v2>
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]: L7 [skipFinallyToErrorBlock]:
4 mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])] 4 mark({ doSmth(3) }) PREV:[jmp(L7)]
r(3) -> <v1> r(3) -> <v1>
mark(doSmth(3)) mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2> call(doSmth(3), doSmth|<v1>) -> <v2>
@@ -818,20 +818,20 @@ L0:
1 <START> 1 <START>
2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } }) 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } })
mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }) mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), mark({ return 1 })] jmp?(L2) NEXT:[v(e: UnsupportedOperationException), mark({ return 1 })]
3 mark({ return 1 }) 3 mark({ return 1 })
r(1) -> <v0> r(1) -> <v0>
ret(*|<v0>) L1 NEXT:[<END>] ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L3 [afterCatches]) NEXT:[merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!<v1>, <v4>) -> <v5>] PREV:[] - 2 jmp(L3) NEXT:[merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!<v1>, <v4>) -> <v5>] PREV:[]
L2 [onException]: L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v2> magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v2>
w(e|<v2>) w(e|<v2>)
4 mark({ doSmth(2) }) 4 mark({ doSmth(2) })
r(2) -> <v3> r(2) -> <v3>
mark(doSmth(2)) mark(doSmth(2))
call(doSmth(2), doSmth|<v3>) -> <v4> call(doSmth(2), doSmth|<v3>) -> <v4>
3 jmp(L3 [afterCatches]) 3 jmp(L3)
L3 [afterCatches]: L3 [afterCatches]:
2 merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!<v1>, <v4>) -> <v5> 2 merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!<v1>, <v4>) -> <v5>
L1: L1:
@@ -858,8 +858,8 @@ L0:
1 <START> 1 <START>
2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }) 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } })
mark(try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }) mark(try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ return 1 })]
3 mark({ return 1 }) 3 mark({ return 1 })
r(1) -> <v0> r(1) -> <v0>
L4 [start finally]: L4 [start finally]:
@@ -869,9 +869,9 @@ L4 [start finally]:
call(doSmth(3), doSmth|<v1>) -> <v2> call(doSmth(3), doSmth|<v1>) -> <v2>
L5 [finish finally]: L5 [finish finally]:
3 ret(*|<v0>) L1 NEXT:[<END>] 3 ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[] - 2 jmp(L6) NEXT:[jmp(L7)] PREV:[]
L2 [onException]: L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v4> magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v4>
w(e|<v4>) w(e|<v4>)
4 mark({ return 2 }) 4 mark({ return 2 })
@@ -881,11 +881,11 @@ L2 [onException]:
mark(doSmth(3)) mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2> call(doSmth(3), doSmth|<v1>) -> <v2>
ret(*|<v5>) L1 NEXT:[<END>] ret(*|<v5>) L1 NEXT:[<END>]
- 3 jmp(L6 [afterCatches]) PREV:[] - 3 jmp(L6) PREV:[]
L6 [afterCatches]: L6 [afterCatches]:
- 2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[] - 2 jmp(L7) NEXT:[mark({ doSmth(3) })] PREV:[]
L3 [onExceptionToFinallyBlock]: L3 [onExceptionToFinallyBlock]:
4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] 4 mark({ doSmth(3) }) PREV:[jmp?(L3)]
r(3) -> <v1> r(3) -> <v1>
mark(doSmth(3)) mark(doSmth(3))
call(doSmth(3), doSmth|<v1>) -> <v2> call(doSmth(3), doSmth|<v1>) -> <v2>
@@ -920,15 +920,15 @@ L0:
1 <START> 1 <START>
2 mark({ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }) 2 mark({ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } })
mark(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }) mark(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) })
jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ doSmth(1) })] jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ doSmth(1) })]
3 mark({ doSmth(1) }) 3 mark({ doSmth(1) })
r(1) -> <v0> r(1) -> <v0>
mark(doSmth(1)) mark(doSmth(1))
call(doSmth(1), doSmth|<v0>) -> <v1> call(doSmth(1), doSmth|<v0>) -> <v1>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] 2 jmp(L4) NEXT:[jmp(L7)]
L2 [onException]: L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v2> magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v2>
w(e|<v2>) w(e|<v2>)
4 mark({ return 2 }) 4 mark({ return 2 })
@@ -940,17 +940,17 @@ L5 [start finally]:
call(doSmth(3), doSmth|<v4>) -> <v5> call(doSmth(3), doSmth|<v4>) -> <v5>
L6 [finish finally]: L6 [finish finally]:
4 ret(*|<v3>) L1 NEXT:[<END>] 4 ret(*|<v3>) L1 NEXT:[<END>]
- 3 jmp(L4 [afterCatches]) PREV:[] - 3 jmp(L4) PREV:[]
L4 [afterCatches]: L4 [afterCatches]:
2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4 [afterCatches])] 2 jmp(L7) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4)]
L3 [onExceptionToFinallyBlock]: L3 [onExceptionToFinallyBlock]:
5 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] 5 mark({ doSmth(3) }) PREV:[jmp?(L3)]
r(3) -> <v4> r(3) -> <v4>
mark(doSmth(3)) mark(doSmth(3))
call(doSmth(3), doSmth|<v4>) -> <v5> call(doSmth(3), doSmth|<v4>) -> <v5>
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L7 [skipFinallyToErrorBlock]: L7 [skipFinallyToErrorBlock]:
5 mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])] 5 mark({ doSmth(3) }) PREV:[jmp(L7)]
r(3) -> <v4> r(3) -> <v4>
mark(doSmth(3)) mark(doSmth(3))
call(doSmth(3), doSmth|<v4>) -> <v5> call(doSmth(3), doSmth|<v4>) -> <v5>
@@ -979,4 +979,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
+61 -61
View File
@@ -74,40 +74,40 @@ L0:
1 <START> 1 <START>
2 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 } }) 2 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 } })
mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 }) mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 })
jmp?(L2 [onException]) NEXT:[jmp?(L5 [catch 0]), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L2) NEXT:[jmp?(L5), jmp?(L3)]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ return 1 }), mark({ doSmth() })] jmp?(L3) NEXT:[mark({ return 1 }), mark({ doSmth() })]
3 mark({ doSmth() }) 3 mark({ doSmth() })
mark(doSmth()) mark(doSmth())
call(doSmth(), doSmth) -> <v0> call(doSmth(), doSmth) -> <v0>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])] 2 jmp(L4) NEXT:[jmp(L6)]
L2 [onException]: L2 [onException]:
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])] jmp?(L5) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2)]
3 v(e: NullPointerException) 3 v(e: NullPointerException)
magic[FAKE_INITIALIZER](e: NullPointerException) -> <v1> magic[FAKE_INITIALIZER](e: NullPointerException) -> <v1>
w(e|<v1>) w(e|<v1>)
4 mark({ doSmth1() }) 4 mark({ doSmth1() })
mark(doSmth1()) mark(doSmth1())
call(doSmth1(), doSmth1) -> <v2> call(doSmth1(), doSmth1) -> <v2>
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])] 3 jmp(L4) NEXT:[jmp(L6)]
L5 [catch 0]: L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])] v(e: Exception) PREV:[jmp?(L5)]
magic[FAKE_INITIALIZER](e: Exception) -> <v3> magic[FAKE_INITIALIZER](e: Exception) -> <v3>
w(e|<v3>) w(e|<v3>)
4 mark({ doSmth2() }) 4 mark({ doSmth2() })
mark(doSmth2()) mark(doSmth2())
call(doSmth2(), doSmth2) -> <v4> call(doSmth2(), doSmth2) -> <v4>
3 jmp(L4 [afterCatches]) 3 jmp(L4)
L4 [afterCatches]: L4 [afterCatches]:
2 jmp(L6 [skipFinallyToErrorBlock]) NEXT:[mark({ return 1 })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])] 2 jmp(L6) NEXT:[mark({ return 1 })] PREV:[jmp(L4), jmp(L4), jmp(L4)]
L3 [onExceptionToFinallyBlock]: L3 [onExceptionToFinallyBlock]:
L7 [start finally]: L7 [start finally]:
3 mark({ return 1 }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] 3 mark({ return 1 }) PREV:[jmp?(L3)]
r(1) -> <v5> r(1) -> <v5>
ret(*|<v5>) L1 NEXT:[<END>] ret(*|<v5>) L1 NEXT:[<END>]
L8 [finish finally]: L8 [finish finally]:
- 2 jmp(error) NEXT:[<ERROR>] PREV:[] - 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L6 [skipFinallyToErrorBlock]: L6 [skipFinallyToErrorBlock]:
3 mark({ return 1 }) PREV:[jmp(L6 [skipFinallyToErrorBlock])] 3 mark({ return 1 }) PREV:[jmp(L6)]
r(1) -> <v5> r(1) -> <v5>
ret(*|<v5>) L1 NEXT:[<END>] ret(*|<v5>) L1 NEXT:[<END>]
- 2 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 }|<v0>, <v2>, <v4>) -> <v7> PREV:[] - 2 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 }|<v0>, <v2>, <v4>) -> <v7> PREV:[]
@@ -142,68 +142,68 @@ L0:
2 mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } }) 2 mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } })
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
mark(cond()) PREV:[mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } }), jmp(L6 [condition entry point]), jmp(L6 [condition entry point])] mark(cond()) PREV:[mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } }), jmp(L6), jmp(L6)]
call(cond(), cond) -> <v0> call(cond(), cond) -> <v0>
mark(while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } }) mark(while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
jf(L3 [loop exit point]|<v0>) NEXT:[read (Unit), mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })] jf(L3|<v0>) NEXT:[read (Unit), mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })]
L4 [body entry point]: L4 [body entry point]:
3 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } }) 3 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }) mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue })
jmp?(L7 [onException]) NEXT:[jmp?(L10 [catch 0]), jmp?(L8 [onExceptionToFinallyBlock])] jmp?(L7) NEXT:[jmp?(L10), jmp?(L8)]
jmp?(L8 [onExceptionToFinallyBlock]) NEXT:[mark({ if (cond()) return else continue }), mark({ doSmth() })] jmp?(L8) NEXT:[mark({ if (cond()) return else continue }), mark({ doSmth() })]
4 mark({ doSmth() }) 4 mark({ doSmth() })
mark(doSmth()) mark(doSmth())
call(doSmth(), doSmth) -> <v1> call(doSmth(), doSmth) -> <v1>
3 jmp(L9 [afterCatches]) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] 3 jmp(L9) NEXT:[jmp(L11)]
L7 [onException]: L7 [onException]:
jmp?(L10 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L7 [onException])] jmp?(L10) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L7)]
4 v(e: NullPointerException) 4 v(e: NullPointerException)
magic[FAKE_INITIALIZER](e: NullPointerException) -> <v2> magic[FAKE_INITIALIZER](e: NullPointerException) -> <v2>
w(e|<v2>) w(e|<v2>)
5 mark({ doSmth1() }) 5 mark({ doSmth1() })
mark(doSmth1()) mark(doSmth1())
call(doSmth1(), doSmth1) -> <v3> call(doSmth1(), doSmth1) -> <v3>
4 jmp(L9 [afterCatches]) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] 4 jmp(L9) NEXT:[jmp(L11)]
L10 [catch 0]: L10 [catch 0]:
v(e: Exception) PREV:[jmp?(L10 [catch 0])] v(e: Exception) PREV:[jmp?(L10)]
magic[FAKE_INITIALIZER](e: Exception) -> <v4> magic[FAKE_INITIALIZER](e: Exception) -> <v4>
w(e|<v4>) w(e|<v4>)
5 mark({ doSmth2() }) 5 mark({ doSmth2() })
mark(doSmth2()) mark(doSmth2())
call(doSmth2(), doSmth2) -> <v5> call(doSmth2(), doSmth2) -> <v5>
4 jmp(L9 [afterCatches]) 4 jmp(L9)
L9 [afterCatches]: L9 [afterCatches]:
3 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ if (cond()) return else continue })] PREV:[jmp(L9 [afterCatches]), jmp(L9 [afterCatches]), jmp(L9 [afterCatches])] 3 jmp(L11) NEXT:[mark({ if (cond()) return else continue })] PREV:[jmp(L9), jmp(L9), jmp(L9)]
L8 [onExceptionToFinallyBlock]: L8 [onExceptionToFinallyBlock]:
L12 [start finally]: L12 [start finally]:
4 mark({ if (cond()) return else continue }) PREV:[jmp?(L8 [onExceptionToFinallyBlock])] 4 mark({ if (cond()) return else continue }) PREV:[jmp?(L8)]
mark(if (cond()) return else continue) mark(if (cond()) return else continue)
mark(cond()) mark(cond())
call(cond(), cond) -> <v6> call(cond(), cond) -> <v6>
jf(L13 [else branch]|<v6>) NEXT:[jmp(L6 [condition entry point]), ret L1] jf(L13|<v6>) NEXT:[jmp(L6), ret L1]
ret L1 NEXT:[<END>] ret L1 NEXT:[<END>]
- jmp(L14 ['if' expression result]) NEXT:[merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9>] PREV:[] - jmp(L14) NEXT:[merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9>] PREV:[]
L13 [else branch]: L13 [else branch]:
jmp(L6 [condition entry point]) NEXT:[mark(cond())] PREV:[jf(L13 [else branch]|<v6>)] jmp(L6) NEXT:[mark(cond())] PREV:[jf(L13|<v6>)]
L14 ['if' expression result]: L14 ['if' expression result]:
- merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9> PREV:[] - merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9> PREV:[]
L15 [finish finally]: L15 [finish finally]:
- 3 jmp(error) NEXT:[<ERROR>] PREV:[] - 3 jmp(error) NEXT:[<ERROR>] PREV:[]
L11 [skipFinallyToErrorBlock]: L11 [skipFinallyToErrorBlock]:
4 mark({ if (cond()) return else continue }) PREV:[jmp(L11 [skipFinallyToErrorBlock])] 4 mark({ if (cond()) return else continue }) PREV:[jmp(L11)]
mark(if (cond()) return else continue) mark(if (cond()) return else continue)
mark(cond()) mark(cond())
call(cond(), cond) -> <v6> call(cond(), cond) -> <v6>
jf(copy L13 [else branch]|<v6>) NEXT:[jmp(L6 [condition entry point]), ret L1] jf(L17|<v6>) NEXT:[jmp(L6), ret L1]
ret L1 NEXT:[<END>] ret L1 NEXT:[<END>]
- jmp(copy L14 ['if' expression result]) NEXT:[merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9>] PREV:[] - jmp(L18) NEXT:[merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9>] PREV:[]
jmp(L6 [condition entry point]) NEXT:[mark(cond())] PREV:[jf(copy L13 [else branch]|<v6>)] jmp(L6) NEXT:[mark(cond())] PREV:[jf(L17|<v6>)]
- merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9> PREV:[] - merge(if (cond()) return else continue|!<v7>, !<v8>) -> <v9> PREV:[]
- 3 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }|<v1>, <v3>, <v5>) -> <v10> PREV:[] - 3 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }|<v1>, <v3>, <v5>) -> <v10> PREV:[]
- 2 jmp(L2 [loop entry point]) NEXT:[mark(cond())] PREV:[] - 2 jmp(L2) NEXT:[mark(cond())] PREV:[]
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) PREV:[jf(L3 [loop exit point]|<v0>)] read (Unit) PREV:[jf(L3|<v0>)]
L1: L1:
1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)] 1 <END> NEXT:[<SINK>] PREV:[ret L1, ret L1, read (Unit)]
error: error:
@@ -231,55 +231,55 @@ L0:
1 <START> 1 <START>
2 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); } }) 2 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); } })
mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); }) mark(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); })
jmp?(L2 [onException]) NEXT:[jmp?(L5 [catch 0]), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L2) NEXT:[jmp?(L5), jmp?(L3)]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ while (cond()); }), mark({ doSmth() })] jmp?(L3) NEXT:[mark({ while (cond()); }), mark({ doSmth() })]
3 mark({ doSmth() }) 3 mark({ doSmth() })
mark(doSmth()) mark(doSmth())
call(doSmth(), doSmth) -> <v0> call(doSmth(), doSmth) -> <v0>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])] 2 jmp(L4) NEXT:[jmp(L6)]
L2 [onException]: L2 [onException]:
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])] jmp?(L5) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2)]
3 v(e: NullPointerException) 3 v(e: NullPointerException)
magic[FAKE_INITIALIZER](e: NullPointerException) -> <v1> magic[FAKE_INITIALIZER](e: NullPointerException) -> <v1>
w(e|<v1>) w(e|<v1>)
4 mark({ doSmth1() }) 4 mark({ doSmth1() })
mark(doSmth1()) mark(doSmth1())
call(doSmth1(), doSmth1) -> <v2> call(doSmth1(), doSmth1) -> <v2>
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])] 3 jmp(L4) NEXT:[jmp(L6)]
L5 [catch 0]: L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])] v(e: Exception) PREV:[jmp?(L5)]
magic[FAKE_INITIALIZER](e: Exception) -> <v3> magic[FAKE_INITIALIZER](e: Exception) -> <v3>
w(e|<v3>) w(e|<v3>)
4 mark({ doSmth2() }) 4 mark({ doSmth2() })
mark(doSmth2()) mark(doSmth2())
call(doSmth2(), doSmth2) -> <v4> call(doSmth2(), doSmth2) -> <v4>
3 jmp(L4 [afterCatches]) 3 jmp(L4)
L4 [afterCatches]: L4 [afterCatches]:
2 jmp(L6 [skipFinallyToErrorBlock]) NEXT:[mark({ while (cond()); })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])] 2 jmp(L6) NEXT:[mark({ while (cond()); })] PREV:[jmp(L4), jmp(L4), jmp(L4)]
L3 [onExceptionToFinallyBlock]: L3 [onExceptionToFinallyBlock]:
L7 [start finally]: L7 [start finally]:
3 mark({ while (cond()); }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] 3 mark({ while (cond()); }) PREV:[jmp?(L3)]
L8 [loop entry point]: L8 [loop entry point]:
L12 [condition entry point]: L12 [condition entry point]:
mark(cond()) PREV:[mark({ while (cond()); }), jmp(L8 [loop entry point])] mark(cond()) PREV:[mark({ while (cond()); }), jmp(L8)]
call(cond(), cond) -> <v5> call(cond(), cond) -> <v5>
mark(while (cond())) mark(while (cond()))
jf(L9 [loop exit point]|<v5>) NEXT:[read (Unit), jmp(L8 [loop entry point])] jf(L9|<v5>) NEXT:[read (Unit), jmp(L8)]
L10 [body entry point]: L10 [body entry point]:
jmp(L8 [loop entry point]) NEXT:[mark(cond())] jmp(L8) NEXT:[mark(cond())]
L9 [loop exit point]: L9 [loop exit point]:
L11 [body exit point]: L11 [body exit point]:
read (Unit) PREV:[jf(L9 [loop exit point]|<v5>)] read (Unit) PREV:[jf(L9|<v5>)]
L13 [finish finally]: L13 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L6 [skipFinallyToErrorBlock]: L6 [skipFinallyToErrorBlock]:
3 mark({ while (cond()); }) PREV:[jmp(L6 [skipFinallyToErrorBlock])] 3 mark({ while (cond()); }) PREV:[jmp(L6)]
mark(cond()) PREV:[mark({ while (cond()); }), jmp(copy L8 [loop entry point])] mark(cond()) PREV:[mark({ while (cond()); }), jmp(L15)]
call(cond(), cond) -> <v5> call(cond(), cond) -> <v5>
mark(while (cond())) mark(while (cond()))
jf(copy L9 [loop exit point]|<v5>) NEXT:[read (Unit), jmp(copy L8 [loop entry point])] jf(L16|<v5>) NEXT:[read (Unit), jmp(L15)]
jmp(copy L8 [loop entry point]) NEXT:[mark(cond())] jmp(L15) NEXT:[mark(cond())]
read (Unit) PREV:[jf(copy L9 [loop exit point]|<v5>)] read (Unit) PREV:[jf(L16|<v5>)]
2 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); }|<v0>, <v2>, <v4>) -> <v7> 2 merge(try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); }|<v0>, <v2>, <v4>) -> <v7>
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
@@ -306,42 +306,42 @@ L0:
w(list|<v0>) w(list|<v0>)
2 mark({ try { doSmth() } finally { if(list != null) { } } }) 2 mark({ try { doSmth() } finally { if(list != null) { } } })
mark(try { doSmth() } finally { if(list != null) { } }) mark(try { doSmth() } finally { if(list != null) { } })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ if(list != null) { } }), mark({ doSmth() })] jmp?(L2) NEXT:[mark({ if(list != null) { } }), mark({ doSmth() })]
3 mark({ doSmth() }) 3 mark({ doSmth() })
mark(doSmth()) mark(doSmth())
call(doSmth(), doSmth) -> <v1> call(doSmth(), doSmth) -> <v1>
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ if(list != null) { } })] 2 jmp(L3) NEXT:[mark({ if(list != null) { } })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L4 [start finally]: L4 [start finally]:
3 mark({ if(list != null) { } }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ if(list != null) { } }) PREV:[jmp?(L2)]
mark(if(list != null) { }) mark(if(list != null) { })
r(list) -> <v2> r(list) -> <v2>
r(null) -> <v3> r(null) -> <v3>
mark(list != null) mark(list != null)
call(list != null, equals|<v2>, <v3>) -> <v4> call(list != null, equals|<v2>, <v3>) -> <v4>
jf(L5 [else branch]|<v4>) NEXT:[read (Unit), mark({ })] jf(L5|<v4>) NEXT:[read (Unit), mark({ })]
4 mark({ }) 4 mark({ })
read (Unit) read (Unit)
3 jmp(L6 ['if' expression result]) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>] 3 jmp(L6) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>]
L5 [else branch]: L5 [else branch]:
read (Unit) PREV:[jf(L5 [else branch]|<v4>)] read (Unit) PREV:[jf(L5|<v4>)]
L6 ['if' expression result]: L6 ['if' expression result]:
merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(L6 ['if' expression result]), read (Unit)] merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(L6), read (Unit)]
L7 [finish finally]: L7 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]: L3 [skipFinallyToErrorBlock]:
3 mark({ if(list != null) { } }) PREV:[jmp(L3 [skipFinallyToErrorBlock])] 3 mark({ if(list != null) { } }) PREV:[jmp(L3)]
mark(if(list != null) { }) mark(if(list != null) { })
r(list) -> <v2> r(list) -> <v2>
r(null) -> <v3> r(null) -> <v3>
mark(list != null) mark(list != null)
call(list != null, equals|<v2>, <v3>) -> <v4> call(list != null, equals|<v2>, <v3>) -> <v4>
jf(copy L5 [else branch]|<v4>) NEXT:[read (Unit), mark({ })] jf(L9|<v4>) NEXT:[read (Unit), mark({ })]
4 mark({ }) 4 mark({ })
read (Unit) read (Unit)
3 jmp(copy L6 ['if' expression result]) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>] 3 jmp(L10) NEXT:[merge(if(list != null) { }|!<v5>) -> <v6>]
read (Unit) PREV:[jf(copy L5 [else branch]|<v4>)] read (Unit) PREV:[jf(L9|<v4>)]
merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(copy L6 ['if' expression result]), read (Unit)] merge(if(list != null) { }|!<v5>) -> <v6> PREV:[jmp(L10), read (Unit)]
2 merge(try { doSmth() } finally { if(list != null) { } }|<v1>) -> <v7> 2 merge(try { doSmth() } finally { if(list != null) { } }|<v1>) -> <v7>
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
@@ -349,4 +349,4 @@ error:
<ERROR> PREV:[jmp(error)] <ERROR> PREV:[jmp(error)]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/controlStructures/For.instructions
+4 -4
View File
@@ -15,7 +15,7 @@ L0:
v(i) v(i)
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
jmp?(L3 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>] PREV:[v(i), jmp(L2 [loop entry point])] jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>] PREV:[v(i), jmp(L2)]
magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3> magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>
w(i|<v3>) w(i|<v3>)
mark(for (i in 1..2) { doSmth(i) }) mark(for (i in 1..2) { doSmth(i) })
@@ -24,10 +24,10 @@ L4 [body entry point]:
r(i) -> <v4> r(i) -> <v4>
mark(doSmth(i)) mark(doSmth(i))
call(doSmth(i), doSmth|<v4>) -> <v5> call(doSmth(i), doSmth|<v4>) -> <v5>
3 jmp(L2 [loop entry point]) NEXT:[jmp?(L3 [loop exit point])] 3 jmp(L2) NEXT:[jmp?(L3)]
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) PREV:[jmp?(L3 [loop exit point])] read (Unit) PREV:[jmp?(L3)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
@@ -51,4 +51,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/controlStructures/If.instructions
+14 -14
View File
@@ -25,35 +25,35 @@ L0:
v(var u: String) v(var u: String)
mark(if (b) { u = "s" }) mark(if (b) { u = "s" })
r(b) -> <v1> r(b) -> <v1>
jf(L2 [else branch]|<v1>) NEXT:[read (Unit), mark({ u = "s" })] jf(L2|<v1>) NEXT:[read (Unit), mark({ u = "s" })]
3 mark({ u = "s" }) 3 mark({ u = "s" })
mark("s") mark("s")
r("s") -> <v2> r("s") -> <v2>
w(u|<v2>) w(u|<v2>)
2 jmp(L3 ['if' expression result]) NEXT:[merge(if (b) { u = "s" }|!<v3>) -> <v4>] 2 jmp(L3) NEXT:[merge(if (b) { u = "s" }|!<v3>) -> <v4>]
L2 [else branch]: L2 [else branch]:
read (Unit) PREV:[jf(L2 [else branch]|<v1>)] read (Unit) PREV:[jf(L2|<v1>)]
L3 ['if' expression result]: L3 ['if' expression result]:
merge(if (b) { u = "s" }|!<v3>) -> <v4> PREV:[jmp(L3 ['if' expression result]), read (Unit)] merge(if (b) { u = "s" }|!<v3>) -> <v4> PREV:[jmp(L3), read (Unit)]
r(u) -> <v5> r(u) -> <v5>
mark(doSmth(u)) mark(doSmth(u))
call(doSmth(u), doSmth|<v5>) -> <v6> call(doSmth(u), doSmth|<v5>) -> <v6>
v(var r: String) v(var r: String)
mark(if (b) { r = "s" } else { r = "t" }) mark(if (b) { r = "s" } else { r = "t" })
r(b) -> <v7> r(b) -> <v7>
jf(L4 [else branch]|<v7>) NEXT:[mark({ r = "t" }), mark({ r = "s" })] jf(L4|<v7>) NEXT:[mark({ r = "t" }), mark({ r = "s" })]
3 mark({ r = "s" }) 3 mark({ r = "s" })
mark("s") mark("s")
r("s") -> <v8> r("s") -> <v8>
w(r|<v8>) w(r|<v8>)
2 jmp(L5 ['if' expression result]) NEXT:[merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>] 2 jmp(L5) NEXT:[merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>]
L4 [else branch]: L4 [else branch]:
3 mark({ r = "t" }) PREV:[jf(L4 [else branch]|<v7>)] 3 mark({ r = "t" }) PREV:[jf(L4|<v7>)]
mark("t") mark("t")
r("t") -> <v10> r("t") -> <v10>
w(r|<v10>) w(r|<v10>)
L5 ['if' expression result]: L5 ['if' expression result]:
2 merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12> PREV:[jmp(L5 ['if' expression result]), w(r|<v10>)] 2 merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12> PREV:[jmp(L5), w(r|<v10>)]
r(r) -> <v13> r(r) -> <v13>
mark(doSmth(r)) mark(doSmth(r))
call(doSmth(r), doSmth|<v13>) -> <v14> call(doSmth(r), doSmth|<v13>) -> <v14>
@@ -87,12 +87,12 @@ L0:
w(i|<v1>) w(i|<v1>)
mark(if (b) { return; }) mark(if (b) { return; })
r(b) -> <v2> r(b) -> <v2>
jf(L2 [else branch]|<v2>) NEXT:[read (Unit), mark({ return; })] jf(L2|<v2>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; }) 3 mark({ return; })
ret L1 NEXT:[<END>] ret L1 NEXT:[<END>]
- 2 jmp(L3 ['if' expression result]) NEXT:[merge(if (b) { return; }|!<v3>) -> <v4>] PREV:[] - 2 jmp(L3) NEXT:[merge(if (b) { return; }|!<v3>) -> <v4>] PREV:[]
L2 [else branch]: L2 [else branch]:
read (Unit) PREV:[jf(L2 [else branch]|<v2>)] read (Unit) PREV:[jf(L2|<v2>)]
L3 ['if' expression result]: L3 ['if' expression result]:
merge(if (b) { return; }|!<v3>) -> <v4> merge(if (b) { return; }|!<v3>) -> <v4>
r(i) -> <v5> r(i) -> <v5>
@@ -102,12 +102,12 @@ L3 ['if' expression result]:
mark(i is Int) mark(i is Int)
r(i) -> <v7> r(i) -> <v7>
magic[IS](i is Int|<v7>) -> <v8> magic[IS](i is Int|<v7>) -> <v8>
jf(L4 [else branch]|<v8>) NEXT:[read (Unit), mark({ return; })] jf(L4|<v8>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; }) 3 mark({ return; })
ret L1 NEXT:[<END>] ret L1 NEXT:[<END>]
- 2 jmp(L5 ['if' expression result]) NEXT:[merge(if (i is Int) { return; }|!<v9>) -> <v10>] PREV:[] - 2 jmp(L5) NEXT:[merge(if (i is Int) { return; }|!<v9>) -> <v10>] PREV:[]
L4 [else branch]: L4 [else branch]:
read (Unit) PREV:[jf(L4 [else branch]|<v8>)] read (Unit) PREV:[jf(L4|<v8>)]
L5 ['if' expression result]: L5 ['if' expression result]:
merge(if (i is Int) { return; }|!<v9>) -> <v10> merge(if (i is Int) { return; }|!<v9>) -> <v10>
L1: L1:
compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.instructions
+6 -6
View File
@@ -10,19 +10,19 @@ L0:
2 mark({ while(0 > 1) { 2 } }) 2 mark({ while(0 > 1) { 2 } })
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
r(0) -> <v0> PREV:[mark({ while(0 > 1) { 2 } }), jmp(L2 [loop entry point])] r(0) -> <v0> PREV:[mark({ while(0 > 1) { 2 } }), jmp(L2)]
r(1) -> <v1> r(1) -> <v1>
mark(0 > 1) mark(0 > 1)
call(0 > 1, compareTo|<v0>, <v1>) -> <v2> call(0 > 1, compareTo|<v0>, <v1>) -> <v2>
mark(while(0 > 1) { 2 }) mark(while(0 > 1) { 2 })
jf(L3 [loop exit point]|<v2>) NEXT:[read (Unit), mark({ 2 })] jf(L3|<v2>) NEXT:[read (Unit), mark({ 2 })]
L4 [body entry point]: L4 [body entry point]:
3 mark({ 2 }) 3 mark({ 2 })
r(2) -> <v3> r(2) -> <v3>
2 jmp(L2 [loop entry point]) NEXT:[r(0) -> <v0>] 2 jmp(L2) NEXT:[r(0) -> <v0>]
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) PREV:[jf(L3 [loop exit point]|<v2>)] read (Unit) PREV:[jf(L3|<v2>)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
@@ -50,7 +50,7 @@ L6 [condition entry point]:
- r(1) -> <v2> PREV:[] - r(1) -> <v2> PREV:[]
- mark(0 > 1) PREV:[] - mark(0 > 1) PREV:[]
- call(0 > 1, compareTo|<v1>, <v2>) -> <v3> PREV:[] - call(0 > 1, compareTo|<v1>, <v2>) -> <v3> PREV:[]
- jt(L2 [loop entry point]|<v3>) NEXT:[read (Unit), mark({return})] PREV:[] - jt(L2|<v3>) NEXT:[read (Unit), mark({return})] PREV:[]
L3 [loop exit point]: L3 [loop exit point]:
- read (Unit) PREV:[] - read (Unit) PREV:[]
L1: L1:
@@ -59,4 +59,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/controlStructures/continueInDoWhile.instructions
+9 -9
View File
@@ -15,27 +15,27 @@ L0:
3 mark(do { if (b) break; continue; } while (true)) 3 mark(do { if (b) break; continue; } while (true))
L2 [loop entry point]: L2 [loop entry point]:
L4 [body entry point]: L4 [body entry point]:
mark({ if (b) break; continue; }) PREV:[mark(do { if (b) break; continue; } while (true)), jt(L2 [loop entry point]|<v5>)] mark({ if (b) break; continue; }) PREV:[mark(do { if (b) break; continue; } while (true)), jt(L2|<v5>)]
mark(if (b) break) mark(if (b) break)
r(b) -> <v1> r(b) -> <v1>
jf(L7 [else branch]|<v1>) NEXT:[read (Unit), jmp(L3 [loop exit point])] jf(L7|<v1>) NEXT:[read (Unit), jmp(L3)]
jmp(L3 [loop exit point]) NEXT:[read (Unit)] jmp(L3) NEXT:[read (Unit)]
- jmp(L8 ['if' expression result]) NEXT:[merge(if (b) break|!<v2>) -> <v3>] PREV:[] - jmp(L8) NEXT:[merge(if (b) break|!<v2>) -> <v3>] PREV:[]
L7 [else branch]: L7 [else branch]:
read (Unit) PREV:[jf(L7 [else branch]|<v1>)] read (Unit) PREV:[jf(L7|<v1>)]
L8 ['if' expression result]: L8 ['if' expression result]:
merge(if (b) break|!<v2>) -> <v3> merge(if (b) break|!<v2>) -> <v3>
jmp(L6 [condition entry point]) jmp(L6)
L5 [body exit point]: L5 [body exit point]:
L6 [condition entry point]: L6 [condition entry point]:
r(true) -> <v5> r(true) -> <v5>
jt(L2 [loop entry point]|<v5>) NEXT:[read (Unit), mark({ if (b) break; continue; })] jt(L2|<v5>) NEXT:[read (Unit), mark({ if (b) break; continue; })]
L3 [loop exit point]: L3 [loop exit point]:
read (Unit) PREV:[jmp(L3 [loop exit point]), jt(L2 [loop entry point]|<v5>)] read (Unit) PREV:[jmp(L3), jt(L2|<v5>)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/controlStructures/continueInFor.instructions
+9 -9
View File
@@ -19,7 +19,7 @@ L0:
v(i) v(i)
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
jmp?(L3 [loop exit point]) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>] PREV:[v(i), jmp(L6 [condition entry point])] jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>] PREV:[v(i), jmp(L6)]
magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4> magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>
w(i|<v4>) w(i|<v4>)
mark(for (i in 1..10) { if (b) break; continue; }) mark(for (i in 1..10) { if (b) break; continue; })
@@ -27,22 +27,22 @@ L4 [body entry point]:
4 mark({ if (b) break; continue; }) 4 mark({ if (b) break; continue; })
mark(if (b) break) mark(if (b) break)
r(b) -> <v5> r(b) -> <v5>
jf(L7 [else branch]|<v5>) NEXT:[read (Unit), jmp(L3 [loop exit point])] jf(L7|<v5>) NEXT:[read (Unit), jmp(L3)]
jmp(L3 [loop exit point]) NEXT:[read (Unit)] jmp(L3) NEXT:[read (Unit)]
- jmp(L8 ['if' expression result]) NEXT:[merge(if (b) break|!<v6>) -> <v7>] PREV:[] - jmp(L8) NEXT:[merge(if (b) break|!<v6>) -> <v7>] PREV:[]
L7 [else branch]: L7 [else branch]:
read (Unit) PREV:[jf(L7 [else branch]|<v5>)] read (Unit) PREV:[jf(L7|<v5>)]
L8 ['if' expression result]: L8 ['if' expression result]:
merge(if (b) break|!<v6>) -> <v7> merge(if (b) break|!<v6>) -> <v7>
jmp(L6 [condition entry point]) NEXT:[jmp?(L3 [loop exit point])] jmp(L6) NEXT:[jmp?(L3)]
- 3 jmp(L2 [loop entry point]) NEXT:[jmp?(L3 [loop exit point])] PREV:[] - 3 jmp(L2) NEXT:[jmp?(L3)] PREV:[]
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) PREV:[jmp?(L3 [loop exit point]), jmp(L3 [loop exit point])] read (Unit) PREV:[jmp?(L3), jmp(L3)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/controlStructures/continueInWhile.instructions
+9 -9
View File
@@ -14,29 +14,29 @@ L0:
2 mark({ while (true) { if (b) break; continue; } }) 2 mark({ while (true) { if (b) break; continue; } })
L2 [loop entry point]: L2 [loop entry point]:
L6 [condition entry point]: L6 [condition entry point]:
r(true) -> <v1> PREV:[mark({ while (true) { if (b) break; continue; } }), jmp(L6 [condition entry point])] r(true) -> <v1> PREV:[mark({ while (true) { if (b) break; continue; } }), jmp(L6)]
mark(while (true) { if (b) break; continue; }) mark(while (true) { if (b) break; continue; })
magic[VALUE_CONSUMER](true|<v1>) -> <v2> magic[VALUE_CONSUMER](true|<v1>) -> <v2>
L4 [body entry point]: L4 [body entry point]:
3 mark({ if (b) break; continue; }) 3 mark({ if (b) break; continue; })
mark(if (b) break) mark(if (b) break)
r(b) -> <v3> r(b) -> <v3>
jf(L7 [else branch]|<v3>) NEXT:[read (Unit), jmp(L3 [loop exit point])] jf(L7|<v3>) NEXT:[read (Unit), jmp(L3)]
jmp(L3 [loop exit point]) NEXT:[read (Unit)] jmp(L3) NEXT:[read (Unit)]
- jmp(L8 ['if' expression result]) NEXT:[merge(if (b) break|!<v4>) -> <v5>] PREV:[] - jmp(L8) NEXT:[merge(if (b) break|!<v4>) -> <v5>] PREV:[]
L7 [else branch]: L7 [else branch]:
read (Unit) PREV:[jf(L7 [else branch]|<v3>)] read (Unit) PREV:[jf(L7|<v3>)]
L8 ['if' expression result]: L8 ['if' expression result]:
merge(if (b) break|!<v4>) -> <v5> merge(if (b) break|!<v4>) -> <v5>
jmp(L6 [condition entry point]) NEXT:[r(true) -> <v1>] jmp(L6) NEXT:[r(true) -> <v1>]
- 2 jmp(L2 [loop entry point]) NEXT:[r(true) -> <v1>] PREV:[] - 2 jmp(L2) NEXT:[r(true) -> <v1>] PREV:[]
L3 [loop exit point]: L3 [loop exit point]:
L5 [body exit point]: L5 [body exit point]:
read (Unit) PREV:[jmp(L3 [loop exit point])] read (Unit) PREV:[jmp(L3)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/controlStructures/returnsInWhen.instructions
+3 -3
View File
@@ -16,14 +16,14 @@ L0:
mark(is Int -> return a) mark(is Int -> return a)
mark(is Int) mark(is Int)
magic[IS](is Int|<v1>) -> <v2> magic[IS](is Int|<v1>) -> <v2>
jmp?(L4 [next 'when' entry]|<v2>) NEXT:[merge(when(a) { is Int -> return a }|!<v4>) -> <v5>, r(a) -> <v3>] jmp?(L4|<v2>) NEXT:[merge(when(a) { is Int -> return a }|!<v4>) -> <v5>, r(a) -> <v3>]
L3 ['when' entry body]: L3 ['when' entry body]:
r(a) -> <v3> r(a) -> <v3>
ret(*|<v3>) L1 NEXT:[<END>] ret(*|<v3>) L1 NEXT:[<END>]
- jmp(L2 [after 'when' expression]) PREV:[] - jmp(L2) PREV:[]
L2 [after 'when' expression]: L2 [after 'when' expression]:
L4 [next 'when' entry]: L4 [next 'when' entry]:
merge(when(a) { is Int -> return a }|!<v4>) -> <v5> PREV:[jmp?(L4 [next 'when' entry]|<v2>)] merge(when(a) { is Int -> return a }|!<v4>) -> <v5> PREV:[jmp?(L4|<v2>)]
L1: L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v3>) L1, merge(when(a) { is Int -> return a }|!<v4>) -> <v5>] 1 <END> NEXT:[<SINK>] PREV:[ret(*|<v3>) L1, merge(when(a) { is Int -> return a }|!<v4>) -> <v5>]
error: error:
compiler/testData/cfg/controlStructures/whenConditions.instructions
+17 -17
View File
@@ -23,62 +23,62 @@ L0:
mark(1) mark(1)
r(1) -> <v2> r(1) -> <v2>
magic[EQUALS_IN_WHEN_CONDITION](1|<v1>, <v2>) -> <v3> magic[EQUALS_IN_WHEN_CONDITION](1|<v1>, <v2>) -> <v3>
jmp?(L4 [next 'when' entry]|<v3>) NEXT:[mark(in Collections.singleton(2) -> "2"), mark("1")] jmp?(L4|<v3>) NEXT:[mark(in Collections.singleton(2) -> "2"), mark("1")]
L3 ['when' entry body]: L3 ['when' entry body]:
mark("1") mark("1")
r("1") -> <v4> r("1") -> <v4>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>] jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L4 [next 'when' entry]: L4 [next 'when' entry]:
mark(in Collections.singleton(2) -> "2") PREV:[jmp?(L4 [next 'when' entry]|<v3>)] mark(in Collections.singleton(2) -> "2") PREV:[jmp?(L4|<v3>)]
mark(Collections.singleton(2)) mark(Collections.singleton(2))
r(2) -> <v5> r(2) -> <v5>
mark(singleton(2)) mark(singleton(2))
call(singleton(2), singleton|<v5>) -> <v6> call(singleton(2), singleton|<v5>) -> <v6>
mark(in Collections.singleton(2)) mark(in Collections.singleton(2))
call(in Collections.singleton(2), contains|<v6>, <v1>) -> <v7> call(in Collections.singleton(2), contains|<v6>, <v1>) -> <v7>
jmp?(L6 [next 'when' entry]|<v7>) NEXT:[mark(is Int -> "Int"), mark("2")] jmp?(L6|<v7>) NEXT:[mark(is Int -> "Int"), mark("2")]
L5 ['when' entry body]: L5 ['when' entry body]:
mark("2") mark("2")
r("2") -> <v8> r("2") -> <v8>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>] jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L6 [next 'when' entry]: L6 [next 'when' entry]:
mark(is Int -> "Int") PREV:[jmp?(L6 [next 'when' entry]|<v7>)] mark(is Int -> "Int") PREV:[jmp?(L6|<v7>)]
mark(is Int) mark(is Int)
magic[IS](is Int|<v1>) -> <v9> magic[IS](is Int|<v1>) -> <v9>
jmp?(L8 [next 'when' entry]|<v9>) NEXT:[mark(!in Collections.singleton(3) -> "!3"), mark("Int")] jmp?(L8|<v9>) NEXT:[mark(!in Collections.singleton(3) -> "!3"), mark("Int")]
L7 ['when' entry body]: L7 ['when' entry body]:
mark("Int") mark("Int")
r("Int") -> <v10> r("Int") -> <v10>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>] jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L8 [next 'when' entry]: L8 [next 'when' entry]:
mark(!in Collections.singleton(3) -> "!3") PREV:[jmp?(L8 [next 'when' entry]|<v9>)] mark(!in Collections.singleton(3) -> "!3") PREV:[jmp?(L8|<v9>)]
mark(Collections.singleton(3)) mark(Collections.singleton(3))
r(3) -> <v11> r(3) -> <v11>
mark(singleton(3)) mark(singleton(3))
call(singleton(3), singleton|<v11>) -> <v12> call(singleton(3), singleton|<v11>) -> <v12>
mark(!in Collections.singleton(3)) mark(!in Collections.singleton(3))
call(!in Collections.singleton(3), contains|<v12>, <v1>) -> <v13> call(!in Collections.singleton(3), contains|<v12>, <v1>) -> <v13>
jmp?(L10 [next 'when' entry]|<v13>) NEXT:[mark(!is Number -> "!Number"), mark("!3")] jmp?(L10|<v13>) NEXT:[mark(!is Number -> "!Number"), mark("!3")]
L9 ['when' entry body]: L9 ['when' entry body]:
mark("!3") mark("!3")
r("!3") -> <v14> r("!3") -> <v14>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>] jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L10 [next 'when' entry]: L10 [next 'when' entry]:
mark(!is Number -> "!Number") PREV:[jmp?(L10 [next 'when' entry]|<v13>)] mark(!is Number -> "!Number") PREV:[jmp?(L10|<v13>)]
mark(!is Number) mark(!is Number)
magic[IS](!is Number|<v1>) -> <v15> magic[IS](!is Number|<v1>) -> <v15>
jmp?(L12 [next 'when' entry]|<v15>) NEXT:[mark(else -> null), mark("!Number")] jmp?(L12|<v15>) NEXT:[mark(else -> null), mark("!Number")]
L11 ['when' entry body]: L11 ['when' entry body]:
mark("!Number") mark("!Number")
r("!Number") -> <v16> r("!Number") -> <v16>
jmp(L2 [after 'when' expression]) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>] jmp(L2) NEXT:[merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18>]
L12 [next 'when' entry]: L12 [next 'when' entry]:
mark(else -> null) PREV:[jmp?(L12 [next 'when' entry]|<v15>)] mark(else -> null) PREV:[jmp?(L12|<v15>)]
L13 ['when' entry body]: L13 ['when' entry body]:
r(null) -> <v17> r(null) -> <v17>
jmp(L2 [after 'when' expression]) jmp(L2)
L2 [after 'when' expression]: L2 [after 'when' expression]:
merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18> PREV:[jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression]), jmp(L2 [after 'when' expression])] merge(when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }|<v4>, <v8>, <v10>, <v14>, <v16>, <v17>) -> <v18> PREV:[jmp(L2), jmp(L2), jmp(L2), jmp(L2), jmp(L2), jmp(L2)]
w(t|<v18>) w(t|<v18>)
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
compiler/testData/cfg/conventions/bothReceivers.instructions
+1 -1
View File
@@ -62,4 +62,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/conventions/equals.instructions
+4 -4
View File
@@ -18,14 +18,14 @@ L0:
r(b) -> <v3> r(b) -> <v3>
mark(a == b) mark(a == b)
call(a == b, equals|<v2>, <v3>) -> <v4> call(a == b, equals|<v2>, <v3>) -> <v4>
jf(L2 [else branch]|<v4>) NEXT:[read (Unit), mark({ })] jf(L2|<v4>) NEXT:[read (Unit), mark({ })]
3 mark({ }) 3 mark({ })
read (Unit) read (Unit)
2 jmp(L3 ['if' expression result]) NEXT:[merge(if (a == b) { }|!<v5>) -> <v6>] 2 jmp(L3) NEXT:[merge(if (a == b) { }|!<v5>) -> <v6>]
L2 [else branch]: L2 [else branch]:
read (Unit) PREV:[jf(L2 [else branch]|<v4>)] read (Unit) PREV:[jf(L2|<v4>)]
L3 ['if' expression result]: L3 ['if' expression result]:
merge(if (a == b) { }|!<v5>) -> <v6> PREV:[jmp(L3 ['if' expression result]), read (Unit)] merge(if (a == b) { }|!<v5>) -> <v6> PREV:[jmp(L3), read (Unit)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
compiler/testData/cfg/conventions/incrementAtTheEnd.instructions
+1 -1
View File
@@ -20,4 +20,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/conventions/invoke.instructions
+1 -1
View File
@@ -18,4 +18,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/conventions/notEqual.instructions
+4 -4
View File
@@ -17,14 +17,14 @@ L0:
r(b) -> <v3> r(b) -> <v3>
mark(a != b) mark(a != b)
call(a != b, equals|<v2>, <v3>) -> <v4> call(a != b, equals|<v2>, <v3>) -> <v4>
jf(L2 [else branch]|<v4>) NEXT:[read (Unit), mark({})] jf(L2|<v4>) NEXT:[read (Unit), mark({})]
3 mark({}) 3 mark({})
read (Unit) read (Unit)
2 jmp(L3 ['if' expression result]) NEXT:[merge(if (a != b) {}|!<v5>) -> <v6>] 2 jmp(L3) NEXT:[merge(if (a != b) {}|!<v5>) -> <v6>]
L2 [else branch]: L2 [else branch]:
read (Unit) PREV:[jf(L2 [else branch]|<v4>)] read (Unit) PREV:[jf(L2|<v4>)]
L3 ['if' expression result]: L3 ['if' expression result]:
merge(if (a != b) {}|!<v5>) -> <v6> PREV:[jmp(L3 ['if' expression result]), read (Unit)] merge(if (a != b) {}|!<v5>) -> <v6> PREV:[jmp(L3), read (Unit)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
compiler/testData/cfg/deadCode/DeadCode.instructions
+1 -1
View File
@@ -19,4 +19,4 @@ error:
<ERROR> PREV:[throw (throw Exception()|<v0>)] <ERROR> PREV:[throw (throw Exception()|<v0>)]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/deadCode/returnInElvis.instructions
+2 -2
View File
@@ -8,7 +8,7 @@ L0:
2 mark({ return ?: null }) 2 mark({ return ?: null })
ret L1 NEXT:[<END>] ret L1 NEXT:[<END>]
- mark(return ?: null) PREV:[] - mark(return ?: null) PREV:[]
- jt(L2 [after elvis operator]) NEXT:[r(null) -> <v0>, merge(return ?: null|!<v1>, <v0>) -> <v2>] PREV:[] - jt(L2) NEXT:[r(null) -> <v0>, merge(return ?: null|!<v1>, <v0>) -> <v2>] PREV:[]
- r(null) -> <v0> PREV:[] - r(null) -> <v0> PREV:[]
L2 [after elvis operator]: L2 [after elvis operator]:
- merge(return ?: null|!<v1>, <v0>) -> <v2> PREV:[] - merge(return ?: null|!<v1>, <v0>) -> <v2> PREV:[]
@@ -18,4 +18,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/deadCode/stringTemplate.instructions
+1 -1
View File
@@ -19,4 +19,4 @@ error:
<ERROR> PREV:[throw (throw Exception()|<v0>)] <ERROR> PREV:[throw (throw Exception()|<v0>)]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.instructions
+1 -1
View File
@@ -36,4 +36,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.instructions
+1 -1
View File
@@ -56,4 +56,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.instructions
+1 -1
View File
@@ -43,4 +43,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.instructions
+6 -6
View File
@@ -7,16 +7,16 @@ L0:
1 <START> 1 <START>
2 mark({ {} }) 2 mark({ {} })
mark({}) mark({})
jmp?(L2 [after local declaration]) NEXT:[r({}) -> <v0>, d({})] jmp?(L2) NEXT:[r({}) -> <v0>, d({})]
d({}) NEXT:[<SINK>] d({}) NEXT:[<SINK>]
L2 [after local declaration]: L2 [after local declaration]:
r({}) -> <v0> PREV:[jmp?(L2 [after local declaration])] r({}) -> <v0> PREV:[jmp?(L2)]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>, d({})] <SINK> PREV:[<ERROR>, <END>, d({})]
===================== =====================
== anonymous_0 == == anonymous_0 ==
{} {}
compiler/testData/cfg/declarations/functions/FailFunction.instructions
+1 -1
View File
@@ -17,4 +17,4 @@ error:
<ERROR> PREV:[throw (throw java.lang.RuntimeException()|<v0>)] <ERROR> PREV:[throw (throw java.lang.RuntimeException()|<v0>)]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/functions/typeParameter.instructions
+1 -1
View File
@@ -14,4 +14,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/local/LocalDeclarations.instructions
+7 -7
View File
@@ -141,10 +141,10 @@ L0:
v(val a = object { val y : Int fun inner_bar() { y = 10 } }) v(val a = object { val y : Int fun inner_bar() { y = 10 } })
mark(object { val y : Int fun inner_bar() { y = 10 } }) mark(object { val y : Int fun inner_bar() { y = 10 } })
v(val y : Int) v(val y : Int)
jmp?(L2 [after local declaration]) NEXT:[r(object { val y : Int fun inner_bar() { y = 10 } }) -> <v0>, d(fun inner_bar() { y = 10 })] jmp?(L2) NEXT:[r(object { val y : Int fun inner_bar() { y = 10 } }) -> <v0>, d(fun inner_bar() { y = 10 })]
d(fun inner_bar() { y = 10 }) NEXT:[<SINK>] d(fun inner_bar() { y = 10 }) NEXT:[<SINK>]
L2 [after local declaration]: L2 [after local declaration]:
r(object { val y : Int fun inner_bar() { y = 10 } }) -> <v0> PREV:[jmp?(L2 [after local declaration])] r(object { val y : Int fun inner_bar() { y = 10 } }) -> <v0> PREV:[jmp?(L2)]
w(a|<v0>) w(a|<v0>)
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
@@ -196,10 +196,10 @@ L0:
magic[IMPLICIT_RECEIVER]($x) -> <v0> magic[IMPLICIT_RECEIVER]($x) -> <v0>
r(1) -> <v1> r(1) -> <v1>
w($x|<v0>, <v1>) w($x|<v0>, <v1>)
2 jmp?(L2 [after local declaration]) NEXT:[r(object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }) -> <v3>, d(fun ggg() { y = 10 })] 2 jmp?(L2) NEXT:[r(object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }) -> <v3>, d(fun ggg() { y = 10 })]
d(fun ggg() { y = 10 }) NEXT:[<SINK>] d(fun ggg() { y = 10 }) NEXT:[<SINK>]
L2 [after local declaration]: L2 [after local declaration]:
r(object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }) -> <v3> PREV:[jmp?(L2 [after local declaration])] r(object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }) -> <v3> PREV:[jmp?(L2)]
w(a|<v3>) w(a|<v3>)
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
@@ -254,13 +254,13 @@ L0:
magic[IMPLICIT_RECEIVER]($x) -> <v1> magic[IMPLICIT_RECEIVER]($x) -> <v1>
r(2) -> <v2> r(2) -> <v2>
w($x|<v1>, <v2>) w($x|<v1>, <v2>)
2 jmp?(L2 [after local declaration]) NEXT:[jmp?(L5 [after local declaration]), d(fun foo() { x = 3 })] 2 jmp?(L2) NEXT:[jmp?(L5), d(fun foo() { x = 3 })]
d(fun foo() { x = 3 }) NEXT:[<SINK>] d(fun foo() { x = 3 }) NEXT:[<SINK>]
L2 [after local declaration]: L2 [after local declaration]:
jmp?(L5 [after local declaration]) NEXT:[r(object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }) -> <v4>, d(fun bar() { x = 4 })] PREV:[jmp?(L2 [after local declaration])] jmp?(L5) NEXT:[r(object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }) -> <v4>, d(fun bar() { x = 4 })] PREV:[jmp?(L2)]
d(fun bar() { x = 4 }) NEXT:[<SINK>] d(fun bar() { x = 4 }) NEXT:[<SINK>]
L5 [after local declaration]: L5 [after local declaration]:
r(object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }) -> <v4> PREV:[jmp?(L5 [after local declaration])] r(object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }) -> <v4> PREV:[jmp?(L5)]
w(a|<v4>) w(a|<v4>)
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
compiler/testData/cfg/declarations/local/ObjectExpression.instructions
+1 -1
View File
@@ -81,4 +81,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/local/localClass.instructions
+4 -4
View File
@@ -14,11 +14,11 @@ fun f() {
L0: L0:
1 <START> 1 <START>
2 mark({ class LocalClass() { fun f() { val x = "" fun loc() { val x3 = "" } } } }) 2 mark({ class LocalClass() { fun f() { val x = "" fun loc() { val x3 = "" } } } })
jmp?(L2 [after local declaration]) NEXT:[<END>, d(fun f() { val x = "" fun loc() { val x3 = "" } })] jmp?(L2) NEXT:[<END>, d(fun f() { val x = "" fun loc() { val x3 = "" } })]
d(fun f() { val x = "" fun loc() { val x3 = "" } }) NEXT:[<SINK>] d(fun f() { val x = "" fun loc() { val x3 = "" } }) NEXT:[<SINK>]
L1: L1:
L2 [after local declaration]: L2 [after local declaration]:
1 <END> NEXT:[<SINK>] PREV:[jmp?(L2 [after local declaration])] 1 <END> NEXT:[<SINK>] PREV:[jmp?(L2)]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
@@ -40,11 +40,11 @@ L3:
mark("") mark("")
r("") -> <v0> r("") -> <v0>
w(x|<v0>) w(x|<v0>)
jmp?(L5 [after local declaration]) NEXT:[<END>, d(fun loc() { val x3 = "" })] jmp?(L5) NEXT:[<END>, d(fun loc() { val x3 = "" })]
d(fun loc() { val x3 = "" }) NEXT:[<SINK>] d(fun loc() { val x3 = "" }) NEXT:[<SINK>]
L4: L4:
L5 [after local declaration]: L5 [after local declaration]:
3 <END> NEXT:[<SINK>] PREV:[jmp?(L5 [after local declaration])] 3 <END> NEXT:[<SINK>] PREV:[jmp?(L5)]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
compiler/testData/cfg/declarations/local/localProperty.instructions
+2 -2
View File
@@ -13,11 +13,11 @@ L0:
1 <START> 1 <START>
2 mark({ class B { val a: Int get() { val b: Int return b } } }) 2 mark({ class B { val a: Int get() { val b: Int return b } } })
v(val a: Int get() { val b: Int return b }) v(val a: Int get() { val b: Int return b })
jmp?(L2 [after local declaration]) NEXT:[<END>, d(get() { val b: Int return b })] jmp?(L2) NEXT:[<END>, d(get() { val b: Int return b })]
d(get() { val b: Int return b }) NEXT:[<SINK>] d(get() { val b: Int return b }) NEXT:[<SINK>]
L1: L1:
L2 [after local declaration]: L2 [after local declaration]:
1 <END> NEXT:[<SINK>] PREV:[jmp?(L2 [after local declaration])] 1 <END> NEXT:[<SINK>] PREV:[jmp?(L2)]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.instructions
+1 -1
View File
@@ -69,4 +69,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.instructions
+1 -1
View File
@@ -24,4 +24,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/properties/DelegatedProperty.instructions
+1 -1
View File
@@ -62,4 +62,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/properties/backingFieldAccess.instructions
+1 -1
View File
@@ -20,4 +20,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.instructions
+1 -1
View File
@@ -33,4 +33,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/Assignments.instructions
+8 -8
View File
@@ -44,27 +44,27 @@ L0:
w(x|<v4>) w(x|<v4>)
mark(if (true) 1 else 2) mark(if (true) 1 else 2)
r(true) -> <v5> r(true) -> <v5>
jf(L2 [else branch]|<v5>) NEXT:[r(2) -> <v7>, r(1) -> <v6>] jf(L2|<v5>) NEXT:[r(2) -> <v7>, r(1) -> <v6>]
r(1) -> <v6> r(1) -> <v6>
jmp(L3 ['if' expression result]) NEXT:[merge(if (true) 1 else 2|<v6>, <v7>) -> <v8>] jmp(L3) NEXT:[merge(if (true) 1 else 2|<v6>, <v7>) -> <v8>]
L2 [else branch]: L2 [else branch]:
r(2) -> <v7> PREV:[jf(L2 [else branch]|<v5>)] r(2) -> <v7> PREV:[jf(L2|<v5>)]
L3 ['if' expression result]: L3 ['if' expression result]:
merge(if (true) 1 else 2|<v6>, <v7>) -> <v8> PREV:[jmp(L3 ['if' expression result]), r(2) -> <v7>] merge(if (true) 1 else 2|<v6>, <v7>) -> <v8> PREV:[jmp(L3), r(2) -> <v7>]
w(x|<v8>) w(x|<v8>)
v(val y = true && false) v(val y = true && false)
r(true) -> <v9> r(true) -> <v9>
jf(L4 [result of boolean operation]|<v9>) NEXT:[magic[AND](true && false|<v9>, <v10>) -> <v11>, r(false) -> <v10>] jf(L4|<v9>) NEXT:[magic[AND](true && false|<v9>, <v10>) -> <v11>, r(false) -> <v10>]
r(false) -> <v10> r(false) -> <v10>
L4 [result of boolean operation]: L4 [result of boolean operation]:
magic[AND](true && false|<v9>, <v10>) -> <v11> PREV:[jf(L4 [result of boolean operation]|<v9>), r(false) -> <v10>] magic[AND](true && false|<v9>, <v10>) -> <v11> PREV:[jf(L4|<v9>), r(false) -> <v10>]
w(y|<v11>) w(y|<v11>)
v(val z = false && true) v(val z = false && true)
r(false) -> <v12> r(false) -> <v12>
jf(L5 [result of boolean operation]|<v12>) NEXT:[magic[AND](false && true|<v12>, <v13>) -> <v14>, r(true) -> <v13>] jf(L5|<v12>) NEXT:[magic[AND](false && true|<v12>, <v13>) -> <v14>, r(true) -> <v13>]
r(true) -> <v13> r(true) -> <v13>
L5 [result of boolean operation]: L5 [result of boolean operation]:
magic[AND](false && true|<v12>, <v13>) -> <v14> PREV:[jf(L5 [result of boolean operation]|<v12>), r(true) -> <v13>] magic[AND](false && true|<v12>, <v13>) -> <v14> PREV:[jf(L5|<v12>), r(true) -> <v13>]
w(z|<v14>) w(z|<v14>)
v(val t = Test()) v(val t = Test())
mark(Test()) mark(Test())
compiler/testData/cfg/expressions/LazyBooleans.instructions
+24 -24
View File
@@ -28,63 +28,63 @@ L0:
2 mark({ if (a) { 1 } else { 2 } 3 if (a && b) 5 else 6 7 if (a || b) 8 else 9 10 if (a) 11 12 if (a) else 13 14 }) 2 mark({ if (a) { 1 } else { 2 } 3 if (a && b) 5 else 6 7 if (a || b) 8 else 9 10 if (a) 11 12 if (a) else 13 14 })
mark(if (a) { 1 } else { 2 }) mark(if (a) { 1 } else { 2 })
r(a) -> <v2> r(a) -> <v2>
jf(L2 [else branch]|<v2>) NEXT:[mark({ 2 }), mark({ 1 })] jf(L2|<v2>) NEXT:[mark({ 2 }), mark({ 1 })]
3 mark({ 1 }) 3 mark({ 1 })
r(1) -> <v3> r(1) -> <v3>
2 jmp(L3 ['if' expression result]) NEXT:[merge(if (a) { 1 } else { 2 }|<v3>, <v4>) -> <v5>] 2 jmp(L3) NEXT:[merge(if (a) { 1 } else { 2 }|<v3>, <v4>) -> <v5>]
L2 [else branch]: L2 [else branch]:
3 mark({ 2 }) PREV:[jf(L2 [else branch]|<v2>)] 3 mark({ 2 }) PREV:[jf(L2|<v2>)]
r(2) -> <v4> r(2) -> <v4>
L3 ['if' expression result]: L3 ['if' expression result]:
2 merge(if (a) { 1 } else { 2 }|<v3>, <v4>) -> <v5> PREV:[jmp(L3 ['if' expression result]), r(2) -> <v4>] 2 merge(if (a) { 1 } else { 2 }|<v3>, <v4>) -> <v5> PREV:[jmp(L3), r(2) -> <v4>]
r(3) -> <v6> r(3) -> <v6>
mark(if (a && b) 5 else 6) mark(if (a && b) 5 else 6)
r(a) -> <v7> r(a) -> <v7>
jf(L4 [result of boolean operation]|<v7>) NEXT:[magic[AND](a && b|<v7>, <v8>) -> <v9>, r(b) -> <v8>] jf(L4|<v7>) NEXT:[magic[AND](a && b|<v7>, <v8>) -> <v9>, r(b) -> <v8>]
r(b) -> <v8> r(b) -> <v8>
L4 [result of boolean operation]: L4 [result of boolean operation]:
magic[AND](a && b|<v7>, <v8>) -> <v9> PREV:[jf(L4 [result of boolean operation]|<v7>), r(b) -> <v8>] magic[AND](a && b|<v7>, <v8>) -> <v9> PREV:[jf(L4|<v7>), r(b) -> <v8>]
jf(L5 [else branch]|<v9>) NEXT:[r(6) -> <v11>, r(5) -> <v10>] jf(L5|<v9>) NEXT:[r(6) -> <v11>, r(5) -> <v10>]
r(5) -> <v10> r(5) -> <v10>
jmp(L6 ['if' expression result]) NEXT:[merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12>] jmp(L6) NEXT:[merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12>]
L5 [else branch]: L5 [else branch]:
r(6) -> <v11> PREV:[jf(L5 [else branch]|<v9>)] r(6) -> <v11> PREV:[jf(L5|<v9>)]
L6 ['if' expression result]: L6 ['if' expression result]:
merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12> PREV:[jmp(L6 ['if' expression result]), r(6) -> <v11>] merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12> PREV:[jmp(L6), r(6) -> <v11>]
r(7) -> <v13> r(7) -> <v13>
mark(if (a || b) 8 else 9) mark(if (a || b) 8 else 9)
r(a) -> <v14> r(a) -> <v14>
jt(L7 [result of boolean operation]|<v14>) NEXT:[r(b) -> <v15>, magic[OR](a || b|<v14>, <v15>) -> <v16>] jt(L7|<v14>) NEXT:[r(b) -> <v15>, magic[OR](a || b|<v14>, <v15>) -> <v16>]
r(b) -> <v15> r(b) -> <v15>
L7 [result of boolean operation]: L7 [result of boolean operation]:
magic[OR](a || b|<v14>, <v15>) -> <v16> PREV:[jt(L7 [result of boolean operation]|<v14>), r(b) -> <v15>] magic[OR](a || b|<v14>, <v15>) -> <v16> PREV:[jt(L7|<v14>), r(b) -> <v15>]
jf(L8 [else branch]|<v16>) NEXT:[r(9) -> <v18>, r(8) -> <v17>] jf(L8|<v16>) NEXT:[r(9) -> <v18>, r(8) -> <v17>]
r(8) -> <v17> r(8) -> <v17>
jmp(L9 ['if' expression result]) NEXT:[merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19>] jmp(L9) NEXT:[merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19>]
L8 [else branch]: L8 [else branch]:
r(9) -> <v18> PREV:[jf(L8 [else branch]|<v16>)] r(9) -> <v18> PREV:[jf(L8|<v16>)]
L9 ['if' expression result]: L9 ['if' expression result]:
merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19> PREV:[jmp(L9 ['if' expression result]), r(9) -> <v18>] merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19> PREV:[jmp(L9), r(9) -> <v18>]
r(10) -> <v20> r(10) -> <v20>
mark(if (a) 11) mark(if (a) 11)
r(a) -> <v21> r(a) -> <v21>
jf(L10 [else branch]|<v21>) NEXT:[read (Unit), r(11) -> <v22>] jf(L10|<v21>) NEXT:[read (Unit), r(11) -> <v22>]
r(11) -> <v22> r(11) -> <v22>
jmp(L11 ['if' expression result]) NEXT:[merge(if (a) 11|<v22>) -> <v23>] jmp(L11) NEXT:[merge(if (a) 11|<v22>) -> <v23>]
L10 [else branch]: L10 [else branch]:
read (Unit) PREV:[jf(L10 [else branch]|<v21>)] read (Unit) PREV:[jf(L10|<v21>)]
L11 ['if' expression result]: L11 ['if' expression result]:
merge(if (a) 11|<v22>) -> <v23> PREV:[jmp(L11 ['if' expression result]), read (Unit)] merge(if (a) 11|<v22>) -> <v23> PREV:[jmp(L11), read (Unit)]
r(12) -> <v24> r(12) -> <v24>
mark(if (a) else 13) mark(if (a) else 13)
r(a) -> <v25> r(a) -> <v25>
jf(L12 [else branch]|<v25>) NEXT:[r(13) -> <v26>, read (Unit)] jf(L12|<v25>) NEXT:[r(13) -> <v26>, read (Unit)]
read (Unit) read (Unit)
jmp(L13 ['if' expression result]) NEXT:[merge(if (a) else 13|<v26>) -> <v27>] jmp(L13) NEXT:[merge(if (a) else 13|<v26>) -> <v27>]
L12 [else branch]: L12 [else branch]:
r(13) -> <v26> PREV:[jf(L12 [else branch]|<v25>)] r(13) -> <v26> PREV:[jf(L12|<v25>)]
L13 ['if' expression result]: L13 ['if' expression result]:
merge(if (a) else 13|<v26>) -> <v27> PREV:[jmp(L13 ['if' expression result]), r(13) -> <v26>] merge(if (a) else 13|<v26>) -> <v27> PREV:[jmp(L13), r(13) -> <v26>]
r(14) -> <v28> r(14) -> <v28>
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
compiler/testData/cfg/expressions/ReturnFromExpression.instructions
+2 -2
View File
@@ -7,12 +7,12 @@ L0:
1 <START> 1 <START>
2 mark({ false || (return false) }) 2 mark({ false || (return false) })
r(false) -> <v0> r(false) -> <v0>
jt(L2 [result of boolean operation]|<v0>) NEXT:[mark((return false)), magic[OR](false || (return false)|<v0>, !<v2>) -> <v3>] jt(L2|<v0>) NEXT:[mark((return false)), magic[OR](false || (return false)|<v0>, !<v2>) -> <v3>]
mark((return false)) mark((return false))
r(false) -> <v1> r(false) -> <v1>
ret(*|<v1>) L1 NEXT:[<END>] ret(*|<v1>) L1 NEXT:[<END>]
L2 [result of boolean operation]: L2 [result of boolean operation]:
magic[OR](false || (return false)|<v0>, !<v2>) -> <v3> PREV:[jt(L2 [result of boolean operation]|<v0>)] magic[OR](false || (return false)|<v0>, !<v2>) -> <v3> PREV:[jt(L2|<v0>)]
L1: L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v1>) L1, magic[OR](false || (return false)|<v0>, !<v2>) -> <v3>] 1 <END> NEXT:[<SINK>] PREV:[ret(*|<v1>) L1, magic[OR](false || (return false)|<v0>, !<v2>) -> <v3>]
error: error:
compiler/testData/cfg/expressions/assignmentToThis.instructions
+1 -1
View File
@@ -17,4 +17,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/callableReferences.instructions
+1 -1
View File
@@ -26,4 +26,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/chainedQualifiedExpression.instructions
+1 -1
View File
@@ -573,4 +573,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/expressionAsFunction.instructions
+1 -1
View File
@@ -19,4 +19,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/incdec.instructions
+1 -1
View File
@@ -62,4 +62,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/nothingExpr.instructions
+1 -1
View File
@@ -55,4 +55,4 @@ error:
<ERROR> PREV:[jmp(error)] <ERROR> PREV:[jmp(error)]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/parenthesizedSelector.instructions
+2 -2
View File
@@ -49,10 +49,10 @@ L0:
2 mark({ with(1) { "".(foo)() } }) 2 mark({ with(1) { "".(foo)() } })
r(1) -> <v0> r(1) -> <v0>
mark({ "".(foo)() }) mark({ "".(foo)() })
jmp?(L2 [after local declaration]) NEXT:[r({ "".(foo)() }) -> <v1>, d({ "".(foo)() })] jmp?(L2) NEXT:[r({ "".(foo)() }) -> <v1>, d({ "".(foo)() })]
d({ "".(foo)() }) NEXT:[<SINK>] d({ "".(foo)() }) NEXT:[<SINK>]
L2 [after local declaration]: L2 [after local declaration]:
r({ "".(foo)() }) -> <v1> PREV:[jmp?(L2 [after local declaration])] r({ "".(foo)() }) -> <v1> PREV:[jmp?(L2)]
mark(with(1) { "".(foo)() }) mark(with(1) { "".(foo)() })
call(with(1) { "".(foo)() }, with|<v0>, <v1>) -> <v2> call(with(1) { "".(foo)() }, with|<v0>, <v1>) -> <v2>
L1: L1:
compiler/testData/cfg/expressions/propertySafeCall.instructions
+1 -1
View File
@@ -18,4 +18,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.instructions
+1 -1
View File
@@ -18,4 +18,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/thisExpression.instructions
+1 -1
View File
@@ -14,4 +14,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/unresolvedCall.instructions
+1 -1
View File
@@ -21,4 +21,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/unresolvedProperty.instructions
+1 -1
View File
@@ -19,4 +19,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/unresolvedWriteLHS.instructions
+1 -1
View File
@@ -15,4 +15,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/unusedExpressionSimpleName.instructions
+1 -1
View File
@@ -17,4 +17,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/functions/DefaultValuesForArguments.instructions
+6 -6
View File
@@ -4,10 +4,10 @@ fun foo(i: Int = 1, j: Int) = i + j
L0: L0:
1 <START> 1 <START>
v(i: Int = 1) v(i: Int = 1)
jmp?(L2 [after default value for parameter i]) NEXT:[magic[FAKE_INITIALIZER](i: Int = 1) -> <v1>, r(1) -> <v0>] jmp?(L2) NEXT:[magic[FAKE_INITIALIZER](i: Int = 1) -> <v1>, r(1) -> <v0>]
r(1) -> <v0> r(1) -> <v0>
L2 [after default value for parameter i]: L2 [after default value for parameter i]:
magic[FAKE_INITIALIZER](i: Int = 1) -> <v1> PREV:[jmp?(L2 [after default value for parameter i]), r(1) -> <v0>] magic[FAKE_INITIALIZER](i: Int = 1) -> <v1> PREV:[jmp?(L2), r(1) -> <v0>]
merge(i: Int = 1|<v0>, <v1>) -> <v2> merge(i: Int = 1|<v0>, <v1>) -> <v2>
w(i|<v2>) w(i|<v2>)
v(j: Int) v(j: Int)
@@ -19,9 +19,9 @@ L2 [after default value for parameter i]:
call(i + j, plus|<v4>, <v5>) -> <v6> call(i + j, plus|<v4>, <v5>) -> <v6>
ret(*|<v6>) L1 ret(*|<v6>) L1
L1: L1:
<END> NEXT:[<SINK>] <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/tailCalls/finally.instructions
+5 -5
View File
@@ -11,19 +11,19 @@ L0:
1 <START> 1 <START>
2 mark({ try { // do nothing } finally { test() } }) 2 mark({ try { // do nothing } finally { test() } })
mark(try { // do nothing } finally { test() }) mark(try { // do nothing } finally { test() })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ test() }), mark({ // do nothing })] jmp?(L2) NEXT:[mark({ test() }), mark({ // do nothing })]
3 mark({ // do nothing }) 3 mark({ // do nothing })
read (Unit) read (Unit)
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ test() })] 2 jmp(L3) NEXT:[mark({ test() })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L4 [start finally]: L4 [start finally]:
3 mark({ test() }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ test() }) PREV:[jmp?(L2)]
mark(test()) mark(test())
call(test(), test) -> <v0> call(test(), test) -> <v0>
L5 [finish finally]: L5 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L3 [skipFinallyToErrorBlock]: L3 [skipFinallyToErrorBlock]:
3 mark({ test() }) PREV:[jmp(L3 [skipFinallyToErrorBlock])] 3 mark({ test() }) PREV:[jmp(L3)]
mark(test()) mark(test())
call(test(), test) -> <v0> call(test(), test) -> <v0>
2 merge(try { // do nothing } finally { test() }|!<v1>) -> <v2> 2 merge(try { // do nothing } finally { test() }|!<v1>) -> <v2>
@@ -33,4 +33,4 @@ error:
<ERROR> PREV:[jmp(error)] <ERROR> PREV:[jmp(error)]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/tailCalls/finallyWithReturn.instructions
+5 -5
View File
@@ -11,20 +11,20 @@ L0:
1 <START> 1 <START>
2 mark({ try { // do nothing } finally { return test() } }) 2 mark({ try { // do nothing } finally { return test() } })
mark(try { // do nothing } finally { return test() }) mark(try { // do nothing } finally { return test() })
jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return test() }), mark({ // do nothing })] jmp?(L2) NEXT:[mark({ return test() }), mark({ // do nothing })]
3 mark({ // do nothing }) 3 mark({ // do nothing })
read (Unit) read (Unit)
2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ return test() })] 2 jmp(L3) NEXT:[mark({ return test() })]
L2 [onExceptionToFinallyBlock]: L2 [onExceptionToFinallyBlock]:
L4 [start finally]: L4 [start finally]:
3 mark({ return test() }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] 3 mark({ return test() }) PREV:[jmp?(L2)]
mark(test()) mark(test())
call(test(), test) -> <v0> call(test(), test) -> <v0>
ret(*|<v0>) L1 NEXT:[<END>] ret(*|<v0>) L1 NEXT:[<END>]
L5 [finish finally]: L5 [finish finally]:
- 2 jmp(error) NEXT:[<ERROR>] PREV:[] - 2 jmp(error) NEXT:[<ERROR>] PREV:[]
L3 [skipFinallyToErrorBlock]: L3 [skipFinallyToErrorBlock]:
3 mark({ return test() }) PREV:[jmp(L3 [skipFinallyToErrorBlock])] 3 mark({ return test() }) PREV:[jmp(L3)]
mark(test()) mark(test())
call(test(), test) -> <v0> call(test(), test) -> <v0>
ret(*|<v0>) L1 NEXT:[<END>] ret(*|<v0>) L1 NEXT:[<END>]
@@ -35,4 +35,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/tailCalls/sum.instructions
+3 -3
View File
@@ -21,12 +21,12 @@ L0:
call(toLong(), toLong|<v3>) -> <v4> call(toLong(), toLong|<v3>) -> <v4>
mark(x == 0.toLong()) mark(x == 0.toLong())
call(x == 0.toLong(), equals|<v2>, <v4>) -> <v5> call(x == 0.toLong(), equals|<v2>, <v4>) -> <v5>
jf(L2 [else branch]|<v5>) NEXT:[read (Unit), r(sum) -> <v6>] jf(L2|<v5>) NEXT:[read (Unit), r(sum) -> <v6>]
r(sum) -> <v6> r(sum) -> <v6>
ret(*|<v6>) L1 NEXT:[<END>] ret(*|<v6>) L1 NEXT:[<END>]
- jmp(L3 ['if' expression result]) NEXT:[merge(if (x == 0.toLong()) return sum|!<v7>) -> <v8>] PREV:[] - jmp(L3) NEXT:[merge(if (x == 0.toLong()) return sum|!<v7>) -> <v8>] PREV:[]
L2 [else branch]: L2 [else branch]:
read (Unit) PREV:[jf(L2 [else branch]|<v5>)] read (Unit) PREV:[jf(L2|<v5>)]
L3 ['if' expression result]: L3 ['if' expression result]:
merge(if (x == 0.toLong()) return sum|!<v7>) -> <v8> merge(if (x == 0.toLong()) return sum|!<v7>) -> <v8>
r(x) -> <v9> r(x) -> <v9>
compiler/testData/cfg/tailCalls/try.instructions
+5 -5
View File
@@ -11,19 +11,19 @@ L0:
1 <START> 1 <START>
2 mark({ try { return foo() } catch (e: Throwable) { } }) 2 mark({ try { return foo() } catch (e: Throwable) { } })
mark(try { return foo() } catch (e: Throwable) { }) mark(try { return foo() } catch (e: Throwable) { })
jmp?(L2 [onException]) NEXT:[v(e: Throwable), mark({ return foo() })] jmp?(L2) NEXT:[v(e: Throwable), mark({ return foo() })]
3 mark({ return foo() }) 3 mark({ return foo() })
mark(foo()) mark(foo())
call(foo(), foo) -> <v0> call(foo(), foo) -> <v0>
ret(*|<v0>) L1 NEXT:[<END>] ret(*|<v0>) L1 NEXT:[<END>]
- 2 jmp(L3 [afterCatches]) NEXT:[merge(try { return foo() } catch (e: Throwable) { }|!<v1>, !<v3>) -> <v4>] PREV:[] - 2 jmp(L3) NEXT:[merge(try { return foo() } catch (e: Throwable) { }|!<v1>, !<v3>) -> <v4>] PREV:[]
L2 [onException]: L2 [onException]:
3 v(e: Throwable) PREV:[jmp?(L2 [onException])] 3 v(e: Throwable) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](e: Throwable) -> <v2> magic[FAKE_INITIALIZER](e: Throwable) -> <v2>
w(e|<v2>) w(e|<v2>)
4 mark({ }) 4 mark({ })
read (Unit) read (Unit)
3 jmp(L3 [afterCatches]) 3 jmp(L3)
L3 [afterCatches]: L3 [afterCatches]:
2 merge(try { return foo() } catch (e: Throwable) { }|!<v1>, !<v3>) -> <v4> 2 merge(try { return foo() } catch (e: Throwable) { }|!<v1>, !<v3>) -> <v4>
L1: L1:
@@ -32,4 +32,4 @@ error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/tailCalls/tryCatchFinally.instructions
+9 -9
View File
@@ -13,31 +13,31 @@ L0:
1 <START> 1 <START>
2 mark({ try { test() } catch (any : Exception) { test() } finally { test() } }) 2 mark({ try { test() } catch (any : Exception) { test() } finally { test() } })
mark(try { test() } catch (any : Exception) { test() } finally { test() }) mark(try { test() } catch (any : Exception) { test() } finally { test() })
jmp?(L2 [onException]) NEXT:[v(any : Exception), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L2) NEXT:[v(any : Exception), jmp?(L3)]
jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ test() }), mark({ test() })] jmp?(L3) NEXT:[mark({ test() }), mark({ test() })]
3 mark({ test() }) 3 mark({ test() })
mark(test()) mark(test())
call(test(), test) -> <v0> call(test(), test) -> <v0>
2 jmp(L4 [afterCatches]) NEXT:[jmp(L5 [skipFinallyToErrorBlock])] 2 jmp(L4) NEXT:[jmp(L5)]
L2 [onException]: L2 [onException]:
3 v(any : Exception) PREV:[jmp?(L2 [onException])] 3 v(any : Exception) PREV:[jmp?(L2)]
magic[FAKE_INITIALIZER](any : Exception) -> <v1> magic[FAKE_INITIALIZER](any : Exception) -> <v1>
w(any|<v1>) w(any|<v1>)
4 mark({ test() }) 4 mark({ test() })
mark(test()) mark(test())
call(test(), test) -> <v2> call(test(), test) -> <v2>
3 jmp(L4 [afterCatches]) 3 jmp(L4)
L4 [afterCatches]: L4 [afterCatches]:
2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ test() })] PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches])] 2 jmp(L5) NEXT:[mark({ test() })] PREV:[jmp(L4), jmp(L4)]
L3 [onExceptionToFinallyBlock]: L3 [onExceptionToFinallyBlock]:
L6 [start finally]: L6 [start finally]:
3 mark({ test() }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] 3 mark({ test() }) PREV:[jmp?(L3)]
mark(test()) mark(test())
call(test(), test) -> <v3> call(test(), test) -> <v3>
L7 [finish finally]: L7 [finish finally]:
2 jmp(error) NEXT:[<ERROR>] 2 jmp(error) NEXT:[<ERROR>]
L5 [skipFinallyToErrorBlock]: L5 [skipFinallyToErrorBlock]:
3 mark({ test() }) PREV:[jmp(L5 [skipFinallyToErrorBlock])] 3 mark({ test() }) PREV:[jmp(L5)]
mark(test()) mark(test())
call(test(), test) -> <v3> call(test(), test) -> <v3>
2 merge(try { test() } catch (any : Exception) { test() } finally { test() }|<v0>, <v2>) -> <v4> 2 merge(try { test() } catch (any : Exception) { test() } finally { test() }|<v0>, <v2>) -> <v4>
@@ -47,4 +47,4 @@ error:
<ERROR> PREV:[jmp(error)] <ERROR> PREV:[jmp(error)]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/tests/org/jetbrains/jet/cfg/AbstractPseudocodeTest.java
+1 -1
View File
@@ -188,7 +188,7 @@ public abstract class AbstractPseudocodeTest extends KotlinTestWithEnvironment {
Instruction instruction = instructions.get(i); Instruction instruction = instructions.get(i);
for (PseudocodeImpl.PseudocodeLabel label: labels) { for (PseudocodeImpl.PseudocodeLabel label: labels) {
if (label.getTargetInstructionIndex() == i) { if (label.getTargetInstructionIndex() == i) {
out.append(label.getName()).append(":\n"); out.append(label).append(":\n");
} }
} }