path: root/src/jdk/nashorn/internal/runtime/RewriteException.java

/*
 * Copyright (c) 2010, 2013, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.nashorn.internal.runtime;

import static jdk.nashorn.internal.codegen.CompilerConstants.staticCall;
import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCallNoLookup;

import java.io.NotSerializableException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.invoke.CallSite;
import java.lang.invoke.ConstantCallSite;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.invoke.MethodType;
import java.lang.reflect.Array;
import java.util.Arrays;
import jdk.nashorn.internal.codegen.CompilerConstants;
import jdk.nashorn.internal.codegen.CompilerConstants.Call;
import jdk.nashorn.internal.codegen.types.Type;
import jdk.nashorn.internal.lookup.MethodHandleFactory;
import jdk.nashorn.internal.lookup.MethodHandleFunctionality;
import jdk.nashorn.internal.objects.Global;
import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;

/**
 * Used to signal to the linker to relink the callee
 */
@SuppressWarnings("serial")
public final class RewriteException extends Exception {
    private static final MethodHandleFunctionality MH = MethodHandleFactory.getFunctionality();

    // Runtime scope in effect at the time of the compilation. Used to evaluate types of expressions and prevent overly
    // optimistic assumptions (which will lead to unnecessary deoptimizing recompilations).
    private ScriptObject runtimeScope;

    // Contents of bytecode slots
    private Object[] byteCodeSlots;

    private final int[] previousContinuationEntryPoints;

    /** Call for getting the contents of the bytecode slots in the exception */
    public static final Call GET_BYTECODE_SLOTS       = virtualCallNoLookup(RewriteException.class, "getByteCodeSlots", Object[].class);
    /** Call for getting the program point in the exception */
    public static final Call GET_PROGRAM_POINT        = virtualCallNoLookup(RewriteException.class, "getProgramPoint", int.class);
    /** Call for getting the return value for the exception */
    public static final Call GET_RETURN_VALUE         = virtualCallNoLookup(RewriteException.class, "getReturnValueDestructive", Object.class);
    /** Call for the populate array bootstrap */
    public static final Call BOOTSTRAP                = staticCallNoLookup(RewriteException.class, "populateArrayBootstrap", CallSite.class, Lookup.class, String.class, MethodType.class, int.class);

    /** Call for populating an array with local variable state */
    private static final Call POPULATE_ARRAY           = staticCall(MethodHandles.lookup(), RewriteException.class, "populateArray", Object[].class, Object[].class, int.class, Object[].class);

    /** Call for converting an array to a long array. */
    public static final Call TO_LONG_ARRAY   = staticCallNoLookup(RewriteException.class, "toLongArray",   long[].class, Object.class, RewriteException.class);
    /** Call for converting an array to a double array. */
    public static final Call TO_DOUBLE_ARRAY = staticCallNoLookup(RewriteException.class, "toDoubleArray", double[].class, Object.class, RewriteException.class);
    /** Call for converting an array to an object array. */
    public static final Call TO_OBJECT_ARRAY = staticCallNoLookup(RewriteException.class, "toObjectArray", Object[].class, Object.class, RewriteException.class);
    /** Call for converting an object to null if it can't be represented as an instance of a class. */
    public static final Call INSTANCE_OR_NULL = staticCallNoLookup(RewriteException.class, "instanceOrNull", Object.class, Object.class, Class.class);
    /** Call for asserting the length of an array. */
    public static final Call ASSERT_ARRAY_LENGTH = staticCallNoLookup(RewriteException.class, "assertArrayLength", void.class, Object[].class, int.class);

    private RewriteException(
            final UnwarrantedOptimismException e,
            final Object[] byteCodeSlots,
            final String[] byteCodeSymbolNames,
            final int[] previousContinuationEntryPoints) {
        super("", e, false, Context.DEBUG);
        this.byteCodeSlots = byteCodeSlots;
        this.runtimeScope = mergeSlotsWithScope(byteCodeSlots, byteCodeSymbolNames);
        this.previousContinuationEntryPoints = previousContinuationEntryPoints;
    }

    /**
     * Constructor for a rewrite exception thrown from an optimistic function.
     * @param e the {@link UnwarrantedOptimismException} that triggered this exception.
     * @param byteCodeSlots contents of local variable slots at the time of rewrite at the program point
     * @param byteCodeSymbolNames the names of the variables in the {@code byteCodeSlots} parameter. The array might
     * have less elements, and some elements might be unnamed (the name can be null). The information is provided in an
     * effort to assist evaluation of expressions for their types by the compiler doing the deoptimizing recompilation,
     * and can thus be incomplete - the more complete it is, the more expressions can be evaluated by the compiler, and
     * the more unnecessary deoptimizing compilations can be avoided.
     * @return a new rewrite exception
     */
    public static RewriteException create(final UnwarrantedOptimismException e,
            final Object[] byteCodeSlots,
            final String[] byteCodeSymbolNames) {
        return create(e, byteCodeSlots, byteCodeSymbolNames, null);
    }

    /**
     * Constructor for a rewrite exception thrown from a rest-of method.
     * @param e the {@link UnwarrantedOptimismException} that triggered this exception.
     * @param byteCodeSlots contents of local variable slots at the time of rewrite at the program point
     * @param byteCodeSymbolNames the names of the variables in the {@code byteCodeSlots} parameter. The array might
     * have less elements, and some elements might be unnamed (the name can be null). The information is provided in an
     * effort to assist evaluation of expressions for their types by the compiler doing the deoptimizing recompilation,
     * and can thus be incomplete - the more complete it is, the more expressions can be evaluated by the compiler, and
     * the more unnecessary deoptimizing compilations can be avoided.
     * @param previousContinuationEntryPoints an array of continuation entry points that were already executed during
     * one logical invocation of the function (a rest-of triggering a rest-of triggering a...)
     * @return a new rewrite exception
     */
    public static RewriteException create(final UnwarrantedOptimismException e,
            final Object[] byteCodeSlots,
            final String[] byteCodeSymbolNames,
            final int[] previousContinuationEntryPoints) {
        return new RewriteException(e, byteCodeSlots, byteCodeSymbolNames, previousContinuationEntryPoints);
    }

    /**
     * Bootstrap method for populate array
     * @param lookup     lookup
     * @param name       name (ignored)
     * @param type       method type for signature
     * @param startIndex start index to start writing to
     * @return callsite to array populator (constant)
     */
    public static CallSite populateArrayBootstrap(final MethodHandles.Lookup lookup, final String name, final MethodType type, final int startIndex) {
        MethodHandle mh = POPULATE_ARRAY.methodHandle();
        mh = MH.insertArguments(mh, 1, startIndex);
        mh = MH.asCollector(mh, Object[].class, type.parameterCount() - 1);
        mh = MH.asType(mh, type);
        return new ConstantCallSite(mh);
    }

    private static ScriptObject mergeSlotsWithScope(final Object[] byteCodeSlots, final String[] byteCodeSymbolNames) {
        final ScriptObject locals = Global.newEmptyInstance();
        final int l = Math.min(byteCodeSlots.length, byteCodeSymbolNames.length);
        ScriptObject runtimeScope = null;
        final String scopeName = CompilerConstants.SCOPE.symbolName();
        for(int i = 0; i < l; ++i) {
            final String name = byteCodeSymbolNames[i];
            final Object value = byteCodeSlots[i];
            if(scopeName.equals(name)) {
                assert runtimeScope == null;
                runtimeScope = (ScriptObject)value;
            } else if(name != null) {
                locals.set(name, value, NashornCallSiteDescriptor.CALLSITE_STRICT);
            }
        }
        locals.setProto(runtimeScope);
        return locals;
    }

    /**
     * Array populator used for saving the local variable state into the array contained in the
     * RewriteException
     * @param arrayToBePopluated array to be populated
     * @param startIndex start index to write to
     * @param items items with which to populate the array
     * @return the populated array - same array object
     */
    public static Object[] populateArray(final Object[] arrayToBePopluated, final int startIndex, final Object[] items) {
        System.arraycopy(items, 0, arrayToBePopluated, startIndex, items.length);
        return arrayToBePopluated;
    }

    /**
     * Continuation handler calls this method when a local variable carried over into the continuation is expected to be
     * a long array in the continued method. Normally, it will also be a long array in the original (interrupted by
     * deoptimization) method, but it can actually be an int array that underwent widening in the new code version.
     * @param obj the object that has to be converted into a long array
     * @param e the exception being processed
     * @return a long array
     */
    public static long[] toLongArray(final Object obj, final RewriteException e) {
        if(obj instanceof long[]) {
            return (long[])obj;
        }

        assert obj instanceof int[];

        final int[] in = (int[])obj;
        final long[] out = new long[in.length];
        for(int i = 0; i < in.length; ++i) {
            out[i] = in[i];
        }
        return e.replaceByteCodeValue(in, out);
    }

    /**
     * Continuation handler calls this method when a local variable carried over into the continuation is expected to be
     * a double array in the continued method. Normally, it will also be a double array in the original (interrupted by
     * deoptimization) method, but it can actually be an int or long array that underwent widening in the new code version.
     * @param obj the object that has to be converted into a double array
     * @param e the exception being processed
     * @return a double array
     */
    public static double[] toDoubleArray(final Object obj, final RewriteException e) {
        if(obj instanceof double[]) {
            return (double[])obj;
        }

        assert obj instanceof int[] || obj instanceof long[];

        final int l = Array.getLength(obj);
        final double[] out = new double[l];
        for(int i = 0; i < l; ++i) {
            out[i] = Array.getDouble(obj, i);
        }
        return e.replaceByteCodeValue(obj, out);
    }

    /**
     * Continuation handler calls this method when a local variable carried over into the continuation is expected to be
     * an Object array in the continued method. Normally, it will also be an Object array in the original (interrupted by
     * deoptimization) method, but it can actually be an int, long, or double array that underwent widening in the new
     * code version.
     * @param obj the object that has to be converted into an Object array
     * @param e the exception being processed
     * @return an Object array
     */
    public static Object[] toObjectArray(final Object obj, final RewriteException e) {
        if(obj instanceof Object[]) {
            return (Object[])obj;
        }

        assert obj instanceof int[] || obj instanceof long[] || obj instanceof double[] : obj + " is " + obj.getClass().getName();

        final int l = Array.getLength(obj);
        final Object[] out = new Object[l];
        for(int i = 0; i < l; ++i) {
            out[i] = Array.get(obj, i);
        }
        return e.replaceByteCodeValue(obj, out);
    }

    /**
     * Continuation handler calls this method when a local variable carried over into the continuation is expected to
     * have a certain type, but the value can have a different type coming from the deoptimized method as it was a dead
     * store. If we had precise liveness analysis, we wouldn't need this.
     * @param obj the object inspected for being of a particular type
     * @param clazz the type the object must belong to
     * @return the object if it belongs to the type, or null otherwise
     */
    public static Object instanceOrNull(final Object obj, final Class<?> clazz) {
        return clazz.isInstance(obj) ? obj : null;
    }

    /**
     * Asserts the length of an array. Invoked from continuation handler only when running with assertions enabled.
     * The array can, in fact, have more elements than asserted, but they must all have Undefined as their value. The
     * method does not test for the array having less elements than asserted, as those would already have caused an
     * {@code ArrayIndexOutOfBoundsException} to be thrown as the continuation handler attempts to access the missing
     * elements.
     * @param arr the array
     * @param length the asserted length
     */
    public static void assertArrayLength(final Object[] arr, final int length) {
        for(int i = arr.length; i-- > length;) {
            if(arr[i] != ScriptRuntime.UNDEFINED) {
                throw new AssertionError(String.format("Expected array length %d, but it is %d", length, i + 1));
            }
        }
    }

    private <T> T replaceByteCodeValue(final Object in, final T out) {
        for(int i = 0; i < byteCodeSlots.length; ++i) {
            if(byteCodeSlots[i] == in) {
                byteCodeSlots[i] = out;
            }
        }
        return out;
    }

    private UnwarrantedOptimismException getUOE() {
        return (UnwarrantedOptimismException)getCause();
    }
    /**
     * Get return value. This method is destructive, after it is invoked subsequent invocation of either
     * {@link #getByteCodeSlots()} or this method will return null. This method is invoked from the generated
     * continuation code as the last step before continuing the execution, and we need to make sure we don't hang on to
     * either the entry bytecode slot values or the return value and prevent them from being garbage collected.
     * @return return value
     */
    public Object getReturnValueDestructive() {
        assert byteCodeSlots != null;
        byteCodeSlots = null;
        runtimeScope = null;
        return getUOE().getReturnValueDestructive();
    }

    Object getReturnValueNonDestructive() {
        return getUOE().getReturnValueNonDestructive();
    }

    /**
     * Get return type
     * @return return type
     */
    public Type getReturnType() {
        return getUOE().getReturnType();
    }

    /**
     * Get the program point.
     * @return program point.
     */
    public int getProgramPoint() {
        return getUOE().getProgramPoint();
    }

    /**
     * Get the bytecode slot contents.
     * @return bytecode slot contents.
     */
    public Object[] getByteCodeSlots() {
        return byteCodeSlots == null ? null : byteCodeSlots.clone();
    }

    /**
     * @return an array of continuation entry points that were already executed during one logical invocation of the
     * function (a rest-of triggering a rest-of triggering a...)
     */
    public int[] getPreviousContinuationEntryPoints() {
        return previousContinuationEntryPoints == null ? null : previousContinuationEntryPoints.clone();
    }

    /**
     * Returns the runtime scope that was in effect when the exception was thrown.
     * @return the runtime scope.
     */
    public ScriptObject getRuntimeScope() {
        return runtimeScope;
    }

    private static String stringify(final Object returnValue) {
        if (returnValue == null) {
            return "null";
        }
        String str = returnValue.toString();
        if (returnValue instanceof String) {
            str = '\'' + str + '\'';
        } else if (returnValue instanceof Double) {
            str = str + 'd';
        } else if (returnValue instanceof Long) {
            str = str + 'l';
        }
        return str;
    }

    @Override
    public String getMessage() {
        return getMessage(false);
    }

    /**
     * Short toString function for message
     * @return short message
     */
    public String getMessageShort() {
        return getMessage(true);
    }

    private String getMessage(final boolean isShort) {
        final StringBuilder sb = new StringBuilder();

        //program point
        sb.append("[pp=").
            append(getProgramPoint()).
            append(", ");

        //slot contents
        if (!isShort) {
            final Object[] slots = byteCodeSlots;
            if (slots != null) {
                sb.append("slots=").
                    append(Arrays.asList(slots)).
                    append(", ");
            }
        }

        //return type
        sb.append("type=").
            append(getReturnType()).
            append(", ");

        //return value
        sb.append("value=").
            append(stringify(getReturnValueNonDestructive())).
            append(")]");

        return sb.toString();
    }

    private void writeObject(final ObjectOutputStream out) throws NotSerializableException {
        throw new NotSerializableException(getClass().getName());
    }

    private void readObject(final ObjectInputStream in) throws NotSerializableException {
        throw new NotSerializableException(getClass().getName());
    }
}