src/jdk/nashorn/internal/runtime/RewriteException.java - platform/external/jetbrains/jdk8u_nashorn - Git at Google

 /*
  * 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());
     }
 }
	/*
	* 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());
	}
	}