1 /*
   2  * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.lang.invoke;
  27 
  28 import java.io.FileOutputStream;
  29 import java.io.IOException;
  30 import java.lang.reflect.Method;
  31 import java.security.ProtectionDomain;
  32 import java.util.concurrent.atomic.AtomicInteger;
  33 import sun.util.logging.PlatformLogger;

  34 import jdk.internal.org.objectweb.asm.*;
  35 import static jdk.internal.org.objectweb.asm.Opcodes.*;
  36 import sun.misc.Unsafe;
  37 
  38 /**
  39  * InnerClassLambdaMetafactory
  40  */
  41 /*non-public*/ final class InnerClassLambdaMetafactory extends AbstractValidatingLambdaMetafactory {
  42     private static final int CLASSFILE_VERSION = 51;
  43     private static final Type TYPE_VOID = Type.getType(void.class);
  44     private static final String METHOD_DESCRIPTOR_VOID = Type.getMethodDescriptor(Type.VOID_TYPE);
  45     private static final String NAME_MAGIC_ACCESSOR_IMPL = "java/lang/invoke/MagicLambdaImpl";
  46     private static final String NAME_SERIALIZABLE = "java/io/Serializable";
  47     private static final String NAME_CTOR = "<init>";
  48 
  49     //Serialization support
  50     private static final String NAME_SERIALIZED_LAMBDA = "com/oracle/java/lang/invoke/SerializedLambdaImpl";
  51     private static final String DESCR_METHOD_WRITE_REPLACE = "()Ljava/lang/Object;";
  52     private static final String NAME_METHOD_WRITE_REPLACE = "writeReplace";
  53     private static final String NAME_OBJECT = "java/lang/Object";
  54 
  55     // Used to ensure that each spun class name is unique
  56     private static final AtomicInteger counter = new AtomicInteger(0);
  57 
  58     // See context values in AbstractValidatingLambdaMetafactory
  59     private final String implMethodClassName;        // Name of type containing implementation "CC"
  60     private final String implMethodName;             // Name of implementation method "impl"
  61     private final String implMethodDesc;             // Type descriptor for implementation methods "(I)Ljava/lang/String;"
  62     private final Type[] implMethodArgumentTypes;    // ASM types for implementaion method parameters
  63     private final Type implMethodReturnType;         // ASM type for implementaion method return type "Ljava/lang/String;"
  64     private final MethodType constructorType;        // Generated class constructor type "(CC)void"
  65     private final String constructorDesc;            // Type descriptor for constructor "(LCC;)V"
  66     private final ClassWriter cw;                    // ASM class writer
  67     private final Type[] argTypes;                   // ASM types for the constructor arguments
  68     private final String[] argNames;                 // Generated names for the constructor arguments
  69     private final String lambdaClassName;            // Generated name for the generated class "X$$Lambda$1"
  70     private final Type[] instantiatedArgumentTypes;  // ASM types for the functional interface arguments
  71 
  72     /**
  73      * Meta-factory constructor.
  74      *
  75      * @param caller Stacked automatically by VM; represents a lookup context with the accessibility privileges
  76      *               of the caller.
  77      * @param invokedType Stacked automatically by VM; the signature of the invoked method, which includes the
  78      *                    expected static type of the returned lambda object, and the static types of the captured
  79      *                    arguments for the lambda.  In the event that the implementation method is an instance method,
  80      *                    the first argument in the invocation signature will correspond to the receiver.
  81      * @param samMethod The primary method in the functional interface to which the lambda or method reference is
  82      *                  being converted, represented as a method handle.
  83      * @param implMethod The implementation method which should be called (with suitable adaptation of argument
  84      *                   types, return types, and adjustment for captured arguments) when methods of the resulting
  85      *                   functional interface instance are invoked.
  86      * @param instantiatedMethodType The signature of the SAM method from the functional interface's perspective
  87      * @throws ReflectiveOperationException
  88      */
  89     public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,
  90                                        MethodType invokedType,
  91                                        MethodHandle samMethod,
  92                                        MethodHandle implMethod,
  93                                        MethodType instantiatedMethodType)
  94             throws ReflectiveOperationException {
  95         super(caller, invokedType, samMethod, implMethod, instantiatedMethodType);
  96         implMethodClassName = implDefiningClass.getName().replace('.', '/');
  97         implMethodName = implInfo.getName();
  98         implMethodDesc = implMethodType.toMethodDescriptorString();
  99         Type implMethodAsmType = Type.getMethodType(implMethodDesc);
 100         implMethodArgumentTypes = implMethodAsmType.getArgumentTypes();
 101         implMethodReturnType = implMethodAsmType.getReturnType();
 102         constructorType = invokedType.changeReturnType(Void.TYPE);
 103         constructorDesc = constructorType.toMethodDescriptorString();
 104         lambdaClassName = targetClass.getName().replace('.', '/') + "$$Lambda$" + counter.incrementAndGet();
 105         cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
 106         argTypes = Type.getArgumentTypes(constructorDesc);
 107         argNames = new String[argTypes.length];
 108         for (int i = 0; i < argTypes.length; i++) {
 109             argNames[i] = "arg$" + (i + 1);
 110         }
 111         instantiatedArgumentTypes = Type.getArgumentTypes(instantiatedMethodType.toMethodDescriptorString());
 112 
 113     }
 114 
 115     /**
 116      * Build the CallSite. Generate a class file which implements the functional
 117      * interface, define the class, if there are no parameters create an instance
 118      * of the class which the CallSite will return, otherwise, generate handles
 119      * which will call the class' constructor.
 120      *
 121      * @return a CallSite, which, when invoked, will return an instance of the
 122      * functional interface
 123      * @throws ReflectiveOperationException
 124      */
 125     @Override
 126     CallSite buildCallSite() throws ReflectiveOperationException, LambdaConversionException {
 127         final Class<?> innerClass = spinInnerClass();
 128         if (invokedType.parameterCount() == 0) {
 129             return new ConstantCallSite(MethodHandles.constant(samBase, innerClass.newInstance()));
 130         } else {
 131             return new ConstantCallSite(
 132                     MethodHandles.Lookup.IMPL_LOOKUP
 133                     .findConstructor(innerClass, constructorType)
 134                     .asType(constructorType.changeReturnType(samBase)));
 135         }
 136     }
 137 
 138     /**
 139      * Generate a class file which implements the functional
 140      * interface, define and return the class.
 141      *
 142      * @return a Class which implements the functional interface
 143      */
 144     private <T> Class<? extends T> spinInnerClass() throws LambdaConversionException {
 145         String samName = samBase.getName().replace('.', '/');
 146 
 147         cw.visit(CLASSFILE_VERSION, ACC_PUBLIC + ACC_SUPER, lambdaClassName, null, NAME_MAGIC_ACCESSOR_IMPL,
 148                  isSerializable ? new String[]{samName, NAME_SERIALIZABLE} : new String[]{samName});
 149 
 150         // Generate final fields to be filled in by constructor
 151         for (int i = 0; i < argTypes.length; i++) {
 152             FieldVisitor fv = cw.visitField(ACC_PRIVATE + ACC_FINAL, argNames[i], argTypes[i].getDescriptor(), null, null);
 153             fv.visitEnd();
 154         }
 155 
 156         generateConstructor();
 157 
 158         MethodAnalyzer ma = new MethodAnalyzer();
 159 
 160         // Forward the SAM method
 161         if (ma.getSamMethod() == null) {
 162             throw new LambdaConversionException(String.format("SAM method not found: %s", samMethodType));
 163         } else {
 164             generateForwardingMethod(ma.getSamMethod(), false);
 165         }
 166 
 167         // Forward the bridges
 168         // @@@ Once the VM can do fail-over, uncomment the default method test
 169         if (!ma.getMethodsToBridge().isEmpty() /* && !ma.wasDefaultMethodFound() */) {
 170             for (Method m : ma.getMethodsToBridge()) {
 171                 generateForwardingMethod(m, true);
 172             }
 173         }
 174 
 175         /***** Serialization not yet supported
 176         if (isSerializable) {
 177             String samMethodName = samInfo.getName();
 178             Type samType = Type.getType(samBase);
 179             generateSerializationMethod(samType, samMethodName);
 180         }
 181         ******/
 182 
 183         cw.visitEnd();
 184 
 185         // Define the generated class in this VM.
 186 
 187         final byte[] classBytes = cw.toByteArray();
 188 
 189         if (System.getProperty("debug.dump.generated") != null) {
 190             System.out.printf("Loaded: %s (%d bytes) %n", lambdaClassName, classBytes.length);
 191             try (FileOutputStream fos = new FileOutputStream(lambdaClassName.replace('/', '.') + ".class")) {
 192                 fos.write(classBytes);
 193             } catch (IOException ex) {
 194                 PlatformLogger.getLogger(InnerClassLambdaMetafactory.class.getName()).severe(ex.getMessage(), ex);
 195             }
 196         }
 197 
 198         ClassLoader loader = targetClass.getClassLoader();
 199         ProtectionDomain pd = (loader == null) ? null : targetClass.getProtectionDomain();
 200         return (Class<? extends T>) Unsafe.getUnsafe().defineClass(lambdaClassName, classBytes, 0, classBytes.length, loader, pd);
 201     }
 202 
 203     /**
 204      * Generate the constructor for the class
 205      */
 206     private void generateConstructor() {
 207         // Generate constructor
 208         MethodVisitor ctor = cw.visitMethod(ACC_PUBLIC, NAME_CTOR, constructorDesc, null, null);
 209         ctor.visitCode();
 210         ctor.visitVarInsn(ALOAD, 0);
 211         ctor.visitMethodInsn(INVOKESPECIAL, NAME_MAGIC_ACCESSOR_IMPL, NAME_CTOR, METHOD_DESCRIPTOR_VOID);
 212         int lvIndex = 0;
 213         for (int i = 0; i < argTypes.length; i++) {
 214             ctor.visitVarInsn(ALOAD, 0);
 215             ctor.visitVarInsn(argTypes[i].getOpcode(ILOAD), lvIndex + 1);
 216             lvIndex += argTypes[i].getSize();
 217             ctor.visitFieldInsn(PUTFIELD, lambdaClassName, argNames[i], argTypes[i].getDescriptor());
 218         }
 219         ctor.visitInsn(RETURN);
 220         ctor.visitMaxs(-1, -1); // Maxs computed by ClassWriter.COMPUTE_MAXS, these arguments ignored
 221         ctor.visitEnd();
 222     }
 223 
 224     /**
 225      * Generate the serialization method (if needed)
 226      */
 227     /****** This code is out of date -- known to be wrong -- and not currently used ******
 228     private void generateSerializationMethod(Type samType, String samMethodName) {
 229         String samMethodDesc = samMethodType.toMethodDescriptorString();
 230         TypeConvertingMethodAdapter mv = new TypeConvertingMethodAdapter(cw.visitMethod(ACC_PRIVATE + ACC_FINAL, NAME_METHOD_WRITE_REPLACE, DESCR_METHOD_WRITE_REPLACE, null, null));
 231 
 232         mv.visitCode();
 233         mv.visitTypeInsn(NEW, NAME_SERIALIZED_LAMBDA);
 234         mv.dup();
 235         mv.visitLdcInsn(samType);
 236         mv.visitLdcInsn(samMethodName);
 237         mv.visitLdcInsn(samMethodDesc);
 238         mv.visitLdcInsn(Type.getType(implDefiningClass));
 239         mv.visitLdcInsn(implMethodName);
 240         mv.visitLdcInsn(implMethodDesc);
 241 
 242         mv.iconst(argTypes.length);
 243         mv.visitTypeInsn(ANEWARRAY, NAME_OBJECT);
 244         for (int i = 0; i < argTypes.length; i++) {
 245             mv.dup();
 246             mv.iconst(i);
 247             mv.visitVarInsn(ALOAD, 0);
 248             mv.getfield(lambdaClassName, argNames[i], argTypes[i].getDescriptor());
 249             mv.boxIfPrimitive(argTypes[i]);
 250             mv.visitInsn(AASTORE);
 251         }
 252         mv.invokespecial(NAME_SERIALIZED_LAMBDA, NAME_CTOR,
 253                            "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V");
 254         mv.visitInsn(ARETURN);
 255         mv.visitMaxs(-1, -1); // Maxs computed by ClassWriter.COMPUTE_MAXS, these arguments ignored
 256         mv.visitEnd();
 257     }
 258     ********/
 259 
 260     /**
 261      * Generate a method which calls the lambda implementation method,
 262      * converting arguments, as needed.
 263      * @param m The method whose signature should be generated
 264      * @param isBridge True if this methods should be flagged as a bridge
 265      */
 266     private void generateForwardingMethod(Method m, boolean isBridge) {
 267         Class<?>[] exceptionTypes = m.getExceptionTypes();
 268         String[] exceptionNames = new String[exceptionTypes.length];
 269         for (int i = 0; i < exceptionTypes.length; i++) {
 270             exceptionNames[i] = exceptionTypes[i].getName().replace('.', '/');
 271         }
 272         String methodDescriptor = Type.getMethodDescriptor(m);
 273         int access = isBridge? ACC_PUBLIC | ACC_BRIDGE : ACC_PUBLIC;
 274         MethodVisitor mv = cw.visitMethod(access, m.getName(), methodDescriptor, null, exceptionNames);
 275         new ForwardingMethodGenerator(mv).generate(m);
 276     }
 277 
 278     /**
 279      * This class generates a method body which calls the lambda implementation
 280      * method, converting arguments, as needed.
 281      */
 282     private class ForwardingMethodGenerator extends TypeConvertingMethodAdapter {
 283 
 284         ForwardingMethodGenerator(MethodVisitor mv) {
 285             super(mv);
 286         }
 287 
 288         void generate(Method m) throws InternalError {
 289             visitCode();
 290 
 291             if (implKind == MethodHandleInfo.REF_newInvokeSpecial) {
 292                 visitTypeInsn(NEW, implMethodClassName);
 293                 dup();
 294             }
 295             for (int i = 0; i < argTypes.length; i++) {
 296                 visitVarInsn(ALOAD, 0);
 297                 getfield(lambdaClassName, argNames[i], argTypes[i].getDescriptor());
 298             }
 299 
 300             convertArgumentTypes(Type.getArgumentTypes(m));
 301 
 302             // Invoke the method we want to forward to
 303             visitMethodInsn(invocationOpcode(), implMethodClassName, implMethodName, implMethodDesc);
 304 
 305             // Convert the return value (if any) and return it
 306             // Note: if adapting from non-void to void, the 'return' instruction will pop the unneeded result
 307             Type samReturnType = Type.getReturnType(m);
 308             convertType(implMethodReturnType, samReturnType, samReturnType);
 309             areturn(samReturnType);
 310 
 311             visitMaxs(-1, -1); // Maxs computed by ClassWriter.COMPUTE_MAXS, these arguments ignored
 312             visitEnd();
 313         }
 314 
 315         private void convertArgumentTypes(Type[] samArgumentTypes) {
 316             int lvIndex = 0;
 317             boolean samIncludesReceiver = implIsInstanceMethod && argTypes.length == 0;
 318             int samReceiverLength = samIncludesReceiver ? 1 : 0;
 319             if (samIncludesReceiver) {
 320                 // push receiver
 321                 Type rcvrType = samArgumentTypes[0];
 322                 Type instantiatedRcvrType = instantiatedArgumentTypes[0];
 323 
 324                 load(lvIndex + 1, rcvrType);
 325                 lvIndex += rcvrType.getSize();
 326                 convertType(rcvrType, Type.getType(implDefiningClass), instantiatedRcvrType);
 327             }
 328             int argOffset = implMethodArgumentTypes.length - samArgumentTypes.length;
 329             for (int i = samReceiverLength; i < samArgumentTypes.length; i++) {
 330                 Type argType = samArgumentTypes[i];
 331                 Type targetType = implMethodArgumentTypes[argOffset + i];
 332                 Type instantiatedArgType = instantiatedArgumentTypes[i];
 333 
 334                 load(lvIndex + 1, argType);
 335                 lvIndex += argType.getSize();
 336                 convertType(argType, targetType, instantiatedArgType);
 337             }
 338         }
 339 
 340         private void convertType(Type argType, Type targetType, Type functionalType) {
 341             convertType(argType.getDescriptor(), targetType.getDescriptor(), functionalType.getDescriptor());
 342         }
 343 
 344         private int invocationOpcode() throws InternalError {
 345             switch (implKind) {
 346                 case MethodHandleInfo.REF_invokeStatic:
 347                     return INVOKESTATIC;
 348                 case MethodHandleInfo.REF_newInvokeSpecial:
 349                     return INVOKESPECIAL;
 350                  case MethodHandleInfo.REF_invokeVirtual:
 351                     return INVOKEVIRTUAL;
 352                 case MethodHandleInfo.REF_invokeInterface:
 353                     return INVOKEINTERFACE;
 354                 case MethodHandleInfo.REF_invokeSpecial:
 355                     return INVOKESPECIAL;
 356                 default:
 357                     throw new InternalError("Unexpected invocation kind: " + implKind);
 358             }
 359         }
 360 
 361         /**
 362          * The following methods are copied from
 363          * org.objectweb.asm.commons.InstructionAdapter. Part of ASM: a very
 364          * small and fast Java bytecode manipulation framework. Copyright (c)
 365          * 2000-2005 INRIA, France Telecom All rights reserved.
 366          *
 367          * Subclass with that (removing these methods) if that package/class is
 368          * ever added to the JDK.
 369          */
 370         private void iconst(final int cst) {
 371             if (cst >= -1 && cst <= 5) {
 372                 mv.visitInsn(Opcodes.ICONST_0 + cst);
 373             } else if (cst >= Byte.MIN_VALUE && cst <= Byte.MAX_VALUE) {
 374                 mv.visitIntInsn(Opcodes.BIPUSH, cst);
 375             } else if (cst >= Short.MIN_VALUE && cst <= Short.MAX_VALUE) {
 376                 mv.visitIntInsn(Opcodes.SIPUSH, cst);
 377             } else {
 378                 mv.visitLdcInsn(cst);
 379             }
 380         }
 381 
 382         private void load(final int var, final Type type) {
 383             mv.visitVarInsn(type.getOpcode(Opcodes.ILOAD), var);
 384         }
 385 
 386         private void dup() {
 387             mv.visitInsn(Opcodes.DUP);
 388         }
 389 
 390         private void areturn(final Type t) {
 391             mv.visitInsn(t.getOpcode(Opcodes.IRETURN));
 392         }
 393 
 394         private void getfield(
 395                 final String owner,
 396                 final String name,
 397                 final String desc) {
 398             mv.visitFieldInsn(Opcodes.GETFIELD, owner, name, desc);
 399         }
 400     }
 401 }
--- EOF ---