jdk8-mips64-public/nashorn: comparison src/jdk/nashorn/internal/runtime/linker/JavaAdapterBytecodeGenerator.java

-:c59fb10cb0b5
+:11b83c913cca
 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.internal.runtime.Context;
 import jdk.nashorn.internal.runtime.ScriptFunction;
 import jdk.nashorn.internal.runtime.ScriptObject;
+import jdk.nashorn.internal.runtime.linker.AdaptationResult.Outcome;
 import sun.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 between one to three
+* 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).
-* <ul>
+* <li>
-* <li>In every case, a constructor taking a trailing ScriptObject argument preceded by original constructor arguments
+* <li>For adapter classes with instance-level overrides, a constructor taking a trailing ScriptObject argument preceded
-* is always created on the adapter class. When such a constructor is invoked, the passed ScriptObject's member
+* by original constructor arguments is always created on the adapter class. When such a constructor is invoked, the
-* functions are used to implement and/or override methods on the original class, dispatched by name. A single
+* passed ScriptObject's member functions are used to implement and/or override methods on the original class,
-* JavaScript function will act as the implementation for all overloaded methods of the same name. When methods on an
+* dispatched by name. A single JavaScript function will act as the implementation for all overloaded methods of the
-* adapter instance are invoked, the functions are invoked having the ScriptObject passed in the instance constructor as
+* same name. When methods on an adapter instance are invoked, the functions are invoked having the ScriptObject passed
-* their "this". Subsequent changes to the ScriptObject (reassignment or removal of its functions) are not reflected in
+* in the instance constructor as their "this". Subsequent changes to the ScriptObject (reassignment or removal of its
-* the adapter instance; the method implementations are bound to functions at constructor invocation time.
+* functions) are not reflected in the adapter instance; the method implementations are bound to functions at
+* constructor invocation time.
 * {@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 is provided for every original constructor; this one takes a ScriptFunction as
+* same name, an additional constructor for instance-level override adapter is provided for every original constructor;
-* its last argument preceded by original constructor arguments. This constructor will use the passed function as the
+* this one takes a ScriptFunction as its last argument preceded by original constructor arguments. This constructor
-* implementation for all abstract methods. For consistency, any concrete methods sharing the single abstract method
+* will use the passed function as the implementation for all abstract methods. For consistency, any concrete methods
-* name will also be overridden by the function. When methods on the adapter instance are invoked, the ScriptFunction is
+* sharing the single abstract method name will also be overridden by the function. When methods on the adapter instance
-* invoked with global or UNDEFINED as its "this" depending whether the function is non-strict or not.
+* 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 can have class-level overrides, constructors taking same arguments as the superclass
-* constructors are also created. These constructors simply delegate to the superclass constructor. They are used to
+* 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.
+* create instances of the adapter class, with no instance-level overrides, as they don't have them.
 * </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.
 * 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 classes: those that can have both class-level and instance-level overrides,
+* It is possible to create two different adapter classes: those that can have class-level overrides, and those that can
-* and those that can only have instance-level overrides. When
+* have instance-level overrides. When {@link JavaAdapterFactory#getAdapterClassFor(Class[], ScriptObject)} is invoked
-* {@link JavaAdapterFactory#getAdapterClassFor(Class[], ScriptObject)} is invoked with non-null {@code classOverrides}
+* with non-null {@code classOverrides} parameter, an adapter class is created that can have class-level overrides, and
-* parameter, an adapter class is created that can have class-level overrides, and the passed script object will be used
+* the passed script object will be used as the implementations for its methods, just as in the above case of the
-* as the implementations for its methods, just as in the above case of the constructor taking a script object. Note
+* constructor taking a script object. Note that in the case of class-level overrides, a new adapter class is created on
-* that in the case of class-level overrides, a new adapter class is created on every invocation, and the implementation
+* every invocation, and the implementation object is bound to the class, not to any instance. All created instances
-* object is bound to the class, not to any instance. All created instances will share these functions. Of course, when
+* will share these functions. If it is required to have both class-level overrides and instance-level overrides, the
-* instances of such a class are being created, they can still take another object (or possibly a function) in their
+* class-level override adapter class should be subclassed with an instance-override adapter. Since adapters delegate to
-* constructor's trailing position and thus provide further instance-specific overrides. The order of invocation is
+* super class when an overriding method handle is not specified, this will behave as expected. It is not possible to
-* always instance-specified method, then a class-specified method, and finally the superclass method.
+* 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 {
 static final Type CONTEXT_TYPE       = Type.getType(Context.class);
 static final Type OBJECT_TYPE        = Type.getType(Object.class);
 static final Type SCRIPT_OBJECT_TYPE = Type.getType(ScriptObject.class);
 private static final String ADAPTER_CLASS_NAME_SUFFIX = "$$NashornJavaAdapter";
 private static final String JAVA_PACKAGE_PREFIX = "java/";
 private static final int MAX_GENERATED_TYPE_NAME_LENGTH = 255;
 private static final String CLASS_INIT = "<clinit>";
-private static final String STATIC_GLOBAL_FIELD_NAME = "staticGlobal";
 // Method name prefix for invoking super-methods
 static final String SUPER_PREFIX = "super$";
 /**
 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 boolean autoConvertibleFromFunction = false;
+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 both class-level and instance-level
+* @param classOverride true to generate the bytecode for the adapter that has class-level overrides, false to
-* overrides, false to generate the bytecode for the adapter that only has instance-level overrides.
+* 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();
 }
 };
 superClassName = Type.getInternalName(superClass);
 generatedClassName = getGeneratedClassName(superClass, interfaces);
-cw.visit(Opcodes.V1_7, ACC_PUBLIC | ACC_SUPER | ACC_FINAL, generatedClassName, null, superClassName, getInternalTypeNames(interfaces));
+cw.visit(Opcodes.V1_7, ACC_PUBLIC | ACC_SUPER, generatedClassName, null, superClassName, getInternalTypeNames(interfaces));
 generateGlobalFields();
 gatherMethods(superClass);
 gatherMethods(interfaces);
 samName = abstractMethodNames.size() == 1 ? abstractMethodNames.iterator().next() : null;
 generateClassInit();
 }
 generateConstructors();
 generateMethods();
 generateSuperMethods();
+if (hasExplicitFinalizer) {
+generateFinalizerMethods();
+}
 // }
 cw.visitEnd();
 }
 private void generateGlobalFields() {
-cw.visitField(ACC_PRIVATE | ACC_FINAL, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR, null, null).visitEnd();
+cw.visitField(ACC_PRIVATE | ACC_FINAL | (classOverride ? ACC_STATIC : 0), GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR, null, null).visitEnd();
 usedFieldNames.add(GLOBAL_FIELD_NAME);
-if(classOverride) {
-cw.visitField(ACC_PRIVATE | ACC_FINAL | ACC_STATIC, STATIC_GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR, null, null).visitEnd();
-usedFieldNames.add(STATIC_GLOBAL_FIELD_NAME);
-}
 }
 JavaAdapterClassLoader createAdapterClassLoader() {
 return new JavaAdapterClassLoader(generatedClassName, cw.toByteArray());
 }
 }
 return interfaceNames;
 }
 private void generateHandleFields() {
+final int flags = ACC_PRIVATE | ACC_FINAL | (classOverride ? ACC_STATIC : 0);
 for (final MethodInfo mi: methodInfos) {
-cw.visitField(ACC_PRIVATE | ACC_FINAL, mi.methodHandleInstanceFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR, null, null).visitEnd();
+cw.visitField(flags, mi.methodHandleFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR, null, null).visitEnd();
-if(classOverride) {
-cw.visitField(ACC_PRIVATE | ACC_FINAL | ACC_STATIC, mi.methodHandleClassFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR, null, null).visitEnd();
-}
 }
 }
 private void generateClassInit() {
 final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_STATIC, CLASS_INIT,
 mv.aconst(Type.getMethodType(mi.type.toMethodDescriptorString()));
 mv.invokestatic(SERVICES_CLASS_TYPE_NAME, "getHandle", GET_HANDLE_FUNCTION_DESCRIPTOR);
 } else {
 mv.visitInsn(ACONST_NULL);
 }
-mv.putstatic(generatedClassName, mi.methodHandleClassFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
+mv.putstatic(generatedClassName, mi.methodHandleFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
 }
 initGlobal = new Label();
 mv.goTo(initGlobal);
 mv.visitLabel(notAFunction);
 } else {
 for (final MethodInfo mi : methodInfos) {
 mv.dup();
 mv.aconst(mi.getName());
 mv.aconst(Type.getMethodType(mi.type.toMethodDescriptorString()));
 mv.invokestatic(SERVICES_CLASS_TYPE_NAME, "getHandle", GET_HANDLE_OBJECT_DESCRIPTOR);
-mv.putstatic(generatedClassName, mi.methodHandleClassFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
+mv.putstatic(generatedClassName, mi.methodHandleFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
 }
 if(initGlobal != null) {
 mv.visitLabel(initGlobal);
 }
-// Assign "staticGlobal = Context.getGlobal()"
+// Assign "global = Context.getGlobal()"
 invokeGetGlobalWithNullCheck(mv);
-mv.putstatic(generatedClassName, STATIC_GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
+mv.putstatic(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
 endInitMethod(mv);
 }
 private static void invokeGetGlobalWithNullCheck(final InstructionAdapter mv) {
 private void 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);
-}
+} else {
+// Generate a constructor that delegates to ctor, but takes an additional ScriptObject parameter at the
-// Generate a constructor that delegates to ctor, but takes an additional ScriptObject parameter at the
+// beginning of its parameter list.
-// beginning of its parameter list.
+generateOverridingConstructor(ctor, false);
-generateOverridingConstructor(ctor, false);
+if (samName != null) {
-if (samName != null) {
+if (!autoConvertibleFromFunction && ctor.getParameterTypes().length == 0) {
-if (!autoConvertibleFromFunction && ctor.getParameterTypes().length == 0) {
+// If the original type only has a single abstract method name, as well as a default ctor, then it can
-// 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.
-// be automatically converted from JS function.
+autoConvertibleFromFunction = true;
-autoConvertibleFromFunction = true;
+}
-}
+// If all our abstract methods have a single name, generate an additional constructor, one that takes a
-// 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.
-// ScriptFunction as its first parameter and assigns it as the implementation for all abstract methods.
+generateOverridingConstructor(ctor, true);
-generateOverridingConstructor(ctor, true);
+}
 }
 }
 private void generateDelegatingConstructor(final Constructor<?> ctor) {
 final Type originalCtorType = Type.getType(ctor);
 endInitMethod(mv);
 }
 /**
-* Generates a constructor for the adapter class. This constructor will take the same arguments as the supertype
+* 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). There is one method handle field in the adapter class for every method
 * that can be implemented or overridden; the name of every field is same as the name of the method, with a number
 mv.aconst(mi.getName());
 }
 mv.aconst(Type.getMethodType(mi.type.toMethodDescriptorString()));
 mv.invokestatic(SERVICES_CLASS_TYPE_NAME, "getHandle", getHandleDescriptor);
 }
-mv.putfield(generatedClassName, mi.methodHandleInstanceFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
+mv.putfield(generatedClassName, mi.methodHandleFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
 }
 // Assign "this.global = Context.getGlobal()"
 mv.visitVarInsn(ALOAD, 0);
 invokeGetGlobalWithNullCheck(mv);
 *
 */
 private static class MethodInfo {
 private final Method method;
 private final MethodType type;
-private String methodHandleInstanceFieldName;
+private String methodHandleFieldName;
-private String methodHandleClassFieldName;
 private MethodInfo(final Class<?> clazz, final String name, final Class<?>... argTypes) throws NoSuchMethodException {
 this(clazz.getDeclaredMethod(name, argTypes));
 }
 @Override
 public int hashCode() {
 return getName().hashCode() ^ type.hashCode();
 }
-void setIsCanonical(final Set<String> usedFieldNames, boolean classOverride) {
+void setIsCanonical(final JavaAdapterBytecodeGenerator self) {
-methodHandleInstanceFieldName = nextName(usedFieldNames);
+methodHandleFieldName = self.nextName(getName());
-if(classOverride) {
+}
-methodHandleClassFieldName = nextName(usedFieldNames);
+}
-}
-}
+private String nextName(final String name) {
+int i = 0;
-String nextName(final Set<String> usedFieldNames) {
+String nextName = name;
-int i = 0;
+while (!usedFieldNames.add(nextName)) {
-final String name = getName();
+final String ordinal = String.valueOf(i++);
-String nextName = name;
+final int maxNameLen = 255 - ordinal.length();
-while (!usedFieldNames.add(nextName)) {
+nextName = (name.length() <= maxNameLen ? name : name.substring(0, maxNameLen)).concat(ordinal);
-final String ordinal = String.valueOf(i++);
+}
-final int maxNameLen = 255 - ordinal.length();
+return nextName;
-nextName = (name.length() <= maxNameLen ? name : name.substring(0, maxNameLen)).concat(ordinal);
-}
-return nextName;
-}
 }
 private void generateMethods() {
 for(final MethodInfo mi: methodInfos) {
 generateMethod(mi);
 final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(getAccessModifiers(method), name,
 methodDesc, null, exceptionNames));
 mv.visitCode();
-final Label instanceHandleDefined = new Label();
+final Label handleDefined = new Label();
-final Label classHandleDefined = new Label();
 final Type asmReturnType = Type.getType(type.returnType());
-// See if we have instance handle defined
+// See if we have overriding method handle defined
-mv.visitVarInsn(ALOAD, 0);
-mv.getfield(generatedClassName, mi.methodHandleInstanceFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
-// stack: [instanceHandle]
-jumpIfNonNullKeepOperand(mv, instanceHandleDefined);
 if(classOverride) {
-// See if we have the static handle
+mv.getstatic(generatedClassName, mi.methodHandleFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
-mv.getstatic(generatedClassName, mi.methodHandleClassFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
+} else {
-// stack: [classHandle]
+mv.visitVarInsn(ALOAD, 0);
-jumpIfNonNullKeepOperand(mv, classHandleDefined);
+mv.getfield(generatedClassName, mi.methodHandleFieldName, METHOD_HANDLE_TYPE_DESCRIPTOR);
 }
+// stack: [handle]
+jumpIfNonNullKeepOperand(mv, handleDefined);
 // No handle is available, fall back to default behavior
 if(Modifier.isAbstract(method.getModifiers())) {
 // If the super method is abstract, throw an exception
 mv.anew(UNSUPPORTED_OPERATION_TYPE);
 } else {
 // If the super method is not abstract, delegate to it.
 emitSuperCall(mv, name, methodDesc);
 }
+mv.visitLabel(handleDefined);
+// Load the creatingGlobal object
+if(classOverride) {
+// If class handle is defined, load the static defining global
+mv.getstatic(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
+} else {
+mv.visitVarInsn(ALOAD, 0);
+mv.getfield(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
+}
+// stack: [creatingGlobal, handle]
 final Label setupGlobal = new Label();
-if(classOverride) {
-mv.visitLabel(classHandleDefined);
-// If class handle is defined, load the static defining global
-mv.getstatic(generatedClassName, STATIC_GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
-// stack: [creatingGlobal := classGlobal, classHandle]
-mv.goTo(setupGlobal);
-}
-mv.visitLabel(instanceHandleDefined);
-// If instance handle is defined, load the instance defining global
-mv.visitVarInsn(ALOAD, 0);
-mv.getfield(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
-// stack: [creatingGlobal := instanceGlobal, instanceHandle]
-// fallthrough to setupGlobal
-// stack: [creatingGlobal, someHandle]
 mv.visitLabel(setupGlobal);
 // Determine the first index for a local variable
 int nextLocalVar = 1; // "this" is at 0
 for(final Type t: asmArgTypes) {
 // Set our local variable indices
 final int currentGlobalVar  = nextLocalVar++;
 final int globalsDifferVar  = nextLocalVar++;
 mv.dup();
-// stack: [creatingGlobal, creatingGlobal, someHandle]
+// stack: [creatingGlobal, creatingGlobal, handle]
 // Emit code for switching to the creating global
 // ScriptObject currentGlobal = Context.getGlobal();
 invokeGetGlobal(mv);
 mv.dup();
 mv.visitVarInsn(ASTORE, currentGlobalVar);
-// stack: [currentGlobal, creatingGlobal, creatingGlobal, someHandle]
+// stack: [currentGlobal, creatingGlobal, creatingGlobal, handle]
 // if(definingGlobal == currentGlobal) {
 final Label globalsDiffer = new Label();
 mv.ifacmpne(globalsDiffer);
-// stack: [someGlobal, someHandle]
+// stack: [creatingGlobal, handle]
 //     globalsDiffer = false
 mv.pop();
-// stack: [someHandle]
+// stack: [handle]
 mv.iconst(0); // false
-// stack: [false, someHandle]
+// stack: [false, handle]
 final Label invokeHandle = new Label();
 mv.goTo(invokeHandle);
 mv.visitLabel(globalsDiffer);
 // } else {
 //     Context.setGlobal(definingGlobal);
-// stack: [someGlobal, someHandle]
+// stack: [creatingGlobal, handle]
 invokeSetGlobal(mv);
-// stack: [someHandle]
+// stack: [handle]
 //     globalsDiffer = true
 mv.iconst(1);
-// stack: [true, someHandle]
+// stack: [true, handle]
 mv.visitLabel(invokeHandle);
 mv.visitVarInsn(ISTORE, globalsDifferVar);
-// stack: [someHandle]
+// stack: [handle]
 // Load all parameters back on stack for dynamic invocation.
 int varOffset = 1;
 for (final Type t : asmArgTypes) {
 mv.load(varOffset, t);
 }
 mv.invokespecial(superClassName, name, methodDesc);
 mv.areturn(methodType.getReturnType());
 }
+private void generateFinalizerMethods() {
+final String finalizerDelegateName = nextName("access$");
+generateFinalizerDelegate(finalizerDelegateName);
+generateFinalizerOverride(finalizerDelegateName);
+}
+private void generateFinalizerDelegate(final String finalizerDelegateName) {
+// 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,
+finalizerDelegateName, Type.getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE), null, null));
+// Simply invoke super.finalize()
+mv.visitVarInsn(ALOAD, 0);
+mv.checkcast(Type.getType(generatedClassName));
+mv.invokespecial(superClassName, "finalize", Type.getMethodDescriptor(Type.VOID_TYPE), false);
+mv.visitInsn(RETURN);
+endMethod(mv);
+}
+private void generateFinalizerOverride(final String finalizerDelegateName) {
+final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC, "finalize",
+VOID_NOARG_METHOD_DESCRIPTOR, null, null));
+// Overridden finalizer will take a MethodHandle to the finalizer delegating method, ...
+mv.aconst(new Handle(Opcodes.H_INVOKESTATIC, generatedClassName, finalizerDelegateName,
+Type.getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE)));
+mv.visitVarInsn(ALOAD, 0);
+// ...and invoke it through JavaAdapterServices.invokeNoPermissions
+mv.invokestatic(SERVICES_CLASS_TYPE_NAME, "invokeNoPermissions",
+Type.getMethodDescriptor(METHOD_HANDLE_TYPE, OBJECT_TYPE), false);
+mv.visitInsn(RETURN);
+endMethod(mv);
+}
 private static String[] getExceptionNames(final Class<?>[] exceptions) {
 final String[] exceptionNames = new String[exceptions.length];
 for (int i = 0; i < exceptions.length; ++i) {
 exceptionNames[i] = Type.getInternalName(exceptions[i]);
 }
 * the type if the type itself is public. If the type is a class, the method will recursively invoke itself for its
 * superclass and the interfaces it implements, and add further methods that were not directly declared on the
 * class.
 * @param type the type defining the methods.
 */
-private void gatherMethods(final Class<?> type) {
+private void gatherMethods(final Class<?> type) throws AdaptationException {
 if (Modifier.isPublic(type.getModifiers())) {
 final Method[] typeMethods = type.isInterface() ? type.getMethods() : type.getDeclaredMethods();
 for (final Method typeMethod: typeMethods) {
+final String name = typeMethod.getName();
+if(name.startsWith(SUPER_PREFIX)) {
+continue;
+}
 final int m = typeMethod.getModifiers();
 if (Modifier.isStatic(m)) {
 continue;
 }
 if (Modifier.isPublic(m) || Modifier.isProtected(m)) {
+// Is it a "finalize()"?
+if(name.equals("finalize") && typeMethod.getParameterCount() == 0) {
+if(type != Object.class) {
+hasExplicitFinalizer = true;
+if(Modifier.isFinal(m)) {
+// Must be able to override an explicit finalizer
+throw new AdaptationException(Outcome.ERROR_FINAL_FINALIZER, type.getCanonicalName());
+}
+}
+continue;
+}
 final MethodInfo mi = new MethodInfo(typeMethod);
 if (Modifier.isFinal(m) || isCallerSensitive(typeMethod)) {
 finalMethods.add(mi);
 } else if (!finalMethods.contains(mi) && methodInfos.add(mi)) {
 if (Modifier.isAbstract(m)) {
 abstractMethodNames.add(mi.getName());
 }
-mi.setIsCanonical(usedFieldNames, classOverride);
+mi.setIsCanonical(this);
 }
 }
 }
 }
 // If the type is a class, visit its superclasses and declared interfaces. If it's an interface, we're done.
 gatherMethods(itf);
 }
 }
 }
-private void gatherMethods(final List<Class<?>> classes) {
+private void gatherMethods(final List<Class<?>> classes) throws AdaptationException {
 for(final Class<?> c: classes) {
 gatherMethods(c);
 }
 }

Mercurial > jdk8-mips64-public > nashorn / file comparison

comparison: src/jdk/nashorn/internal/runtime/linker/JavaAdapterBytecodeGenerator.java

src/jdk/nashorn/internal/runtime/linker/JavaAdapterBytecodeGenerator.java