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

Pseudocode: Add debug information to magic instructions

Browse Source
This commit is contained in:
Alexey Sedunov
2014-06-26 13:06:28 +04:00
parent d636d362b7
commit 4707f4a5e9
125 changed files with 1204 additions and 1157 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java
+2 -1
View File
@@ -115,7 +115,8 @@ public interface JetControlFlowBuilder {
@NotNull JetElement instructionElement, @NotNull JetElement instructionElement,
@Nullable JetElement valueElement, @Nullable JetElement valueElement,
@NotNull List<PseudoValue> inputValues, @NotNull List<PseudoValue> inputValues,
@NotNull Map<PseudoValue, TypePredicate> expectedTypes @NotNull Map<PseudoValue, TypePredicate> expectedTypes,
@NotNull MagicKind kind
); );
@NotNull @NotNull
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java
+3 -2
View File
@@ -71,9 +71,10 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
@NotNull JetElement instructionElement, @NotNull JetElement instructionElement,
@Nullable JetElement valueElement, @Nullable JetElement valueElement,
@NotNull List<PseudoValue> inputValues, @NotNull List<PseudoValue> inputValues,
@NotNull Map<PseudoValue, TypePredicate> expectedTypes @NotNull Map<PseudoValue, TypePredicate> expectedTypes,
@NotNull MagicKind kind
) { ) {
return getDelegateBuilder().magic(instructionElement, valueElement, inputValues, expectedTypes); return getDelegateBuilder().magic(instructionElement, valueElement, inputValues, expectedTypes, kind);
} }
@NotNull @NotNull
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+31 -27
View File
@@ -30,6 +30,7 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.cfg.pseudocode.*; import org.jetbrains.jet.lang.cfg.pseudocode.*;
import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.AccessTarget; import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.AccessTarget;
import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.InstructionWithValue; import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.InstructionWithValue;
import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.MagicKind;
import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage; import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
@@ -130,14 +131,14 @@ public class JetControlFlowProcessor {
if (!generateCall(condition.getOperationReference())) { if (!generateCall(condition.getOperationReference())) {
JetExpression rangeExpression = condition.getRangeExpression(); JetExpression rangeExpression = condition.getRangeExpression();
generateInstructions(rangeExpression); generateInstructions(rangeExpression);
createNonSyntheticValue(condition, rangeExpression); createNonSyntheticValue(condition, MagicKind.UNRESOLVED_CALL, rangeExpression);
} }
} }
@Override @Override
public void visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition) { public void visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition) {
mark(condition); mark(condition);
createNonSyntheticValue(condition, getSubjectExpression(condition)); createNonSyntheticValue(condition, MagicKind.IS, getSubjectExpression(condition));
} }
@Override @Override
@@ -150,7 +151,7 @@ public class JetControlFlowProcessor {
JetExpression subjectExpression = getSubjectExpression(condition); JetExpression subjectExpression = getSubjectExpression(condition);
if (subjectExpression != null) { if (subjectExpression != null) {
// todo: this can be replaced by equals() invocation (when corresponding resolved call is recorded) // todo: this can be replaced by equals() invocation (when corresponding resolved call is recorded)
createNonSyntheticValue(condition, subjectExpression, expression); createNonSyntheticValue(condition, MagicKind.EQUALS_IN_WHEN_CONDITION, subjectExpression, expression);
} }
else { else {
copyValue(expression, condition); copyValue(expression, condition);
@@ -195,20 +196,22 @@ public class JetControlFlowProcessor {
} }
@NotNull @NotNull
private PseudoValue createSyntheticValue(@NotNull JetElement instructionElement, JetElement... from) { private PseudoValue createSyntheticValue(@NotNull JetElement instructionElement, @NotNull MagicKind kind, JetElement... from) {
List<PseudoValue> values = elementsToValues(from.length > 0 ? Arrays.asList(from) : Collections.<JetElement>emptyList()); List<PseudoValue> values = elementsToValues(from.length > 0 ? Arrays.asList(from) : Collections.<JetElement>emptyList());
return builder.magic(instructionElement, null, values, defaultTypeMap(values)).getOutputValue(); return builder.magic(instructionElement, null, values, defaultTypeMap(values), kind).getOutputValue();
} }
@NotNull @NotNull
private PseudoValue createNonSyntheticValue(@NotNull JetElement to, @NotNull List<? extends JetElement> from) { private PseudoValue createNonSyntheticValue(
@NotNull JetElement to, @NotNull List<? extends JetElement> from, @NotNull MagicKind kind
) {
List<PseudoValue> values = elementsToValues(from); List<PseudoValue> values = elementsToValues(from);
return builder.magic(to, to, values, defaultTypeMap(values)).getOutputValue(); return builder.magic(to, to, values, defaultTypeMap(values), kind).getOutputValue();
} }
@NotNull @NotNull
private PseudoValue createNonSyntheticValue(@NotNull JetElement to, JetElement... from) { private PseudoValue createNonSyntheticValue(@NotNull JetElement to, @NotNull MagicKind kind, JetElement... from) {
return createNonSyntheticValue(to, Arrays.asList(from)); return createNonSyntheticValue(to, Arrays.asList(from), kind);
} }
@NotNull @NotNull
@@ -299,7 +302,7 @@ public class JetControlFlowProcessor {
public void visitThisExpression(@NotNull JetThisExpression expression) { public void visitThisExpression(@NotNull JetThisExpression expression) {
ResolvedCall<?> resolvedCall = getResolvedCall(expression, trace.getBindingContext()); ResolvedCall<?> resolvedCall = getResolvedCall(expression, trace.getBindingContext());
if (resolvedCall == null) { if (resolvedCall == null) {
createNonSyntheticValue(expression); createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL);
return; return;
} }
@@ -325,7 +328,7 @@ public class JetControlFlowProcessor {
generateCall(variableAsFunctionResolvedCall.getVariableCall()); generateCall(variableAsFunctionResolvedCall.getVariableCall());
} }
else if (!generateCall(expression) && !(expression.getParent() instanceof JetCallExpression)) { else if (!generateCall(expression) && !(expression.getParent() instanceof JetCallExpression)) {
createNonSyntheticValue(expression, generateAndGetReceiverIfAny(expression)); createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, generateAndGetReceiverIfAny(expression));
} }
} }
@@ -437,7 +440,7 @@ public class JetControlFlowProcessor {
if (right != null) { if (right != null) {
generateInstructions(right); generateInstructions(right);
} }
createNonSyntheticValue(expression, left, right); createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, left, right);
mark(expression); mark(expression);
} }
@@ -557,7 +560,7 @@ public class JetControlFlowProcessor {
) { ) {
VariableDescriptor descriptor = BindingContextUtils.extractVariableDescriptorIfAny(trace.getBindingContext(), left, false); VariableDescriptor descriptor = BindingContextUtils.extractVariableDescriptorIfAny(trace.getBindingContext(), left, false);
if (descriptor != null) { if (descriptor != null) {
PseudoValue rValue = rightValue != null ? rightValue : createSyntheticValue(parentExpression); PseudoValue rValue = rightValue != null ? rightValue : createSyntheticValue(parentExpression, MagicKind.UNRECOGNIZED_WRITE_RHS);
builder.write(parentExpression, left, rValue, target, receiverValues); builder.write(parentExpression, left, rValue, target, receiverValues);
} }
} }
@@ -570,7 +573,7 @@ public class JetControlFlowProcessor {
} }
private void generateArrayAccessWithoutCall(JetArrayAccessExpression arrayAccessExpression) { private void generateArrayAccessWithoutCall(JetArrayAccessExpression arrayAccessExpression) {
createNonSyntheticValue(arrayAccessExpression, generateArrayAccessArguments(arrayAccessExpression)); createNonSyntheticValue(arrayAccessExpression, generateArrayAccessArguments(arrayAccessExpression), MagicKind.UNRESOLVED_CALL);
} }
private List<JetExpression> generateArrayAccessArguments(JetArrayAccessExpression arrayAccessExpression) { private List<JetExpression> generateArrayAccessArguments(JetArrayAccessExpression arrayAccessExpression) {
@@ -609,7 +612,7 @@ public class JetControlFlowProcessor {
} }
else { else {
generateInstructions(baseExpression); generateInstructions(baseExpression);
rhsValue = createNonSyntheticValue(expression, baseExpression); rhsValue = createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, baseExpression);
} }
if (incrementOrDecrement) { if (incrementOrDecrement) {
@@ -775,7 +778,7 @@ public class JetControlFlowProcessor {
JetParameter catchParameter = catchClause.getCatchParameter(); JetParameter catchParameter = catchClause.getCatchParameter();
if (catchParameter != null) { if (catchParameter != null) {
builder.declareParameter(catchParameter); builder.declareParameter(catchParameter);
generateInitializer(catchParameter, createSyntheticValue(catchParameter)); generateInitializer(catchParameter, createSyntheticValue(catchParameter, MagicKind.FAKE_INITIALIZER));
} }
JetExpression catchBody = catchClause.getCatchBody(); JetExpression catchBody = catchClause.getCatchBody();
if (catchBody != null) { if (catchBody != null) {
@@ -903,7 +906,8 @@ public class JetControlFlowProcessor {
loopRange != null ? loopRange : expression, loopRange != null ? loopRange : expression,
null, null,
Collections.singletonList(loopRangeValue), Collections.singletonList(loopRangeValue),
Collections.singletonMap(loopRangeValue, loopRangeTypePredicate) Collections.singletonMap(loopRangeValue, loopRangeTypePredicate),
MagicKind.LOOP_RANGE_ITERATION
).getOutputValue(); ).getOutputValue();
if (loopParameter != null) { if (loopParameter != null) {
@@ -1029,7 +1033,7 @@ public class JetControlFlowProcessor {
@NotNull @NotNull
private PseudoValue computePseudoValueForParameter(@NotNull JetParameter parameter) { private PseudoValue computePseudoValueForParameter(@NotNull JetParameter parameter) {
PseudoValue syntheticValue = createSyntheticValue(parameter); PseudoValue syntheticValue = createSyntheticValue(parameter, MagicKind.FAKE_INITIALIZER);
PseudoValue defaultValue = builder.getBoundValue(parameter.getDefaultValue()); PseudoValue defaultValue = builder.getBoundValue(parameter.getDefaultValue());
if (defaultValue == null) { if (defaultValue == null) {
return syntheticValue; return syntheticValue;
@@ -1091,7 +1095,7 @@ public class JetControlFlowProcessor {
} }
else { else {
generateInstructions(receiverExpression); generateInstructions(receiverExpression);
createNonSyntheticValue(expression, receiverExpression); createNonSyntheticValue(expression, MagicKind.UNSUPPORTED_OPERATION, receiverExpression);
} }
} }
@@ -1116,7 +1120,7 @@ public class JetControlFlowProcessor {
inputExpressions.add(generateAndGetReceiverIfAny(expression)); inputExpressions.add(generateAndGetReceiverIfAny(expression));
mark(expression); mark(expression);
createNonSyntheticValue(expression, inputExpressions); createNonSyntheticValue(expression, inputExpressions, MagicKind.UNRESOLVED_CALL);
} }
} }
@@ -1175,11 +1179,11 @@ public class JetControlFlowProcessor {
).getOutputValue(); ).getOutputValue();
} }
else { else {
writtenValue = createSyntheticValue(entry, initializer); writtenValue = createSyntheticValue(entry, MagicKind.UNRESOLVED_CALL, initializer);
} }
if (generateWriteForEntries) { if (generateWriteForEntries) {
generateInitializer(entry, writtenValue != null ? writtenValue : createSyntheticValue(entry)); generateInitializer(entry, writtenValue != null ? writtenValue : createSyntheticValue(entry, MagicKind.FAKE_INITIALIZER));
} }
} }
} }
@@ -1201,7 +1205,7 @@ public class JetControlFlowProcessor {
} }
else { else {
visitJetElement(expression); visitJetElement(expression);
createNonSyntheticValue(expression, left); createNonSyntheticValue(expression, MagicKind.UNSUPPORTED_OPERATION, left);
} }
} }
@@ -1234,7 +1238,7 @@ public class JetControlFlowProcessor {
mark(expression); mark(expression);
JetExpression left = expression.getLeftHandSide(); JetExpression left = expression.getLeftHandSide();
generateInstructions(left); generateInstructions(left);
createNonSyntheticValue(expression, left); createNonSyntheticValue(expression, MagicKind.IS, left);
} }
@Override @Override
@@ -1384,7 +1388,7 @@ public class JetControlFlowProcessor {
for (JetExpression argument : arguments) { for (JetExpression argument : arguments) {
generateInstructions(argument); generateInstructions(argument);
} }
createNonSyntheticValue(call, arguments); createNonSyntheticValue(call, arguments, MagicKind.UNRESOLVED_CALL);
} }
} }
@@ -1398,7 +1402,7 @@ public class JetControlFlowProcessor {
if (expectedTypePredicate == null) { if (expectedTypePredicate == null) {
expectedTypePredicate = AllTypes.instance$; expectedTypePredicate = AllTypes.instance$;
} }
builder.magic(specifier, specifier, arguments, PseudocodePackage.expectedTypeFor(expectedTypePredicate, arguments)); builder.magic(specifier, specifier, arguments, PseudocodePackage.expectedTypeFor(expectedTypePredicate, arguments), MagicKind.VALUE_CONSUMER);
} }
@Override @Override
@@ -1483,7 +1487,7 @@ public class JetControlFlowProcessor {
if (receiver instanceof ThisReceiver) { if (receiver instanceof ThisReceiver) {
if (generateInstructions) { if (generateInstructions) {
receiverValues = receiverValues.plus(createSyntheticValue(callElement), receiver); receiverValues = receiverValues.plus(createSyntheticValue(callElement, MagicKind.IMPLICIT_RECEIVER), receiver);
} }
} }
else if (receiver instanceof ExpressionReceiver) { else if (receiver instanceof ExpressionReceiver) {
compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
+20 -4
View File
@@ -418,7 +418,8 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
@Override @Override
public InstructionWithValue loadStringTemplate(@NotNull JetStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues) { public InstructionWithValue loadStringTemplate(@NotNull JetStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues) {
if (inputValues.isEmpty()) return read(expression); if (inputValues.isEmpty()) return read(expression);
return magic(expression, expression, inputValues, PseudocodePackage.expectedTypeFor(AllTypes.instance$, inputValues)); Map<PseudoValue, TypePredicate> predicate = PseudocodePackage.expectedTypeFor(AllTypes.instance$, inputValues);
return magic(expression, expression, inputValues, predicate, MagicKind.STRING_TEMPLATE);
} }
@NotNull @NotNull
@@ -427,10 +428,11 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
@NotNull JetElement instructionElement, @NotNull JetElement instructionElement,
@Nullable JetElement valueElement, @Nullable JetElement valueElement,
@NotNull List<PseudoValue> inputValues, @NotNull List<PseudoValue> inputValues,
@NotNull Map<PseudoValue, TypePredicate> expectedTypes @NotNull Map<PseudoValue, TypePredicate> expectedTypes,
@NotNull MagicKind kind
) { ) {
MagicInstruction instruction = MagicInstruction.object$.create( MagicInstruction instruction = MagicInstruction.object$.create(
instructionElement, valueElement, getCurrentScope(), inputValues, expectedTypes, valueFactory instructionElement, valueElement, getCurrentScope(), inputValues, expectedTypes, kind, valueFactory
); );
add(instruction); add(instruction);
return instruction; return instruction;
@@ -496,7 +498,21 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
throw new IllegalArgumentException("Invalid operation: " + operation); throw new IllegalArgumentException("Invalid operation: " + operation);
} }
return magic(expression, expression, inputValues, expectedTypes); return magic(expression, expression, inputValues, expectedTypes, getMagicKind(operation));
}
@NotNull
private MagicKind getMagicKind(@NotNull PredefinedOperation operation) {
switch(operation) {
case AND:
return MagicKind.AND;
case OR:
return MagicKind.OR;
case NOT_NULL_ASSERTION:
return MagicKind.NOT_NULL_ASSERTION;
default:
throw new IllegalArgumentException("Invalid operation: " + operation);
}
} }
@Override @Override
compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/eval/operationInstructions.kt
+35 -10
View File
@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.cfg.pseudocode.instructions.InstructionVisitorWith
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor
import org.jetbrains.jet.lang.cfg.pseudocode.TypePredicate import org.jetbrains.jet.lang.cfg.pseudocode.TypePredicate
import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.MagicKind
public abstract class OperationInstruction protected( public abstract class OperationInstruction protected(
element: JetElement, element: JetElement,
@@ -101,7 +102,8 @@ public class MagicInstruction(
element: JetElement, element: JetElement,
lexicalScope: LexicalScope, lexicalScope: LexicalScope,
inputValues: List<PseudoValue>, inputValues: List<PseudoValue>,
val expectedTypes: Map<PseudoValue, TypePredicate> val expectedTypes: Map<PseudoValue, TypePredicate>,
val kind: MagicKind
) : OperationInstruction(element, lexicalScope, inputValues), StrictlyValuedOperationInstruction { ) : OperationInstruction(element, lexicalScope, inputValues), StrictlyValuedOperationInstruction {
public val synthetic: Boolean get() = outputValue.element == null public val synthetic: Boolean get() = outputValue.element == null
@@ -109,22 +111,45 @@ public class MagicInstruction(
override fun <R> accept(visitor: InstructionVisitorWithResult<R>): R = visitor.visitMagic(this) override fun <R> accept(visitor: InstructionVisitorWithResult<R>): R = visitor.visitMagic(this)
override fun createCopy() = MagicInstruction(element, lexicalScope, inputValues, expectedTypes).setResult(resultValue) override fun createCopy() =
MagicInstruction(element, lexicalScope, inputValues, expectedTypes, kind).setResult(resultValue)
override fun toString() = renderInstruction("magic", render(element)) override fun toString() = renderInstruction("magic[$kind]", render(element))
class object { class object {
fun create(element: JetElement, fun create(
valueElement: JetElement?, element: JetElement,
lexicalScope: LexicalScope, valueElement: JetElement?,
inputValues: List<PseudoValue>, lexicalScope: LexicalScope,
expectedTypes: Map<PseudoValue, TypePredicate>, inputValues: List<PseudoValue>,
factory: PseudoValueFactory): MagicInstruction = MagicInstruction( expectedTypes: Map<PseudoValue, TypePredicate>,
element, lexicalScope, inputValues, expectedTypes kind: MagicKind,
factory: PseudoValueFactory
): MagicInstruction = MagicInstruction(
element, lexicalScope, inputValues, expectedTypes, kind
).setResult(factory, valueElement) as MagicInstruction ).setResult(factory, valueElement) as MagicInstruction
} }
} }
public enum class MagicKind {
// builtin operations
STRING_TEMPLATE
AND
OR
NOT_NULL_ASSERTION
EQUALS_IN_WHEN_CONDITION
IS
// implicit operations
LOOP_RANGE_ITERATION
IMPLICIT_RECEIVER
VALUE_CONSUMER
// unrecognized operations
UNRESOLVED_CALL
UNSUPPORTED_OPERATION
UNRECOGNIZED_WRITE_RHS
FAKE_INITIALIZER
}
// Merges values produced by alternative control-flow paths (such as 'if' branches) // Merges values produced by alternative control-flow paths (such as 'if' branches)
class MergeInstruction private( class MergeInstruction private(
element: JetElement, element: JetElement,
compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions
+7 -7
View File
@@ -40,16 +40,16 @@ sink:
fun use(vararg a: Any?) = a fun use(vararg a: Any?) = a
--------------------- ---------------------
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(vararg a: Any?) INIT: in: {} out: {a=D} v(vararg a: Any?) INIT: in: {} out: {a=D}
magic(vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D} magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID} USE: in: {a=READ} out: {a=READ} w(a|<v0>) INIT: in: {a=D} out: {a=ID} USE: in: {a=READ} out: {a=READ}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ} r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ}
ret(*|<v1>) L1 ret(*|<v1>) L1
L1: L1:
<END> <END>
error: 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/IfWithUninitialized.values
+1 -1
View File
@@ -22,6 +22,6 @@ if (1 < 2) { use(b) } else { b = true } <v4>: *
== use == == use ==
fun use(vararg a: Any?) = a fun use(vararg a: Any?) = a
--------------------- ---------------------
<v0>: {<: Array<Any?>} NEW: magic(vararg a: Any?) -> <v0> <v0>: {<: Array<Any?>} NEW: magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0>
a <v1>: {<: Array<Any?>} NEW: r(a) -> <v1> a <v1>: {<: Array<Any?>} NEW: r(a) -> <v1>
===================== =====================
compiler/testData/cfg-variables/basic/InitializedNotDeclared.instructions
+8 -8
View File
@@ -7,16 +7,16 @@ class A {
} }
--------------------- ---------------------
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
2 mark({ x = 1 }) 2 mark({ x = 1 })
magic(x) -> <v0> magic[IMPLICIT_RECEIVER](x) -> <v0>
r(1) -> <v1> USE: in: {x=ONLY_WRITTEN_NEVER_READ} out: {x=ONLY_WRITTEN_NEVER_READ} r(1) -> <v1> USE: in: {x=ONLY_WRITTEN_NEVER_READ} out: {x=ONLY_WRITTEN_NEVER_READ}
w(x|<v0>, <v1>) INIT: in: {} out: {x=I} USE: in: {} out: {x=ONLY_WRITTEN_NEVER_READ} w(x|<v0>, <v1>) INIT: in: {} out: {x=I} USE: in: {} out: {x=ONLY_WRITTEN_NEVER_READ}
1 v(val x: Int) INIT: in: {x=I} out: {x=ID} 1 v(val x: Int) INIT: in: {x=I} out: {x=ID}
L1: L1:
<END> INIT: in: {x=ID} out: {x=ID} <END> INIT: in: {x=ID} out: {x=ID}
error: 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/InitializedNotDeclared.values
+1 -1
View File
@@ -6,6 +6,6 @@ class A {
val x: Int val x: Int
} }
--------------------- ---------------------
<v0>: A NEW: magic(x) -> <v0> <v0>: A NEW: magic[IMPLICIT_RECEIVER](x) -> <v0>
1 <v1>: Int NEW: r(1) -> <v1> 1 <v1>: Int NEW: r(1) -> <v1>
===================== =====================
compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions
+19 -19
View File
@@ -34,42 +34,42 @@ sink:
} }
--------------------- ---------------------
L3: L3:
3 <START> INIT: in: {} out: {} 3 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {x=D} v(x: Int) INIT: in: {} out: {x=D}
magic(x: Int) -> <v0> INIT: in: {x=D} out: {x=D} magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {x=D} out: {x=D}
w(x|<v0>) INIT: in: {x=D} out: {x=ID} w(x|<v0>) INIT: in: {x=D} out: {x=ID}
4 mark(val y = x + a use(a)) INIT: in: {x=ID} out: {x=ID} 4 mark(val y = x + a use(a)) INIT: in: {x=ID} out: {x=ID}
v(val y = x + a) INIT: in: {x=ID} out: {x=ID, y=D} USE: in: {a=READ, x=READ} out: {a=READ, x=READ} v(val y = x + a) INIT: in: {x=ID} out: {x=ID, y=D} USE: in: {a=READ, x=READ} out: {a=READ, x=READ}
r(x) -> <v1> INIT: in: {x=ID, y=D} out: {x=ID, y=D} USE: in: {a=READ} out: {a=READ, x=READ} r(x) -> <v1> INIT: in: {x=ID, y=D} out: {x=ID, y=D} USE: in: {a=READ} out: {a=READ, x=READ}
r(a) -> <v2> r(a) -> <v2>
mark(x + a) mark(x + a)
call(x + a, plus|<v1>, <v2>) -> <v3> call(x + a, plus|<v1>, <v2>) -> <v3>
w(y|<v3>) INIT: in: {x=ID, y=D} out: {x=ID, y=ID} USE: in: {a=READ} out: {a=READ} w(y|<v3>) INIT: in: {x=ID, y=D} out: {x=ID, y=ID} USE: in: {a=READ} out: {a=READ}
r(a) -> <v4> INIT: in: {x=ID, y=ID} out: {x=ID, y=ID} USE: in: {} out: {a=READ} r(a) -> <v4> INIT: in: {x=ID, y=ID} out: {x=ID, y=ID} USE: in: {} out: {a=READ}
mark(use(a)) mark(use(a))
call(use(a), use|<v4>) -> <v5> call(use(a), use|<v4>) -> <v5>
3 ret(*|<v5>) L4 INIT: in: {x=ID} out: {x=ID} 3 ret(*|<v5>) L4 INIT: in: {x=ID} out: {x=ID}
L4: L4:
<END> <END>
error: 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: {}
===================== =====================
== use == == use ==
fun use(vararg a: Any?) = a fun use(vararg a: Any?) = a
--------------------- ---------------------
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(vararg a: Any?) INIT: in: {} out: {a=D} v(vararg a: Any?) INIT: in: {} out: {a=D}
magic(vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D} magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID} USE: in: {a=READ} out: {a=READ} w(a|<v0>) INIT: in: {a=D} out: {a=ID} USE: in: {a=READ} out: {a=READ}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ} r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ}
ret(*|<v1>) L1 ret(*|<v1>) L1
L1: L1:
<END> <END>
error: 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/UsageInFunctionLiteral.values
+2 -2
View File
@@ -16,7 +16,7 @@ fun foo() {
use(a) use(a)
} }
--------------------- ---------------------
<v0>: Int NEW: magic(x: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](x: Int) -> <v0>
x <v1>: Int NEW: r(x) -> <v1> x <v1>: Int NEW: r(x) -> <v1>
a <v2>: Int NEW: r(a) -> <v2> a <v2>: Int NEW: r(a) -> <v2>
x + a <v3>: Int NEW: call(x + a, plus|<v1>, <v2>) -> <v3> x + a <v3>: Int NEW: call(x + a, plus|<v1>, <v2>) -> <v3>
@@ -27,6 +27,6 @@ val y = x + a use(a) <v5>: {<: Array<Any?>} COPY
== use == == use ==
fun use(vararg a: Any?) = a fun use(vararg a: Any?) = a
--------------------- ---------------------
<v0>: {<: Array<Any?>} NEW: magic(vararg a: Any?) -> <v0> <v0>: {<: Array<Any?>} NEW: magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0>
a <v1>: {<: Array<Any?>} NEW: r(a) -> <v1> a <v1>: {<: Array<Any?>} NEW: r(a) -> <v1>
===================== =====================
compiler/testData/cfg-variables/basic/VariablesInitialization.instructions
+13 -13
View File
@@ -31,24 +31,24 @@ fun bar(foo: Foo) {
} }
--------------------- ---------------------
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(foo: Foo) INIT: in: {} out: {foo=D} v(foo: Foo) INIT: in: {} out: {foo=D}
magic(foo: Foo) -> <v0> INIT: in: {foo=D} out: {foo=D} magic[FAKE_INITIALIZER](foo: Foo) -> <v0> INIT: in: {foo=D} out: {foo=D}
w(foo|<v0>) INIT: in: {foo=D} out: {foo=ID} w(foo|<v0>) INIT: in: {foo=D} out: {foo=ID}
2 mark({ foo.c foo.c = 2 42 }) INIT: in: {foo=ID} out: {foo=ID} 2 mark({ foo.c foo.c = 2 42 }) INIT: in: {foo=ID} out: {foo=ID}
mark(foo.c) mark(foo.c)
r(foo) -> <v1> USE: in: {c=READ, foo=READ} out: {c=READ, foo=READ} r(foo) -> <v1> USE: in: {c=READ, foo=READ} out: {c=READ, foo=READ}
r(c|<v1>) -> <v2> USE: in: {c=ONLY_WRITTEN_NEVER_READ, foo=READ} out: {c=READ, foo=READ} r(c|<v1>) -> <v2> USE: in: {c=ONLY_WRITTEN_NEVER_READ, foo=READ} out: {c=READ, foo=READ}
r(foo) -> <v3> USE: in: {c=ONLY_WRITTEN_NEVER_READ} out: {c=ONLY_WRITTEN_NEVER_READ, foo=READ} r(foo) -> <v3> USE: in: {c=ONLY_WRITTEN_NEVER_READ} out: {c=ONLY_WRITTEN_NEVER_READ, foo=READ}
r(2) -> <v4> USE: in: {c=ONLY_WRITTEN_NEVER_READ} out: {c=ONLY_WRITTEN_NEVER_READ} r(2) -> <v4> USE: in: {c=ONLY_WRITTEN_NEVER_READ} out: {c=ONLY_WRITTEN_NEVER_READ}
w(foo.c|<v3>, <v4>) INIT: in: {foo=ID} out: {c=I, foo=ID} USE: in: {} out: {c=ONLY_WRITTEN_NEVER_READ} w(foo.c|<v3>, <v4>) INIT: in: {foo=ID} out: {c=I, foo=ID} USE: in: {} out: {c=ONLY_WRITTEN_NEVER_READ}
r(42) -> <v5> INIT: in: {c=I, foo=ID} out: {c=I, foo=ID} r(42) -> <v5> INIT: in: {c=I, foo=ID} out: {c=I, foo=ID}
L1: L1:
1 <END> 1 <END>
error: error:
<ERROR> INIT: in: {} out: {} <ERROR> INIT: in: {} out: {}
sink: sink:
<SINK> INIT: in: {c=I, foo=ID} out: {c=I, foo=ID} USE: in: {} out: {} <SINK> INIT: in: {c=I, foo=ID} out: {c=I, foo=ID} USE: in: {} out: {}
===================== =====================
== Foo == == Foo ==
trait Foo { trait Foo {
compiler/testData/cfg-variables/basic/VariablesInitialization.values
+1 -1
View File
@@ -18,7 +18,7 @@ fun bar(foo: Foo) {
42 42
} }
--------------------- ---------------------
<v0>: {<: Foo} NEW: magic(foo: Foo) -> <v0> <v0>: {<: Foo} NEW: magic[FAKE_INITIALIZER](foo: Foo) -> <v0>
foo <v1>: {<: Foo} NEW: r(foo) -> <v1> foo <v1>: {<: Foo} NEW: r(foo) -> <v1>
c <v2>: * NEW: r(c|<v1>) -> <v2> c <v2>: * NEW: r(c|<v1>) -> <v2>
foo.c <v2>: * COPY foo.c <v2>: * COPY
compiler/testData/cfg-variables/basic/VariablesUsage.instructions
+7 -7
View File
@@ -50,16 +50,16 @@ sink:
fun use(a: Int) = a fun use(a: Int) = a
--------------------- ---------------------
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(a: Int) INIT: in: {} out: {a=D} v(a: Int) INIT: in: {} out: {a=D}
magic(a: Int) -> <v0> INIT: in: {a=D} out: {a=D} magic[FAKE_INITIALIZER](a: Int) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID} USE: in: {a=READ} out: {a=READ} w(a|<v0>) INIT: in: {a=D} out: {a=ID} USE: in: {a=READ} out: {a=READ}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ} r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ}
ret(*|<v1>) L1 ret(*|<v1>) L1
L1: L1:
<END> <END>
error: 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/VariablesUsage.values
+1 -1
View File
@@ -25,6 +25,6 @@ fun bar() {
== use == == use ==
fun use(a: Int) = a fun use(a: Int) = a
--------------------- ---------------------
<v0>: Int NEW: magic(a: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a: Int) -> <v0>
a <v1>: Int NEW: r(a) -> <v1> a <v1>: Int NEW: r(a) -> <v1>
===================== =====================
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
+19 -19
View File
@@ -29,10 +29,10 @@ sink:
L3: L3:
2 <START> INIT: in: {} out: {} 2 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {x=D} v(x: Int) INIT: in: {} out: {x=D}
magic(x: Int) -> <v0> INIT: in: {x=D} out: {x=D} magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {x=D} out: {x=D}
w(x|<v0>) INIT: in: {x=D} out: {x=ID} w(x|<v0>) INIT: in: {x=D} out: {x=ID}
3 mark(sum(x - 1) + x) INIT: in: {x=ID} out: {x=ID} 3 mark(sum(x - 1) + x) INIT: in: {x=ID} out: {x=ID}
magic(sum) -> <v1> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ} magic[IMPLICIT_RECEIVER](sum) -> <v1> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
r(sum|<v1>) -> <v2> USE: in: {x=READ} out: {sum=READ, x=READ} r(sum|<v1>) -> <v2> USE: in: {x=READ} out: {sum=READ, x=READ}
r(x) -> <v3> r(x) -> <v3>
r(1) -> <v4> r(1) -> <v4>
@@ -55,16 +55,16 @@ sink:
open class A(val a: A) open class A(val a: A)
--------------------- ---------------------
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(val a: A) INIT: in: {} out: {a=D} v(val a: A) INIT: in: {} out: {a=D}
magic(val a: A) -> <v0> INIT: in: {a=D} out: {a=D} magic[FAKE_INITIALIZER](val a: A) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID} w(a|<v0>) INIT: in: {a=D} out: {a=ID}
L1: L1:
<END> INIT: in: {a=ID} out: {a=ID} <END> INIT: in: {a=ID} out: {a=ID}
error: 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: {}
===================== =====================
== TestObjectLiteral == == TestObjectLiteral ==
class TestObjectLiteral { class TestObjectLiteral {
@@ -82,13 +82,13 @@ L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(val obj: A = object: A(obj) { { val x = obj } fun foo() { val y = obj } }) INIT: in: {} out: {obj=D} v(val obj: A = object: A(obj) { { val x = obj } fun foo() { val y = obj } }) INIT: in: {} out: {obj=D}
mark(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) INIT: in: {obj=D} out: {obj=D} mark(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) INIT: in: {obj=D} out: {obj=D}
magic(obj) -> <v0> magic[IMPLICIT_RECEIVER](obj) -> <v0>
r(obj|<v0>) -> <v1> r(obj|<v0>) -> <v1>
mark(A(obj)) mark(A(obj))
call(A(obj), <init>|<v1>) -> <v2> call(A(obj), <init>|<v1>) -> <v2>
2 mark({ val x = obj }) 2 mark({ val x = obj })
v(val x = obj) INIT: in: {obj=D} out: {obj=D, x=D} v(val x = obj) INIT: in: {obj=D} out: {obj=D, x=D}
magic(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) INIT: in: {obj=D} out: {obj=D} 1 jmp?(L2) INIT: in: {obj=D} out: {obj=D}
@@ -109,18 +109,18 @@ fun foo() {
} }
--------------------- ---------------------
L3: L3:
2 <START> INIT: in: {} out: {} 2 <START> INIT: in: {} out: {}
3 mark({ val y = obj }) 3 mark({ val y = obj })
v(val y = obj) INIT: in: {} out: {y=D} v(val y = obj) INIT: in: {} out: {y=D}
magic(obj) -> <v0> INIT: in: {y=D} out: {y=D} USE: in: {obj=READ} out: {obj=READ} magic[IMPLICIT_RECEIVER](obj) -> <v0> INIT: in: {y=D} out: {y=D} USE: in: {obj=READ} out: {obj=READ}
r(obj|<v0>) -> <v1> USE: in: {} out: {obj=READ} r(obj|<v0>) -> <v1> USE: in: {} out: {obj=READ}
w(y|<v1>) INIT: in: {y=D} out: {y=ID} w(y|<v1>) INIT: in: {y=D} out: {y=ID}
L4: L4:
2 <END> INIT: in: {} out: {} 2 <END> INIT: in: {} out: {}
error: error:
<ERROR> <ERROR>
sink: sink:
<SINK> USE: in: {} out: {} <SINK> USE: in: {} out: {}
===================== =====================
== TestOther == == TestOther ==
class TestOther { class TestOther {
@@ -130,7 +130,7 @@ class TestOther {
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(val x: Int = x + 1) INIT: in: {} out: {x=D} v(val x: Int = x + 1) INIT: in: {} out: {x=D}
magic(x) -> <v0> INIT: in: {x=D} out: {x=D} USE: in: {x=READ} out: {x=READ} magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {x=D} out: {x=D} USE: in: {x=READ} out: {x=READ}
r(x|<v0>) -> <v1> USE: in: {} out: {x=READ} r(x|<v0>) -> <v1> USE: in: {} out: {x=READ}
r(1) -> <v2> r(1) -> <v2>
mark(x + 1) mark(x + 1)
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values
+7 -7
View File
@@ -12,8 +12,8 @@ class TestFunctionLiteral {
sum(x - 1) + x sum(x - 1) + x
} }
--------------------- ---------------------
<v0>: Int NEW: magic(x: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](x: Int) -> <v0>
<v1>: TestFunctionLiteral NEW: magic(sum) -> <v1> <v1>: TestFunctionLiteral NEW: magic[IMPLICIT_RECEIVER](sum) -> <v1>
sum <v2>: {<: (Int) -> Int} NEW: r(sum|<v1>) -> <v2> sum <v2>: {<: (Int) -> Int} NEW: r(sum|<v1>) -> <v2>
x <v3>: Int NEW: r(x) -> <v3> x <v3>: Int NEW: r(x) -> <v3>
1 <v4>: Int NEW: r(1) -> <v4> 1 <v4>: Int NEW: r(1) -> <v4>
@@ -26,7 +26,7 @@ sum(x - 1) + x <v8>: Int COPY
== A == == A ==
open class A(val a: A) open class A(val a: A)
--------------------- ---------------------
<v0>: {<: A} NEW: magic(val a: A) -> <v0> <v0>: {<: A} NEW: magic[FAKE_INITIALIZER](val a: A) -> <v0>
===================== =====================
== TestObjectLiteral == == TestObjectLiteral ==
class TestObjectLiteral { class TestObjectLiteral {
@@ -40,8 +40,8 @@ class TestObjectLiteral {
} }
} }
--------------------- ---------------------
<v0>: TestObjectLiteral NEW: magic(obj) -> <v0> <v0>: TestObjectLiteral NEW: magic[IMPLICIT_RECEIVER](obj) -> <v0>
<v3>: TestObjectLiteral NEW: magic(obj) -> <v3> <v3>: TestObjectLiteral NEW: magic[IMPLICIT_RECEIVER](obj) -> <v3>
obj <v1>: {<: A} NEW: r(obj|<v0>) -> <v1> obj <v1>: {<: A} NEW: r(obj|<v0>) -> <v1>
A(obj) <v2>: * NEW: call(A(obj), <init>|<v1>) -> <v2> A(obj) <v2>: * NEW: call(A(obj), <init>|<v1>) -> <v2>
obj <v4>: {<: A} NEW: r(obj|<v3>) -> <v4> obj <v4>: {<: A} NEW: r(obj|<v3>) -> <v4>
@@ -52,7 +52,7 @@ fun foo() {
val y = obj val y = obj
} }
--------------------- ---------------------
<v0>: TestObjectLiteral NEW: magic(obj) -> <v0> <v0>: TestObjectLiteral NEW: magic[IMPLICIT_RECEIVER](obj) -> <v0>
obj <v1>: {<: A} NEW: r(obj|<v0>) -> <v1> obj <v1>: {<: A} NEW: r(obj|<v0>) -> <v1>
===================== =====================
== TestOther == == TestOther ==
@@ -60,7 +60,7 @@ class TestOther {
val x: Int = x + 1 val x: Int = x + 1
} }
--------------------- ---------------------
<v0>: TestOther NEW: magic(x) -> <v0> <v0>: TestOther NEW: magic[IMPLICIT_RECEIVER](x) -> <v0>
x <v1>: Int NEW: r(x|<v0>) -> <v1> x <v1>: Int NEW: r(x|<v0>) -> <v1>
1 <v2>: Int NEW: r(1) -> <v2> 1 <v2>: Int NEW: r(1) -> <v2>
x + 1 <v3>: Int NEW: call(x + 1, plus|<v1>, <v2>) -> <v3> x + 1 <v3>: Int NEW: call(x + 1, plus|<v1>, <v2>) -> <v3>
compiler/testData/cfg-variables/bugs/varInitializationInIf.instructions
+1 -1
View File
@@ -33,7 +33,7 @@ L3:
r(b) -> <v5> USE: in: {} out: {b=READ} r(b) -> <v5> USE: in: {} out: {b=READ}
error(use, No resolved call) error(use, No resolved call)
mark(use(b)) mark(use(b))
magic(use(b)|<v5>) -> <v6> magic[UNRESOLVED_CALL](use(b)|<v5>) -> <v6>
L1: L1:
1 <END> INIT: in: {} out: {} 1 <END> INIT: in: {} out: {}
error: error:
compiler/testData/cfg-variables/bugs/varInitializationInIf.values
+1 -1
View File
@@ -16,6 +16,6 @@ fun foo() {
false <v3>: Boolean NEW: r(false) -> <v3> false <v3>: Boolean NEW: r(false) -> <v3>
true <v4>: Boolean NEW: r(true) -> <v4> true <v4>: Boolean NEW: r(true) -> <v4>
b <v5>: * NEW: r(b) -> <v5> b <v5>: * NEW: r(b) -> <v5>
use(b) <v6>: * NEW: magic(use(b)|<v5>) -> <v6> use(b) <v6>: * NEW: magic[UNRESOLVED_CALL](use(b)|<v5>) -> <v6>
{ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) } <v6>: * COPY { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) } <v6>: * COPY
===================== =====================
compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions
+9 -9
View File
@@ -16,7 +16,7 @@ fun foo(numbers: Collection<Int>) {
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(numbers: Collection<Int>) INIT: in: {} out: {numbers=D} v(numbers: Collection<Int>) INIT: in: {} out: {numbers=D}
magic(numbers: Collection<Int>) -> <v0> INIT: in: {numbers=D} out: {numbers=D} magic[FAKE_INITIALIZER](numbers: Collection<Int>) -> <v0> INIT: in: {numbers=D} out: {numbers=D}
w(numbers|<v0>) INIT: in: {numbers=D} out: {numbers=ID} w(numbers|<v0>) INIT: in: {numbers=D} out: {numbers=ID}
2 mark({ for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue } }) INIT: in: {numbers=ID} out: {numbers=ID} USE: in: {numbers=READ} out: {numbers=READ} 2 mark({ for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue } }) INIT: in: {numbers=ID} out: {numbers=ID} USE: in: {numbers=READ} out: {numbers=READ}
3 r(numbers) -> <v1> USE: in: {} out: {numbers=READ} 3 r(numbers) -> <v1> USE: in: {} out: {numbers=READ}
@@ -25,7 +25,7 @@ L3:
jmp?(L2) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID} jmp?(L2) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID}
L4 [loop entry point]: L4 [loop entry point]:
L5 [body entry point]: L5 [body entry point]:
magic(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: {}
4 mark({ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue }) 4 mark({ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue })
@@ -63,16 +63,16 @@ sink:
fun use(vararg a: Any?) = a fun use(vararg a: Any?) = a
--------------------- ---------------------
L0: L0:
1 <START> INIT: in: {} out: {} 1 <START> INIT: in: {} out: {}
v(vararg a: Any?) INIT: in: {} out: {a=D} v(vararg a: Any?) INIT: in: {} out: {a=D}
magic(vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D} magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID} USE: in: {a=READ} out: {a=READ} w(a|<v0>) INIT: in: {a=D} out: {a=ID} USE: in: {a=READ} out: {a=READ}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ} r(a) -> <v1> INIT: in: {a=ID} out: {a=ID} USE: in: {} out: {a=READ}
ret(*|<v1>) L1 ret(*|<v1>) L1
L1: L1:
<END> <END>
error: 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/varInitializationInIfInCycle.values
+3 -3
View File
@@ -13,8 +13,8 @@ fun foo(numbers: Collection<Int>) {
} }
} }
--------------------- ---------------------
<v0>: {<: Collection<Int>} NEW: magic(numbers: Collection<Int>) -> <v0> <v0>: {<: Collection<Int>} NEW: magic[FAKE_INITIALIZER](numbers: Collection<Int>) -> <v0>
<v2>: Int NEW: magic(numbers|<v1>) -> <v2> <v2>: Int NEW: magic[LOOP_RANGE_ITERATION](numbers|<v1>) -> <v2>
numbers <v1>: {<: Iterable<Int>} NEW: r(numbers) -> <v1> numbers <v1>: {<: Iterable<Int>} NEW: r(numbers) -> <v1>
1 <v3>: {<: Comparable<Int>} NEW: r(1) -> <v3> 1 <v3>: {<: Comparable<Int>} NEW: r(1) -> <v3>
2 <v4>: Int NEW: r(2) -> <v4> 2 <v4>: Int NEW: r(2) -> <v4>
@@ -27,6 +27,6 @@ use(b) <v9>: * NEW: call(use(b), use|<v8>) -> <v9>
== use == == use ==
fun use(vararg a: Any?) = a fun use(vararg a: Any?) = a
--------------------- ---------------------
<v0>: {<: Array<Any?>} NEW: magic(vararg a: Any?) -> <v0> <v0>: {<: Array<Any?>} NEW: magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0>
a <v1>: {<: Array<Any?>} NEW: r(a) -> <v1> a <v1>: {<: Array<Any?>} NEW: r(a) -> <v1>
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/forScope.instructions
+1 -1
View File
@@ -21,7 +21,7 @@ L3:
jmp?(L2) INIT: in: {i=D} out: {i=D} jmp?(L2) INIT: in: {i=D} out: {i=D}
L4 [loop entry point]: L4 [loop entry point]:
L5 [body entry point]: L5 [body entry point]:
magic(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}
4 mark({ val a = i }) 4 mark({ val a = i })
compiler/testData/cfg-variables/lexicalScopes/forScope.values
+1 -1
View File
@@ -7,7 +7,7 @@ fun foo() {
"after" "after"
} }
--------------------- ---------------------
<v4>: Int NEW: magic(1..10|<v3>) -> <v4> <v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..10|<v3>) -> <v4>
"before" <v0>: * NEW: r("before") -> <v0> "before" <v0>: * NEW: r("before") -> <v0>
1 <v1>: Int NEW: r(1) -> <v1> 1 <v1>: Int NEW: r(1) -> <v1>
10 <v2>: Int NEW: r(10) -> <v2> 10 <v2>: Int NEW: r(10) -> <v2>
compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions
+12 -12
View File
@@ -38,21 +38,21 @@ sink:
} }
--------------------- ---------------------
L3: L3:
3 <START> INIT: in: {} out: {} 3 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {x=D} v(x: Int) INIT: in: {} out: {x=D}
magic(x: Int) -> <v0> INIT: in: {x=D} out: {x=D} magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {x=D} out: {x=D}
w(x|<v0>) INIT: in: {x=D} out: {x=ID} w(x|<v0>) INIT: in: {x=D} out: {x=ID}
4 mark(val a = x + b) INIT: in: {x=ID} out: {x=ID} 4 mark(val a = x + b) INIT: in: {x=ID} out: {x=ID}
v(val a = x + b) INIT: in: {x=ID} out: {a=D, x=ID} USE: in: {b=READ, x=READ} out: {b=READ, x=READ} v(val a = x + b) INIT: in: {x=ID} out: {a=D, x=ID} USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
r(x) -> <v1> INIT: in: {a=D, x=ID} out: {a=D, x=ID} USE: in: {b=READ} out: {b=READ, x=READ} r(x) -> <v1> INIT: in: {a=D, x=ID} out: {a=D, x=ID} USE: in: {b=READ} out: {b=READ, x=READ}
r(b) -> <v2> USE: in: {} out: {b=READ} r(b) -> <v2> USE: in: {} out: {b=READ}
mark(x + b) mark(x + b)
call(x + b, plus|<v1>, <v2>) -> <v3> call(x + b, plus|<v1>, <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}
L4: L4:
3 <END> INIT: in: {x=ID} out: {x=ID} 3 <END> INIT: in: {x=ID} out: {x=ID}
error: 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/lexicalScopes/functionLiteralScope.values
+1 -1
View File
@@ -19,7 +19,7 @@ fun foo() {
val a = x + b val a = x + b
} }
--------------------- ---------------------
<v0>: Int NEW: magic(x: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](x: Int) -> <v0>
x <v1>: Int NEW: r(x) -> <v1> x <v1>: Int NEW: r(x) -> <v1>
b <v2>: Int NEW: r(b) -> <v2> b <v2>: Int NEW: r(b) -> <v2>
x + b <v3>: Int NEW: call(x + b, plus|<v1>, <v2>) -> <v3> x + b <v3>: Int NEW: call(x + b, plus|<v1>, <v2>) -> <v3>
compiler/testData/cfg-variables/lexicalScopes/localClass.instructions
+9 -9
View File
@@ -18,11 +18,11 @@ L0:
mark("before") mark("before")
r("before") -> <v0> r("before") -> <v0>
v(val x: Int) INIT: in: {} out: {x=D} v(val x: Int) INIT: in: {} out: {x=D}
magic(val x: Int) -> <v1> INIT: in: {x=D} out: {x=D} magic[FAKE_INITIALIZER](val x: Int) -> <v1> INIT: in: {x=D} out: {x=D}
w(x|<v1>) INIT: in: {x=D} out: {x=ID} w(x|<v1>) INIT: in: {x=D} out: {x=ID}
3 mark({ val a = x }) INIT: in: {x=ID} out: {x=ID} 3 mark({ val a = x }) INIT: in: {x=ID} out: {x=ID}
v(val a = x) INIT: in: {x=ID} out: {a=D, x=ID} v(val a = x) INIT: in: {x=ID} out: {a=D, x=ID}
magic(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) INIT: in: {x=ID} out: {x=ID} 2 jmp?(L2) INIT: in: {x=ID} out: {x=ID}
@@ -43,16 +43,16 @@ fun foo() {
} }
--------------------- ---------------------
L3: L3:
3 <START> INIT: in: {} out: {} 3 <START> INIT: in: {} out: {}
4 mark({ val b = x }) 4 mark({ val b = x })
v(val b = x) INIT: in: {} out: {b=D} v(val b = x) INIT: in: {} out: {b=D}
magic(x) -> <v0> INIT: in: {b=D} out: {b=D} USE: in: {x=READ} out: {x=READ} magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {b=D} out: {b=D} USE: in: {x=READ} out: {x=READ}
r(x|<v0>) -> <v1> USE: in: {} out: {x=READ} r(x|<v0>) -> <v1> USE: in: {} out: {x=READ}
w(b|<v1>) INIT: in: {b=D} out: {b=ID} w(b|<v1>) INIT: in: {b=D} out: {b=ID}
L4: L4:
3 <END> INIT: in: {} out: {} 3 <END> INIT: in: {} out: {}
error: error:
<ERROR> <ERROR>
sink: sink:
<SINK> USE: in: {} out: {} <SINK> USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/localClass.values
+3 -3
View File
@@ -12,8 +12,8 @@ fun foo() {
"after" "after"
} }
--------------------- ---------------------
<v1>: Int NEW: magic(val x: Int) -> <v1> <v1>: Int NEW: magic[FAKE_INITIALIZER](val x: Int) -> <v1>
<v2>: A NEW: magic(x) -> <v2> <v2>: A NEW: magic[IMPLICIT_RECEIVER](x) -> <v2>
"before" <v0>: * NEW: r("before") -> <v0> "before" <v0>: * NEW: r("before") -> <v0>
x <v3>: Int NEW: r(x|<v2>) -> <v3> x <v3>: Int NEW: r(x|<v2>) -> <v3>
"after" <v4>: * NEW: r("after") -> <v4> "after" <v4>: * NEW: r("after") -> <v4>
@@ -24,6 +24,6 @@ fun foo() {
val b = x val b = x
} }
--------------------- ---------------------
<v0>: A NEW: magic(x) -> <v0> <v0>: A NEW: magic[IMPLICIT_RECEIVER](x) -> <v0>
x <v1>: Int NEW: r(x|<v0>) -> <v1> x <v1>: Int NEW: r(x|<v0>) -> <v1>
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions
+12 -12
View File
@@ -34,21 +34,21 @@ fun local(x: Int) {
} }
--------------------- ---------------------
L3: L3:
3 <START> INIT: in: {} out: {} 3 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {x=D} v(x: Int) INIT: in: {} out: {x=D}
magic(x: Int) -> <v0> INIT: in: {x=D} out: {x=D} magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {x=D} out: {x=D}
w(x|<v0>) INIT: in: {x=D} out: {x=ID} w(x|<v0>) INIT: in: {x=D} out: {x=ID}
4 mark({ val a = x + b }) INIT: in: {x=ID} out: {x=ID} 4 mark({ val a = x + b }) INIT: in: {x=ID} out: {x=ID}
v(val a = x + b) INIT: in: {x=ID} out: {a=D, x=ID} USE: in: {b=READ, x=READ} out: {b=READ, x=READ} v(val a = x + b) INIT: in: {x=ID} out: {a=D, x=ID} USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
r(x) -> <v1> INIT: in: {a=D, x=ID} out: {a=D, x=ID} USE: in: {b=READ} out: {b=READ, x=READ} r(x) -> <v1> INIT: in: {a=D, x=ID} out: {a=D, x=ID} USE: in: {b=READ} out: {b=READ, x=READ}
r(b) -> <v2> USE: in: {} out: {b=READ} r(b) -> <v2> USE: in: {} out: {b=READ}
mark(x + b) mark(x + b)
call(x + b, plus|<v1>, <v2>) -> <v3> call(x + b, plus|<v1>, <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}
L4: L4:
3 <END> INIT: in: {x=ID} out: {x=ID} 3 <END> INIT: in: {x=ID} out: {x=ID}
error: 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/lexicalScopes/localFunctionScope.values
+1 -1
View File
@@ -18,7 +18,7 @@ fun local(x: Int) {
val a = x + b val a = x + b
} }
--------------------- ---------------------
<v0>: Int NEW: magic(x: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](x: Int) -> <v0>
x <v1>: Int NEW: r(x) -> <v1> x <v1>: Int NEW: r(x) -> <v1>
b <v2>: Int NEW: r(b) -> <v2> b <v2>: Int NEW: r(b) -> <v2>
x + b <v3>: Int NEW: call(x + b, plus|<v1>, <v2>) -> <v3> x + b <v3>: Int NEW: call(x + b, plus|<v1>, <v2>) -> <v3>
compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions
+8 -8
View File
@@ -30,19 +30,19 @@ sink:
fun local(x: Int) = x + b fun local(x: Int) = x + b
--------------------- ---------------------
L3: L3:
3 <START> INIT: in: {} out: {} 3 <START> INIT: in: {} out: {}
v(x: Int) INIT: in: {} out: {x=D} v(x: Int) INIT: in: {} out: {x=D}
magic(x: Int) -> <v0> INIT: in: {x=D} out: {x=D} magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {x=D} out: {x=D}
w(x|<v0>) INIT: in: {x=D} out: {x=ID} USE: in: {b=READ, x=READ} out: {b=READ, x=READ} w(x|<v0>) INIT: in: {x=D} out: {x=ID} USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
r(x) -> <v1> INIT: in: {x=ID} out: {x=ID} USE: in: {b=READ} out: {b=READ, x=READ} r(x) -> <v1> INIT: in: {x=ID} out: {x=ID} USE: in: {b=READ} out: {b=READ, x=READ}
r(b) -> <v2> USE: in: {} out: {b=READ} r(b) -> <v2> USE: in: {} out: {b=READ}
mark(x + b) mark(x + b)
call(x + b, plus|<v1>, <v2>) -> <v3> call(x + b, plus|<v1>, <v2>) -> <v3>
ret(*|<v3>) L4 ret(*|<v3>) L4
L4: L4:
<END> <END>
error: 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/lexicalScopes/localFunctionScopeWithoutBody.values
+1 -1
View File
@@ -14,7 +14,7 @@ fun foo() {
== local == == local ==
fun local(x: Int) = x + b fun local(x: Int) = x + b
--------------------- ---------------------
<v0>: Int NEW: magic(x: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](x: Int) -> <v0>
x <v1>: Int NEW: r(x) -> <v1> x <v1>: Int NEW: r(x) -> <v1>
b <v2>: Int NEW: r(b) -> <v2> b <v2>: Int NEW: r(b) -> <v2>
x + b <v3>: Int NEW: call(x + b, plus|<v1>, <v2>) -> <v3> x + b <v3>: Int NEW: call(x + b, plus|<v1>, <v2>) -> <v3>
compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.instructions
+15 -15
View File
@@ -34,17 +34,17 @@ get() {
} }
--------------------- ---------------------
L3: L3:
3 <START> INIT: in: {} out: {} 3 <START> INIT: in: {} out: {}
4 mark({ return $a }) 4 mark({ return $a })
magic($a) -> <v0> USE: in: {a=READ} out: {a=READ} magic[IMPLICIT_RECEIVER]($a) -> <v0> USE: in: {a=READ} out: {a=READ}
r($a|<v0>) -> <v1> USE: in: {} out: {a=READ} r($a|<v0>) -> <v1> USE: in: {} out: {a=READ}
ret(*|<v1>) L4 ret(*|<v1>) L4
L4: L4:
3 <END> 3 <END>
error: error:
<ERROR> <ERROR>
sink: sink:
<SINK> USE: in: {} out: {} <SINK> USE: in: {} out: {}
===================== =====================
== set_a == == set_a ==
set(v: Int) { set(v: Int) {
@@ -52,18 +52,18 @@ set(v: Int) {
} }
--------------------- ---------------------
L6: L6:
3 <START> INIT: in: {} out: {} 3 <START> INIT: in: {} out: {}
v(v: Int) INIT: in: {} out: {v=D} v(v: Int) INIT: in: {} out: {v=D}
magic(v: Int) -> <v0> INIT: in: {v=D} out: {v=D} magic[FAKE_INITIALIZER](v: Int) -> <v0> INIT: in: {v=D} out: {v=D}
w(v|<v0>) INIT: in: {v=D} out: {v=ID} w(v|<v0>) INIT: in: {v=D} out: {v=ID}
4 mark({ $a = v }) INIT: in: {v=ID} out: {v=ID} 4 mark({ $a = v }) INIT: in: {v=ID} out: {v=ID}
magic($a) -> <v1> USE: in: {a=ONLY_WRITTEN_NEVER_READ, v=READ} out: {a=ONLY_WRITTEN_NEVER_READ, v=READ} magic[IMPLICIT_RECEIVER]($a) -> <v1> USE: in: {a=ONLY_WRITTEN_NEVER_READ, v=READ} out: {a=ONLY_WRITTEN_NEVER_READ, v=READ}
r(v) -> <v2> USE: in: {a=ONLY_WRITTEN_NEVER_READ} out: {a=ONLY_WRITTEN_NEVER_READ, v=READ} r(v) -> <v2> USE: in: {a=ONLY_WRITTEN_NEVER_READ} out: {a=ONLY_WRITTEN_NEVER_READ, v=READ}
w($a|<v1>, <v2>) INIT: in: {v=ID} out: {a=I, v=ID} USE: in: {} out: {a=ONLY_WRITTEN_NEVER_READ} w($a|<v1>, <v2>) INIT: in: {v=ID} out: {a=I, v=ID} USE: in: {} out: {a=ONLY_WRITTEN_NEVER_READ}
L7: L7:
3 <END> INIT: in: {a=I, v=ID} out: {a=I, v=ID} 3 <END> INIT: in: {a=I, v=ID} out: {a=I, v=ID}
error: error:
<ERROR> INIT: in: {} out: {} <ERROR> INIT: in: {} out: {}
sink: sink:
<SINK> INIT: in: {a=I, v=ID} out: {a=I, v=ID} USE: in: {} out: {} <SINK> INIT: in: {a=I, v=ID} out: {a=I, v=ID} USE: in: {} out: {}
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.values
+3 -3
View File
@@ -17,7 +17,7 @@ get() {
return $a return $a
} }
--------------------- ---------------------
<v0>: A NEW: magic($a) -> <v0> <v0>: A NEW: magic[IMPLICIT_RECEIVER]($a) -> <v0>
$a <v1>: Int NEW: r($a|<v0>) -> <v1> $a <v1>: Int NEW: r($a|<v0>) -> <v1>
===================== =====================
== set_a == == set_a ==
@@ -25,7 +25,7 @@ set(v: Int) {
$a = v $a = v
} }
--------------------- ---------------------
<v0>: Int NEW: magic(v: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](v: Int) -> <v0>
<v1>: A NEW: magic($a) -> <v1> <v1>: A NEW: magic[IMPLICIT_RECEIVER]($a) -> <v1>
v <v2>: Int NEW: r(v) -> <v2> v <v2>: Int NEW: r(v) -> <v2>
===================== =====================
compiler/testData/cfg-variables/lexicalScopes/tryScope.instructions
+1 -1
View File
@@ -27,7 +27,7 @@ L0:
2 jmp(L4 [afterCatches]) USE: in: {} out: {} 2 jmp(L4 [afterCatches]) 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(e: Exception) -> <v2> INIT: in: {e=D} out: {e=D} magic[FAKE_INITIALIZER](e: Exception) -> <v2> INIT: in: {e=D} out: {e=D}
w(e|<v2>) INIT: in: {e=D} out: {e=ID} w(e|<v2>) INIT: in: {e=D} out: {e=ID}
4 mark({ val a = e }) INIT: in: {e=ID} out: {e=ID} 4 mark({ val a = e }) INIT: in: {e=ID} out: {e=ID}
v(val a = e) INIT: in: {e=ID} out: {a=D, e=ID} USE: in: {e=READ} out: {e=READ} v(val a = e) INIT: in: {e=ID} out: {a=D, e=ID} USE: in: {e=READ} out: {e=READ}
compiler/testData/cfg-variables/lexicalScopes/tryScope.values
+1 -1
View File
@@ -13,7 +13,7 @@ fun foo() {
"after" "after"
} }
--------------------- ---------------------
<v2>: {<: Exception} NEW: magic(e: Exception) -> <v2> <v2>: {<: Exception} NEW: magic[FAKE_INITIALIZER](e: Exception) -> <v2>
"before" <v0>: * NEW: r("before") -> <v0> "before" <v0>: * NEW: r("before") -> <v0>
foo() <v1>: * NEW: call(foo(), foo) -> <v1> foo() <v1>: * NEW: call(foo(), foo) -> <v1>
{ foo() } <v1>: * COPY { foo() } <v1>: * COPY
compiler/testData/cfg/arrays/ArrayOfFunctions.instructions
+4 -4
View File
@@ -6,7 +6,7 @@ fun test(array: Array<(Int)->Unit>) {
L0: L0:
1 <START> 1 <START>
v(array: Array<(Int)->Unit>) v(array: Array<(Int)->Unit>)
magic(array: Array<(Int)->Unit>) -> <v0> magic[FAKE_INITIALIZER](array: Array<(Int)->Unit>) -> <v0>
w(array|<v0>) w(array|<v0>)
2 mark({ array[11](3) }) 2 mark({ array[11](3) })
mark(array[11]) mark(array[11])
@@ -18,9 +18,9 @@ L0:
mark(array[11](3)) mark(array[11](3))
call(array[11](3), invoke|<v3>, <v4>) -> <v5> call(array[11](3), invoke|<v3>, <v4>) -> <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/arrays/ArrayOfFunctions.values
+1 -1
View File
@@ -3,7 +3,7 @@ fun test(array: Array<(Int)->Unit>) {
array[11](3) array[11](3)
} }
--------------------- ---------------------
<v0>: {<: Array<(Int) -> Unit>} NEW: magic(array: Array<(Int)->Unit>) -> <v0> <v0>: {<: Array<(Int) -> Unit>} NEW: magic[FAKE_INITIALIZER](array: Array<(Int)->Unit>) -> <v0>
array <v1>: {<: Array<(Int) -> Unit>} NEW: r(array) -> <v1> array <v1>: {<: Array<(Int) -> Unit>} NEW: r(array) -> <v1>
11 <v2>: Int NEW: r(11) -> <v2> 11 <v2>: Int NEW: r(11) -> <v2>
array[11] <v3>: {<: (Int) -> Unit} NEW: call(array[11], get|<v1>, <v2>) -> <v3> array[11] <v3>: {<: (Int) -> Unit} NEW: call(array[11], get|<v1>, <v2>) -> <v3>
compiler/testData/cfg/arrays/arrayAccessExpression.instructions
+1 -1
View File
@@ -32,7 +32,7 @@ fun test(ab: Ab) {
L0: L0:
1 <START> 1 <START>
v(ab: Ab) v(ab: Ab)
magic(ab: Ab) -> <v0> magic[FAKE_INITIALIZER](ab: Ab) -> <v0>
w(ab|<v0>) w(ab|<v0>)
2 mark({ ab.getArray()[1] }) 2 mark({ ab.getArray()[1] })
mark(ab.getArray()[1]) mark(ab.getArray()[1])
compiler/testData/cfg/arrays/arrayAccessExpression.values
+1 -1
View File
@@ -13,7 +13,7 @@ fun test(ab: Ab) {
ab.getArray()[1] ab.getArray()[1]
} }
--------------------- ---------------------
<v0>: {<: Ab} NEW: magic(ab: Ab) -> <v0> <v0>: {<: Ab} NEW: magic[FAKE_INITIALIZER](ab: Ab) -> <v0>
ab <v1>: {<: Ab} NEW: r(ab) -> <v1> ab <v1>: {<: Ab} NEW: r(ab) -> <v1>
getArray() <v2>: {<: Array<Int>} NEW: call(getArray(), getArray|<v1>) -> <v2> getArray() <v2>: {<: Array<Int>} NEW: call(getArray(), getArray|<v1>) -> <v2>
ab.getArray() <v2>: {<: Array<Int>} COPY ab.getArray() <v2>: {<: Array<Int>} COPY
compiler/testData/cfg/arrays/arrayInc.instructions
+4 -4
View File
@@ -6,7 +6,7 @@ fun foo(a: Array<Int>) {
L0: L0:
1 <START> 1 <START>
v(a: Array<Int>) v(a: Array<Int>)
magic(a: Array<Int>) -> <v0> magic[FAKE_INITIALIZER](a: Array<Int>) -> <v0>
w(a|<v0>) w(a|<v0>)
2 mark({ a[0]++ }) 2 mark({ a[0]++ })
mark(a[0]) mark(a[0])
@@ -20,9 +20,9 @@ L0:
r(0) -> <v6> r(0) -> <v6>
call(a[0]++, set|<v5>, <v6>, <v4>) -> <v7> call(a[0]++, set|<v5>, <v6>, <v4>) -> <v7>
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/arrays/arrayInc.values
+1 -1
View File
@@ -3,7 +3,7 @@ fun foo(a: Array<Int>) {
a[0]++ a[0]++
} }
--------------------- ---------------------
<v0>: {<: Array<Int>} NEW: magic(a: Array<Int>) -> <v0> <v0>: {<: Array<Int>} NEW: magic[FAKE_INITIALIZER](a: Array<Int>) -> <v0>
a <v5>: {<: Array<Int>} NEW: r(a) -> <v5> a <v5>: {<: Array<Int>} NEW: r(a) -> <v5>
0 <v6>: Int NEW: r(0) -> <v6> 0 <v6>: Int NEW: r(0) -> <v6>
a[0] <v3>: Int NEW: call(a[0], get|<v1>, <v2>) -> <v3> a[0] <v3>: Int NEW: call(a[0], get|<v1>, <v2>) -> <v3>
compiler/testData/cfg/arrays/arraySet.instructions
+4 -4
View File
@@ -6,7 +6,7 @@ fun foo(a: Array<Int>) {
L0: L0:
1 <START> 1 <START>
v(a: Array<Int>) v(a: Array<Int>)
magic(a: Array<Int>) -> <v0> magic[FAKE_INITIALIZER](a: Array<Int>) -> <v0>
w(a|<v0>) w(a|<v0>)
2 mark({ a[1] = 2 }) 2 mark({ a[1] = 2 })
mark(a[1]) mark(a[1])
@@ -15,9 +15,9 @@ L0:
r(2) -> <v3> r(2) -> <v3>
call(a[1] = 2, set|<v1>, <v2>, <v3>) -> <v4> call(a[1] = 2, set|<v1>, <v2>, <v3>) -> <v4>
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/arrays/arraySet.values
+1 -1
View File
@@ -3,7 +3,7 @@ fun foo(a: Array<Int>) {
a[1] = 2 a[1] = 2
} }
--------------------- ---------------------
<v0>: {<: Array<Int>} NEW: magic(a: Array<Int>) -> <v0> <v0>: {<: Array<Int>} NEW: magic[FAKE_INITIALIZER](a: Array<Int>) -> <v0>
a <v1>: {<: Array<Int>} NEW: r(a) -> <v1> a <v1>: {<: Array<Int>} NEW: r(a) -> <v1>
1 <v2>: Int NEW: r(1) -> <v2> 1 <v2>: Int NEW: r(1) -> <v2>
2 <v3>: Int NEW: r(2) -> <v3> 2 <v3>: Int NEW: r(2) -> <v3>
compiler/testData/cfg/arrays/arraySetPlusAssign.instructions
+4 -4
View File
@@ -6,7 +6,7 @@ fun foo(a: Array<Int>) {
L0: L0:
1 <START> 1 <START>
v(a: Array<Int>) v(a: Array<Int>)
magic(a: Array<Int>) -> <v0> magic[FAKE_INITIALIZER](a: Array<Int>) -> <v0>
w(a|<v0>) w(a|<v0>)
2 mark({ a[0] += 1 }) 2 mark({ a[0] += 1 })
mark(a[0]) mark(a[0])
@@ -21,9 +21,9 @@ L0:
r(0) -> <v7> r(0) -> <v7>
call(a[0] += 1, set|<v6>, <v7>, <v5>) -> <v8> call(a[0] += 1, set|<v6>, <v7>, <v5>) -> <v8>
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/arrays/arraySetPlusAssign.values
+1 -1
View File
@@ -3,7 +3,7 @@ fun foo(a: Array<Int>) {
a[0] += 1 a[0] += 1
} }
--------------------- ---------------------
<v0>: {<: Array<Int>} NEW: magic(a: Array<Int>) -> <v0> <v0>: {<: Array<Int>} NEW: magic[FAKE_INITIALIZER](a: Array<Int>) -> <v0>
a <v6>: {<: Array<Int>} NEW: r(a) -> <v6> a <v6>: {<: Array<Int>} NEW: r(a) -> <v6>
0 <v7>: Int NEW: r(0) -> <v7> 0 <v7>: Int NEW: r(0) -> <v7>
a[0] <v3>: Int NEW: call(a[0], get|<v1>, <v2>) -> <v3> a[0] <v3>: Int NEW: call(a[0], get|<v1>, <v2>) -> <v3>
compiler/testData/cfg/basic/Basic.instructions
+14 -14
View File
@@ -20,7 +20,7 @@ fun f(a : Boolean) : Unit {
L0: L0:
1 <START> 1 <START>
v(a : Boolean) v(a : Boolean)
magic(a : Boolean) -> <v0> magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
w(a|<v0>) w(a|<v0>)
2 mark({ 1 a 2.toLong() foo(a, 3) genfun<Any>() flfun {1} 3.equals(4) 3 equals 4 1 + 2 a && true a || false }) 2 mark({ 1 a 2.toLong() foo(a, 3) genfun<Any>() flfun {1} 3.equals(4) 3 equals 4 1 + 2 a && true a || false })
r(1) -> <v1> r(1) -> <v1>
@@ -56,15 +56,15 @@ L2:
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|<v20>) NEXT:[magic(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: L5:
magic(a && true|<v20>, <v21>) -> <v22> PREV:[jf(L5|<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|<v23>) NEXT:[r(false) -> <v24>, magic(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: L6:
magic(a || false|<v23>, <v24>) -> <v25> PREV:[jt(L6|<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:
@@ -93,19 +93,19 @@ fun foo(a : Boolean, b : Int) : Unit {}
L0: L0:
1 <START> 1 <START>
v(a : Boolean) v(a : Boolean)
magic(a : Boolean) -> <v0> magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
w(a|<v0>) w(a|<v0>)
v(b : Int) v(b : Int)
magic(b : Int) -> <v1> magic[FAKE_INITIALIZER](b : Int) -> <v1>
w(b|<v1>) w(b|<v1>)
2 mark({}) 2 mark({})
read (Unit) read (Unit)
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>]
===================== =====================
== genfun == == genfun ==
fun genfun<T>() : Unit {} fun genfun<T>() : Unit {}
@@ -127,14 +127,14 @@ fun flfun(f : () -> Any) : Unit {}
L0: L0:
1 <START> 1 <START>
v(f : () -> Any) v(f : () -> Any)
magic(f : () -> Any) -> <v0> magic[FAKE_INITIALIZER](f : () -> Any) -> <v0>
w(f|<v0>) w(f|<v0>)
2 mark({}) 2 mark({})
read (Unit) read (Unit)
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/basic/Basic.values
+6 -6
View File
@@ -17,7 +17,7 @@ fun f(a : Boolean) : Unit {
} }
--------------------- ---------------------
<v0>: Boolean NEW: magic(a : Boolean) -> <v0> <v0>: Boolean NEW: magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
1 <v1>: * NEW: r(1) -> <v1> 1 <v1>: * NEW: r(1) -> <v1>
a <v2>: * NEW: r(a) -> <v2> a <v2>: * NEW: r(a) -> <v2>
2 <v3>: {<: Number} NEW: r(2) -> <v3> 2 <v3>: {<: Number} NEW: r(2) -> <v3>
@@ -41,10 +41,10 @@ equals(4)
1 + 2 <v19>: * NEW: call(1 + 2, plus|<v17>, <v18>) -> <v19> 1 + 2 <v19>: * NEW: call(1 + 2, plus|<v17>, <v18>) -> <v19>
a <v20>: Boolean NEW: r(a) -> <v20> a <v20>: Boolean NEW: r(a) -> <v20>
true <v21>: Boolean NEW: r(true) -> <v21> true <v21>: Boolean NEW: r(true) -> <v21>
a && true <v22>: * NEW: magic(a && true|<v20>, <v21>) -> <v22> a && true <v22>: * NEW: magic[AND](a && true|<v20>, <v21>) -> <v22>
a <v23>: Boolean NEW: r(a) -> <v23> a <v23>: Boolean NEW: r(a) -> <v23>
false <v24>: Boolean NEW: r(false) -> <v24> false <v24>: Boolean NEW: r(false) -> <v24>
a || false <v25>: * NEW: magic(a || false|<v23>, <v24>) -> <v25> a || false <v25>: * NEW: magic[OR](a || false|<v23>, <v24>) -> <v25>
{ 1 a 2.toLong() foo(a, 3) genfun<Any>() flfun {1} 3.equals(4) 3 equals 4 1 + 2 a && true a || false } <v25>: * COPY { 1 a 2.toLong() foo(a, 3) genfun<Any>() flfun {1} 3.equals(4) 3 equals 4 1 + 2 a && true a || false } <v25>: * COPY
===================== =====================
== anonymous_0 == == anonymous_0 ==
@@ -56,8 +56,8 @@ a || false
== foo == == foo ==
fun foo(a : Boolean, b : Int) : Unit {} fun foo(a : Boolean, b : Int) : Unit {}
--------------------- ---------------------
<v0>: Boolean NEW: magic(a : Boolean) -> <v0> <v0>: Boolean NEW: magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
<v1>: Int NEW: magic(b : Int) -> <v1> <v1>: Int NEW: magic[FAKE_INITIALIZER](b : Int) -> <v1>
===================== =====================
== genfun == == genfun ==
fun genfun<T>() : Unit {} fun genfun<T>() : Unit {}
@@ -66,5 +66,5 @@ fun genfun<T>() : Unit {}
== flfun == == flfun ==
fun flfun(f : () -> Any) : Unit {} fun flfun(f : () -> Any) : Unit {}
--------------------- ---------------------
<v0>: {<: () -> Any} NEW: magic(f : () -> Any) -> <v0> <v0>: {<: () -> Any} NEW: magic[FAKE_INITIALIZER](f : () -> Any) -> <v0>
===================== =====================
compiler/testData/cfg/bugs/jumpToOuterScope.instructions
+11 -11
View File
@@ -10,33 +10,33 @@ fun foo(c: Collection<Int>) {
L0: L0:
1 <START> 1 <START>
v(c: Collection<Int>) v(c: Collection<Int>)
magic(c: Collection<Int>) -> <v0> magic[FAKE_INITIALIZER](c: Collection<Int>) -> <v0>
w(c|<v0>) w(c|<v0>)
2 mark({ for (e in c) { { break } } }) 2 mark({ for (e in c) { { break } } })
3 r(c) -> <v1> 3 r(c) -> <v1>
v(e) v(e)
L3: L3:
jmp?(L2) NEXT:[read (Unit), magic(c|<v1>) -> <v2>] jmp?(L2) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](c|<v1>) -> <v2>]
L4 [loop entry point]: L4 [loop entry point]:
L5 [body entry point]: L5 [body entry point]:
magic(c|<v1>) -> <v2> PREV:[jmp?(L2), jmp?(L4 [loop entry point])] magic[LOOP_RANGE_ITERATION](c|<v1>) -> <v2> PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
w(e|<v2>) w(e|<v2>)
mark(for (e in c) { { break } }) mark(for (e in c) { { break } })
4 mark({ { break } }) 4 mark({ { break } })
mark({ break }) mark({ break })
jmp?(L6) NEXT:[r({ break }) -> <v3>, d({ break })] jmp?(L6) NEXT:[r({ break }) -> <v3>, d({ break })]
d({ break }) NEXT:[<SINK>] d({ break }) NEXT:[<SINK>]
L6: L6:
r({ break }) -> <v3> PREV:[jmp?(L6)] r({ break }) -> <v3> PREV:[jmp?(L6)]
3 jmp?(L4 [loop entry point]) NEXT:[magic(c|<v1>) -> <v2>, read (Unit)] 3 jmp?(L4 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](c|<v1>) -> <v2>, read (Unit)]
L2: L2:
read (Unit) PREV:[jmp?(L2), jmp(L2), jmp?(L4 [loop entry point])] read (Unit) PREV:[jmp?(L2), jmp(L2), jmp?(L4 [loop entry point])]
L1: L1:
1 <END> NEXT:[<SINK>] 1 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>, d({ break })] <SINK> PREV:[<ERROR>, <END>, d({ break })]
===================== =====================
== anonymous_0 == == anonymous_0 ==
{ {
compiler/testData/cfg/bugs/jumpToOuterScope.values
+2 -2
View File
@@ -7,8 +7,8 @@ fun foo(c: Collection<Int>) {
} }
} }
--------------------- ---------------------
<v0>: {<: Collection<Int>} NEW: magic(c: Collection<Int>) -> <v0> <v0>: {<: Collection<Int>} NEW: magic[FAKE_INITIALIZER](c: Collection<Int>) -> <v0>
<v2>: Int NEW: magic(c|<v1>) -> <v2> <v2>: Int NEW: magic[LOOP_RANGE_ITERATION](c|<v1>) -> <v2>
c <v1>: {<: Iterable<Int>} NEW: r(c) -> <v1> c <v1>: {<: Iterable<Int>} NEW: r(c) -> <v1>
{ break } <v3>: * NEW: r({ break }) -> <v3> { break } <v3>: * NEW: r({ break }) -> <v3>
{ { break } } <v3>: * COPY { { break } } <v3>: * COPY
compiler/testData/cfg/controlStructures/Finally.instructions
+23 -23
View File
@@ -435,7 +435,7 @@ fun t8(a : Int) {
L0: L0:
1 <START> 1 <START>
v(a : Int) v(a : Int)
magic(a : Int) -> <v0> magic[FAKE_INITIALIZER](a : Int) -> <v0>
w(a|<v0>) w(a|<v0>)
2 mark({ @l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } }) 2 mark({ @l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } })
mark(@l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } }) mark(@l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } })
@@ -445,10 +445,10 @@ L0:
call(1..a, rangeTo|<v1>, <v2>) -> <v3> call(1..a, rangeTo|<v1>, <v2>) -> <v3>
v(i) v(i)
L3: L3:
jmp?(L2) NEXT:[read (Unit), magic(1..a|<v3>) -> <v4>] jmp?(L2) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
L4 [loop entry point]: L4 [loop entry point]:
L5 [body entry point]: L5 [body entry point]:
magic(1..a|<v3>) -> <v4> PREV:[jmp?(L2), jmp(L4 [loop entry point]), jmp?(L4 [loop entry point])] magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> PREV:[jmp?(L2), jmp(L4 [loop entry point]), jmp?(L4 [loop entry point])]
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 } })
4 mark({ try { 1 if (2 > 3) { continue @l } } finally { 2 } }) 4 mark({ try { 1 if (2 > 3) { continue @l } } finally { 2 } })
@@ -467,7 +467,7 @@ L8 [start finally]:
7 mark({ 2 }) 7 mark({ 2 })
r(2) -> <v9> r(2) -> <v9>
L9 [finish finally]: L9 [finish finally]:
6 jmp(L4 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>] 6 jmp(L4 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
- 5 jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[] - 5 jmp(L10) NEXT:[jmp(L11 [skipFinallyToErrorBlock])] PREV:[]
L7: L7:
read (Unit) PREV:[jf(L7|<v8>)] read (Unit) PREV:[jf(L7|<v8>)]
@@ -480,7 +480,7 @@ L6 [onExceptionToFinallyBlock]:
L11 [skipFinallyToErrorBlock]: L11 [skipFinallyToErrorBlock]:
7 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])] 7 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])]
r(2) -> <v9> r(2) -> <v9>
3 jmp?(L4 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>, read (Unit)] 3 jmp?(L4 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>, read (Unit)]
L2: L2:
read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])] read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
L1: L1:
@@ -508,7 +508,7 @@ fun t9(a : Int) {
L0: L0:
1 <START> 1 <START>
v(a : Int) v(a : Int)
magic(a : Int) -> <v0> magic[FAKE_INITIALIZER](a : Int) -> <v0>
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 })
@@ -521,10 +521,10 @@ L0:
call(1..a, rangeTo|<v1>, <v2>) -> <v3> call(1..a, rangeTo|<v1>, <v2>) -> <v3>
v(i) v(i)
L4: L4:
jmp?(L3) NEXT:[read (Unit), magic(1..a|<v3>) -> <v4>] jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
L5 [loop entry point]: L5 [loop entry point]:
L6 [body entry point]: L6 [body entry point]:
magic(1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])] magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
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 } })
5 mark({ 1 if (2 > 3) { continue @l } }) 5 mark({ 1 if (2 > 3) { continue @l } })
@@ -536,12 +536,12 @@ L6 [body entry point]:
call(2 > 3, compareTo|<v6>, <v7>) -> <v8> call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })] jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l }) 6 mark({ continue @l })
jmp(L5 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>] jmp(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
- 5 jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[] - 5 jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
L7: L7:
read (Unit) PREV:[jf(L7|<v8>)] read (Unit) PREV:[jf(L7|<v8>)]
L8: L8:
4 jmp?(L5 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>, read (Unit)] 4 jmp?(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>, read (Unit)]
L3: L3:
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])] read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
3 r(5) -> <v9> 3 r(5) -> <v9>
@@ -579,7 +579,7 @@ fun t10(a : Int) {
L0: L0:
1 <START> 1 <START>
v(a : Int) v(a : Int)
magic(a : Int) -> <v0> magic[FAKE_INITIALIZER](a : Int) -> <v0>
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 })
@@ -592,10 +592,10 @@ L0:
call(1..a, rangeTo|<v1>, <v2>) -> <v3> call(1..a, rangeTo|<v1>, <v2>) -> <v3>
v(i) v(i)
L4: L4:
jmp?(L3) NEXT:[read (Unit), magic(1..a|<v3>) -> <v4>] jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
L5 [loop entry point]: L5 [loop entry point]:
L6 [body entry point]: L6 [body entry point]:
magic(1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])] magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
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 } })
5 mark({ 1 if (2 > 3) { continue @l } }) 5 mark({ 1 if (2 > 3) { continue @l } })
@@ -607,12 +607,12 @@ L6 [body entry point]:
call(2 > 3, compareTo|<v6>, <v7>) -> <v8> call(2 > 3, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })] jf(L7|<v8>) NEXT:[read (Unit), mark({ continue @l })]
6 mark({ continue @l }) 6 mark({ continue @l })
jmp(L5 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>] jmp(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>]
- 5 jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[] - 5 jmp(L8) NEXT:[jmp?(L5 [loop entry point])] PREV:[]
L7: L7:
read (Unit) PREV:[jf(L7|<v8>)] read (Unit) PREV:[jf(L7|<v8>)]
L8: L8:
4 jmp?(L5 [loop entry point]) NEXT:[magic(1..a|<v3>) -> <v4>, read (Unit)] 4 jmp?(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>, read (Unit)]
L3: L3:
read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])] read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] 2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })]
@@ -746,7 +746,7 @@ L5 [finish finally]:
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[] - 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
L2 [onException]: L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
magic(e: UnsupportedOperationException) -> <v3> magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v3>
w(e|<v3>) w(e|<v3>)
4 mark({ doSmth(2) }) 4 mark({ doSmth(2) })
r(2) -> <v4> r(2) -> <v4>
@@ -794,7 +794,7 @@ L0:
- 2 jmp(L3 [afterCatches]) NEXT:[<END>] PREV:[] - 2 jmp(L3 [afterCatches]) NEXT:[<END>] PREV:[]
L2 [onException]: L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
magic(e: UnsupportedOperationException) -> <v1> magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v1>
w(e|<v1>) w(e|<v1>)
4 mark({ doSmth(2) }) 4 mark({ doSmth(2) })
r(2) -> <v2> r(2) -> <v2>
@@ -840,7 +840,7 @@ L5 [finish finally]:
- 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[] - 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[]
L2 [onException]: L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
magic(e: UnsupportedOperationException) -> <v3> magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v3>
w(e|<v3>) w(e|<v3>)
4 mark({ return 2 }) 4 mark({ return 2 })
r(2) -> <v4> r(2) -> <v4>
@@ -896,7 +896,7 @@ L0:
2 jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] 2 jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])]
L2 [onException]: L2 [onException]:
3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])]
magic(e: UnsupportedOperationException) -> <v2> magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v2>
w(e|<v2>) w(e|<v2>)
4 mark({ return 2 }) 4 mark({ return 2 })
r(2) -> <v3> r(2) -> <v3>
@@ -935,14 +935,14 @@ fun doSmth(i: Int) {
L0: L0:
1 <START> 1 <START>
v(i: Int) v(i: Int)
magic(i: Int) -> <v0> magic[FAKE_INITIALIZER](i: Int) -> <v0>
w(i|<v0>) w(i|<v0>)
2 mark({ }) 2 mark({ })
read (Unit) read (Unit)
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/Finally.values
+11 -11
View File
@@ -189,8 +189,8 @@ fun t8(a : Int) {
} }
} }
--------------------- ---------------------
<v0>: Int NEW: magic(a : Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic(1..a|<v3>) -> <v4> <v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1> 1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2> a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3> 1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
@@ -216,8 +216,8 @@ fun t9(a : Int) {
} }
} }
--------------------- ---------------------
<v0>: Int NEW: magic(a : Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic(1..a|<v3>) -> <v4> <v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1> 1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2> a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3> 1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
@@ -246,8 +246,8 @@ fun t10(a : Int) {
} }
} }
--------------------- ---------------------
<v0>: Int NEW: magic(a : Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a : Int) -> <v0>
<v4>: Int NEW: magic(1..a|<v3>) -> <v4> <v4>: Int NEW: magic[LOOP_RANGE_ITERATION](1..a|<v3>) -> <v4>
1 <v1>: Int NEW: r(1) -> <v1> 1 <v1>: Int NEW: r(1) -> <v1>
a <v2>: Int NEW: r(a) -> <v2> a <v2>: Int NEW: r(a) -> <v2>
1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3> 1..a <v3>: {<: Iterable<Int>} NEW: call(1..a, rangeTo|<v1>, <v2>) -> <v3>
@@ -299,7 +299,7 @@ fun t13() : Int {
} }
} }
--------------------- ---------------------
<v3>: {<: UnsupportedOperationException} NEW: magic(e: UnsupportedOperationException) -> <v3> <v3>: {<: UnsupportedOperationException} NEW: magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v3>
1 <v0>: Int NEW: r(1) -> <v0> 1 <v0>: Int NEW: r(1) -> <v0>
2 <v4>: Int NEW: r(2) -> <v4> 2 <v4>: Int NEW: r(2) -> <v4>
doSmth(2) <v5>: * NEW: call(doSmth(2), doSmth|<v4>) -> <v5> doSmth(2) <v5>: * NEW: call(doSmth(2), doSmth|<v4>) -> <v5>
@@ -320,7 +320,7 @@ fun t14() : Int {
} }
} }
--------------------- ---------------------
<v1>: {<: UnsupportedOperationException} NEW: magic(e: UnsupportedOperationException) -> <v1> <v1>: {<: UnsupportedOperationException} NEW: magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v1>
1 <v0>: Int NEW: r(1) -> <v0> 1 <v0>: Int NEW: r(1) -> <v0>
2 <v2>: Int NEW: r(2) -> <v2> 2 <v2>: Int NEW: r(2) -> <v2>
doSmth(2) <v3>: * NEW: call(doSmth(2), doSmth|<v2>) -> <v3> doSmth(2) <v3>: * NEW: call(doSmth(2), doSmth|<v2>) -> <v3>
@@ -341,7 +341,7 @@ fun t15() : Int {
} }
} }
--------------------- ---------------------
<v3>: {<: UnsupportedOperationException} NEW: magic(e: UnsupportedOperationException) -> <v3> <v3>: {<: UnsupportedOperationException} NEW: magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v3>
1 <v0>: Int NEW: r(1) -> <v0> 1 <v0>: Int NEW: r(1) -> <v0>
2 <v4>: Int NEW: r(2) -> <v4> 2 <v4>: Int NEW: r(2) -> <v4>
3 <v1>: Int NEW: r(3) -> <v1> 3 <v1>: Int NEW: r(3) -> <v1>
@@ -361,7 +361,7 @@ fun t16() : Int {
} }
} }
--------------------- ---------------------
<v2>: {<: UnsupportedOperationException} NEW: magic(e: UnsupportedOperationException) -> <v2> <v2>: {<: UnsupportedOperationException} NEW: magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> <v2>
1 <v0>: Int NEW: r(1) -> <v0> 1 <v0>: Int NEW: r(1) -> <v0>
doSmth(1) <v1>: * NEW: call(doSmth(1), doSmth|<v0>) -> <v1> doSmth(1) <v1>: * NEW: call(doSmth(1), doSmth|<v0>) -> <v1>
{ doSmth(1) } <v1>: * COPY { doSmth(1) } <v1>: * COPY
@@ -376,5 +376,5 @@ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally
fun doSmth(i: Int) { fun doSmth(i: Int) {
} }
--------------------- ---------------------
<v0>: Int NEW: magic(i: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](i: Int) -> <v0>
===================== =====================
compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
+7 -7
View File
@@ -83,7 +83,7 @@ L0:
L2 [onException]: L2 [onException]:
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])] jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])]
3 v(e: NullPointerException) 3 v(e: NullPointerException)
magic(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())
@@ -91,7 +91,7 @@ L2 [onException]:
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])] 3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
L5 [catch 0]: L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])] v(e: Exception) PREV:[jmp?(L5 [catch 0])]
magic(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())
@@ -158,7 +158,7 @@ L4 [body entry point]:
L6 [onException]: L6 [onException]:
jmp?(L9 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L6 [onException])] jmp?(L9 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L6 [onException])]
4 v(e: NullPointerException) 4 v(e: NullPointerException)
magic(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())
@@ -166,7 +166,7 @@ L6 [onException]:
4 jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])] 4 jmp(L8 [afterCatches]) NEXT:[jmp(L10 [skipFinallyToErrorBlock])]
L9 [catch 0]: L9 [catch 0]:
v(e: Exception) PREV:[jmp?(L9 [catch 0])] v(e: Exception) PREV:[jmp?(L9 [catch 0])]
magic(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())
@@ -237,7 +237,7 @@ L0:
L2 [onException]: L2 [onException]:
jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])] jmp?(L5 [catch 0]) NEXT:[v(e: Exception), v(e: NullPointerException)] PREV:[jmp?(L2 [onException])]
3 v(e: NullPointerException) 3 v(e: NullPointerException)
magic(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())
@@ -245,7 +245,7 @@ L2 [onException]:
3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])] 3 jmp(L4 [afterCatches]) NEXT:[jmp(L6 [skipFinallyToErrorBlock])]
L5 [catch 0]: L5 [catch 0]:
v(e: Exception) PREV:[jmp?(L5 [catch 0])] v(e: Exception) PREV:[jmp?(L5 [catch 0])]
magic(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())
@@ -298,7 +298,7 @@ fun doTestCopy4(list: List<String>?) : Int {
L0: L0:
1 <START> 1 <START>
v(list: List<String>?) v(list: List<String>?)
magic(list: List<String>?) -> <v0> magic[FAKE_INITIALIZER](list: List<String>?) -> <v0>
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) { } })
compiler/testData/cfg/controlStructures/FinallyTestCopy.values
+7 -7
View File
@@ -30,8 +30,8 @@ fun testCopy1() : Int {
} }
} }
--------------------- ---------------------
<v1>: {<: NullPointerException} NEW: magic(e: NullPointerException) -> <v1> <v1>: {<: NullPointerException} NEW: magic[FAKE_INITIALIZER](e: NullPointerException) -> <v1>
<v3>: {<: Exception} NEW: magic(e: Exception) -> <v3> <v3>: {<: Exception} NEW: magic[FAKE_INITIALIZER](e: Exception) -> <v3>
doSmth() <v0>: * NEW: call(doSmth(), doSmth) -> <v0> doSmth() <v0>: * NEW: call(doSmth(), doSmth) -> <v0>
{ doSmth() } <v0>: * COPY { doSmth() } <v0>: * COPY
doSmth1() <v2>: * NEW: call(doSmth1(), doSmth1) -> <v2> doSmth1() <v2>: * NEW: call(doSmth1(), doSmth1) -> <v2>
@@ -61,8 +61,8 @@ fun testCopy2() {
} }
} }
--------------------- ---------------------
<v2>: {<: NullPointerException} NEW: magic(e: NullPointerException) -> <v2> <v2>: {<: NullPointerException} NEW: magic[FAKE_INITIALIZER](e: NullPointerException) -> <v2>
<v4>: {<: Exception} NEW: magic(e: Exception) -> <v4> <v4>: {<: Exception} NEW: magic[FAKE_INITIALIZER](e: Exception) -> <v4>
cond() <v0>: Boolean NEW: call(cond(), cond) -> <v0> cond() <v0>: Boolean NEW: call(cond(), cond) -> <v0>
doSmth() <v1>: * NEW: call(doSmth(), doSmth) -> <v1> doSmth() <v1>: * NEW: call(doSmth(), doSmth) -> <v1>
{ doSmth() } <v1>: * COPY { doSmth() } <v1>: * COPY
@@ -90,8 +90,8 @@ fun testCopy3() {
} }
} }
--------------------- ---------------------
<v1>: {<: NullPointerException} NEW: magic(e: NullPointerException) -> <v1> <v1>: {<: NullPointerException} NEW: magic[FAKE_INITIALIZER](e: NullPointerException) -> <v1>
<v3>: {<: Exception} NEW: magic(e: Exception) -> <v3> <v3>: {<: Exception} NEW: magic[FAKE_INITIALIZER](e: Exception) -> <v3>
doSmth() <v0>: * NEW: call(doSmth(), doSmth) -> <v0> doSmth() <v0>: * NEW: call(doSmth(), doSmth) -> <v0>
{ doSmth() } <v0>: * COPY { doSmth() } <v0>: * COPY
doSmth1() <v2>: * NEW: call(doSmth1(), doSmth1) -> <v2> doSmth1() <v2>: * NEW: call(doSmth1(), doSmth1) -> <v2>
@@ -113,7 +113,7 @@ fun doTestCopy4(list: List<String>?) : Int {
} }
} }
--------------------- ---------------------
<v0>: {<: List<String>?} NEW: magic(list: List<String>?) -> <v0> <v0>: {<: List<String>?} NEW: magic[FAKE_INITIALIZER](list: List<String>?) -> <v0>
doSmth() <v1>: * NEW: call(doSmth(), doSmth) -> <v1> doSmth() <v1>: * NEW: call(doSmth(), doSmth) -> <v1>
{ doSmth() } <v1>: * COPY { doSmth() } <v1>: * COPY
list <v2>: {<: Any?} NEW: r(list) -> <v2> list <v2>: {<: Any?} NEW: r(list) -> <v2>
compiler/testData/cfg/controlStructures/For.instructions
+11 -11
View File
@@ -14,25 +14,25 @@ L0:
call(1..2, rangeTo|<v0>, <v1>) -> <v2> call(1..2, rangeTo|<v0>, <v1>) -> <v2>
v(i) v(i)
L3: L3:
jmp?(L2) NEXT:[read (Unit), magic(1..2|<v2>) -> <v3>] jmp?(L2) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>]
L4 [loop entry point]: L4 [loop entry point]:
L5 [body entry point]: L5 [body entry point]:
magic(1..2|<v2>) -> <v3> PREV:[jmp?(L2), jmp?(L4 [loop entry point])] magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3> PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
w(i|<v3>) w(i|<v3>)
mark(for (i in 1..2) { doSmth(i) }) mark(for (i in 1..2) { doSmth(i) })
4 mark({ doSmth(i) }) 4 mark({ doSmth(i) })
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?(L4 [loop entry point]) NEXT:[magic(1..2|<v2>) -> <v3>, read (Unit)] 3 jmp?(L4 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>, read (Unit)]
L2: L2:
read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])] read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
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>]
===================== =====================
== doSmth == == doSmth ==
fun doSmth(i: Int) {} fun doSmth(i: Int) {}
@@ -40,14 +40,14 @@ fun doSmth(i: Int) {}
L0: L0:
1 <START> 1 <START>
v(i: Int) v(i: Int)
magic(i: Int) -> <v0> magic[FAKE_INITIALIZER](i: Int) -> <v0>
w(i|<v0>) w(i|<v0>)
2 mark({}) 2 mark({})
read (Unit) read (Unit)
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/For.values
+2 -2
View File
@@ -5,7 +5,7 @@ fun t1() {
} }
} }
--------------------- ---------------------
<v3>: Int NEW: magic(1..2|<v2>) -> <v3> <v3>: Int NEW: magic[LOOP_RANGE_ITERATION](1..2|<v2>) -> <v3>
1 <v0>: Int NEW: r(1) -> <v0> 1 <v0>: Int NEW: r(1) -> <v0>
2 <v1>: Int NEW: r(2) -> <v1> 2 <v1>: Int NEW: r(2) -> <v1>
1..2 <v2>: {<: Iterable<Int>} NEW: call(1..2, rangeTo|<v0>, <v1>) -> <v2> 1..2 <v2>: {<: Iterable<Int>} NEW: call(1..2, rangeTo|<v0>, <v1>) -> <v2>
@@ -16,5 +16,5 @@ doSmth(i) <v5>: * NEW: call(doSmth(i), doSmth|<v4>) ->
== doSmth == == doSmth ==
fun doSmth(i: Int) {} fun doSmth(i: Int) {}
--------------------- ---------------------
<v0>: Int NEW: magic(i: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](i: Int) -> <v0>
===================== =====================
compiler/testData/cfg/controlStructures/If.instructions
+7 -7
View File
@@ -19,7 +19,7 @@ fun t1(b: Boolean) {
L0: L0:
1 <START> 1 <START>
v(b: Boolean) v(b: Boolean)
magic(b: Boolean) -> <v0> magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
w(b|<v0>) w(b|<v0>)
2 mark({ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) }) 2 mark({ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) })
v(var u: String) v(var u: String)
@@ -77,7 +77,7 @@ fun t2(b: Boolean) {
L0: L0:
1 <START> 1 <START>
v(b: Boolean) v(b: Boolean)
magic(b: Boolean) -> <v0> magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
w(b|<v0>) w(b|<v0>)
2 mark({ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } }) 2 mark({ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } })
v(val i = 3) v(val i = 3)
@@ -98,7 +98,7 @@ L3:
mark(if (i is Int) { return; }) mark(if (i is Int) { return; })
mark(i is Int) mark(i is Int)
r(i) -> <v5> r(i) -> <v5>
magic(i is Int|<v5>) -> <v6> magic[IS](i is Int|<v5>) -> <v6>
jf(L4|<v6>) NEXT:[read (Unit), mark({ return; })] jf(L4|<v6>) NEXT:[read (Unit), mark({ return; })]
3 mark({ return; }) 3 mark({ return; })
ret L1 NEXT:[<END>] ret L1 NEXT:[<END>]
@@ -119,14 +119,14 @@ fun doSmth(s: String) {}
L0: L0:
1 <START> 1 <START>
v(s: String) v(s: String)
magic(s: String) -> <v0> magic[FAKE_INITIALIZER](s: String) -> <v0>
w(s|<v0>) w(s|<v0>)
2 mark({}) 2 mark({})
read (Unit) read (Unit)
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/If.values
+4 -4
View File
@@ -16,7 +16,7 @@ fun t1(b: Boolean) {
doSmth(r) doSmth(r)
} }
--------------------- ---------------------
<v0>: Boolean NEW: magic(b: Boolean) -> <v0> <v0>: Boolean NEW: magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
b <v1>: Boolean NEW: r(b) -> <v1> b <v1>: Boolean NEW: r(b) -> <v1>
"s" <v2>: String NEW: r("s") -> <v2> "s" <v2>: String NEW: r("s") -> <v2>
u <v3>: String NEW: r(u) -> <v3> u <v3>: String NEW: r(u) -> <v3>
@@ -40,16 +40,16 @@ fun t2(b: Boolean) {
} }
} }
--------------------- ---------------------
<v0>: Boolean NEW: magic(b: Boolean) -> <v0> <v0>: Boolean NEW: magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
3 <v1>: Int NEW: r(3) -> <v1> 3 <v1>: Int NEW: r(3) -> <v1>
b <v2>: Boolean NEW: r(b) -> <v2> b <v2>: Boolean NEW: r(b) -> <v2>
i <v3>: String NEW: r(i) -> <v3> i <v3>: String NEW: r(i) -> <v3>
doSmth(i) <v4>: * NEW: call(doSmth(i), doSmth|<v3>) -> <v4> doSmth(i) <v4>: * NEW: call(doSmth(i), doSmth|<v3>) -> <v4>
i <v5>: * NEW: r(i) -> <v5> i <v5>: * NEW: r(i) -> <v5>
i is Int <v6>: Boolean NEW: magic(i is Int|<v5>) -> <v6> i is Int <v6>: Boolean NEW: magic[IS](i is Int|<v5>) -> <v6>
===================== =====================
== doSmth == == doSmth ==
fun doSmth(s: String) {} fun doSmth(s: String) {}
--------------------- ---------------------
<v0>: String NEW: magic(s: String) -> <v0> <v0>: String NEW: magic[FAKE_INITIALIZER](s: String) -> <v0>
===================== =====================
compiler/testData/cfg/controlStructures/returnsInWhen.instructions
+2 -2
View File
@@ -8,14 +8,14 @@ fun illegalWhenBlock(a: Any): Any {
L0: L0:
1 <START> 1 <START>
v(a: Any) v(a: Any)
magic(a: Any) -> <v0> magic[FAKE_INITIALIZER](a: Any) -> <v0>
w(a|<v0>) w(a|<v0>)
2 mark({ when(a) { is Int -> return a } }) 2 mark({ when(a) { is Int -> return a } })
mark(when(a) { is Int -> return a }) mark(when(a) { is Int -> return a })
r(a) -> <v1> r(a) -> <v1>
mark(is Int -> return a) mark(is Int -> return a)
mark(is Int) mark(is Int)
magic(is Int|<v1>) -> <v2> magic[IS](is Int|<v1>) -> <v2>
jmp?(L4|<v2>) NEXT:[<END>, r(a) -> <v3>] jmp?(L4|<v2>) NEXT:[<END>, r(a) -> <v3>]
L3: L3:
r(a) -> <v3> r(a) -> <v3>
compiler/testData/cfg/controlStructures/returnsInWhen.values
+2 -2
View File
@@ -5,8 +5,8 @@ fun illegalWhenBlock(a: Any): Any {
} }
} }
--------------------- ---------------------
<v0>: {<: Any} NEW: magic(a: Any) -> <v0> <v0>: {<: Any} NEW: magic[FAKE_INITIALIZER](a: Any) -> <v0>
a <v1>: * NEW: r(a) -> <v1> a <v1>: * NEW: r(a) -> <v1>
is Int <v2>: * NEW: magic(is Int|<v1>) -> <v2> is Int <v2>: * NEW: magic[IS](is Int|<v1>) -> <v2>
a <v3>: {<: Any} NEW: r(a) -> <v3> a <v3>: {<: Any} NEW: r(a) -> <v3>
===================== =====================
compiler/testData/cfg/controlStructures/whenConditions.instructions
+4 -4
View File
@@ -13,7 +13,7 @@ fun foo(a: Number) {
L0: L0:
1 <START> 1 <START>
v(a: Number) v(a: Number)
magic(a: Number) -> <v0> magic[FAKE_INITIALIZER](a: Number) -> <v0>
w(a|<v0>) w(a|<v0>)
2 mark({ val t = when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null } }) 2 mark({ val t = when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null } })
v(val t = when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null }) v(val t = when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null })
@@ -22,7 +22,7 @@ L0:
mark(1 -> "1") mark(1 -> "1")
mark(1) mark(1)
r(1) -> <v2> r(1) -> <v2>
magic(1|<v1>, <v2>) -> <v3> magic[EQUALS_IN_WHEN_CONDITION](1|<v1>, <v2>) -> <v3>
jmp?(L4|<v3>) NEXT:[mark(in Collections.singleton(2) -> "2"), mark("1")] jmp?(L4|<v3>) NEXT:[mark(in Collections.singleton(2) -> "2"), mark("1")]
L3: L3:
mark("1") mark("1")
@@ -44,7 +44,7 @@ L5:
L6: L6:
mark(is Int -> "Int") PREV:[jmp?(L6|<v7>)] mark(is Int -> "Int") PREV:[jmp?(L6|<v7>)]
mark(is Int) mark(is Int)
magic(is Int|<v1>) -> <v9> magic[IS](is Int|<v1>) -> <v9>
jmp?(L8|<v9>) NEXT:[mark(!in Collections.singleton(3) -> "!3"), mark("Int")] jmp?(L8|<v9>) NEXT:[mark(!in Collections.singleton(3) -> "!3"), mark("Int")]
L7: L7:
mark("Int") mark("Int")
@@ -66,7 +66,7 @@ L9:
L10: L10:
mark(!is Number -> "!Number") PREV:[jmp?(L10|<v13>)] mark(!is Number -> "!Number") PREV:[jmp?(L10|<v13>)]
mark(!is Number) mark(!is Number)
magic(!is Number|<v1>) -> <v15> magic[IS](!is Number|<v1>) -> <v15>
jmp?(L12|<v15>) NEXT:[mark(else -> null), mark("!Number")] jmp?(L12|<v15>) NEXT:[mark(else -> null), mark("!Number")]
L11: L11:
mark("!Number") mark("!Number")
compiler/testData/cfg/controlStructures/whenConditions.values
+5 -5
View File
@@ -10,24 +10,24 @@ fun foo(a: Number) {
} }
} }
--------------------- ---------------------
<v0>: {<: Number} NEW: magic(a: Number) -> <v0> <v0>: {<: Number} NEW: magic[FAKE_INITIALIZER](a: Number) -> <v0>
a <v1>: AND{{<: Any?}, *} NEW: r(a) -> <v1> a <v1>: AND{*, {<: Any?}} NEW: r(a) -> <v1>
1 <v2>: * NEW: r(1) -> <v2> 1 <v2>: * NEW: r(1) -> <v2>
1 <v3>: * NEW: magic(1|<v1>, <v2>) -> <v3> 1 <v3>: * NEW: magic[EQUALS_IN_WHEN_CONDITION](1|<v1>, <v2>) -> <v3>
"1" <v4>: {<: String?} NEW: r("1") -> <v4> "1" <v4>: {<: String?} NEW: r("1") -> <v4>
2 <v5>: {<: Int?} NEW: r(2) -> <v5> 2 <v5>: {<: Int?} NEW: r(2) -> <v5>
singleton(2) <v6>: OR{{<: Collection<Int>}, {<: Collection<Int>}} NEW: call(singleton(2), singleton|<v5>) -> <v6> singleton(2) <v6>: OR{{<: Collection<Int>}, {<: Collection<Int>}} NEW: call(singleton(2), singleton|<v5>) -> <v6>
Collections.singleton(2) <v6>: OR{{<: Collection<Int>}, {<: Collection<Int>}} COPY Collections.singleton(2) <v6>: OR{{<: Collection<Int>}, {<: Collection<Int>}} COPY
in Collections.singleton(2) <v7>: * NEW: call(in Collections.singleton(2), contains|<v6>, <v1>) -> <v7> in Collections.singleton(2) <v7>: * NEW: call(in Collections.singleton(2), contains|<v6>, <v1>) -> <v7>
"2" <v8>: {<: String?} NEW: r("2") -> <v8> "2" <v8>: {<: String?} NEW: r("2") -> <v8>
is Int <v9>: * NEW: magic(is Int|<v1>) -> <v9> is Int <v9>: * NEW: magic[IS](is Int|<v1>) -> <v9>
"Int" <v10>: {<: String?} NEW: r("Int") -> <v10> "Int" <v10>: {<: String?} NEW: r("Int") -> <v10>
3 <v11>: {<: Int?} NEW: r(3) -> <v11> 3 <v11>: {<: Int?} NEW: r(3) -> <v11>
singleton(3) <v12>: OR{{<: Collection<Int>}, {<: Collection<Int>}} NEW: call(singleton(3), singleton|<v11>) -> <v12> singleton(3) <v12>: OR{{<: Collection<Int>}, {<: Collection<Int>}} NEW: call(singleton(3), singleton|<v11>) -> <v12>
Collections.singleton(3) <v12>: OR{{<: Collection<Int>}, {<: Collection<Int>}} COPY Collections.singleton(3) <v12>: OR{{<: Collection<Int>}, {<: Collection<Int>}} COPY
!in Collections.singleton(3) <v13>: * NEW: call(!in Collections.singleton(3), contains|<v12>, <v1>) -> <v13> !in Collections.singleton(3) <v13>: * NEW: call(!in Collections.singleton(3), contains|<v12>, <v1>) -> <v13>
"!3" <v14>: {<: String?} NEW: r("!3") -> <v14> "!3" <v14>: {<: String?} NEW: r("!3") -> <v14>
!is Number <v15>: * NEW: magic(!is Number|<v1>) -> <v15> !is Number <v15>: * NEW: magic[IS](!is Number|<v1>) -> <v15>
"!Number" <v16>: {<: String?} NEW: r("!Number") -> <v16> "!Number" <v16>: {<: String?} NEW: r("!Number") -> <v16>
null <v17>: {<: String?} NEW: r(null) -> <v17> null <v17>: {<: String?} NEW: r(null) -> <v17>
when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null } <v18>: {<: String?} NEW: 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> when (a) { 1 -> "1" in Collections.singleton(2) -> "2" is Int -> "Int" !in Collections.singleton(3) -> "!3" !is Number -> "!Number" else -> null } <v18>: {<: String?} NEW: 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>
compiler/testData/cfg/conventions/bothReceivers.instructions
+4 -4
View File
@@ -47,7 +47,7 @@ fun foobar(f: Foo) {
L0: L0:
1 <START> 1 <START>
v(f: Foo) v(f: Foo)
magic(f: Foo) -> <v0> magic[FAKE_INITIALIZER](f: Foo) -> <v0>
w(f|<v0>) w(f|<v0>)
2 mark({ Bar().f() }) 2 mark({ Bar().f() })
mark(Bar().f()) mark(Bar().f())
@@ -57,9 +57,9 @@ L0:
mark(f()) mark(f())
call(f(), invoke|<v1>, <v2>) -> <v3> call(f(), invoke|<v1>, <v2>) -> <v3>
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/conventions/bothReceivers.values
+1 -1
View File
@@ -18,7 +18,7 @@ fun foobar(f: Foo) {
Bar().f() Bar().f()
} }
--------------------- ---------------------
<v0>: Foo NEW: magic(f: Foo) -> <v0> <v0>: Foo NEW: magic[FAKE_INITIALIZER](f: Foo) -> <v0>
Bar() <v2>: Bar NEW: call(Bar(), <init>) -> <v2> Bar() <v2>: Bar NEW: call(Bar(), <init>) -> <v2>
f <v1>: Foo NEW: r(f) -> <v1> f <v1>: Foo NEW: r(f) -> <v1>
f() <v3>: * NEW: call(f(), invoke|<v1>, <v2>) -> <v3> f() <v3>: * NEW: call(f(), invoke|<v1>, <v2>) -> <v3>
compiler/testData/cfg/conventions/equals.instructions
+2 -2
View File
@@ -7,10 +7,10 @@ fun foo(a: Int, b: Int) {
L0: L0:
1 <START> 1 <START>
v(a: Int) v(a: Int)
magic(a: Int) -> <v0> magic[FAKE_INITIALIZER](a: Int) -> <v0>
w(a|<v0>) w(a|<v0>)
v(b: Int) v(b: Int)
magic(b: Int) -> <v1> magic[FAKE_INITIALIZER](b: Int) -> <v1>
w(b|<v1>) w(b|<v1>)
2 mark({ if (a == b) { } }) 2 mark({ if (a == b) { } })
mark(if (a == b) { }) mark(if (a == b) { })
compiler/testData/cfg/conventions/equals.values
+2 -2
View File
@@ -4,8 +4,8 @@ fun foo(a: Int, b: Int) {
} }
} }
--------------------- ---------------------
<v0>: Int NEW: magic(a: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1> <v1>: Int NEW: magic[FAKE_INITIALIZER](b: Int) -> <v1>
a <v2>: OR{{<: Any}, {<: Any}} NEW: r(a) -> <v2> a <v2>: OR{{<: Any}, {<: Any}} NEW: r(a) -> <v2>
b <v3>: {<: Any?} NEW: r(b) -> <v3> b <v3>: {<: Any?} NEW: r(b) -> <v3>
a == b <v4>: Boolean NEW: call(a == b, equals|<v2>, <v3>) -> <v4> a == b <v4>: Boolean NEW: call(a == b, equals|<v2>, <v3>) -> <v4>
compiler/testData/cfg/conventions/invoke.instructions
+4 -4
View File
@@ -6,16 +6,16 @@ fun foo(f: () -> Unit) {
L0: L0:
1 <START> 1 <START>
v(f: () -> Unit) v(f: () -> Unit)
magic(f: () -> Unit) -> <v0> magic[FAKE_INITIALIZER](f: () -> Unit) -> <v0>
w(f|<v0>) w(f|<v0>)
2 mark({ f() }) 2 mark({ f() })
r(f) -> <v1> r(f) -> <v1>
mark(f()) mark(f())
call(f(), invoke|<v1>) -> <v2> call(f(), invoke|<v1>) -> <v2>
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/conventions/invoke.values
+1 -1
View File
@@ -3,7 +3,7 @@ fun foo(f: () -> Unit) {
f() f()
} }
--------------------- ---------------------
<v0>: {<: () -> Unit} NEW: magic(f: () -> Unit) -> <v0> <v0>: {<: () -> Unit} NEW: magic[FAKE_INITIALIZER](f: () -> Unit) -> <v0>
f <v1>: {<: () -> Unit} NEW: r(f) -> <v1> f <v1>: {<: () -> Unit} NEW: r(f) -> <v1>
f() <v2>: * NEW: call(f(), invoke|<v1>) -> <v2> f() <v2>: * NEW: call(f(), invoke|<v1>) -> <v2>
{ f() } <v2>: * COPY { f() } <v2>: * COPY
compiler/testData/cfg/conventions/notEqual.instructions
+2 -2
View File
@@ -6,10 +6,10 @@ fun neq(a: Int, b: Int) {
L0: L0:
1 <START> 1 <START>
v(a: Int) v(a: Int)
magic(a: Int) -> <v0> magic[FAKE_INITIALIZER](a: Int) -> <v0>
w(a|<v0>) w(a|<v0>)
v(b: Int) v(b: Int)
magic(b: Int) -> <v1> magic[FAKE_INITIALIZER](b: Int) -> <v1>
w(b|<v1>) w(b|<v1>)
2 mark({ if (a != b) {} }) 2 mark({ if (a != b) {} })
mark(if (a != b) {}) mark(if (a != b) {})
compiler/testData/cfg/conventions/notEqual.values
+2 -2
View File
@@ -3,8 +3,8 @@ fun neq(a: Int, b: Int) {
if (a != b) {} if (a != b) {}
} }
--------------------- ---------------------
<v0>: Int NEW: magic(a: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1> <v1>: Int NEW: magic[FAKE_INITIALIZER](b: Int) -> <v1>
a <v2>: OR{{<: Any}, {<: Any}} NEW: r(a) -> <v2> a <v2>: OR{{<: Any}, {<: Any}} NEW: r(a) -> <v2>
b <v3>: {<: Any?} NEW: r(b) -> <v3> b <v3>: {<: Any?} NEW: r(b) -> <v3>
a != b <v4>: Boolean NEW: call(a != b, equals|<v2>, <v3>) -> <v4> a != b <v4>: Boolean NEW: call(a != b, equals|<v2>, <v3>) -> <v4>
compiler/testData/cfg/deadCode/stringTemplate.instructions
+6 -6
View File
@@ -10,13 +10,13 @@ L0:
mark(throw Exception()) mark(throw Exception())
mark(Exception()) mark(Exception())
call(Exception(), <init>) -> <v0> call(Exception(), <init>) -> <v0>
throw (throw Exception()|<v0>) NEXT:[<ERROR>] throw (throw Exception()|<v0>) NEXT:[<ERROR>]
- r(1) -> <v1> PREV:[] - r(1) -> <v1> PREV:[]
- magic("${throw Exception()} ${1}"|<v1>) -> <v2> PREV:[] - magic[STRING_TEMPLATE]("${throw Exception()} ${1}"|<v1>) -> <v2> PREV:[]
L1: L1:
1 <END> NEXT:[<SINK>] PREV:[] 1 <END> NEXT:[<SINK>] PREV:[]
error: 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/stringTemplate.values
+1 -1
View File
@@ -5,6 +5,6 @@ fun test() {
--------------------- ---------------------
Exception() <v0>: {<: Throwable} NEW: call(Exception(), <init>) -> <v0> Exception() <v0>: {<: Throwable} NEW: call(Exception(), <init>) -> <v0>
1 <v1>: * NEW: r(1) -> <v1> 1 <v1>: * NEW: r(1) -> <v1>
"${throw Exception()} ${1}" <v2>: * NEW: magic("${throw Exception()} ${1}"|<v1>) -> <v2> "${throw Exception()} ${1}" <v2>: * NEW: magic[STRING_TEMPLATE]("${throw Exception()} ${1}"|<v1>) -> <v2>
{ "${throw Exception()} ${1}" } <v2>: * COPY { "${throw Exception()} ${1}" } <v2>: * COPY
===================== =====================
compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.instructions
+5 -5
View File
@@ -22,18 +22,18 @@ L0:
w(k|<v0>) w(k|<v0>)
v(val i: Int) v(val i: Int)
2 mark({ $i = 12 }) 2 mark({ $i = 12 })
magic($i) -> <v1> magic[IMPLICIT_RECEIVER]($i) -> <v1>
r(12) -> <v2> r(12) -> <v2>
w($i|<v1>, <v2>) w($i|<v1>, <v2>)
1 v(val j: Int get() = 20) 1 v(val j: Int get() = 20)
2 mark({ $i = 13 }) 2 mark({ $i = 13 })
magic($i) -> <v3> magic[IMPLICIT_RECEIVER]($i) -> <v3>
r(13) -> <v4> r(13) -> <v4>
w($i|<v3>, <v4>) w($i|<v3>, <v4>)
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/declarations/classesAndObjects/AnonymousInitializers.values
+2 -2
View File
@@ -15,8 +15,8 @@ class AnonymousInitializers() {
} }
} }
--------------------- ---------------------
<v1>: AnonymousInitializers NEW: magic($i) -> <v1> <v1>: AnonymousInitializers NEW: magic[IMPLICIT_RECEIVER]($i) -> <v1>
<v3>: AnonymousInitializers NEW: magic($i) -> <v3> <v3>: AnonymousInitializers NEW: magic[IMPLICIT_RECEIVER]($i) -> <v3>
34 <v0>: Int NEW: r(34) -> <v0> 34 <v0>: Int NEW: r(34) -> <v0>
12 <v2>: Int NEW: r(12) -> <v2> 12 <v2>: Int NEW: r(12) -> <v2>
13 <v4>: Int NEW: r(13) -> <v4> 13 <v4>: Int NEW: r(13) -> <v4>
compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.instructions
+11 -11
View File
@@ -16,18 +16,18 @@ class A(a: Int, b: Int): T
L0: L0:
1 <START> 1 <START>
v(a: Int) v(a: Int)
magic(a: Int) -> <v0> magic[FAKE_INITIALIZER](a: Int) -> <v0>
w(a|<v0>) w(a|<v0>)
v(b: Int) v(b: Int)
magic(b: Int) -> <v1> magic[FAKE_INITIALIZER](b: Int) -> <v1>
w(b|<v1>) w(b|<v1>)
unsupported(DELEGATOR_SUPER_CLASS : T) unsupported(DELEGATOR_SUPER_CLASS : T)
L1: L1:
<END> NEXT:[<SINK>] <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
== B == == B ==
class B(a: Int, b: Int): T by A(a + b, a - b) class B(a: Int, b: Int): T by A(a + b, a - b)
@@ -35,10 +35,10 @@ class B(a: Int, b: Int): T by A(a + b, a - b)
L0: L0:
1 <START> 1 <START>
v(a: Int) v(a: Int)
magic(a: Int) -> <v0> magic[FAKE_INITIALIZER](a: Int) -> <v0>
w(a|<v0>) w(a|<v0>)
v(b: Int) v(b: Int)
magic(b: Int) -> <v1> magic[FAKE_INITIALIZER](b: Int) -> <v1>
w(b|<v1>) w(b|<v1>)
r(a) -> <v2> r(a) -> <v2>
r(b) -> <v3> r(b) -> <v3>
@@ -50,11 +50,11 @@ L0:
call(a - b, minus|<v5>, <v6>) -> <v7> call(a - b, minus|<v5>, <v6>) -> <v7>
mark(A(a + b, a - b)) mark(A(a + b, a - b))
call(A(a + b, a - b), <init>|<v4>, <v7>) -> <v8> call(A(a + b, a - b), <init>|<v4>, <v7>) -> <v8>
magic(T by A(a + b, a - b)|<v8>) -> <v9> magic[VALUE_CONSUMER](T by A(a + b, a - b)|<v8>) -> <v9>
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/declarations/classesAndObjects/delegationByExpression.values
+5 -5
View File
@@ -5,14 +5,14 @@ trait T
== A == == A ==
class A(a: Int, b: Int): T class A(a: Int, b: Int): T
--------------------- ---------------------
<v0>: Int NEW: magic(a: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1> <v1>: Int NEW: magic[FAKE_INITIALIZER](b: Int) -> <v1>
===================== =====================
== B == == B ==
class B(a: Int, b: Int): T by A(a + b, a - b) class B(a: Int, b: Int): T by A(a + b, a - b)
--------------------- ---------------------
<v0>: Int NEW: magic(a: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1> <v1>: Int NEW: magic[FAKE_INITIALIZER](b: Int) -> <v1>
a <v2>: Int NEW: r(a) -> <v2> a <v2>: Int NEW: r(a) -> <v2>
b <v3>: Int NEW: r(b) -> <v3> b <v3>: Int NEW: r(b) -> <v3>
a + b <v4>: Int NEW: call(a + b, plus|<v2>, <v3>) -> <v4> a + b <v4>: Int NEW: call(a + b, plus|<v2>, <v3>) -> <v4>
@@ -20,5 +20,5 @@ a <v5>: Int NEW: r(a) -> <v5>
b <v6>: Int NEW: r(b) -> <v6> b <v6>: Int NEW: r(b) -> <v6>
a - b <v7>: Int NEW: call(a - b, minus|<v5>, <v6>) -> <v7> a - b <v7>: Int NEW: call(a - b, minus|<v5>, <v6>) -> <v7>
A(a + b, a - b) <v8>: {<: T} NEW: call(A(a + b, a - b), <init>|<v4>, <v7>) -> <v8> A(a + b, a - b) <v8>: {<: T} NEW: call(A(a + b, a - b), <init>|<v4>, <v7>) -> <v8>
T by A(a + b, a - b) <v9>: * NEW: magic(T by A(a + b, a - b)|<v8>) -> <v9> T by A(a + b, a - b) <v9>: * NEW: magic[VALUE_CONSUMER](T by A(a + b, a - b)|<v8>) -> <v9>
===================== =====================
compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.instructions
+7 -7
View File
@@ -4,17 +4,17 @@ open class A(a: Int, b: Int)
L0: L0:
1 <START> 1 <START>
v(a: Int) v(a: Int)
magic(a: Int) -> <v0> magic[FAKE_INITIALIZER](a: Int) -> <v0>
w(a|<v0>) w(a|<v0>)
v(b: Int) v(b: Int)
magic(b: Int) -> <v1> magic[FAKE_INITIALIZER](b: Int) -> <v1>
w(b|<v1>) w(b|<v1>)
L1: L1:
<END> NEXT:[<SINK>] <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
== B == == B ==
class B(a: Int, b: Int): A(a + b, a - b) class B(a: Int, b: Int): A(a + b, a - b)
@@ -22,10 +22,10 @@ class B(a: Int, b: Int): A(a + b, a - b)
L0: L0:
1 <START> 1 <START>
v(a: Int) v(a: Int)
magic(a: Int) -> <v0> magic[FAKE_INITIALIZER](a: Int) -> <v0>
w(a|<v0>) w(a|<v0>)
v(b: Int) v(b: Int)
magic(b: Int) -> <v1> magic[FAKE_INITIALIZER](b: Int) -> <v1>
w(b|<v1>) w(b|<v1>)
r(a) -> <v2> r(a) -> <v2>
r(b) -> <v3> r(b) -> <v3>
compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.values
+4 -4
View File
@@ -1,14 +1,14 @@
== A == == A ==
open class A(a: Int, b: Int) open class A(a: Int, b: Int)
--------------------- ---------------------
<v0>: Int NEW: magic(a: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1> <v1>: Int NEW: magic[FAKE_INITIALIZER](b: Int) -> <v1>
===================== =====================
== B == == B ==
class B(a: Int, b: Int): A(a + b, a - b) class B(a: Int, b: Int): A(a + b, a - b)
--------------------- ---------------------
<v0>: Int NEW: magic(a: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1> <v1>: Int NEW: magic[FAKE_INITIALIZER](b: Int) -> <v1>
a <v2>: Int NEW: r(a) -> <v2> a <v2>: Int NEW: r(a) -> <v2>
b <v3>: Int NEW: r(b) -> <v3> b <v3>: Int NEW: r(b) -> <v3>
a + b <v4>: Int NEW: call(a + b, plus|<v2>, <v3>) -> <v4> a + b <v4>: Int NEW: call(a + b, plus|<v2>, <v3>) -> <v4>
compiler/testData/cfg/declarations/functions/typeParameter.instructions
+4 -4
View File
@@ -7,11 +7,11 @@ L0:
1 <START> 1 <START>
2 mark({ T }) 2 mark({ T })
error(T, No resolved call) error(T, No resolved call)
magic(T) -> <v0> magic[UNRESOLVED_CALL](T) -> <v0>
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/declarations/functions/typeParameter.values
+1 -1
View File
@@ -3,6 +3,6 @@ fun <T> foo() {
T T
} }
--------------------- ---------------------
T <v0>: * NEW: magic(T) -> <v0> T <v0>: * NEW: magic[UNRESOLVED_CALL](T) -> <v0>
{ T } <v0>: * COPY { T } <v0>: * COPY
===================== =====================
compiler/testData/cfg/declarations/local/LocalDeclarations.instructions
+27 -27
View File
@@ -35,16 +35,16 @@ fun doSmth(i: Int) {}
L0: L0:
1 <START> 1 <START>
v(i: Int) v(i: Int)
magic(i: Int) -> <v0> magic[FAKE_INITIALIZER](i: Int) -> <v0>
w(i|<v0>) w(i|<v0>)
2 mark({}) 2 mark({})
read (Unit) read (Unit)
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>]
===================== =====================
== test1 == == test1 ==
fun test1() { fun test1() {
@@ -63,7 +63,7 @@ L0:
mark(object { val x : Int { $x = 1 } }) mark(object { val x : Int { $x = 1 } })
v(val x : Int) v(val x : Int)
3 mark({ $x = 1 }) 3 mark({ $x = 1 })
magic($x) -> <v0> magic[IMPLICIT_RECEIVER]($x) -> <v0>
r(1) -> <v1> r(1) -> <v1>
w($x|<v0>, <v1>) w($x|<v0>, <v1>)
2 r(object { val x : Int { $x = 1 } }) -> <v2> 2 r(object { val x : Int { $x = 1 } }) -> <v2>
@@ -87,15 +87,15 @@ L0:
1 <START> 1 <START>
v(val x : Int) v(val x : Int)
2 mark({ $x = 1 }) 2 mark({ $x = 1 })
magic($x) -> <v0> magic[IMPLICIT_RECEIVER]($x) -> <v0>
r(1) -> <v1> r(1) -> <v1>
w($x|<v0>, <v1>) w($x|<v0>, <v1>)
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>]
===================== =====================
== test2 == == test2 ==
fun test2() { fun test2() {
@@ -161,15 +161,15 @@ fun inner_bar() {
L3: L3:
3 <START> 3 <START>
4 mark({ y = 10 }) 4 mark({ y = 10 })
magic(y) -> <v0> magic[IMPLICIT_RECEIVER](y) -> <v0>
r(10) -> <v1> r(10) -> <v1>
w(y|<v0>, <v1>) w(y|<v0>, <v1>)
L4: L4:
3 <END> NEXT:[<SINK>] 3 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
== test4 == == test4 ==
fun test4() { fun test4() {
@@ -193,7 +193,7 @@ L0:
v(val x : Int) v(val x : Int)
v(val y : Int) v(val y : Int)
3 mark({ $x = 1 }) 3 mark({ $x = 1 })
magic($x) -> <v0> magic[IMPLICIT_RECEIVER]($x) -> <v0>
r(1) -> <v1> r(1) -> <v1>
w($x|<v0>, <v1>) w($x|<v0>, <v1>)
2 jmp?(L2) NEXT:[r(object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }) -> <v2>, d(fun ggg() { y = 10 })] 2 jmp?(L2) NEXT:[r(object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }) -> <v2>, d(fun ggg() { y = 10 })]
@@ -216,15 +216,15 @@ fun ggg() {
L3: L3:
3 <START> 3 <START>
4 mark({ y = 10 }) 4 mark({ y = 10 })
magic(y) -> <v0> magic[IMPLICIT_RECEIVER](y) -> <v0>
r(10) -> <v1> r(10) -> <v1>
w(y|<v0>, <v1>) w(y|<v0>, <v1>)
L4: L4:
3 <END> NEXT:[<SINK>] 3 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
== test5 == == test5 ==
fun test5() { fun test5() {
@@ -251,7 +251,7 @@ L0:
r(1) -> <v0> r(1) -> <v0>
w(x|<v0>) w(x|<v0>)
3 mark({ $x = 2 }) 3 mark({ $x = 2 })
magic($x) -> <v1> magic[IMPLICIT_RECEIVER]($x) -> <v1>
r(2) -> <v2> r(2) -> <v2>
w($x|<v1>, <v2>) w($x|<v1>, <v2>)
2 jmp?(L2) NEXT:[jmp?(L5), d(fun foo() { x = 3 })] 2 jmp?(L2) NEXT:[jmp?(L5), d(fun foo() { x = 3 })]
@@ -277,15 +277,15 @@ fun foo() {
L3: L3:
3 <START> 3 <START>
4 mark({ x = 3 }) 4 mark({ x = 3 })
magic(x) -> <v0> magic[IMPLICIT_RECEIVER](x) -> <v0>
r(3) -> <v1> r(3) -> <v1>
w(x|<v0>, <v1>) w(x|<v0>, <v1>)
L4: L4:
3 <END> NEXT:[<SINK>] 3 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
== bar == == bar ==
fun bar() { fun bar() {
@@ -295,13 +295,13 @@ fun bar() {
L6: L6:
3 <START> 3 <START>
4 mark({ x = 4 }) 4 mark({ x = 4 })
magic(x) -> <v0> magic[IMPLICIT_RECEIVER](x) -> <v0>
r(4) -> <v1> r(4) -> <v1>
w(x|<v0>, <v1>) w(x|<v0>, <v1>)
L7: L7:
3 <END> NEXT:[<SINK>] 3 <END> NEXT:[<SINK>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/declarations/local/LocalDeclarations.values
+9 -9
View File
@@ -22,7 +22,7 @@ class C() {
== doSmth == == doSmth ==
fun doSmth(i: Int) {} fun doSmth(i: Int) {}
--------------------- ---------------------
<v0>: Int NEW: magic(i: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](i: Int) -> <v0>
===================== =====================
== test1 == == test1 ==
fun test1() { fun test1() {
@@ -34,7 +34,7 @@ fun test1() {
} }
} }
--------------------- ---------------------
<v0>: <no name provided> NEW: magic($x) -> <v0> <v0>: <no name provided> NEW: magic[IMPLICIT_RECEIVER]($x) -> <v0>
1 <v1>: Int NEW: r(1) -> <v1> 1 <v1>: Int NEW: r(1) -> <v1>
object { val x : Int { $x = 1 } } <v2>: <no name provided> NEW: r(object { val x : Int { $x = 1 } }) -> <v2> object { val x : Int { $x = 1 } } <v2>: <no name provided> NEW: r(object { val x : Int { $x = 1 } }) -> <v2>
===================== =====================
@@ -46,7 +46,7 @@ object O {
} }
} }
--------------------- ---------------------
<v0>: O NEW: magic($x) -> <v0> <v0>: O NEW: magic[IMPLICIT_RECEIVER]($x) -> <v0>
1 <v1>: Int NEW: r(1) -> <v1> 1 <v1>: Int NEW: r(1) -> <v1>
===================== =====================
== test2 == == test2 ==
@@ -78,7 +78,7 @@ fun inner_bar() {
y = 10 y = 10
} }
--------------------- ---------------------
<v0>: <no name provided> NEW: magic(y) -> <v0> <v0>: <no name provided> NEW: magic[IMPLICIT_RECEIVER](y) -> <v0>
10 <v1>: Int NEW: r(10) -> <v1> 10 <v1>: Int NEW: r(10) -> <v1>
===================== =====================
== test4 == == test4 ==
@@ -95,7 +95,7 @@ fun test4() {
} }
} }
--------------------- ---------------------
<v0>: <no name provided> NEW: magic($x) -> <v0> <v0>: <no name provided> NEW: magic[IMPLICIT_RECEIVER]($x) -> <v0>
1 <v1>: Int NEW: r(1) -> <v1> 1 <v1>: Int NEW: r(1) -> <v1>
object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } } <v2>: <no name provided> NEW: r(object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }) -> <v2> object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } } <v2>: <no name provided> NEW: r(object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }) -> <v2>
===================== =====================
@@ -104,7 +104,7 @@ fun ggg() {
y = 10 y = 10
} }
--------------------- ---------------------
<v0>: <no name provided> NEW: magic(y) -> <v0> <v0>: <no name provided> NEW: magic[IMPLICIT_RECEIVER](y) -> <v0>
10 <v1>: Int NEW: r(10) -> <v1> 10 <v1>: Int NEW: r(10) -> <v1>
===================== =====================
== test5 == == test5 ==
@@ -123,7 +123,7 @@ fun test5() {
} }
} }
--------------------- ---------------------
<v1>: <no name provided> NEW: magic($x) -> <v1> <v1>: <no name provided> NEW: magic[IMPLICIT_RECEIVER]($x) -> <v1>
1 <v0>: Int NEW: r(1) -> <v0> 1 <v0>: Int NEW: r(1) -> <v0>
2 <v2>: Int NEW: r(2) -> <v2> 2 <v2>: Int NEW: r(2) -> <v2>
object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } } <v3>: <no name provided> NEW: r(object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }) -> <v3> object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } } <v3>: <no name provided> NEW: r(object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }) -> <v3>
@@ -133,7 +133,7 @@ fun foo() {
x = 3 x = 3
} }
--------------------- ---------------------
<v0>: <no name provided> NEW: magic(x) -> <v0> <v0>: <no name provided> NEW: magic[IMPLICIT_RECEIVER](x) -> <v0>
3 <v1>: Int NEW: r(3) -> <v1> 3 <v1>: Int NEW: r(3) -> <v1>
===================== =====================
== bar == == bar ==
@@ -141,6 +141,6 @@ fun bar() {
x = 4 x = 4
} }
--------------------- ---------------------
<v0>: <no name provided> NEW: magic(x) -> <v0> <v0>: <no name provided> NEW: magic[IMPLICIT_RECEIVER](x) -> <v0>
4 <v1>: Int NEW: r(4) -> <v1> 4 <v1>: Int NEW: r(4) -> <v1>
===================== =====================
compiler/testData/cfg/declarations/local/ObjectExpression.instructions
+2 -2
View File
@@ -62,13 +62,13 @@ fun foo(b: B) : Int {
L0: L0:
1 <START> 1 <START>
v(b: B) v(b: B)
magic(b: B) -> <v0> magic[FAKE_INITIALIZER](b: B) -> <v0>
w(b|<v0>) w(b|<v0>)
2 mark({ val o = object : A by b {} return o.foo() }) 2 mark({ val o = object : A by b {} return o.foo() })
v(val o = object : A by b {}) v(val o = object : A by b {})
mark(object : A by b {}) mark(object : A by b {})
r(b) -> <v1> r(b) -> <v1>
magic(A by b|<v1>) -> <v2> magic[VALUE_CONSUMER](A by b|<v1>) -> <v2>
r(object : A by b {}) -> <v3> r(object : A by b {}) -> <v3>
w(o|<v3>) w(o|<v3>)
mark(o.foo()) mark(o.foo())
compiler/testData/cfg/declarations/local/ObjectExpression.values
+2 -2
View File
@@ -25,9 +25,9 @@ fun foo(b: B) : Int {
return o.foo() return o.foo()
} }
--------------------- ---------------------
<v0>: B NEW: magic(b: B) -> <v0> <v0>: B NEW: magic[FAKE_INITIALIZER](b: B) -> <v0>
b <v1>: {<: A} NEW: r(b) -> <v1> b <v1>: {<: A} NEW: r(b) -> <v1>
A by b <v2>: * NEW: magic(A by b|<v1>) -> <v2> A by b <v2>: * NEW: magic[VALUE_CONSUMER](A by b|<v1>) -> <v2>
object : A by b {} <v3>: <no name provided> NEW: r(object : A by b {}) -> <v3> object : A by b {} <v3>: <no name provided> NEW: r(object : A by b {}) -> <v3>
o <v4>: {<: A} NEW: r(o) -> <v4> o <v4>: {<: A} NEW: r(o) -> <v4>
foo() <v5>: Int NEW: call(foo(), foo|<v4>) -> <v5> foo() <v5>: Int NEW: call(foo(), foo|<v4>) -> <v5>
compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.instructions
+4 -4
View File
@@ -50,7 +50,7 @@ fun test(c: C) {
L0: L0:
1 <START> 1 <START>
v(c: C) v(c: C)
magic(c: C) -> <v0> magic[FAKE_INITIALIZER](c: C) -> <v0>
w(c|<v0>) w(c|<v0>)
2 mark({ val (a, b) = c val d = 1 }) 2 mark({ val (a, b) = c val d = 1 })
r(c) -> <v1> r(c) -> <v1>
@@ -64,9 +64,9 @@ L0:
r(1) -> <v4> r(1) -> <v4>
w(d|<v4>) w(d|<v4>)
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/declarations/multiDeclaration/MultiDecl.values
+1 -1
View File
@@ -21,7 +21,7 @@ fun test(c: C) {
val d = 1 val d = 1
} }
--------------------- ---------------------
<v0>: C NEW: magic(c: C) -> <v0> <v0>: C NEW: magic[FAKE_INITIALIZER](c: C) -> <v0>
a <v2>: Int NEW: call(a, component1|<v1>) -> <v2> a <v2>: Int NEW: call(a, component1|<v1>) -> <v2>
b <v3>: Int NEW: call(b, component2|<v1>) -> <v3> b <v3>: Int NEW: call(b, component2|<v1>) -> <v3>
c <v1>: C NEW: r(c) -> <v1> c <v1>: C NEW: r(c) -> <v1>
compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.instructions
+6 -6
View File
@@ -7,21 +7,21 @@ fun foo(x: Int) {
L0: L0:
1 <START> 1 <START>
v(x: Int) v(x: Int)
magic(x: Int) -> <v0> magic[FAKE_INITIALIZER](x: Int) -> <v0>
w(x|<v0>) w(x|<v0>)
2 mark({ val (a, b) = x a }) 2 mark({ val (a, b) = x a })
r(x) -> <v1> r(x) -> <v1>
v(a) v(a)
magic(a|<v1>) -> <v2> magic[UNRESOLVED_CALL](a|<v1>) -> <v2>
w(a|<v2>) w(a|<v2>)
v(b) v(b)
magic(b|<v1>) -> <v3> magic[UNRESOLVED_CALL](b|<v1>) -> <v3>
w(b|<v3>) w(b|<v3>)
r(a) -> <v4> r(a) -> <v4>
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/declarations/multiDeclaration/multiDeclarationWithError.values
+3 -3
View File
@@ -4,9 +4,9 @@ fun foo(x: Int) {
a a
} }
--------------------- ---------------------
<v0>: Int NEW: magic(x: Int) -> <v0> <v0>: Int NEW: magic[FAKE_INITIALIZER](x: Int) -> <v0>
<v2>: {<: [ERROR : component1() return type]} NEW: magic(a|<v1>) -> <v2> <v2>: {<: [ERROR : component1() return type]} NEW: magic[UNRESOLVED_CALL](a|<v1>) -> <v2>
<v3>: {<: [ERROR : component2() return type]} NEW: magic(b|<v1>) -> <v3> <v3>: {<: [ERROR : component2() return type]} NEW: magic[UNRESOLVED_CALL](b|<v1>) -> <v3>
x <v1>: * NEW: r(x) -> <v1> x <v1>: * NEW: r(x) -> <v1>
a <v4>: * NEW: r(a) -> <v4> a <v4>: * NEW: r(a) -> <v4>
{ val (a, b) = x a } <v4>: * COPY { val (a, b) = x a } <v4>: * COPY
compiler/testData/cfg/declarations/properties/DelegatedProperty.instructions
+5 -5
View File
@@ -18,19 +18,19 @@ fun get(_this: Any, p: PropertyMetadata): Int = 0
L0: L0:
1 <START> 1 <START>
v(_this: Any) v(_this: Any)
magic(_this: Any) -> <v0> magic[FAKE_INITIALIZER](_this: Any) -> <v0>
w(_this|<v0>) w(_this|<v0>)
v(p: PropertyMetadata) v(p: PropertyMetadata)
magic(p: PropertyMetadata) -> <v1> magic[FAKE_INITIALIZER](p: PropertyMetadata) -> <v1>
w(p|<v1>) w(p|<v1>)
r(0) -> <v2> r(0) -> <v2>
ret(*|<v2>) L1 ret(*|<v2>) 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>]
===================== =====================
== a == == a ==
val a = Delegate() val a = Delegate()
compiler/testData/cfg/declarations/properties/DelegatedProperty.values
+2 -2
View File
@@ -7,8 +7,8 @@ class Delegate {
== get == == get ==
fun get(_this: Any, p: PropertyMetadata): Int = 0 fun get(_this: Any, p: PropertyMetadata): Int = 0
--------------------- ---------------------
<v0>: {<: Any} NEW: magic(_this: Any) -> <v0> <v0>: {<: Any} NEW: magic[FAKE_INITIALIZER](_this: Any) -> <v0>
<v1>: {<: PropertyMetadata} NEW: magic(p: PropertyMetadata) -> <v1> <v1>: {<: PropertyMetadata} NEW: magic[FAKE_INITIALIZER](p: PropertyMetadata) -> <v1>
0 <v2>: Int NEW: r(0) -> <v2> 0 <v2>: Int NEW: r(0) -> <v2>
===================== =====================
== a == == a ==
compiler/testData/cfg/declarations/properties/backingFieldAccess.instructions
+4 -4
View File
@@ -12,12 +12,12 @@ L0:
1 <START> 1 <START>
v(val a: Int get() = 1) v(val a: Int get() = 1)
2 mark({ $a }) 2 mark({ $a })
magic($a) -> <v0> magic[IMPLICIT_RECEIVER]($a) -> <v0>
r($a|<v0>) -> <v1> r($a|<v0>) -> <v1>
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/declarations/properties/backingFieldAccess.values
+1 -1
View File
@@ -8,7 +8,7 @@ class C {
} }
} }
--------------------- ---------------------
<v0>: C NEW: magic($a) -> <v0> <v0>: C NEW: magic[IMPLICIT_RECEIVER]($a) -> <v0>
$a <v1>: * NEW: r($a|<v0>) -> <v1> $a <v1>: * NEW: r($a|<v0>) -> <v1>
{ $a } <v1>: * COPY { $a } <v1>: * COPY
===================== =====================
compiler/testData/cfg/expressions/Assignments.instructions
+4 -4
View File
@@ -54,17 +54,17 @@ L3:
w(x|<v8>) w(x|<v8>)
v(val y = true && false) v(val y = true && false)
r(true) -> <v9> r(true) -> <v9>
jf(L4|<v9>) NEXT:[magic(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: L4:
magic(true && false|<v9>, <v10>) -> <v11> PREV:[jf(L4|<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|<v12>) NEXT:[magic(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: L5:
magic(false && true|<v12>, <v13>) -> <v14> PREV:[jf(L5|<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/Assignments.values
+2 -2
View File
@@ -31,10 +31,10 @@ true
if (true) 1 else 2 <v8>: Int NEW: merge(if (true) 1 else 2|<v6>, <v7>) -> <v8> if (true) 1 else 2 <v8>: Int NEW: merge(if (true) 1 else 2|<v6>, <v7>) -> <v8>
true <v9>: Boolean NEW: r(true) -> <v9> true <v9>: Boolean NEW: r(true) -> <v9>
false <v10>: Boolean NEW: r(false) -> <v10> false <v10>: Boolean NEW: r(false) -> <v10>
true && false <v11>: Boolean NEW: magic(true && false|<v9>, <v10>) -> <v11> true && false <v11>: Boolean NEW: magic[AND](true && false|<v9>, <v10>) -> <v11>
false <v12>: Boolean NEW: r(false) -> <v12> false <v12>: Boolean NEW: r(false) -> <v12>
true <v13>: Boolean NEW: r(true) -> <v13> true <v13>: Boolean NEW: r(true) -> <v13>
false && true <v14>: Boolean NEW: magic(false && true|<v12>, <v13>) -> <v14> false && true <v14>: Boolean NEW: magic[AND](false && true|<v12>, <v13>) -> <v14>
Test() <v15>: Test NEW: call(Test(), <init>) -> <v15> Test() <v15>: Test NEW: call(Test(), <init>) -> <v15>
t <v16>: Test NEW: r(t) -> <v16> t <v16>: Test NEW: r(t) -> <v16>
1 <v17>: Int NEW: r(1) -> <v17> 1 <v17>: Int NEW: r(1) -> <v17>
compiler/testData/cfg/expressions/LazyBooleans.instructions
+6 -6
View File
@@ -20,10 +20,10 @@ fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
L0: L0:
1 <START> 1 <START>
v(a : Boolean) v(a : Boolean)
magic(a : Boolean) -> <v0> magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
w(a|<v0>) w(a|<v0>)
v(b : Boolean) v(b : Boolean)
magic(b : Boolean) -> <v1> magic[FAKE_INITIALIZER](b : Boolean) -> <v1>
w(b|<v1>) w(b|<v1>)
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 })
@@ -40,10 +40,10 @@ L3:
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|<v7>) NEXT:[magic(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: L4:
magic(a && b|<v7>, <v8>) -> <v9> PREV:[jf(L4|<v7>), r(b) -> <v8>] magic[AND](a && b|<v7>, <v8>) -> <v9> PREV:[jf(L4|<v7>), r(b) -> <v8>]
jf(L5|<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) NEXT:[merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12>] jmp(L6) NEXT:[merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12>]
@@ -54,10 +54,10 @@ L6:
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|<v14>) NEXT:[r(b) -> <v15>, magic(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: L7:
magic(a || b|<v14>, <v15>) -> <v16> PREV:[jt(L7|<v14>), r(b) -> <v15>] magic[OR](a || b|<v14>, <v15>) -> <v16> PREV:[jt(L7|<v14>), r(b) -> <v15>]
jf(L8|<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) NEXT:[merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19>] jmp(L9) NEXT:[merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19>]
compiler/testData/cfg/expressions/LazyBooleans.values
+4 -4
View File
@@ -17,8 +17,8 @@ fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
14 14
} }
--------------------- ---------------------
<v0>: Boolean NEW: magic(a : Boolean) -> <v0> <v0>: Boolean NEW: magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
<v1>: Boolean NEW: magic(b : Boolean) -> <v1> <v1>: Boolean NEW: magic[FAKE_INITIALIZER](b : Boolean) -> <v1>
a <v2>: Boolean NEW: r(a) -> <v2> a <v2>: Boolean NEW: r(a) -> <v2>
1 <v3>: * NEW: r(1) -> <v3> 1 <v3>: * NEW: r(1) -> <v3>
{ 1 } <v3>: * COPY { 1 } <v3>: * COPY
@@ -28,14 +28,14 @@ if (a) { 1 } else { 2 }
3 <v6>: * NEW: r(3) -> <v6> 3 <v6>: * NEW: r(3) -> <v6>
a <v7>: Boolean NEW: r(a) -> <v7> a <v7>: Boolean NEW: r(a) -> <v7>
b <v8>: Boolean NEW: r(b) -> <v8> b <v8>: Boolean NEW: r(b) -> <v8>
a && b <v9>: Boolean NEW: magic(a && b|<v7>, <v8>) -> <v9> a && b <v9>: Boolean NEW: magic[AND](a && b|<v7>, <v8>) -> <v9>
5 <v10>: * NEW: r(5) -> <v10> 5 <v10>: * NEW: r(5) -> <v10>
6 <v11>: * NEW: r(6) -> <v11> 6 <v11>: * NEW: r(6) -> <v11>
if (a && b) 5 else 6 <v12>: * NEW: merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12> if (a && b) 5 else 6 <v12>: * NEW: merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12>
7 <v13>: * NEW: r(7) -> <v13> 7 <v13>: * NEW: r(7) -> <v13>
a <v14>: Boolean NEW: r(a) -> <v14> a <v14>: Boolean NEW: r(a) -> <v14>
b <v15>: Boolean NEW: r(b) -> <v15> b <v15>: Boolean NEW: r(b) -> <v15>
a || b <v16>: Boolean NEW: magic(a || b|<v14>, <v15>) -> <v16> a || b <v16>: Boolean NEW: magic[OR](a || b|<v14>, <v15>) -> <v16>
8 <v17>: * NEW: r(8) -> <v17> 8 <v17>: * NEW: r(8) -> <v17>
9 <v18>: * NEW: r(9) -> <v18> 9 <v18>: * NEW: r(9) -> <v18>
if (a || b) 8 else 9 <v19>: * NEW: merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19> if (a || b) 8 else 9 <v19>: * NEW: merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19>
compiler/testData/cfg/expressions/ReturnFromExpression.instructions
+6 -6
View File
@@ -7,16 +7,16 @@ L0:
1 <START> 1 <START>
2 mark({ false || (return false) }) 2 mark({ false || (return false) })
r(false) -> <v0> r(false) -> <v0>
jt(L2|<v0>) NEXT:[mark((return false)), magic(false || (return false)|<v0>) -> <v2>] jt(L2|<v0>) NEXT:[mark((return false)), magic[OR](false || (return false)|<v0>) -> <v2>]
mark((return false)) mark((return false))
r(false) -> <v1> r(false) -> <v1>
ret(*|<v1>) L1 NEXT:[<END>] ret(*|<v1>) L1 NEXT:[<END>]
L2: L2:
magic(false || (return false)|<v0>) -> <v2> PREV:[jt(L2|<v0>)] magic[OR](false || (return false)|<v0>) -> <v2> PREV:[jt(L2|<v0>)]
L1: L1:
1 <END> NEXT:[<SINK>] PREV:[ret(*|<v1>) L1, magic(false || (return false)|<v0>) -> <v2>] 1 <END> NEXT:[<SINK>] PREV:[ret(*|<v1>) L1, magic[OR](false || (return false)|<v0>) -> <v2>]
error: error:
<ERROR> PREV:[] <ERROR> PREV:[]
sink: sink:
<SINK> PREV:[<ERROR>, <END>] <SINK> PREV:[<ERROR>, <END>]
===================== =====================
compiler/testData/cfg/expressions/ReturnFromExpression.values
+1 -1
View File
@@ -5,6 +5,6 @@ fun blockAndAndMismatch() : Boolean {
--------------------- ---------------------
false <v0>: Boolean NEW: r(false) -> <v0> false <v0>: Boolean NEW: r(false) -> <v0>
false <v1>: Boolean NEW: r(false) -> <v1> false <v1>: Boolean NEW: r(false) -> <v1>
false || (return false) <v2>: * NEW: magic(false || (return false)|<v0>) -> <v2> false || (return false) <v2>: * NEW: magic[OR](false || (return false)|<v0>) -> <v2>
{ false || (return false) } <v2>: * COPY { false || (return false) } <v2>: * COPY
===================== =====================
compiler/testData/cfg/expressions/assignmentToThis.instructions
+1 -1
View File
@@ -6,7 +6,7 @@ fun Int.bar(c: C) {
L0: L0:
1 <START> 1 <START>
v(c: C) v(c: C)
magic(c: C) -> <v0> magic[FAKE_INITIALIZER](c: C) -> <v0>
w(c|<v0>) w(c|<v0>)
2 mark({ this = c }) 2 mark({ this = c })
r(c) -> <v1> r(c) -> <v1>
compiler/testData/cfg/expressions/assignmentToThis.values
+1 -1
View File
@@ -3,6 +3,6 @@ fun Int.bar(c: C) {
this = c this = c
} }
--------------------- ---------------------
<v0>: {<: [ERROR : C]} NEW: magic(c: C) -> <v0> <v0>: {<: [ERROR : C]} NEW: magic[FAKE_INITIALIZER](c: C) -> <v0>
c <v1>: * NEW: r(c) -> <v1> c <v1>: * NEW: r(c) -> <v1>
===================== =====================
compiler/testData/cfg/expressions/chainedQualifiedExpression.instructions
+2 -2
View File
@@ -87,7 +87,7 @@ L0:
mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)) mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)) mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)) mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
magic(BunchKeywordRegister()) -> <v1> magic[IMPLICIT_RECEIVER](BunchKeywordRegister()) -> <v1>
mark(BunchKeywordRegister()) mark(BunchKeywordRegister())
call(BunchKeywordRegister(), <init>|<v1>) -> <v2> call(BunchKeywordRegister(), <init>|<v1>) -> <v2>
r(ABSTRACT_KEYWORD) -> <v3> r(ABSTRACT_KEYWORD) -> <v3>
@@ -213,7 +213,7 @@ L0:
call(add(OUT_KEYWORD, inTopLevel), add|<v99>, <v100>, <v101>) -> <v102> call(add(OUT_KEYWORD, inTopLevel), add|<v99>, <v100>, <v101>) -> <v102>
r(OBJECT_KEYWORD) -> <v103> r(OBJECT_KEYWORD) -> <v103>
error(unresolvedCode, No resolved call) error(unresolvedCode, No resolved call)
magic(unresolvedCode) -> <v104> magic[UNRESOLVED_CALL](unresolvedCode) -> <v104>
mark(add(OBJECT_KEYWORD, unresolvedCode)) mark(add(OBJECT_KEYWORD, unresolvedCode))
call(add(OBJECT_KEYWORD, unresolvedCode), add|<v102>, <v103>, <v104>) -> <v105> call(add(OBJECT_KEYWORD, unresolvedCode), add|<v102>, <v103>, <v104>) -> <v105>
mark(registerAll()) mark(registerAll())

Some files were not shown because too many files have changed in this diff Show More