JDK14/Java14源码在线阅读
JDK14/Java14源码在线阅读 /
jdk.scripting.nashorn /
share /
classes /
jdk /
nashorn /
internal /
runtime /
linker /
JavaAdapterBytecodeGenerator.java
/*
* 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.linker;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_FINAL;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PRIVATE;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_SUPER;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_VARARGS;
import static jdk.internal.org.objectweb.asm.Opcodes.ALOAD;
import static jdk.internal.org.objectweb.asm.Opcodes.ASTORE;
import static jdk.internal.org.objectweb.asm.Opcodes.D2F;
import static jdk.internal.org.objectweb.asm.Opcodes.H_INVOKESTATIC;
import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESPECIAL;
import static jdk.internal.org.objectweb.asm.Opcodes.I2B;
import static jdk.internal.org.objectweb.asm.Opcodes.I2S;
import static jdk.internal.org.objectweb.asm.Opcodes.RETURN;
import static jdk.nashorn.internal.codegen.CompilerConstants.interfaceCallNoLookup;
import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
import static jdk.nashorn.internal.lookup.Lookup.MH;
import static jdk.nashorn.internal.runtime.linker.AdaptationResult.Outcome.ERROR_NO_ACCESSIBLE_CONSTRUCTOR;
import java.lang.invoke.CallSite;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.invoke.MethodType;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.Handle;
import jdk.internal.org.objectweb.asm.Label;
import jdk.internal.org.objectweb.asm.Opcodes;
import jdk.internal.org.objectweb.asm.Type;
import jdk.internal.org.objectweb.asm.commons.InstructionAdapter;
import jdk.nashorn.api.scripting.ScriptObjectMirror;
import jdk.nashorn.api.scripting.ScriptUtils;
import jdk.nashorn.internal.codegen.CompilerConstants.Call;
import jdk.nashorn.internal.runtime.ScriptFunction;
import jdk.nashorn.internal.runtime.ScriptObject;
import jdk.nashorn.internal.runtime.linker.AdaptationResult.Outcome;
import jdk.internal.reflect.CallerSensitive;
/**
* Generates bytecode for a Java adapter class. Used by the {@link JavaAdapterFactory}.
* </p><p>
* For every protected or public constructor in the extended class, the adapter class will have either one or two
* public constructors (visibility of protected constructors in the extended class is promoted to public).
* <li>
* <li>For adapter classes with instance-level overrides, a constructor taking a trailing ScriptObject argument preceded
* by original constructor arguments is always created on the adapter class. When such a constructor is invoked, the
* passed ScriptObject's member functions are used to implement and/or override methods on the original class,
* dispatched by name. A single JavaScript function will act as the implementation for all overloaded methods of the
* same name. When methods on an adapter instance are invoked, the functions are invoked having the ScriptObject passed
* in the instance constructor as their "this". Subsequent changes to the ScriptObject (reassignment or removal of its
* functions) will be reflected in the adapter instance as it is live dispatching to its members on every method invocation.
* {@code java.lang.Object} methods {@code equals}, {@code hashCode}, and {@code toString} can also be overridden. The
* only restriction is that since every JavaScript object already has a {@code toString} function through the
* {@code Object.prototype}, the {@code toString} in the adapter is only overridden if the passed ScriptObject has a
* {@code toString} function as its own property, and not inherited from a prototype. All other adapter methods can be
* implemented or overridden through a prototype-inherited function of the ScriptObject passed to the constructor too.
* </li>
* <li>
* If the original types collectively have only one abstract method, or have several of them, but all share the
* same name, an additional constructor for instance-level override adapter is provided for every original constructor;
* this one takes a ScriptFunction as its last argument preceded by original constructor arguments. This constructor
* will use the passed function as the implementation for all abstract methods. For consistency, any concrete methods
* sharing the single abstract method name will also be overridden by the function. When methods on the adapter instance
* are invoked, the ScriptFunction is invoked with UNDEFINED or Global as its "this" depending whether the function is
* strict or not.
* </li>
* <li>
* If the adapter being generated has class-level overrides, constructors taking same arguments as the superclass
* constructors are created. These constructors simply delegate to the superclass constructor. They are simply used to
* create instances of the adapter class, with no instance-level overrides, as they don't have them. If the original
* class' constructor was variable arity, the adapter constructor will also be variable arity. Protected constructors
* are exposed as public.
* </li>
* </ul>
* </p><p>
* For adapter methods that return values, all the JavaScript-to-Java conversions supported by Nashorn will be in effect
* to coerce the JavaScript function return value to the expected Java return type.
* </p><p>
* Since we are adding a trailing argument to the generated constructors in the adapter class with instance-level overrides, they will never be
* declared as variable arity, even if the original constructor in the superclass was declared as variable arity. The
* reason we are passing the additional argument at the end of the argument list instead at the front is that the
* source-level script expression <code>new X(a, b) { ... }</code> (which is a proprietary syntax extension Nashorn uses
* to resemble Java anonymous classes) is actually equivalent to <code>new X(a, b, { ... })</code>.
* </p><p>
* It is possible to create two different adapter classes: those that can have class-level overrides, and those that can
* have instance-level overrides. When {@link JavaAdapterFactory#getAdapterClassFor(Class[], ScriptObject, ProtectionDomain)}
* or {@link JavaAdapterFactory#getAdapterClassFor(Class[], ScriptObject, Lookup)} is invoked
* with non-null {@code classOverrides} parameter, an adapter class is created that can have class-level overrides, and
* the passed script object will be used as the implementations for its methods, just as in the above case of the
* constructor taking a script object. Note that in the case of class-level overrides, a new adapter class is created on
* every invocation, and the implementation object is bound to the class, not to any instance. All created instances
* will share these functions. If it is required to have both class-level overrides and instance-level overrides, the
* class-level override adapter class should be subclassed with an instance-override adapter. Since adapters delegate to
* super class when an overriding method handle is not specified, this will behave as expected. It is not possible to
* have both class-level and instance-level overrides in the same class for security reasons: adapter classes are
* defined with a protection domain of their creator code, and an adapter class that has both class and instance level
* overrides would need to have two potentially different protection domains: one for class-based behavior and one for
* instance-based behavior; since Java classes can only belong to a single protection domain, this could not be
* implemented securely.
*/
final class JavaAdapterBytecodeGenerator {
// Field names in adapters
private static final String GLOBAL_FIELD_NAME = "global";
private static final String DELEGATE_FIELD_NAME = "delegate";
private static final String IS_FUNCTION_FIELD_NAME = "isFunction";
private static final String CALL_THIS_FIELD_NAME = "callThis";
// Initializer names
private static final String INIT = "<init>";
private static final String CLASS_INIT = "<clinit>";
// Types often used in generated bytecode
private static final Type OBJECT_TYPE = Type.getType(Object.class);
private static final Type SCRIPT_OBJECT_TYPE = Type.getType(ScriptObject.class);
private static final Type SCRIPT_FUNCTION_TYPE = Type.getType(ScriptFunction.class);
private static final Type SCRIPT_OBJECT_MIRROR_TYPE = Type.getType(ScriptObjectMirror.class);
// JavaAdapterServices methods used in generated bytecode
private static final Call CHECK_FUNCTION = lookupServiceMethod("checkFunction", ScriptFunction.class, Object.class, String.class);
private static final Call EXPORT_RETURN_VALUE = lookupServiceMethod("exportReturnValue", Object.class, Object.class);
private static final Call GET_CALL_THIS = lookupServiceMethod("getCallThis", Object.class, ScriptFunction.class, Object.class);
private static final Call GET_CLASS_OVERRIDES = lookupServiceMethod("getClassOverrides", ScriptObject.class);
private static final Call GET_NON_NULL_GLOBAL = lookupServiceMethod("getNonNullGlobal", ScriptObject.class);
private static final Call HAS_OWN_TO_STRING = lookupServiceMethod("hasOwnToString", boolean.class, ScriptObject.class);
private static final Call INVOKE_NO_PERMISSIONS = lookupServiceMethod("invokeNoPermissions", void.class, MethodHandle.class, Object.class);
private static final Call NOT_AN_OBJECT = lookupServiceMethod("notAnObject", void.class, Object.class);
private static final Call SET_GLOBAL = lookupServiceMethod("setGlobal", Runnable.class, ScriptObject.class);
private static final Call TO_CHAR_PRIMITIVE = lookupServiceMethod("toCharPrimitive", char.class, Object.class);
private static final Call UNSUPPORTED = lookupServiceMethod("unsupported", UnsupportedOperationException.class);
private static final Call WRAP_THROWABLE = lookupServiceMethod("wrapThrowable", RuntimeException.class, Throwable.class);
private static final Call UNWRAP_MIRROR = lookupServiceMethod("unwrapMirror", ScriptObject.class, Object.class, boolean.class);
// Other methods invoked by the generated bytecode
private static final Call UNWRAP = staticCallNoLookup(ScriptUtils.class, "unwrap", Object.class, Object.class);
private static final Call CHAR_VALUE_OF = staticCallNoLookup(Character.class, "valueOf", Character.class, char.class);
private static final Call DOUBLE_VALUE_OF = staticCallNoLookup(Double.class, "valueOf", Double.class, double.class);
private static final Call LONG_VALUE_OF = staticCallNoLookup(Long.class, "valueOf", Long.class, long.class);
private static final Call RUN = interfaceCallNoLookup(Runnable.class, "run", void.class);
// ASM handle to the bootstrap method
private static final Handle BOOTSTRAP_HANDLE = new Handle(H_INVOKESTATIC,
Type.getInternalName(JavaAdapterServices.class), "bootstrap",
MethodType.methodType(CallSite.class, Lookup.class, String.class,
MethodType.class, int.class).toMethodDescriptorString(), false);
// ASM handle to the bootstrap method for array populator
private static final Handle CREATE_ARRAY_BOOTSTRAP_HANDLE = new Handle(H_INVOKESTATIC,
Type.getInternalName(JavaAdapterServices.class), "createArrayBootstrap",
MethodType.methodType(CallSite.class, Lookup.class, String.class,
MethodType.class).toMethodDescriptorString(), false);
// Field type names used in the generated bytecode
private static final String SCRIPT_OBJECT_TYPE_DESCRIPTOR = SCRIPT_OBJECT_TYPE.getDescriptor();
private static final String OBJECT_TYPE_DESCRIPTOR = OBJECT_TYPE.getDescriptor();
private static final String BOOLEAN_TYPE_DESCRIPTOR = Type.BOOLEAN_TYPE.getDescriptor();
// Throwable names used in the generated bytecode
private static final String RUNTIME_EXCEPTION_TYPE_NAME = Type.getInternalName(RuntimeException.class);
private static final String ERROR_TYPE_NAME = Type.getInternalName(Error.class);
private static final String THROWABLE_TYPE_NAME = Type.getInternalName(Throwable.class);
// Some more frequently used method descriptors
private static final String GET_METHOD_PROPERTY_METHOD_DESCRIPTOR = Type.getMethodDescriptor(OBJECT_TYPE, SCRIPT_OBJECT_TYPE);
private static final String VOID_METHOD_DESCRIPTOR = Type.getMethodDescriptor(Type.VOID_TYPE);
private static final String ADAPTER_PACKAGE_INTERNAL = "jdk/nashorn/javaadapters/";
private static final int MAX_GENERATED_TYPE_NAME_LENGTH = 255;
// Method name prefix for invoking super-methods
static final String SUPER_PREFIX = "super$";
// Method name and type for the no-privilege finalizer delegate
private static final String FINALIZER_DELEGATE_NAME = "$$nashornFinalizerDelegate";
private static final String FINALIZER_DELEGATE_METHOD_DESCRIPTOR = Type.getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE);
/**
* Collection of methods we never override: Object.clone(), Object.finalize().
*/
private static final Collection<MethodInfo> EXCLUDED = getExcludedMethods();
// This is the superclass for our generated adapter.
private final Class<?> superClass;
// Interfaces implemented by our generated adapter.
private final List<Class<?>> interfaces;
// Class loader used as the parent for the class loader we'll create to load the generated class. It will be a class
// loader that has the visibility of all original types (class to extend and interfaces to implement) and of the
// Nashorn classes.
private final ClassLoader commonLoader;
// Is this a generator for the version of the class that can have overrides on the class level?
private final boolean classOverride;
// Binary name of the superClass
private final String superClassName;
// Binary name of the generated class.
private final String generatedClassName;
private final Set<String> abstractMethodNames = new HashSet<>();
private final String samName;
private final Set<MethodInfo> finalMethods = new HashSet<>(EXCLUDED);
private final Set<MethodInfo> methodInfos = new HashSet<>();
private final boolean autoConvertibleFromFunction;
private boolean hasExplicitFinalizer = false;
private final ClassWriter cw;
/**
* Creates a generator for the bytecode for the adapter for the specified superclass and interfaces.
* @param superClass the superclass the adapter will extend.
* @param interfaces the interfaces the adapter will implement.
* @param commonLoader the class loader that can see all of superClass, interfaces, and Nashorn classes.
* @param classOverride true to generate the bytecode for the adapter that has class-level overrides, false to
* generate the bytecode for the adapter that has instance-level overrides.
* @throws AdaptationException if the adapter can not be generated for some reason.
*/
JavaAdapterBytecodeGenerator(final Class<?> superClass, final List<Class<?>> interfaces,
final ClassLoader commonLoader, final boolean classOverride) throws AdaptationException {
assert superClass != null && !superClass.isInterface();
assert interfaces != null;
this.superClass = superClass;
this.interfaces = interfaces;
this.classOverride = classOverride;
this.commonLoader = commonLoader;
cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS) {
@Override
protected String getCommonSuperClass(final String type1, final String type2) {
// We need to override ClassWriter.getCommonSuperClass to use this factory's commonLoader as a class
// loader to find the common superclass of two types when needed.
return JavaAdapterBytecodeGenerator.this.getCommonSuperClass(type1, type2);
}
};
superClassName = Type.getInternalName(superClass);
generatedClassName = getGeneratedClassName(superClass, interfaces);
cw.visit(Opcodes.V1_8, ACC_PUBLIC | ACC_SUPER, generatedClassName, null, superClassName, getInternalTypeNames(interfaces));
generateField(GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
generateField(DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
gatherMethods(superClass);
gatherMethods(interfaces);
if (abstractMethodNames.size() == 1) {
samName = abstractMethodNames.iterator().next();
generateField(CALL_THIS_FIELD_NAME, OBJECT_TYPE_DESCRIPTOR);
generateField(IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);
} else {
samName = null;
}
if(classOverride) {
generateClassInit();
}
autoConvertibleFromFunction = generateConstructors();
generateMethods();
generateSuperMethods();
if (hasExplicitFinalizer) {
generateFinalizerMethods();
}
// }
cw.visitEnd();
}
private void generateField(final String name, final String fieldDesc) {
cw.visitField(ACC_PRIVATE | ACC_FINAL | (classOverride ? ACC_STATIC : 0), name, fieldDesc, null, null).visitEnd();
}
JavaAdapterClassLoader createAdapterClassLoader() {
return new JavaAdapterClassLoader(generatedClassName, cw.toByteArray());
}
boolean isAutoConvertibleFromFunction() {
return autoConvertibleFromFunction;
}
private static String getGeneratedClassName(final Class<?> superType, final List<Class<?>> interfaces) {
// The class we use to primarily name our adapter is either the superclass, or if it is Object (meaning we're
// just implementing interfaces or extending Object), then the first implemented interface or Object.
final Class<?> namingType = superType == Object.class ? (interfaces.isEmpty()? Object.class : interfaces.get(0)) : superType;
final Package pkg = namingType.getPackage();
final String namingTypeName = Type.getInternalName(namingType);
final StringBuilder buf = new StringBuilder();
buf.append(ADAPTER_PACKAGE_INTERNAL).append(namingTypeName.replace('/', '_'));
final Iterator<Class<?>> it = interfaces.iterator();
if(superType == Object.class && it.hasNext()) {
it.next(); // Skip first interface, it was used to primarily name the adapter
}
// Append interface names to the adapter name
while(it.hasNext()) {
buf.append("$$").append(it.next().getSimpleName());
}
return buf.toString().substring(0, Math.min(MAX_GENERATED_TYPE_NAME_LENGTH, buf.length()));
}
/**
* Given a list of class objects, return an array with their binary names. Used to generate the array of interface
* names to implement.
* @param classes the classes
* @return an array of names
*/
private static String[] getInternalTypeNames(final List<Class<?>> classes) {
final int interfaceCount = classes.size();
final String[] interfaceNames = new String[interfaceCount];
for(int i = 0; i < interfaceCount; ++i) {
interfaceNames[i] = Type.getInternalName(classes.get(i));
}
return interfaceNames;
}
private void generateClassInit() {
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_STATIC, CLASS_INIT,
VOID_METHOD_DESCRIPTOR, null, null));
// Assign "global = Context.getGlobal()"
GET_NON_NULL_GLOBAL.invoke(mv);
mv.putstatic(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
GET_CLASS_OVERRIDES.invoke(mv);
if(samName != null) {
// If the class is a SAM, allow having ScriptFunction passed as class overrides
mv.dup();
mv.instanceOf(SCRIPT_FUNCTION_TYPE);
mv.dup();
mv.putstatic(generatedClassName, IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);
final Label notFunction = new Label();
mv.ifeq(notFunction);
mv.dup();
mv.checkcast(SCRIPT_FUNCTION_TYPE);
emitInitCallThis(mv);
mv.visitLabel(notFunction);
}
mv.putstatic(generatedClassName, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
endInitMethod(mv);
}
/**
* Emit bytecode for initializing the "callThis" field.
*/
private void emitInitCallThis(final InstructionAdapter mv) {
loadField(mv, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
GET_CALL_THIS.invoke(mv);
if(classOverride) {
mv.putstatic(generatedClassName, CALL_THIS_FIELD_NAME, OBJECT_TYPE_DESCRIPTOR);
} else {
// It is presumed ALOAD 0 was already executed
mv.putfield(generatedClassName, CALL_THIS_FIELD_NAME, OBJECT_TYPE_DESCRIPTOR);
}
}
private boolean generateConstructors() throws AdaptationException {
boolean gotCtor = false;
boolean canBeAutoConverted = false;
for (final Constructor<?> ctor: superClass.getDeclaredConstructors()) {
final int modifier = ctor.getModifiers();
if((modifier & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0 && !isCallerSensitive(ctor)) {
canBeAutoConverted = generateConstructors(ctor) | canBeAutoConverted;
gotCtor = true;
}
}
if(!gotCtor) {
throw new AdaptationException(ERROR_NO_ACCESSIBLE_CONSTRUCTOR, superClass.getCanonicalName());
}
return canBeAutoConverted;
}
private boolean generateConstructors(final Constructor<?> ctor) {
if(classOverride) {
// Generate a constructor that just delegates to ctor. This is used with class-level overrides, when we want
// to create instances without further per-instance overrides.
generateDelegatingConstructor(ctor);
return false;
}
// Generate a constructor that delegates to ctor, but takes an additional ScriptObject parameter at the
// beginning of its parameter list.
generateOverridingConstructor(ctor, false);
if (samName == null) {
return false;
}
// If all our abstract methods have a single name, generate an additional constructor, one that takes a
// ScriptFunction as its first parameter and assigns it as the implementation for all abstract methods.
generateOverridingConstructor(ctor, true);
// If the original type only has a single abstract method name, as well as a default ctor, then it can
// be automatically converted from JS function.
return ctor.getParameterTypes().length == 0;
}
private void generateDelegatingConstructor(final Constructor<?> ctor) {
final Type originalCtorType = Type.getType(ctor);
final Type[] argTypes = originalCtorType.getArgumentTypes();
// All constructors must be public, even if in the superclass they were protected.
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC |
(ctor.isVarArgs() ? ACC_VARARGS : 0), INIT,
Type.getMethodDescriptor(originalCtorType.getReturnType(), argTypes), null, null));
mv.visitCode();
emitSuperConstructorCall(mv, originalCtorType.getDescriptor());
endInitMethod(mv);
}
/**
* Generates a constructor for the instance adapter class. This constructor will take the same arguments as the supertype
* constructor passed as the argument here, and delegate to it. However, it will take an additional argument of
* either ScriptObject or ScriptFunction type (based on the value of the "fromFunction" parameter), and initialize
* all the method handle fields of the adapter instance with functions from the script object (or the script
* function itself, if that's what's passed). Additionally, it will create another constructor with an additional
* Object type parameter that can be used for ScriptObjectMirror objects.
* The constructor will also store the Nashorn global that was current at the constructor
* invocation time in a field named "global". The generated constructor will be public, regardless of whether the
* supertype constructor was public or protected. The generated constructor will not be variable arity, even if the
* supertype constructor was.
* @param ctor the supertype constructor that is serving as the base for the generated constructor.
* @param fromFunction true if we're generating a constructor that initializes SAM types from a single
* ScriptFunction passed to it, false if we're generating a constructor that initializes an arbitrary type from a
* ScriptObject passed to it.
*/
private void generateOverridingConstructor(final Constructor<?> ctor, final boolean fromFunction) {
final Type originalCtorType = Type.getType(ctor);
final Type[] originalArgTypes = originalCtorType.getArgumentTypes();
final int argLen = originalArgTypes.length;
final Type[] newArgTypes = new Type[argLen + 1];
// Insert ScriptFunction|ScriptObject as the last argument to the constructor
final Type extraArgumentType = fromFunction ? SCRIPT_FUNCTION_TYPE : SCRIPT_OBJECT_TYPE;
newArgTypes[argLen] = extraArgumentType;
System.arraycopy(originalArgTypes, 0, newArgTypes, 0, argLen);
// All constructors must be public, even if in the superclass they were protected.
// Existing super constructor <init>(this, args...) triggers generating <init>(this, args..., delegate).
// Any variable arity constructors become fixed-arity with explicit array arguments.
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC, INIT,
Type.getMethodDescriptor(originalCtorType.getReturnType(), newArgTypes), null, null));
mv.visitCode();
// First, invoke super constructor with original arguments.
final int extraArgOffset = emitSuperConstructorCall(mv, originalCtorType.getDescriptor());
// Assign "this.global = Context.getGlobal()"
mv.visitVarInsn(ALOAD, 0);
GET_NON_NULL_GLOBAL.invoke(mv);
mv.putfield(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
// Assign "this.delegate = delegate"
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, extraArgOffset);
mv.putfield(generatedClassName, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
if (fromFunction) {
// Assign "isFunction = true"
mv.visitVarInsn(ALOAD, 0);
mv.iconst(1);
mv.putfield(generatedClassName, IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, extraArgOffset);
emitInitCallThis(mv);
}
endInitMethod(mv);
if (! fromFunction) {
newArgTypes[argLen] = OBJECT_TYPE;
final InstructionAdapter mv2 = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC, INIT,
Type.getMethodDescriptor(originalCtorType.getReturnType(), newArgTypes), null, null));
generateOverridingConstructorWithObjectParam(mv2, originalCtorType.getDescriptor());
}
}
// Object additional param accepting constructor for handling ScriptObjectMirror objects, which are
// unwrapped to work as ScriptObjects or ScriptFunctions. This also handles null and undefined values for
// script adapters by throwing TypeError on such script adapters.
private void generateOverridingConstructorWithObjectParam(final InstructionAdapter mv, final String ctorDescriptor) {
mv.visitCode();
final int extraArgOffset = emitSuperConstructorCall(mv, ctorDescriptor);
// Check for ScriptObjectMirror
mv.visitVarInsn(ALOAD, extraArgOffset);
mv.instanceOf(SCRIPT_OBJECT_MIRROR_TYPE);
final Label notMirror = new Label();
mv.ifeq(notMirror);
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, extraArgOffset);
mv.iconst(0);
UNWRAP_MIRROR.invoke(mv);
mv.putfield(generatedClassName, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, extraArgOffset);
mv.iconst(1);
UNWRAP_MIRROR.invoke(mv);
mv.putfield(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
final Label done = new Label();
if (samName != null) {
mv.visitVarInsn(ALOAD, 0);
mv.getfield(generatedClassName, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
mv.instanceOf(SCRIPT_FUNCTION_TYPE);
mv.ifeq(done);
// Assign "isFunction = true"
mv.visitVarInsn(ALOAD, 0);
mv.iconst(1);
mv.putfield(generatedClassName, IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);
mv.visitVarInsn(ALOAD, 0);
mv.dup();
mv.getfield(generatedClassName, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
mv.checkcast(SCRIPT_FUNCTION_TYPE);
emitInitCallThis(mv);
mv.goTo(done);
}
mv.visitLabel(notMirror);
// Throw error if not a ScriptObject
mv.visitVarInsn(ALOAD, extraArgOffset);
NOT_AN_OBJECT.invoke(mv);
mv.visitLabel(done);
endInitMethod(mv);
}
private static void endInitMethod(final InstructionAdapter mv) {
mv.visitInsn(RETURN);
endMethod(mv);
}
private static void endMethod(final InstructionAdapter mv) {
mv.visitMaxs(0, 0);
mv.visitEnd();
}
/**
* Encapsulation of the information used to generate methods in the adapter classes. Basically, a wrapper around the
* reflective Method object, a cached MethodType, and the name of the field in the adapter class that will hold the
* method handle serving as the implementation of this method in adapter instances.
*
*/
private static class MethodInfo {
private final Method method;
private final MethodType type;
private MethodInfo(final Class<?> clazz, final String name, final Class<?>... argTypes) throws NoSuchMethodException {
this(clazz.getDeclaredMethod(name, argTypes));
}
private MethodInfo(final Method method) {
this.method = method;
this.type = MH.type(method.getReturnType(), method.getParameterTypes());
}
@Override
public boolean equals(final Object obj) {
return obj instanceof MethodInfo && equals((MethodInfo)obj);
}
private boolean equals(final MethodInfo other) {
// Only method name and type are used for comparison; method handle field name is not.
return getName().equals(other.getName()) && type.equals(other.type);
}
String getName() {
return method.getName();
}
@Override
public int hashCode() {
return getName().hashCode() ^ type.hashCode();
}
}
private void generateMethods() {
for(final MethodInfo mi: methodInfos) {
generateMethod(mi);
}
}
/**
* Generates a method in the adapter class that adapts a method from the
* original class. The generated method will either invoke the delegate
* using a CALL dynamic operation call site (if it is a SAM method and the
* delegate is a ScriptFunction), or invoke GET_METHOD_PROPERTY dynamic
* operation with the method name as the argument and then invoke the
* returned ScriptFunction using the CALL dynamic operation. If
* GET_METHOD_PROPERTY returns null or undefined (that is, the JS object
* doesn't provide an implementation for the method) then the method will
* either do a super invocation to base class, or if the method is abstract,
* throw an {@link UnsupportedOperationException}. Finally, if
* GET_METHOD_PROPERTY returns something other than a ScriptFunction, null,
* or undefined, a TypeError is thrown. The current Global is checked before
* the dynamic operations, and if it is different than the Global used to
* create the adapter, the creating Global is set to be the current Global.
* In this case, the previously current Global is restored after the
* invocation. If CALL results in a Throwable that is not one of the
* method's declared exceptions, and is not an unchecked throwable, then it
* is wrapped into a {@link RuntimeException} and the runtime exception is
* thrown.
* @param mi the method info describing the method to be generated.
*/
private void generateMethod(final MethodInfo mi) {
final Method method = mi.method;
final Class<?>[] exceptions = method.getExceptionTypes();
final String[] exceptionNames = getExceptionNames(exceptions);
final MethodType type = mi.type;
final String methodDesc = type.toMethodDescriptorString();
final String name = mi.getName();
final Type asmType = Type.getMethodType(methodDesc);
final Type[] asmArgTypes = asmType.getArgumentTypes();
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(getAccessModifiers(method), name,
methodDesc, null, exceptionNames));
mv.visitCode();
final Class<?> returnType = type.returnType();
final Type asmReturnType = Type.getType(returnType);
// Determine the first index for a local variable
int nextLocalVar = 1; // "this" is at 0
for(final Type t: asmArgTypes) {
nextLocalVar += t.getSize();
}
// Set our local variable index
final int globalRestoringRunnableVar = nextLocalVar++;
// Load the creatingGlobal object
loadField(mv, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
// stack: [creatingGlobal]
SET_GLOBAL.invoke(mv);
// stack: [runnable]
mv.visitVarInsn(ASTORE, globalRestoringRunnableVar);
// stack: []
final Label tryBlockStart = new Label();
mv.visitLabel(tryBlockStart);
final Label callCallee = new Label();
final Label defaultBehavior = new Label();
// If this is a SAM type...
if (samName != null) {
// ...every method will be checking whether we're initialized with a
// function.
loadField(mv, IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);
// stack: [isFunction]
if (name.equals(samName)) {
final Label notFunction = new Label();
mv.ifeq(notFunction);
// stack: []
// If it's a SAM method, it'll load delegate as the "callee" and
// "callThis" as "this" for the call if delegate is a function.
loadField(mv, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
// NOTE: if we added "mv.checkcast(SCRIPT_FUNCTION_TYPE);" here
// we could emit the invokedynamic CALL instruction with signature
// (ScriptFunction, Object, ...) instead of (Object, Object, ...).
// We could combine this with an optimization in
// ScriptFunction.findCallMethod where it could link a call with a
// thinner guard when the call site statically guarantees that the
// callee argument is a ScriptFunction. Additionally, we could use
// a "ScriptFunction function" field in generated classes instead
// of a "boolean isFunction" field to avoid the checkcast.
loadField(mv, CALL_THIS_FIELD_NAME, OBJECT_TYPE_DESCRIPTOR);
// stack: [callThis, delegate]
mv.goTo(callCallee);
mv.visitLabel(notFunction);
} else {
// If it's not a SAM method, and the delegate is a function,
// it'll fall back to default behavior
mv.ifne(defaultBehavior);
// stack: []
}
}
// At this point, this is either not a SAM method or the delegate is
// not a ScriptFunction. We need to emit a GET_METHOD_PROPERTY Nashorn
// invokedynamic.
if(name.equals("toString")) {
// Since every JS Object has a toString, we only override
// "String toString()" it if it's explicitly specified on the object.
loadField(mv, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
// stack: [delegate]
HAS_OWN_TO_STRING.invoke(mv);
// stack: [hasOwnToString]
mv.ifeq(defaultBehavior);
}
loadField(mv, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
//For the cases like scripted overridden methods invoked from super constructors get adapter global/delegate fields as null, since we
//cannot set these fields before invoking super constructor better solution is opt out of scripted overridden method if global/delegate fields
//are null and invoke super method instead
mv.ifnull(defaultBehavior);
loadField(mv, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
mv.dup();
// stack: [delegate, delegate]
final String encodedName = NameCodec.encode(name);
mv.visitInvokeDynamicInsn(encodedName,
GET_METHOD_PROPERTY_METHOD_DESCRIPTOR, BOOTSTRAP_HANDLE,
NashornCallSiteDescriptor.GET_METHOD_PROPERTY);
// stack: [callee, delegate]
mv.visitLdcInsn(name);
// stack: [name, callee, delegate]
CHECK_FUNCTION.invoke(mv);
// stack: [fnCalleeOrNull, delegate]
final Label hasFunction = new Label();
mv.dup();
// stack: [fnCalleeOrNull, fnCalleeOrNull, delegate]
mv.ifnonnull(hasFunction);
// stack: [null, delegate]
// If it's null or undefined, clear stack and fall back to default
// behavior.
mv.pop2();
// stack: []
// We can also arrive here from check for "delegate instanceof ScriptFunction"
// in a non-SAM method as well as from a check for "hasOwnToString(delegate)"
// for a toString delegate.
mv.visitLabel(defaultBehavior);
final Runnable emitFinally = ()->emitFinally(mv, globalRestoringRunnableVar);
final Label normalFinally = new Label();
if(Modifier.isAbstract(method.getModifiers())) {
// If the super method is abstract, throw UnsupportedOperationException
UNSUPPORTED.invoke(mv);
// NOTE: no need to invoke emitFinally.run() as we're inside the
// tryBlockStart/tryBlockEnd range, so throwing this exception will
// transfer control to the rethrow handler and the finally block in it
// will execute.
mv.athrow();
} else {
// If the super method is not abstract, delegate to it.
emitSuperCall(mv, method.getDeclaringClass(), name, methodDesc);
mv.goTo(normalFinally);
}
mv.visitLabel(hasFunction);
// stack: [callee, delegate]
mv.swap();
// stack [delegate, callee]
mv.visitLabel(callCallee);
// Load all parameters back on stack for dynamic invocation.
int varOffset = 1;
// If the param list length is more than 253 slots, we can't invoke it
// directly as with (callee, this) it'll exceed 255.
final boolean isVarArgCall = getParamListLengthInSlots(asmArgTypes) > 253;
for (final Type t : asmArgTypes) {
mv.load(varOffset, t);
convertParam(mv, t, isVarArgCall);
varOffset += t.getSize();
}
// stack: [args..., callee, delegate]
// If the resulting parameter list length is too long...
if (isVarArgCall) {
// ... we pack the parameters (except callee and this) into an array
// and use Nashorn vararg invocation.
mv.visitInvokeDynamicInsn(NameCodec.EMPTY_NAME,
getArrayCreatorMethodType(type).toMethodDescriptorString(),
CREATE_ARRAY_BOOTSTRAP_HANDLE);
}
// Invoke the target method handle
mv.visitInvokeDynamicInsn(encodedName,
getCallMethodType(isVarArgCall, type).toMethodDescriptorString(),
BOOTSTRAP_HANDLE, NashornCallSiteDescriptor.CALL);
// stack: [returnValue]
convertReturnValue(mv, returnType);
mv.visitLabel(normalFinally);
emitFinally.run();
mv.areturn(asmReturnType);
// If Throwable is not declared, we need an adapter from Throwable to RuntimeException
final boolean throwableDeclared = isThrowableDeclared(exceptions);
final Label throwableHandler;
if (!throwableDeclared) {
// Add "throw new RuntimeException(Throwable)" handler for Throwable
throwableHandler = new Label();
mv.visitLabel(throwableHandler);
WRAP_THROWABLE.invoke(mv);
// Fall through to rethrow handler
} else {
throwableHandler = null;
}
final Label rethrowHandler = new Label();
mv.visitLabel(rethrowHandler);
// Rethrow handler for RuntimeException, Error, and all declared exception types
emitFinally.run();
mv.athrow();
if(throwableDeclared) {
mv.visitTryCatchBlock(tryBlockStart, normalFinally, rethrowHandler, THROWABLE_TYPE_NAME);
assert throwableHandler == null;
} else {
mv.visitTryCatchBlock(tryBlockStart, normalFinally, rethrowHandler, RUNTIME_EXCEPTION_TYPE_NAME);
mv.visitTryCatchBlock(tryBlockStart, normalFinally, rethrowHandler, ERROR_TYPE_NAME);
for(final String excName: exceptionNames) {
mv.visitTryCatchBlock(tryBlockStart, normalFinally, rethrowHandler, excName);
}
mv.visitTryCatchBlock(tryBlockStart, normalFinally, throwableHandler, THROWABLE_TYPE_NAME);
}
endMethod(mv);
}
private static MethodType getCallMethodType(final boolean isVarArgCall, final MethodType type) {
final Class<?>[] callParamTypes;
if (isVarArgCall) {
// Variable arity calls are always (Object callee, Object this, Object[] params)
callParamTypes = new Class<?>[] { Object.class, Object.class, Object[].class };
} else {
// Adjust invocation type signature for conversions we instituted in
// convertParam; also, byte and short get passed as ints.
final Class<?>[] origParamTypes = type.parameterArray();
callParamTypes = new Class<?>[origParamTypes.length + 2];
callParamTypes[0] = Object.class; // callee; could be ScriptFunction.class ostensibly
callParamTypes[1] = Object.class; // this
for(int i = 0; i < origParamTypes.length; ++i) {
callParamTypes[i + 2] = getNashornParamType(origParamTypes[i], false);
}
}
return MethodType.methodType(getNashornReturnType(type.returnType()), callParamTypes);
}
private static MethodType getArrayCreatorMethodType(final MethodType type) {
final Class<?>[] callParamTypes = type.parameterArray();
for(int i = 0; i < callParamTypes.length; ++i) {
callParamTypes[i] = getNashornParamType(callParamTypes[i], true);
}
return MethodType.methodType(Object[].class, callParamTypes);
}
private static Class<?> getNashornParamType(final Class<?> clazz, final boolean varArg) {
if (clazz == byte.class || clazz == short.class) {
return int.class;
} else if (clazz == float.class) {
// If using variable arity, we'll pass a Double instead of double
// so that floats don't extend the length of the parameter list.
// We return Object.class instead of Double.class though as the
// array collector will anyway operate on Object.
return varArg ? Object.class : double.class;
} else if (!clazz.isPrimitive() || clazz == long.class || clazz == char.class) {
return Object.class;
}
return clazz;
}
private static Class<?> getNashornReturnType(final Class<?> clazz) {
if (clazz == byte.class || clazz == short.class) {
return int.class;
} else if (clazz == float.class) {
return double.class;
} else if (clazz == void.class || clazz == char.class) {
return Object.class;
}
return clazz;
}
private void loadField(final InstructionAdapter mv, final String name, final String desc) {
if(classOverride) {
mv.getstatic(generatedClassName, name, desc);
} else {
mv.visitVarInsn(ALOAD, 0);
mv.getfield(generatedClassName, name, desc);
}
}
private static void convertReturnValue(final InstructionAdapter mv, final Class<?> origReturnType) {
if (origReturnType == void.class) {
mv.pop();
} else if (origReturnType == Object.class) {
// Must hide ConsString (and potentially other internal Nashorn types) from callers
EXPORT_RETURN_VALUE.invoke(mv);
} else if (origReturnType == byte.class) {
mv.visitInsn(I2B);
} else if (origReturnType == short.class) {
mv.visitInsn(I2S);
} else if (origReturnType == float.class) {
mv.visitInsn(D2F);
} else if (origReturnType == char.class) {
TO_CHAR_PRIMITIVE.invoke(mv);
}
}
/**
* Emits instruction for converting a parameter on the top of the stack to
* a type that is understood by Nashorn.
* @param mv the current method visitor
* @param t the type on the top of the stack
* @param varArg if the invocation will be variable arity
*/
private static void convertParam(final InstructionAdapter mv, final Type t, final boolean varArg) {
// We perform conversions of some primitives to accommodate types that
// Nashorn can handle.
switch(t.getSort()) {
case Type.CHAR:
// Chars are boxed, as we don't know if the JS code wants to treat
// them as an effective "unsigned short" or as a single-char string.
CHAR_VALUE_OF.invoke(mv);
break;
case Type.FLOAT:
// Floats are widened to double.
mv.visitInsn(Opcodes.F2D);
if (varArg) {
// We'll be boxing everything anyway for the vararg invocation,
// so we might as well do it proactively here and thus not cause
// a widening in the number of slots, as that could even make
// the array creation invocation go over 255 param slots.
DOUBLE_VALUE_OF.invoke(mv);
}
break;
case Type.LONG:
// Longs are boxed as Nashorn can't represent them precisely as a
// primitive number.
LONG_VALUE_OF.invoke(mv);
break;
case Type.OBJECT:
if(t.equals(OBJECT_TYPE)) {
// Object can carry a ScriptObjectMirror and needs to be unwrapped
// before passing into a Nashorn function.
UNWRAP.invoke(mv);
}
break;
}
}
private static int getParamListLengthInSlots(final Type[] paramTypes) {
int len = paramTypes.length;
for(final Type t: paramTypes) {
final int sort = t.getSort();
if (sort == Type.FLOAT || sort == Type.DOUBLE) {
// Floats are widened to double, so they'll take up two slots.
// Longs on the other hand are always boxed, so their width
// becomes 1 and thus they don't contribute an extra slot here.
++len;
}
}
return len;
}
/**
* Emit code to restore the previous Nashorn Context when needed.
* @param mv the instruction adapter
* @param globalRestoringRunnableVar index of the local variable holding the reference to the global restoring Runnable
*/
private static void emitFinally(final InstructionAdapter mv, final int globalRestoringRunnableVar) {
mv.visitVarInsn(ALOAD, globalRestoringRunnableVar);
RUN.invoke(mv);
}
private static boolean isThrowableDeclared(final Class<?>[] exceptions) {
for (final Class<?> exception : exceptions) {
if (exception == Throwable.class) {
return true;
}
}
return false;
}
private void generateSuperMethods() {
for(final MethodInfo mi: methodInfos) {
if(!Modifier.isAbstract(mi.method.getModifiers())) {
generateSuperMethod(mi);
}
}
}
private void generateSuperMethod(final MethodInfo mi) {
final Method method = mi.method;
final String methodDesc = mi.type.toMethodDescriptorString();
final String name = mi.getName();
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(getAccessModifiers(method),
SUPER_PREFIX + name, methodDesc, null, getExceptionNames(method.getExceptionTypes())));
mv.visitCode();
emitSuperCall(mv, method.getDeclaringClass(), name, methodDesc);
mv.areturn(Type.getType(mi.type.returnType()));
endMethod(mv);
}
// find the appropriate super type to use for invokespecial on the given interface
private Class<?> findInvokespecialOwnerFor(final Class<?> cl) {
assert Modifier.isInterface(cl.getModifiers()) : cl + " is not an interface";
if (cl.isAssignableFrom(superClass)) {
return superClass;
}
for (final Class<?> iface : interfaces) {
if (cl.isAssignableFrom(iface)) {
return iface;
}
}
// we better that interface that extends the given interface!
throw new AssertionError("can't find the class/interface that extends " + cl);
}
private int emitSuperConstructorCall(final InstructionAdapter mv, final String methodDesc) {
return emitSuperCall(mv, null, INIT, methodDesc, true);
}
private int emitSuperCall(final InstructionAdapter mv, final Class<?> owner, final String name, final String methodDesc) {
return emitSuperCall(mv, owner, name, methodDesc, false);
}
private int emitSuperCall(final InstructionAdapter mv, final Class<?> owner, final String name, final String methodDesc, final boolean constructor) {
mv.visitVarInsn(ALOAD, 0);
int nextParam = 1;
final Type methodType = Type.getMethodType(methodDesc);
for(final Type t: methodType.getArgumentTypes()) {
mv.load(nextParam, t);
nextParam += t.getSize();
}
// default method - non-abstract, interface method
if (!constructor && Modifier.isInterface(owner.getModifiers())) {
// we should call default method on the immediate "super" type - not on (possibly)
// the indirectly inherited interface class!
final Class<?> superType = findInvokespecialOwnerFor(owner);
mv.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(superType), name, methodDesc,
Modifier.isInterface(superType.getModifiers()));
} else {
mv.invokespecial(superClassName, name, methodDesc, false);
}
return nextParam;
}
private void generateFinalizerMethods() {
generateFinalizerDelegate();
generateFinalizerOverride();
}
private void generateFinalizerDelegate() {
// Generate a delegate that will be invoked from the no-permission trampoline. Note it can be private, as we'll
// refer to it with a MethodHandle constant pool entry in the overridden finalize() method (see
// generateFinalizerOverride()).
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PRIVATE | ACC_STATIC,
FINALIZER_DELEGATE_NAME, FINALIZER_DELEGATE_METHOD_DESCRIPTOR, null, null));
// Simply invoke super.finalize()
mv.visitVarInsn(ALOAD, 0);
mv.checkcast(Type.getType('L' + generatedClassName + ';'));
mv.invokespecial(superClassName, "finalize", VOID_METHOD_DESCRIPTOR, false);
mv.visitInsn(RETURN);
endMethod(mv);
}
private void generateFinalizerOverride() {
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC, "finalize",
VOID_METHOD_DESCRIPTOR, null, null));
// Overridden finalizer will take a MethodHandle to the finalizer delegating method, ...
mv.aconst(new Handle(Opcodes.H_INVOKESTATIC, generatedClassName, FINALIZER_DELEGATE_NAME,
FINALIZER_DELEGATE_METHOD_DESCRIPTOR, false));
mv.visitVarInsn(ALOAD, 0);
// ...and invoke it through JavaAdapterServices.invokeNoPermissions
INVOKE_NO_PERMISSIONS.invoke(mv);
mv.visitInsn(RETURN);
endMethod(mv);
}
private static String[] getExceptionNames(final Class<?>[] exceptions) {
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java