| /* |
| * 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.lookup; |
| |
| import static jdk.nashorn.internal.runtime.JSType.isString; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.PrintStream; |
| import java.lang.invoke.MethodHandle; |
| import java.lang.invoke.MethodHandles; |
| import java.lang.invoke.MethodType; |
| import java.lang.invoke.SwitchPoint; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.logging.Level; |
| import jdk.nashorn.internal.runtime.Context; |
| import jdk.nashorn.internal.runtime.Debug; |
| import jdk.nashorn.internal.runtime.ScriptObject; |
| import jdk.nashorn.internal.runtime.logging.DebugLogger; |
| import jdk.nashorn.internal.runtime.logging.Loggable; |
| import jdk.nashorn.internal.runtime.logging.Logger; |
| import jdk.nashorn.internal.runtime.options.Options; |
| |
| /** |
| * This class is abstraction for all method handle, switchpoint and method type |
| * operations. This enables the functionality interface to be subclassed and |
| * instrumented, as it has been proven vital to keep the number of method |
| * handles in the system down. |
| * |
| * All operations of the above type should go through this class, and not |
| * directly into java.lang.invoke |
| * |
| */ |
| public final class MethodHandleFactory { |
| |
| private static final MethodHandles.Lookup PUBLIC_LOOKUP = MethodHandles.publicLookup(); |
| private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); |
| |
| private static final Level TRACE_LEVEL = Level.INFO; |
| |
| private MethodHandleFactory() { |
| } |
| |
| /** |
| * Runtime exception that collects every reason that a method handle lookup operation can go wrong |
| */ |
| @SuppressWarnings("serial") |
| public static class LookupException extends RuntimeException { |
| /** |
| * Constructor |
| * @param e causing exception |
| */ |
| public LookupException(final Exception e) { |
| super(e); |
| } |
| } |
| |
| /** |
| * Helper function that takes a class or an object with a toString override |
| * and shortens it to notation after last dot. This is used to facilitiate |
| * pretty printouts in various debug loggers - internal only |
| * |
| * @param obj class or object |
| * |
| * @return pretty version of object as string |
| */ |
| public static String stripName(final Object obj) { |
| if (obj == null) { |
| return "null"; |
| } |
| |
| if (obj instanceof Class) { |
| return ((Class<?>)obj).getSimpleName(); |
| } |
| return obj.toString(); |
| } |
| |
| private static final MethodHandleFunctionality FUNC = new StandardMethodHandleFunctionality(); |
| private static final boolean PRINT_STACKTRACE = Options.getBooleanProperty("nashorn.methodhandles.debug.stacktrace"); |
| |
| /** |
| * Return the method handle functionality used for all method handle operations |
| * @return a method handle functionality implementation |
| */ |
| public static MethodHandleFunctionality getFunctionality() { |
| return FUNC; |
| } |
| |
| private static final MethodHandle TRACE = FUNC.findStatic(LOOKUP, MethodHandleFactory.class, "traceArgs", MethodType.methodType(void.class, DebugLogger.class, String.class, int.class, Object[].class)); |
| private static final MethodHandle TRACE_RETURN = FUNC.findStatic(LOOKUP, MethodHandleFactory.class, "traceReturn", MethodType.methodType(Object.class, DebugLogger.class, Object.class)); |
| private static final MethodHandle TRACE_RETURN_VOID = FUNC.findStatic(LOOKUP, MethodHandleFactory.class, "traceReturnVoid", MethodType.methodType(void.class, DebugLogger.class)); |
| |
| private static final String VOID_TAG = "[VOID]"; |
| |
| private static void err(final String str) { |
| Context.getContext().getErr().println(str); |
| } |
| |
| /** |
| * Tracer that is applied before a value is returned from the traced function. It will output the return |
| * value and its class |
| * |
| * @param value return value for filter |
| * @return return value unmodified |
| */ |
| static Object traceReturn(final DebugLogger logger, final Object value) { |
| final String str = " return" + |
| (VOID_TAG.equals(value) ? |
| ";" : |
| " " + stripName(value) + "; // [type=" + (value == null ? "null]" : stripName(value.getClass()) + ']')); |
| if (logger == null) { |
| err(str); |
| } else if (logger.isEnabled()) { |
| logger.log(TRACE_LEVEL, str); |
| } |
| |
| return value; |
| } |
| |
| static void traceReturnVoid(final DebugLogger logger) { |
| traceReturn(logger, VOID_TAG); |
| } |
| |
| /** |
| * Tracer that is applied before a function is called, printing the arguments |
| * |
| * @param tag tag to start the debug printout string |
| * @param paramStart param index to start outputting from |
| * @param args arguments to the function |
| */ |
| static void traceArgs(final DebugLogger logger, final String tag, final int paramStart, final Object... args) { |
| final StringBuilder sb = new StringBuilder(); |
| |
| sb.append(tag); |
| |
| for (int i = paramStart; i < args.length; i++) { |
| if (i == paramStart) { |
| sb.append(" => args: "); |
| } |
| |
| sb.append('\''). |
| append(stripName(argString(args[i]))). |
| append('\''). |
| append(' '). |
| append('['). |
| append("type="). |
| append(args[i] == null ? "null" : stripName(args[i].getClass())). |
| append(']'); |
| |
| if (i + 1 < args.length) { |
| sb.append(", "); |
| } |
| } |
| |
| if (logger == null) { |
| err(sb.toString()); |
| } else { |
| logger.log(TRACE_LEVEL, sb); |
| } |
| stacktrace(logger); |
| } |
| |
| private static void stacktrace(final DebugLogger logger) { |
| if (!PRINT_STACKTRACE) { |
| return; |
| } |
| final ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| final PrintStream ps = new PrintStream(baos); |
| new Throwable().printStackTrace(ps); |
| final String st = baos.toString(); |
| if (logger == null) { |
| err(st); |
| } else { |
| logger.log(TRACE_LEVEL, st); |
| } |
| } |
| |
| private static String argString(final Object arg) { |
| if (arg == null) { |
| return "null"; |
| } |
| |
| if (arg.getClass().isArray()) { |
| final List<Object> list = new ArrayList<>(); |
| for (final Object elem : (Object[])arg) { |
| list.add('\'' + argString(elem) + '\''); |
| } |
| |
| return list.toString(); |
| } |
| |
| if (arg instanceof ScriptObject) { |
| return arg.toString() + |
| " (map=" + Debug.id(((ScriptObject)arg).getMap()) + |
| ')'; |
| } |
| |
| return arg.toString(); |
| } |
| |
| /** |
| * Add a debug printout to a method handle, tracing parameters and return values |
| * Output will be unconditional to stderr |
| * |
| * @param mh method handle to trace |
| * @param tag start of trace message |
| * @return traced method handle |
| */ |
| public static MethodHandle addDebugPrintout(final MethodHandle mh, final Object tag) { |
| return addDebugPrintout(null, Level.OFF, mh, 0, true, tag); |
| } |
| |
| /** |
| * Add a debug printout to a method handle, tracing parameters and return values |
| * |
| * @param logger a specific logger to which to write the output |
| * @param level level over which to print |
| * @param mh method handle to trace |
| * @param tag start of trace message |
| * @return traced method handle |
| */ |
| public static MethodHandle addDebugPrintout(final DebugLogger logger, final Level level, final MethodHandle mh, final Object tag) { |
| return addDebugPrintout(logger, level, mh, 0, true, tag); |
| } |
| |
| /** |
| * Add a debug printout to a method handle, tracing parameters and return values |
| * Output will be unconditional to stderr |
| * |
| * @param mh method handle to trace |
| * @param paramStart first param to print/trace |
| * @param printReturnValue should we print/trace return value if available? |
| * @param tag start of trace message |
| * @return traced method handle |
| */ |
| public static MethodHandle addDebugPrintout(final MethodHandle mh, final int paramStart, final boolean printReturnValue, final Object tag) { |
| return addDebugPrintout(null, Level.OFF, mh, paramStart, printReturnValue, tag); |
| } |
| |
| /** |
| * Add a debug printout to a method handle, tracing parameters and return values |
| * |
| * @param logger a specific logger to which to write the output |
| * @param level level over which to print |
| * @param mh method handle to trace |
| * @param paramStart first param to print/trace |
| * @param printReturnValue should we print/trace return value if available? |
| * @param tag start of trace message |
| * @return traced method handle |
| */ |
| public static MethodHandle addDebugPrintout(final DebugLogger logger, final Level level, final MethodHandle mh, final int paramStart, final boolean printReturnValue, final Object tag) { |
| final MethodType type = mh.type(); |
| |
| //if there is no logger, or if it's set to log only coarser events |
| //than the trace level, skip and return |
| if (logger == null || !logger.isLoggable(level)) { |
| return mh; |
| } |
| |
| assert TRACE != null; |
| |
| MethodHandle trace = MethodHandles.insertArguments(TRACE, 0, logger, tag, paramStart); |
| |
| trace = MethodHandles.foldArguments( |
| mh, |
| trace.asCollector( |
| Object[].class, |
| type.parameterCount()). |
| asType(type.changeReturnType(void.class))); |
| |
| final Class<?> retType = type.returnType(); |
| if (printReturnValue) { |
| if (retType != void.class) { |
| final MethodHandle traceReturn = MethodHandles.insertArguments(TRACE_RETURN, 0, logger); |
| trace = MethodHandles.filterReturnValue(trace, |
| traceReturn.asType( |
| traceReturn.type().changeParameterType(0, retType).changeReturnType(retType))); |
| } else { |
| trace = MethodHandles.filterReturnValue(trace, MethodHandles.insertArguments(TRACE_RETURN_VOID, 0, logger)); |
| } |
| } |
| |
| return trace; |
| } |
| |
| /** |
| * Class that marshalls all method handle operations to the java.lang.invoke |
| * package. This exists only so that it can be subclassed and method handles created from |
| * Nashorn made possible to instrument. |
| * |
| * All Nashorn classes should use the MethodHandleFactory for their method handle operations |
| */ |
| @Logger(name="methodhandles") |
| private static class StandardMethodHandleFunctionality implements MethodHandleFunctionality, Loggable { |
| |
| // for bootstrapping reasons, because a lot of static fields use MH for lookups, we |
| // need to set the logger when the Global object is finished. This means that we don't |
| // get instrumentation for public static final MethodHandle SOMETHING = MH... in the builtin |
| // classes, but that doesn't matter, because this is usually not where we want it |
| private DebugLogger log = DebugLogger.DISABLED_LOGGER; |
| |
| public StandardMethodHandleFunctionality() { |
| } |
| |
| @Override |
| public DebugLogger initLogger(final Context context) { |
| return this.log = context.getLogger(this.getClass()); |
| } |
| |
| @Override |
| public DebugLogger getLogger() { |
| return log; |
| } |
| |
| protected static String describe(final Object... data) { |
| final StringBuilder sb = new StringBuilder(); |
| |
| for (int i = 0; i < data.length; i++) { |
| final Object d = data[i]; |
| if (d == null) { |
| sb.append("<null> "); |
| } else if (isString(d)) { |
| sb.append(d.toString()); |
| sb.append(' '); |
| } else if (d.getClass().isArray()) { |
| sb.append("[ "); |
| for (final Object da : (Object[])d) { |
| sb.append(describe(new Object[]{ da })).append(' '); |
| } |
| sb.append("] "); |
| } else { |
| sb.append(d) |
| .append('{') |
| .append(Integer.toHexString(System.identityHashCode(d))) |
| .append('}'); |
| } |
| |
| if (i + 1 < data.length) { |
| sb.append(", "); |
| } |
| } |
| |
| return sb.toString(); |
| } |
| |
| public MethodHandle debug(final MethodHandle master, final String str, final Object... args) { |
| if (log.isEnabled()) { |
| if (PRINT_STACKTRACE) { |
| stacktrace(log); |
| } |
| return addDebugPrintout(log, Level.INFO, master, Integer.MAX_VALUE, false, str + ' ' + describe(args)); |
| } |
| return master; |
| } |
| |
| @Override |
| public MethodHandle filterArguments(final MethodHandle target, final int pos, final MethodHandle... filters) { |
| final MethodHandle mh = MethodHandles.filterArguments(target, pos, filters); |
| return debug(mh, "filterArguments", target, pos, filters); |
| } |
| |
| @Override |
| public MethodHandle filterReturnValue(final MethodHandle target, final MethodHandle filter) { |
| final MethodHandle mh = MethodHandles.filterReturnValue(target, filter); |
| return debug(mh, "filterReturnValue", target, filter); |
| } |
| |
| @Override |
| public MethodHandle guardWithTest(final MethodHandle test, final MethodHandle target, final MethodHandle fallback) { |
| final MethodHandle mh = MethodHandles.guardWithTest(test, target, fallback); |
| return debug(mh, "guardWithTest", test, target, fallback); |
| } |
| |
| @Override |
| public MethodHandle insertArguments(final MethodHandle target, final int pos, final Object... values) { |
| final MethodHandle mh = MethodHandles.insertArguments(target, pos, values); |
| return debug(mh, "insertArguments", target, pos, values); |
| } |
| |
| @Override |
| public MethodHandle dropArguments(final MethodHandle target, final int pos, final Class<?>... values) { |
| final MethodHandle mh = MethodHandles.dropArguments(target, pos, values); |
| return debug(mh, "dropArguments", target, pos, values); |
| } |
| |
| @Override |
| public MethodHandle dropArguments(final MethodHandle target, final int pos, final List<Class<?>> values) { |
| final MethodHandle mh = MethodHandles.dropArguments(target, pos, values); |
| return debug(mh, "dropArguments", target, pos, values); |
| } |
| |
| @Override |
| public MethodHandle asType(final MethodHandle handle, final MethodType type) { |
| final MethodHandle mh = handle.asType(type); |
| return debug(mh, "asType", handle, type); |
| } |
| |
| @Override |
| public MethodHandle bindTo(final MethodHandle handle, final Object x) { |
| final MethodHandle mh = handle.bindTo(x); |
| return debug(mh, "bindTo", handle, x); |
| } |
| |
| @Override |
| public MethodHandle foldArguments(final MethodHandle target, final MethodHandle combiner) { |
| final MethodHandle mh = MethodHandles.foldArguments(target, combiner); |
| return debug(mh, "foldArguments", target, combiner); |
| } |
| |
| @Override |
| public MethodHandle explicitCastArguments(final MethodHandle target, final MethodType type) { |
| final MethodHandle mh = MethodHandles.explicitCastArguments(target, type); |
| return debug(mh, "explicitCastArguments", target, type); |
| } |
| |
| @Override |
| public MethodHandle arrayElementGetter(final Class<?> type) { |
| final MethodHandle mh = MethodHandles.arrayElementGetter(type); |
| return debug(mh, "arrayElementGetter", type); |
| } |
| |
| @Override |
| public MethodHandle arrayElementSetter(final Class<?> type) { |
| final MethodHandle mh = MethodHandles.arrayElementSetter(type); |
| return debug(mh, "arrayElementSetter", type); |
| } |
| |
| @Override |
| public MethodHandle throwException(final Class<?> returnType, final Class<? extends Throwable> exType) { |
| final MethodHandle mh = MethodHandles.throwException(returnType, exType); |
| return debug(mh, "throwException", returnType, exType); |
| } |
| |
| @Override |
| public MethodHandle catchException(final MethodHandle target, final Class<? extends Throwable> exType, final MethodHandle handler) { |
| final MethodHandle mh = MethodHandles.catchException(target, exType, handler); |
| return debug(mh, "catchException", exType); |
| } |
| |
| @Override |
| public MethodHandle constant(final Class<?> type, final Object value) { |
| final MethodHandle mh = MethodHandles.constant(type, value); |
| return debug(mh, "constant", type, value); |
| } |
| |
| @Override |
| public MethodHandle identity(final Class<?> type) { |
| final MethodHandle mh = MethodHandles.identity(type); |
| return debug(mh, "identity", type); |
| } |
| |
| @Override |
| public MethodHandle asCollector(final MethodHandle handle, final Class<?> arrayType, final int arrayLength) { |
| final MethodHandle mh = handle.asCollector(arrayType, arrayLength); |
| return debug(mh, "asCollector", handle, arrayType, arrayLength); |
| } |
| |
| @Override |
| public MethodHandle asSpreader(final MethodHandle handle, final Class<?> arrayType, final int arrayLength) { |
| final MethodHandle mh = handle.asSpreader(arrayType, arrayLength); |
| return debug(mh, "asSpreader", handle, arrayType, arrayLength); |
| } |
| |
| @Override |
| public MethodHandle getter(final MethodHandles.Lookup explicitLookup, final Class<?> clazz, final String name, final Class<?> type) { |
| try { |
| final MethodHandle mh = explicitLookup.findGetter(clazz, name, type); |
| return debug(mh, "getter", explicitLookup, clazz, name, type); |
| } catch (final NoSuchFieldException | IllegalAccessException e) { |
| throw new LookupException(e); |
| } |
| } |
| |
| @Override |
| public MethodHandle staticGetter(final MethodHandles.Lookup explicitLookup, final Class<?> clazz, final String name, final Class<?> type) { |
| try { |
| final MethodHandle mh = explicitLookup.findStaticGetter(clazz, name, type); |
| return debug(mh, "static getter", explicitLookup, clazz, name, type); |
| } catch (final NoSuchFieldException | IllegalAccessException e) { |
| throw new LookupException(e); |
| } |
| } |
| |
| @Override |
| public MethodHandle setter(final MethodHandles.Lookup explicitLookup, final Class<?> clazz, final String name, final Class<?> type) { |
| try { |
| final MethodHandle mh = explicitLookup.findSetter(clazz, name, type); |
| return debug(mh, "setter", explicitLookup, clazz, name, type); |
| } catch (final NoSuchFieldException | IllegalAccessException e) { |
| throw new LookupException(e); |
| } |
| } |
| |
| @Override |
| public MethodHandle staticSetter(final MethodHandles.Lookup explicitLookup, final Class<?> clazz, final String name, final Class<?> type) { |
| try { |
| final MethodHandle mh = explicitLookup.findStaticSetter(clazz, name, type); |
| return debug(mh, "static setter", explicitLookup, clazz, name, type); |
| } catch (final NoSuchFieldException | IllegalAccessException e) { |
| throw new LookupException(e); |
| } |
| } |
| |
| @Override |
| public MethodHandle find(final Method method) { |
| try { |
| final MethodHandle mh = PUBLIC_LOOKUP.unreflect(method); |
| return debug(mh, "find", method); |
| } catch (final IllegalAccessException e) { |
| throw new LookupException(e); |
| } |
| } |
| |
| @Override |
| public MethodHandle findStatic(final MethodHandles.Lookup explicitLookup, final Class<?> clazz, final String name, final MethodType type) { |
| try { |
| final MethodHandle mh = explicitLookup.findStatic(clazz, name, type); |
| return debug(mh, "findStatic", explicitLookup, clazz, name, type); |
| } catch (final NoSuchMethodException | IllegalAccessException e) { |
| throw new LookupException(e); |
| } |
| } |
| |
| @Override |
| public MethodHandle findSpecial(final MethodHandles.Lookup explicitLookup, final Class<?> clazz, final String name, final MethodType type, final Class<?> thisClass) { |
| try { |
| final MethodHandle mh = explicitLookup.findSpecial(clazz, name, type, thisClass); |
| return debug(mh, "findSpecial", explicitLookup, clazz, name, type); |
| } catch (final NoSuchMethodException | IllegalAccessException e) { |
| throw new LookupException(e); |
| } |
| } |
| |
| @Override |
| public MethodHandle findVirtual(final MethodHandles.Lookup explicitLookup, final Class<?> clazz, final String name, final MethodType type) { |
| try { |
| final MethodHandle mh = explicitLookup.findVirtual(clazz, name, type); |
| return debug(mh, "findVirtual", explicitLookup, clazz, name, type); |
| } catch (final NoSuchMethodException | IllegalAccessException e) { |
| throw new LookupException(e); |
| } |
| } |
| |
| @Override |
| public SwitchPoint createSwitchPoint() { |
| final SwitchPoint sp = new SwitchPoint(); |
| log.log(TRACE_LEVEL, "createSwitchPoint ", sp); |
| return sp; |
| } |
| |
| @Override |
| public MethodHandle guardWithTest(final SwitchPoint sp, final MethodHandle before, final MethodHandle after) { |
| final MethodHandle mh = sp.guardWithTest(before, after); |
| return debug(mh, "guardWithTest", sp, before, after); |
| } |
| |
| @Override |
| public MethodType type(final Class<?> returnType, final Class<?>... paramTypes) { |
| final MethodType mt = MethodType.methodType(returnType, paramTypes); |
| log.log(TRACE_LEVEL, "methodType ", returnType, " ", Arrays.toString(paramTypes), " ", mt); |
| return mt; |
| } |
| } |
| } |
