org.openjdk.nashorn.internal.runtime.OptimisticReturnFilters Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of nashorn-core Show documentation
Show all versions of nashorn-core Show documentation
Nashorn is an Open Source JavaScript (ECMAScript 5.1 and some 6 features) engine for the JVM.
The newest version!
/*
* 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 org.openjdk.nashorn.internal.runtime;
import static org.openjdk.nashorn.internal.lookup.Lookup.MH;
import static org.openjdk.nashorn.internal.runtime.JSType.getAccessorTypeIndex;
import static org.openjdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import jdk.dynalink.CallSiteDescriptor;
import jdk.dynalink.linker.GuardedInvocation;
import jdk.dynalink.linker.support.TypeUtilities;
import org.openjdk.nashorn.internal.codegen.types.Type;
import org.openjdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
/**
* Optimistic return value filters
*/
public final class OptimisticReturnFilters {
private static final MethodHandle[] ENSURE_INT;
private static final MethodHandle[] ENSURE_NUMBER;
// These extend the type index constants in JSType
private static final int VOID_TYPE_INDEX;
private static final int BOOLEAN_TYPE_INDEX;
private static final int CHAR_TYPE_INDEX;
private static final int LONG_TYPE_INDEX;
private static final int FLOAT_TYPE_INDEX;
static {
final MethodHandle INT_DOUBLE = findOwnMH("ensureInt", int.class, double.class, int.class);
ENSURE_INT = new MethodHandle[] {
null,
INT_DOUBLE,
findOwnMH("ensureInt", int.class, Object.class, int.class),
findOwnMH("ensureInt", int.class, int.class),
findOwnMH("ensureInt", int.class, boolean.class, int.class),
findOwnMH("ensureInt", int.class, char.class, int.class),
findOwnMH("ensureInt", int.class, long.class, int.class),
INT_DOUBLE.asType(INT_DOUBLE.type().changeParameterType(0, float.class)),
};
VOID_TYPE_INDEX = ENSURE_INT.length - 5;
BOOLEAN_TYPE_INDEX = ENSURE_INT.length - 4;
CHAR_TYPE_INDEX = ENSURE_INT.length - 3;
LONG_TYPE_INDEX = ENSURE_INT.length - 2;
FLOAT_TYPE_INDEX = ENSURE_INT.length - 1;
ENSURE_NUMBER = new MethodHandle[] {
null,
null,
findOwnMH("ensureNumber", double.class, Object.class, int.class),
ENSURE_INT[VOID_TYPE_INDEX].asType(ENSURE_INT[VOID_TYPE_INDEX].type().changeReturnType(double.class)),
ENSURE_INT[BOOLEAN_TYPE_INDEX].asType(ENSURE_INT[BOOLEAN_TYPE_INDEX].type().changeReturnType(double.class)),
ENSURE_INT[CHAR_TYPE_INDEX].asType(ENSURE_INT[CHAR_TYPE_INDEX].type().changeReturnType(double.class)),
findOwnMH("ensureNumber", double.class, long.class, int.class),
null
};
}
/**
* Given a method handle and an expected return type, perform return value filtering
* according to the optimistic type coercion rules
* @param mh method handle
* @param expectedReturnType expected return type
* @param programPoint program point
* @return filtered method
*/
public static MethodHandle filterOptimisticReturnValue(final MethodHandle mh, final Class expectedReturnType, final int programPoint) {
if(!isValid(programPoint)) {
return mh;
}
final MethodType type = mh.type();
final Class actualReturnType = type.returnType();
if(TypeUtilities.isConvertibleWithoutLoss(actualReturnType, expectedReturnType)) {
return mh;
}
final MethodHandle guard = getOptimisticTypeGuard(expectedReturnType, actualReturnType);
return guard == null ? mh : MH.filterReturnValue(mh, MH.insertArguments(guard, guard.type().parameterCount() - 1, programPoint));
}
/**
* Given a guarded invocation and a callsite descriptor, perform return value filtering
* according to the optimistic type coercion rules, using the return value from the descriptor
* @param inv the invocation
* @param desc the descriptor
* @return filtered invocation
*/
public static GuardedInvocation filterOptimisticReturnValue(final GuardedInvocation inv, final CallSiteDescriptor desc) {
if(!NashornCallSiteDescriptor.isOptimistic(desc)) {
return inv;
}
return inv.replaceMethods(filterOptimisticReturnValue(inv.getInvocation(), desc.getMethodType().returnType(),
NashornCallSiteDescriptor.getProgramPoint(desc)), inv.getGuard());
}
private static MethodHandle getOptimisticTypeGuard(final Class actual, final Class provable) {
final MethodHandle guard;
final int provableTypeIndex = getProvableTypeIndex(provable);
if (actual == int.class) {
guard = ENSURE_INT[provableTypeIndex];
} else if (actual == double.class) {
guard = ENSURE_NUMBER[provableTypeIndex];
} else {
guard = null;
assert !actual.isPrimitive() : actual + ", " + provable;
}
if(guard != null && !(provable.isPrimitive())) {
// Make sure filtering a MethodHandle(...)String works with a filter MethodHandle(Object, int)... Note that
// if the return type of the method is incompatible with Number, then the guard will always throw an
// UnwarrantedOperationException when invoked, but we must link it anyway as we need the guarded function to
// successfully execute and return the non-convertible return value that it'll put into the thrown
// UnwarrantedOptimismException.
return guard.asType(guard.type().changeParameterType(0, provable));
}
return guard;
}
private static int getProvableTypeIndex(final Class provable) {
final int accTypeIndex = getAccessorTypeIndex(provable);
if(accTypeIndex != -1) {
return accTypeIndex;
} else if(provable == boolean.class) {
return BOOLEAN_TYPE_INDEX;
} else if(provable == void.class) {
return VOID_TYPE_INDEX;
} else if(provable == byte.class || provable == short.class) {
return 0; // never needs a guard, as it's assignable to int
} else if(provable == char.class) {
return CHAR_TYPE_INDEX;
} else if(provable == long.class) {
return LONG_TYPE_INDEX;
} else if(provable == float.class) {
return FLOAT_TYPE_INDEX;
}
throw new AssertionError(provable.getName());
}
//maps staticallyProvableCallSiteType to actualCallSiteType, throws exception if impossible
@SuppressWarnings("unused")
private static int ensureInt(final long arg, final int programPoint) {
if (JSType.isRepresentableAsInt(arg)) {
return (int)arg;
}
throw UnwarrantedOptimismException.createNarrowest(arg, programPoint);
}
@SuppressWarnings("unused")
private static int ensureInt(final double arg, final int programPoint) {
if (JSType.isStrictlyRepresentableAsInt(arg)) {
return (int)arg;
}
throw new UnwarrantedOptimismException(arg, programPoint, Type.NUMBER);
}
/**
* Returns the argument value as an int. If the argument is not a wrapper for a primitive numeric type
* with a value that can be exactly represented as an int, throw an {@link UnwarrantedOptimismException}.
* This method is only public so that generated script code can use it. See {code CodeGenerator.ENSURE_INT}.
* @param arg the original argument.
* @param programPoint the program point used in the exception
* @return the value of the argument as an int.
* @throws UnwarrantedOptimismException if the argument is not a wrapper for a primitive numeric type with
* a value that can be exactly represented as an int.
*/
public static int ensureInt(final Object arg, final int programPoint) {
// NOTE: this doesn't delegate to ensureInt(double, int) as in that case if arg were a Long, it would throw a
// (potentially imprecise) Double in the UnwarrantedOptimismException. This way, it will put the correct valued
// Long into the exception.
if (isPrimitiveNumberWrapper(arg)) {
final double d = ((Number)arg).doubleValue();
if (JSType.isStrictlyRepresentableAsInt(d)) {
return (int)d;
}
}
throw UnwarrantedOptimismException.createNarrowest(arg, programPoint);
}
private static boolean isPrimitiveNumberWrapper(final Object obj) {
if (obj == null) {
return false;
}
final Class c = obj.getClass();
return c == Integer.class || c == Double.class || c == Long.class ||
c == Float.class || c == Short.class || c == Byte.class;
}
@SuppressWarnings("unused")
private static int ensureInt(final boolean arg, final int programPoint) {
throw new UnwarrantedOptimismException(arg, programPoint, Type.OBJECT);
}
@SuppressWarnings("unused")
private static int ensureInt(final char arg, final int programPoint) {
throw new UnwarrantedOptimismException(arg, programPoint, Type.OBJECT);
}
@SuppressWarnings("unused")
private static int ensureInt(final int programPoint) {
// Turns a void into UNDEFINED
throw new UnwarrantedOptimismException(ScriptRuntime.UNDEFINED, programPoint, Type.OBJECT);
}
@SuppressWarnings("unused")
private static double ensureNumber(final long arg, final int programPoint) {
if (JSType.isRepresentableAsDouble(arg)) {
return (double) arg;
}
throw new UnwarrantedOptimismException(arg, programPoint, Type.OBJECT);
}
/**
* Returns the argument value as a double. If the argument is not a wrapper for a primitive numeric type
* that can be represented as double throw an {@link UnwarrantedOptimismException}.
* This method is only public so that generated script code can use it. See {code CodeGenerator.ENSURE_NUMBER}.
* @param arg the original argument.
* @param programPoint the program point used in the exception
* @return the value of the argument as a double.
* @throws UnwarrantedOptimismException if the argument is not a wrapper for a primitive numeric type.
*/
public static double ensureNumber(final Object arg, final int programPoint) {
if (isPrimitiveNumberWrapper(arg)
&& (arg.getClass() != Long.class || JSType.isRepresentableAsDouble((Long) arg))) {
return ((Number) arg).doubleValue();
}
throw new UnwarrantedOptimismException(arg, programPoint, Type.OBJECT);
}
private static MethodHandle findOwnMH(final String name, final Class rtype, final Class... types) {
return MH.findStatic(MethodHandles.lookup(), OptimisticReturnFilters.class, name, MH.type(rtype, types));
}
}