jdk-sandbox: comparison src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java/FrameStateBuilder.java

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 /*
-* Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 import static org.graalvm.compiler.bytecode.Bytecodes.POP;
 import static org.graalvm.compiler.bytecode.Bytecodes.POP2;
 import static org.graalvm.compiler.bytecode.Bytecodes.SWAP;
 import static org.graalvm.compiler.debug.GraalError.shouldNotReachHere;
 import static org.graalvm.compiler.nodes.FrameState.TWO_SLOT_MARKER;
+import static org.graalvm.compiler.nodes.util.GraphUtil.originalValue;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.function.Function;
 import org.graalvm.compiler.bytecode.Bytecode;
 import org.graalvm.compiler.bytecode.ResolvedJavaMethodBytecode;
-import org.graalvm.compiler.core.common.GraalOptions;
 import org.graalvm.compiler.core.common.PermanentBailoutException;
 import org.graalvm.compiler.core.common.type.StampFactory;
 import org.graalvm.compiler.core.common.type.StampPair;
 import org.graalvm.compiler.debug.DebugContext;
 import org.graalvm.compiler.debug.GraalError;
 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins;
 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderTool;
 import org.graalvm.compiler.nodes.graphbuilderconf.IntrinsicContext.SideEffectsState;
 import org.graalvm.compiler.nodes.graphbuilderconf.ParameterPlugin;
 import org.graalvm.compiler.nodes.java.MonitorIdNode;
-import org.graalvm.compiler.nodes.util.GraphUtil;
 import jdk.vm.ci.code.BytecodeFrame;
 import jdk.vm.ci.meta.Assumptions;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.JavaType;
 assert graph != null;
 this.monitorIds = EMPTY_MONITOR_ARRAY;
 this.graph = graph;
-this.clearNonLiveLocals = GraalOptions.OptClearNonLiveLocals.getValue(graph.getOptions()) && !shouldRetainLocalVariables;
+this.clearNonLiveLocals = !shouldRetainLocalVariables;
 this.canVerifyKind = true;
 }
 public void disableKindVerification() {
 canVerifyKind = false;
 assert other.graph != null;
 graph = other.graph;
 clearNonLiveLocals = other.clearNonLiveLocals;
 monitorIds = other.monitorIds.length == 0 ? other.monitorIds : other.monitorIds.clone();
-assert locals.length == code.getMaxLocals();
-assert stack.length == Math.max(1, code.getMaxStackSize());
 assert lockedObjects.length == monitorIds.length;
 }
 private static ValueNode[] allocateArray(int length) {
 return length == 0 ? EMPTY_ARRAY : new ValueNode[length];
 public FrameStateBuilder copy() {
 return new FrameStateBuilder(this);
 }
-public boolean isCompatibleWith(FrameStateBuilder other) {
+private String incompatibilityErrorMessage(String reason, FrameStateBuilder other) {
+return String.format("Frame states being merged are incompatible: %s%n This frame state: %s%nOther frame state: %s%nParser context: %s", reason, this, other, parser);
+}
+/**
+* Checks invariants that must hold when merging {@code other} into this frame state.
+*
+* @param other
+* @throws PermanentBailoutException if the frame states are incompatible with respect to their
+*             locked objects. This indicates bytecode that has unstructured or unbalanced
+*             locks.
+* @throws GraalError if the frame states are incompatible in terms of {@link #rethrowException}
+*             or stack slots
+*/
+public void checkCompatibleWith(FrameStateBuilder other) {
 assert code.equals(other.code) && graph == other.graph && localsSize() == other.localsSize() : "Can only compare frame states of the same method";
 assert lockedObjects.length == monitorIds.length && other.lockedObjects.length == other.monitorIds.length : "mismatch between lockedObjects and monitorIds";
 if (rethrowException != other.rethrowException) {
-return false;
+throw new GraalError(incompatibilityErrorMessage("mismatch in rethrowException flag", other));
 }
 if (stackSize() != other.stackSize()) {
-return false;
+throw new GraalError(incompatibilityErrorMessage("mismatch in stack sizes", other));
 }
 for (int i = 0; i < stackSize(); i++) {
 ValueNode x = stack[i];
 ValueNode y = other.stack[i];
 assert x != null && y != null;
 if (x != y && (x == TWO_SLOT_MARKER || x.isDeleted() || y == TWO_SLOT_MARKER || y.isDeleted() || x.getStackKind() != y.getStackKind())) {
-return false;
+throw new GraalError(incompatibilityErrorMessage("mismatch in stack types", other));
 }
 }
 if (lockedObjects.length != other.lockedObjects.length) {
-return false;
+throw new PermanentBailoutException(incompatibilityErrorMessage("unbalanced monitors - locked objects do not match", other));
 }
 for (int i = 0; i < lockedObjects.length; i++) {
-if (GraphUtil.originalValue(lockedObjects[i]) != GraphUtil.originalValue(other.lockedObjects[i]) || monitorIds[i] != other.monitorIds[i]) {
+if (originalValue(lockedObjects[i], false) != originalValue(other.lockedObjects[i], false)) {
-throw new PermanentBailoutException("unbalanced monitors");
+throw new PermanentBailoutException(incompatibilityErrorMessage("unbalanced monitors - locked objects do not match", other));
 }
-}
+if (monitorIds[i] != other.monitorIds[i]) {
-return true;
+throw new PermanentBailoutException(incompatibilityErrorMessage("unbalanced monitors - monitors do not match", other));
+}
+}
 }
 public void merge(AbstractMergeNode block, FrameStateBuilder other) {
-GraalError.guarantee(isCompatibleWith(other), "stacks do not match on merge; bytecodes would not verify:%nexpect: %s%nactual: %s", block, other);
+checkCompatibleWith(other);
 for (int i = 0; i < localsSize(); i++) {
 locals[i] = merge(locals[i], other.locals[i], block);
 }
 for (int i = 0; i < stackSize(); i++) {
 * @return the instruction on the top of the stack
 */
 public ValueNode pop(JavaKind slotKind) {
 if (slotKind.needsTwoSlots()) {
 ValueNode s = xpop();
-assert s == TWO_SLOT_MARKER;
+assert s == TWO_SLOT_MARKER : s;
 }
 ValueNode x = xpop();
 assert verifyKind(slotKind, x);
 return x;
 }
 ValueNode x = xpop();
 if (x == TWO_SLOT_MARKER) {
 /* Ignore second slot of two-slot value. */
 x = xpop();
 }
-assert x != null && x != TWO_SLOT_MARKER;
+assert x != null && x != TWO_SLOT_MARKER : x;
 result[i] = x;
 }
 return result;
 }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54914	9feb4852536f
child 58679	9c3209ff7550