--- old/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/OptimisticReturnFilters.java 2020-04-15 18:49:57.000000000 +0530 +++ /dev/null 2020-04-15 18:49:57.000000000 +0530 @@ -1,260 +0,0 @@ -/* - * 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.lookup.Lookup.MH; -import static jdk.nashorn.internal.runtime.JSType.getAccessorTypeIndex; -import static jdk.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 jdk.nashorn.internal.codegen.types.Type; -import jdk.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)); - } -}