/*

 * 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 += 'd';

        } else if (returnValue instanceof Long) {

            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());

    }

}