Mercurial > hg > graal-jvmci-8
view jvmci/jdk.vm.ci.code/src/jdk/vm/ci/code/BytecodeFrame.java @ 23712:66059526b021 jvmci-0.16
8160177: [JVMCI] race condition in HotSpotMemoryAccessProviderImpl.verifyReadRawObject
author | Roland Schatz <roland.schatz@oracle.com> |
---|---|
date | Thu, 23 Jun 2016 16:49:32 +0200 |
parents | 9ac04c6047c8 |
children | 1140503536ae |
line wrap: on
line source
/* * 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 objects 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(); } }