/*
* Copyright (c) 2009, 2015, 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.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.vm.ci.code;
import java.util.Arrays;
import jdk.vm.ci.meta.JavaKind;
import jdk.vm.ci.meta.JavaValue;
import jdk.vm.ci.meta.ResolvedJavaMethod;
import jdk.vm.ci.meta.Value;
/**
* Represents the Java bytecode frame state(s) at a given position including {@link Value locations}
* where to find the local variables, operand stack values and locked objects of the bytecode
* frame(s).
*/
public final class BytecodeFrame extends BytecodePosition {
/**
* An array of values representing how to reconstruct the state of the Java frame. This is array
* is partitioned as follows:
* <p>
* <table summary="" border="1" cellpadding="5" frame="void" rules="all">
* <tr>
* <th>Start index (inclusive)</th>
* <th>End index (exclusive)</th>
* <th>Description</th>
* </tr>
* <tr>
* <td>0</td>
* <td>numLocals</td>
* <td>Local variables</td>
* </tr>
* <tr>
* <td>numLocals</td>
* <td>numLocals + numStack</td>
* <td>Operand stack</td>
* </tr>
* <tr>
* <td>numLocals + numStack</td>
* <td>values.length</td>
* <td>Locked objects</td>
* </tr>
* </table>
* <p>
* Note that the number of locals and the number of stack slots may be smaller than the maximum
* number of locals and stack slots as specified in the compiled method.
*
* This field is intentionally exposed as a mutable array that a compiler may modify (e.g.
* during register allocation).
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "field is intentionally mutable")//
public final JavaValue[] values;
/**
* An array describing the Java kinds in {@link #values}. It records a kind for the locals and
* the operand stack.
*/
private final JavaKind[] slotKinds;
/**
* The number of locals in the values array.
*/
public final int numLocals;
/**
* The number of stack slots in the values array.
*/
public final int numStack;
/**
* The number of locks in the values array.
*/
public final int numLocks;
/**
* True if this is a position inside an exception handler before the exception object has been
* consumed. In this case, {@link #numStack} {@code == 1} and {@link #getStackValue(int)
* getStackValue(0)} is the location of the exception object. If deoptimization happens at this
* position, the interpreter will rethrow the exception instead of executing the bytecode
* instruction at this position.
*/
public final boolean rethrowException;
/**
* Specifies if this object represents a frame state in the middle of executing a call. If true,
* the arguments to the call have been popped from the stack and the return value (for a
* non-void call) has not yet been pushed.
*/
public final boolean duringCall;
/**
* This BCI should be used for frame states that are built for code with no meaningful BCI.
*/
public static final int UNKNOWN_BCI = -5;
/**
* The BCI for exception unwind. This is synthetic code and has no representation in bytecode.
* In contrast with {@link #AFTER_EXCEPTION_BCI}, at this point, if the method is synchronized,
* the monitor is still held.
*/
public static final int UNWIND_BCI = -1;
/**
* The BCI for the state before starting to execute a method. Note that if the method is
* synchronized, the monitor is not yet held.
*/
public static final int BEFORE_BCI = -2;
/**
* The BCI for the state after finishing the execution of a method and returning normally. Note
* that if the method was synchronized the monitor is already released.
*/
public static final int AFTER_BCI = -3;
/**
* The BCI for exception unwind. This is synthetic code and has no representation in bytecode.
* In contrast with {@link #UNWIND_BCI}, at this point, if the method is synchronized, the
* monitor is already released.
*/
public static final int AFTER_EXCEPTION_BCI = -4;
/**
* This BCI should be used for states that cannot be the target of a deoptimization, like
* snippet frame states.
*/
public static final int INVALID_FRAMESTATE_BCI = -6;
/**
* Determines if a given BCI matches one of the placeholder BCI constants defined in this class.
*/
public static boolean isPlaceholderBci(int bci) {
return bci < 0;
}
/**
* Gets the name of a given placeholder BCI.
*/
public static String getPlaceholderBciName(int bci) {
assert isPlaceholderBci(bci);
if (bci == BytecodeFrame.AFTER_BCI) {
return "AFTER_BCI";
} else if (bci == BytecodeFrame.AFTER_EXCEPTION_BCI) {
return "AFTER_EXCEPTION_BCI";
} else if (bci == BytecodeFrame.INVALID_FRAMESTATE_BCI) {
return "INVALID_FRAMESTATE_BCI";
} else if (bci == BytecodeFrame.BEFORE_BCI) {
return "BEFORE_BCI";
} else if (bci == BytecodeFrame.UNKNOWN_BCI) {
return "UNKNOWN_BCI";
} else {
assert bci == BytecodeFrame.UNWIND_BCI;
return "UNWIND_BCI";
}
}
/**
* Creates a new frame object.
*
* @param caller the caller frame (which may be {@code null})
* @param method the method
* @param bci a BCI within the method
* @param rethrowException specifies if the VM should re-throw the pending exception when
* deopt'ing using this frame
* @param values the frame state {@link #values}.
* @param slotKinds the kinds in {@code values}. This array is now owned by this object and must
* not be mutated by the caller.
* @param numLocals the number of local variables
* @param numStack the depth of the stack
* @param numLocks the number of locked objects
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "caller transfers ownership of `slotKinds`")
public BytecodeFrame(BytecodeFrame caller, ResolvedJavaMethod method, int bci, boolean rethrowException, boolean duringCall, JavaValue[] values, JavaKind[] slotKinds, int numLocals, int numStack,
int numLocks) {
super(caller, method, bci);
assert values != null;
this.rethrowException = rethrowException;
this.duringCall = duringCall;
this.values = values;
this.slotKinds = slotKinds;
this.numLocals = numLocals;
this.numStack = numStack;
this.numLocks = numLocks;
assert !rethrowException || numStack == 1 : "must have exception on top of the stack";
}
/**
* Ensure that the frame state is formatted as expected by the JVM, with null or Illegal in the
* slot following a double word item. This should really be checked in FrameState itself but
* because of Word type rewriting and alternative backends that can't be done.
*/
public boolean validateFormat() {
if (caller() != null) {
caller().validateFormat();
}
for (int i = 0; i < numLocals + numStack; i++) {
if (values[i] != null) {
JavaKind kind = slotKinds[i];
if (kind.needsTwoSlots()) {
assert slotKinds.length > i + 1 : String.format("missing second word %s", this);
assert slotKinds[i + 1] == JavaKind.Illegal : this;
}
}
}
return true;
}
/**
* Gets the kind of a local variable.
*
* @param i the local variable to query
* @return the kind of local variable {@code i}
* @throw {@link IndexOutOfBoundsException} if {@code i < 0 || i >= this.numLocals}
*/
public JavaKind getLocalValueKind(int i) {
if (i < 0 || i >= numLocals) {
throw new IndexOutOfBoundsException();
}
return slotKinds[i];
}
/**
* Gets the kind of a stack slot.
*
* @param i the local variable to query
* @return the kind of stack slot {@code i}
* @throw {@link IndexOutOfBoundsException} if {@code i < 0 || i >= this.numStack}
*/
public JavaKind getStackValueKind(int i) {
if (i < 0 || i >= numStack) {
throw new IndexOutOfBoundsException();
}
return slotKinds[i + numLocals];
}
/**
* Gets the value representing the specified local variable.
*
* @param i the local variable index
* @return the value that can be used to reconstruct the local's current value
* @throw {@link IndexOutOfBoundsException} if {@code i < 0 || i >= this.numLocals}
*/
public JavaValue getLocalValue(int i) {
if (i < 0 || i >= numLocals) {
throw new IndexOutOfBoundsException();
}
return values[i];
}
/**
* Gets the value representing the specified stack slot.
*
* @param i the stack index
* @return the value that can be used to reconstruct the stack slot's current value
* @throw {@link IndexOutOfBoundsException} if {@code i < 0 || i >= this.numStack}
*/
public JavaValue getStackValue(int i) {
if (i < 0 || i >= numStack) {
throw new IndexOutOfBoundsException();
}
return values[i + numLocals];
}
/**
* Gets the value representing the specified lock.
*
* @param i the lock index
* @return the value that can be used to reconstruct the lock's current value
* @throw {@link IndexOutOfBoundsException} if {@code i < 0 || i >= this.numLocks}
*/
public JavaValue getLockValue(int i) {
if (i < 0 || i >= numLocks) {
throw new IndexOutOfBoundsException();
}
return values[i + numLocals + numStack];
}
/**
* Gets the caller of this frame.
*
* @return {@code null} if this frame has no caller
*/
public BytecodeFrame caller() {
return (BytecodeFrame) getCaller();
}
@Override
public int hashCode() {
return (numLocals + 1) ^ (numStack + 11) ^ (numLocks + 7);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof BytecodeFrame && super.equals(obj)) {
BytecodeFrame that = (BytecodeFrame) obj;
// @formatter:off
if (this.duringCall == that.duringCall &&
this.rethrowException == that.rethrowException &&
this.numLocals == that.numLocals &&
this.numLocks == that.numLocks &&
this.numStack == that.numStack &&
Arrays.equals(this.values, that.values)) {
return true;
}
// @formatter:off
return true;
}
return false;
}
@Override
public String toString() {
return CodeUtil.append(new StringBuilder(100), this).toString();
}
}