1 /*
2 * Copyright (c) 2012, 2021, 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 jdk.internal.misc.CDS;
29 import jdk.internal.org.objectweb.asm.*;
30 import sun.invoke.util.BytecodeDescriptor;
31 import sun.invoke.util.VerifyAccess;
32 import sun.security.action.GetPropertyAction;
33 import sun.security.action.GetBooleanAction;
34
35 import java.io.FilePermission;
36 import java.io.Serializable;
37 import java.lang.constant.ConstantDescs;
38 import java.lang.invoke.MethodHandles.Lookup;
39 import java.lang.reflect.Modifier;
40 import java.security.AccessController;
41 import java.security.PrivilegedAction;
42 import java.util.HashSet;
43 import java.util.LinkedHashSet;
44 import java.util.concurrent.atomic.AtomicInteger;
45 import java.util.PropertyPermission;
46 import java.util.Set;
47
48 import static java.lang.invoke.MethodHandleStatics.CLASSFILE_VERSION;
49 import static java.lang.invoke.MethodHandles.Lookup.ClassOption.NESTMATE;
50 import static java.lang.invoke.MethodHandles.Lookup.ClassOption.STRONG;
51 import static java.lang.invoke.MethodType.methodType;
52 import static jdk.internal.org.objectweb.asm.Opcodes.*;
53
54 /**
55 * Lambda metafactory implementation which dynamically creates an
56 * inner-class-like class per lambda callsite.
57 *
58 * @see LambdaMetafactory
59 */
60 /* package */ final class InnerClassLambdaMetafactory extends AbstractValidatingLambdaMetafactory {
61 private static final String METHOD_DESCRIPTOR_VOID = Type.getMethodDescriptor(Type.VOID_TYPE);
62 private static final String JAVA_LANG_OBJECT = "java/lang/Object";
63 private static final String NAME_CTOR = "<init>";
64 private static final String LAMBDA_INSTANCE_FIELD = "LAMBDA_INSTANCE$";
65
66 //Serialization support
67 private static final String NAME_SERIALIZED_LAMBDA = "java/lang/invoke/SerializedLambda";
68 private static final String NAME_NOT_SERIALIZABLE_EXCEPTION = "java/io/NotSerializableException";
69 private static final String DESCR_METHOD_WRITE_REPLACE = "()Ljava/lang/Object;";
70 private static final String DESCR_METHOD_WRITE_OBJECT = "(Ljava/io/ObjectOutputStream;)V";
71 private static final String DESCR_METHOD_READ_OBJECT = "(Ljava/io/ObjectInputStream;)V";
72
73 private static final String NAME_METHOD_WRITE_REPLACE = "writeReplace";
74 private static final String NAME_METHOD_READ_OBJECT = "readObject";
75 private static final String NAME_METHOD_WRITE_OBJECT = "writeObject";
76
77 private static final String DESCR_CLASS = "Ljava/lang/Class;";
78 private static final String DESCR_STRING = "Ljava/lang/String;";
79 private static final String DESCR_OBJECT = "Ljava/lang/Object;";
80 private static final String DESCR_CTOR_SERIALIZED_LAMBDA
81 = "(" + DESCR_CLASS + DESCR_STRING + DESCR_STRING + DESCR_STRING + "I"
82 + DESCR_STRING + DESCR_STRING + DESCR_STRING + DESCR_STRING + "[" + DESCR_OBJECT + ")V";
83
84 private static final String DESCR_CTOR_NOT_SERIALIZABLE_EXCEPTION = "(Ljava/lang/String;)V";
85 private static final String[] SER_HOSTILE_EXCEPTIONS = new String[] {NAME_NOT_SERIALIZABLE_EXCEPTION};
86
87 private static final String[] EMPTY_STRING_ARRAY = new String[0];
88
89 // Used to ensure that each spun class name is unique
90 private static final AtomicInteger counter = new AtomicInteger();
91
92 // For dumping generated classes to disk, for debugging purposes
93 private static final ProxyClassesDumper dumper;
94
95 private static final boolean disableEagerInitialization;
96
97 // condy to load implMethod from class data
98 private static final ConstantDynamic implMethodCondy;
99
100 static {
101 final String dumpProxyClassesKey = "jdk.internal.lambda.dumpProxyClasses";
102 String dumpPath = GetPropertyAction.privilegedGetProperty(dumpProxyClassesKey);
103 dumper = (null == dumpPath) ? null : ProxyClassesDumper.getInstance(dumpPath);
104
105 final String disableEagerInitializationKey = "jdk.internal.lambda.disableEagerInitialization";
106 disableEagerInitialization = GetBooleanAction.privilegedGetProperty(disableEagerInitializationKey);
107
108 // condy to load implMethod from class data
109 MethodType classDataMType = methodType(Object.class, MethodHandles.Lookup.class, String.class, Class.class);
110 Handle classDataBsm = new Handle(H_INVOKESTATIC, Type.getInternalName(MethodHandles.class), "classData",
111 classDataMType.descriptorString(), false);
112 implMethodCondy = new ConstantDynamic(ConstantDescs.DEFAULT_NAME, MethodHandle.class.descriptorString(), classDataBsm);
113 }
114
115 // See context values in AbstractValidatingLambdaMetafactory
116 private final String implMethodClassName; // Name of type containing implementation "CC"
117 private final String implMethodName; // Name of implementation method "impl"
118 private final String implMethodDesc; // Type descriptor for implementation methods "(I)Ljava/lang/String;"
119 private final MethodType constructorType; // Generated class constructor type "(CC)void"
120 private final ClassWriter cw; // ASM class writer
121 private final String[] argNames; // Generated names for the constructor arguments
122 private final String[] argDescs; // Type descriptors for the constructor arguments
123 private final String lambdaClassName; // Generated name for the generated class "X$$Lambda$1"
124 private final boolean useImplMethodHandle; // use MethodHandle invocation instead of symbolic bytecode invocation
125
126 /**
127 * General meta-factory constructor, supporting both standard cases and
128 * allowing for uncommon options such as serialization or bridging.
129 *
130 * @param caller Stacked automatically by VM; represents a lookup context
131 * with the accessibility privileges of the caller.
132 * @param factoryType Stacked automatically by VM; the signature of the
133 * invoked method, which includes the expected static
134 * type of the returned lambda object, and the static
135 * types of the captured arguments for the lambda. In
136 * the event that the implementation method is an
137 * instance method, the first argument in the invocation
138 * signature will correspond to the receiver.
139 * @param interfaceMethodName Name of the method in the functional interface to
140 * which the lambda or method reference is being
141 * converted, represented as a String.
142 * @param interfaceMethodType Type of the method in the functional interface to
143 * which the lambda or method reference is being
144 * converted, represented as a MethodType.
145 * @param implementation The implementation method which should be called (with
146 * suitable adaptation of argument types, return types,
147 * and adjustment for captured arguments) when methods of
148 * the resulting functional interface instance are invoked.
149 * @param dynamicMethodType The signature of the primary functional
150 * interface method after type variables are
151 * substituted with their instantiation from
152 * the capture site
153 * @param isSerializable Should the lambda be made serializable? If set,
154 * either the target type or one of the additional SAM
155 * types must extend {@code Serializable}.
156 * @param altInterfaces Additional interfaces which the lambda object
157 * should implement.
158 * @param altMethods Method types for additional signatures to be
159 * implemented by invoking the implementation method
160 * @throws LambdaConversionException If any of the meta-factory protocol
161 * invariants are violated
162 * @throws SecurityException If a security manager is present, and it
163 * <a href="MethodHandles.Lookup.html#secmgr">denies access</a>
164 * from {@code caller} to the package of {@code implementation}.
165 */
166 public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,
167 MethodType factoryType,
168 String interfaceMethodName,
169 MethodType interfaceMethodType,
170 MethodHandle implementation,
171 MethodType dynamicMethodType,
172 boolean isSerializable,
173 Class<?>[] altInterfaces,
174 MethodType[] altMethods)
175 throws LambdaConversionException {
176 super(caller, factoryType, interfaceMethodName, interfaceMethodType,
177 implementation, dynamicMethodType,
178 isSerializable, altInterfaces, altMethods);
179 implMethodClassName = implClass.getName().replace('.', '/');
180 implMethodName = implInfo.getName();
181 implMethodDesc = implInfo.getMethodType().toMethodDescriptorString();
182 constructorType = factoryType.changeReturnType(Void.TYPE);
183 lambdaClassName = lambdaClassName(targetClass);
184 // If the target class invokes a protected method inherited from a
185 // superclass in a different package, or does 'invokespecial', the
186 // lambda class has no access to the resolved method. Instead, we need
187 // to pass the live implementation method handle to the proxy class
188 // to invoke directly. (javac prefers to avoid this situation by
189 // generating bridges in the target class)
190 useImplMethodHandle = (Modifier.isProtected(implInfo.getModifiers()) &&
191 !VerifyAccess.isSamePackage(targetClass, implInfo.getDeclaringClass())) ||
192 implKind == H_INVOKESPECIAL;
193 cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
194 int parameterCount = factoryType.parameterCount();
195 if (parameterCount > 0) {
196 argNames = new String[parameterCount];
197 argDescs = new String[parameterCount];
198 for (int i = 0; i < parameterCount; i++) {
199 argNames[i] = "arg$" + (i + 1);
200 argDescs[i] = BytecodeDescriptor.unparse(factoryType.parameterType(i));
201 }
202 } else {
203 argNames = argDescs = EMPTY_STRING_ARRAY;
204 }
205 }
206
207 private static String lambdaClassName(Class<?> targetClass) {
208 String name = targetClass.getName();
209 if (targetClass.isHidden()) {
210 // use the original class name
211 name = name.replace('/', '_');
212 }
213 return name.replace('.', '/') + "$$Lambda$" + counter.incrementAndGet();
214 }
215
216 /**
217 * Build the CallSite. Generate a class file which implements the functional
218 * interface, define the class, if there are no parameters create an instance
219 * of the class which the CallSite will return, otherwise, generate handles
220 * which will call the class' constructor.
221 *
222 * @return a CallSite, which, when invoked, will return an instance of the
223 * functional interface
224 * @throws LambdaConversionException If properly formed functional interface
225 * is not found
226 */
227 @Override
228 CallSite buildCallSite() throws LambdaConversionException {
229 final Class<?> innerClass = spinInnerClass();
230 if (factoryType.parameterCount() == 0 && disableEagerInitialization) {
231 try {
232 return new ConstantCallSite(caller.findStaticGetter(innerClass, LAMBDA_INSTANCE_FIELD,
233 factoryType.returnType()));
234 } catch (ReflectiveOperationException e) {
235 throw new LambdaConversionException(
236 "Exception finding " + LAMBDA_INSTANCE_FIELD + " static field", e);
237 }
238 } else {
239 try {
240 MethodHandle mh = caller.findConstructor(innerClass, constructorType);
241 if (factoryType.parameterCount() == 0) {
242 // In the case of a non-capturing lambda, we optimize linkage by pre-computing a single instance
243 Object inst = mh.asType(methodType(Object.class)).invokeExact();
244 return new ConstantCallSite(MethodHandles.constant(interfaceClass, inst));
245 } else {
246 return new ConstantCallSite(mh.asType(factoryType));
247 }
248 } catch (ReflectiveOperationException e) {
249 throw new LambdaConversionException("Exception finding constructor", e);
250 } catch (Throwable e) {
251 throw new LambdaConversionException("Exception instantiating lambda object", e);
252 }
253 }
254 }
255
256 /**
257 * Spins the lambda proxy class.
258 *
259 * This first checks if a lambda proxy class can be loaded from CDS archive.
260 * Otherwise, generate the lambda proxy class. If CDS dumping is enabled, it
261 * registers the lambda proxy class for including into the CDS archive.
262 */
263 private Class<?> spinInnerClass() throws LambdaConversionException {
264 // CDS does not handle disableEagerInitialization.
265 if (!disableEagerInitialization) {
266 // include lambda proxy class in CDS archive at dump time
267 if (CDS.isDumpingArchive()) {
268 Class<?> innerClass = generateInnerClass();
269 LambdaProxyClassArchive.register(targetClass,
270 interfaceMethodName,
271 factoryType,
272 interfaceMethodType,
273 implementation,
274 dynamicMethodType,
275 isSerializable,
276 altInterfaces,
277 altMethods,
278 innerClass);
279 return innerClass;
280 }
281
282 // load from CDS archive if present
283 Class<?> innerClass = LambdaProxyClassArchive.find(targetClass,
284 interfaceMethodName,
285 factoryType,
286 interfaceMethodType,
287 implementation,
288 dynamicMethodType,
289 isSerializable,
290 altInterfaces,
291 altMethods);
292 if (innerClass != null) return innerClass;
293 }
294 return generateInnerClass();
295 }
296
297 /**
298 * Generate a class file which implements the functional
299 * interface, define and return the class.
300 *
301 * @return a Class which implements the functional interface
302 * @throws LambdaConversionException If properly formed functional interface
303 * is not found
304 */
305 @SuppressWarnings("removal")
306 private Class<?> generateInnerClass() throws LambdaConversionException {
307 String[] interfaceNames;
308 String interfaceName = interfaceClass.getName().replace('.', '/');
309 boolean accidentallySerializable = !isSerializable && Serializable.class.isAssignableFrom(interfaceClass);
310 if (altInterfaces.length == 0) {
311 interfaceNames = new String[]{interfaceName};
312 } else {
313 // Assure no duplicate interfaces (ClassFormatError)
314 Set<String> itfs = new LinkedHashSet<>(altInterfaces.length + 1);
315 itfs.add(interfaceName);
316 for (Class<?> i : altInterfaces) {
317 itfs.add(i.getName().replace('.', '/'));
318 accidentallySerializable |= !isSerializable && Serializable.class.isAssignableFrom(i);
319 }
320 interfaceNames = itfs.toArray(new String[itfs.size()]);
321 }
322
323 cw.visit(CLASSFILE_VERSION, ACC_SUPER + ACC_FINAL + ACC_SYNTHETIC,
324 lambdaClassName, null,
325 JAVA_LANG_OBJECT, interfaceNames);
326
327 // Generate final fields to be filled in by constructor
328 for (int i = 0; i < argDescs.length; i++) {
329 FieldVisitor fv = cw.visitField(ACC_PRIVATE + ACC_FINAL,
330 argNames[i],
331 argDescs[i],
332 null, null);
333 fv.visitEnd();
334 }
335
336 generateConstructor();
337
338 if (factoryType.parameterCount() == 0 && disableEagerInitialization) {
339 generateClassInitializer();
340 }
341
342 // Forward the SAM method
343 MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, interfaceMethodName,
344 interfaceMethodType.toMethodDescriptorString(), null, null);
345 new ForwardingMethodGenerator(mv).generate(interfaceMethodType);
346
347 // Forward the altMethods
348 if (altMethods != null) {
349 for (MethodType mt : altMethods) {
350 mv = cw.visitMethod(ACC_PUBLIC, interfaceMethodName,
351 mt.toMethodDescriptorString(), null, null);
352 new ForwardingMethodGenerator(mv).generate(mt);
353 }
354 }
355
356 if (isSerializable)
357 generateSerializationFriendlyMethods();
358 else if (accidentallySerializable)
359 generateSerializationHostileMethods();
360
361 // generate Preload attribute if it references any value class
362 PreloadAttributeBuilder builder = new PreloadAttributeBuilder(targetClass);
363 builder.add(factoryType)
364 .add(interfaceMethodType)
365 .add(implMethodType)
366 .add(dynamicMethodType)
367 .add(altMethods);
368 if (!builder.isEmpty())
369 cw.visitAttribute(builder.build());
370
371 cw.visitEnd();
372
373 // Define the generated class in this VM.
374
375 final byte[] classBytes = cw.toByteArray();
376 // If requested, dump out to a file for debugging purposes
377 if (dumper != null) {
378 AccessController.doPrivileged(new PrivilegedAction<>() {
379 @Override
380 public Void run() {
381 dumper.dumpClass(lambdaClassName, classBytes);
382 return null;
383 }
384 }, null,
385 new FilePermission("<<ALL FILES>>", "read, write"),
386 // createDirectories may need it
387 new PropertyPermission("user.dir", "read"));
388 }
389 try {
390 // this class is linked at the indy callsite; so define a hidden nestmate
391 Lookup lookup;
392 if (useImplMethodHandle) {
393 lookup = caller.defineHiddenClassWithClassData(classBytes, implementation, !disableEagerInitialization,
394 NESTMATE, STRONG);
395 } else {
396 lookup = caller.defineHiddenClass(classBytes, !disableEagerInitialization, NESTMATE, STRONG);
397 }
398 return lookup.lookupClass();
399 } catch (IllegalAccessException e) {
400 throw new LambdaConversionException("Exception defining lambda proxy class", e);
401 } catch (Throwable t) {
402 throw new InternalError(t);
403 }
404 }
405
406 /**
407 * Generate a static field and a static initializer that sets this field to an instance of the lambda
408 */
409 private void generateClassInitializer() {
410 String lambdaTypeDescriptor = factoryType.returnType().descriptorString();
411
412 // Generate the static final field that holds the lambda singleton
413 FieldVisitor fv = cw.visitField(ACC_PRIVATE | ACC_STATIC | ACC_FINAL,
414 LAMBDA_INSTANCE_FIELD, lambdaTypeDescriptor, null, null);
415 fv.visitEnd();
416
417 // Instantiate the lambda and store it to the static final field
418 MethodVisitor clinit = cw.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
419 clinit.visitCode();
420
421 clinit.visitTypeInsn(NEW, lambdaClassName);
422 clinit.visitInsn(Opcodes.DUP);
423 assert factoryType.parameterCount() == 0;
424 clinit.visitMethodInsn(INVOKESPECIAL, lambdaClassName, NAME_CTOR, constructorType.toMethodDescriptorString(), false);
425 clinit.visitFieldInsn(PUTSTATIC, lambdaClassName, LAMBDA_INSTANCE_FIELD, lambdaTypeDescriptor);
426
427 clinit.visitInsn(RETURN);
428 clinit.visitMaxs(-1, -1);
429 clinit.visitEnd();
430 }
431
432 /**
433 * Generate the constructor for the class
434 */
435 private void generateConstructor() {
436 // Generate constructor
437 MethodVisitor ctor = cw.visitMethod(ACC_PRIVATE, NAME_CTOR,
438 constructorType.toMethodDescriptorString(), null, null);
439 ctor.visitCode();
440 ctor.visitVarInsn(ALOAD, 0);
441 ctor.visitMethodInsn(INVOKESPECIAL, JAVA_LANG_OBJECT, NAME_CTOR,
442 METHOD_DESCRIPTOR_VOID, false);
443 int parameterCount = factoryType.parameterCount();
444 for (int i = 0, lvIndex = 0; i < parameterCount; i++) {
445 ctor.visitVarInsn(ALOAD, 0);
446 Class<?> argType = factoryType.parameterType(i);
447 ctor.visitVarInsn(getLoadOpcode(argType), lvIndex + 1);
448 lvIndex += getParameterSize(argType);
449 ctor.visitFieldInsn(PUTFIELD, lambdaClassName, argNames[i], argDescs[i]);
450 }
451 ctor.visitInsn(RETURN);
452 // Maxs computed by ClassWriter.COMPUTE_MAXS, these arguments ignored
453 ctor.visitMaxs(-1, -1);
454 ctor.visitEnd();
455 }
456
457 /**
458 * Generate a writeReplace method that supports serialization
459 */
460 private void generateSerializationFriendlyMethods() {
461 TypeConvertingMethodAdapter mv
462 = new TypeConvertingMethodAdapter(
463 cw.visitMethod(ACC_PRIVATE + ACC_FINAL,
464 NAME_METHOD_WRITE_REPLACE, DESCR_METHOD_WRITE_REPLACE,
465 null, null));
466
467 mv.visitCode();
468 mv.visitTypeInsn(NEW, NAME_SERIALIZED_LAMBDA);
469 mv.visitInsn(DUP);
470 mv.visitLdcInsn(Type.getType(targetClass));
471 mv.visitLdcInsn(factoryType.returnType().getName().replace('.', '/'));
472 mv.visitLdcInsn(interfaceMethodName);
473 mv.visitLdcInsn(interfaceMethodType.toMethodDescriptorString());
474 mv.visitLdcInsn(implInfo.getReferenceKind());
475 mv.visitLdcInsn(implInfo.getDeclaringClass().getName().replace('.', '/'));
476 mv.visitLdcInsn(implInfo.getName());
477 mv.visitLdcInsn(implInfo.getMethodType().toMethodDescriptorString());
478 mv.visitLdcInsn(dynamicMethodType.toMethodDescriptorString());
479 mv.iconst(argDescs.length);
480 mv.visitTypeInsn(ANEWARRAY, JAVA_LANG_OBJECT);
481 for (int i = 0; i < argDescs.length; i++) {
482 mv.visitInsn(DUP);
483 mv.iconst(i);
484 mv.visitVarInsn(ALOAD, 0);
485 mv.visitFieldInsn(GETFIELD, lambdaClassName, argNames[i], argDescs[i]);
486 mv.boxIfTypePrimitive(Type.getType(argDescs[i]));
487 mv.visitInsn(AASTORE);
488 }
489 mv.visitMethodInsn(INVOKESPECIAL, NAME_SERIALIZED_LAMBDA, NAME_CTOR,
490 DESCR_CTOR_SERIALIZED_LAMBDA, false);
491 mv.visitInsn(ARETURN);
492 // Maxs computed by ClassWriter.COMPUTE_MAXS, these arguments ignored
493 mv.visitMaxs(-1, -1);
494 mv.visitEnd();
495 }
496
497 /**
498 * Generate a readObject/writeObject method that is hostile to serialization
499 */
500 private void generateSerializationHostileMethods() {
501 MethodVisitor mv = cw.visitMethod(ACC_PRIVATE + ACC_FINAL,
502 NAME_METHOD_WRITE_OBJECT, DESCR_METHOD_WRITE_OBJECT,
503 null, SER_HOSTILE_EXCEPTIONS);
504 mv.visitCode();
505 mv.visitTypeInsn(NEW, NAME_NOT_SERIALIZABLE_EXCEPTION);
506 mv.visitInsn(DUP);
507 mv.visitLdcInsn("Non-serializable lambda");
508 mv.visitMethodInsn(INVOKESPECIAL, NAME_NOT_SERIALIZABLE_EXCEPTION, NAME_CTOR,
509 DESCR_CTOR_NOT_SERIALIZABLE_EXCEPTION, false);
510 mv.visitInsn(ATHROW);
511 mv.visitMaxs(-1, -1);
512 mv.visitEnd();
513
514 mv = cw.visitMethod(ACC_PRIVATE + ACC_FINAL,
515 NAME_METHOD_READ_OBJECT, DESCR_METHOD_READ_OBJECT,
516 null, SER_HOSTILE_EXCEPTIONS);
517 mv.visitCode();
518 mv.visitTypeInsn(NEW, NAME_NOT_SERIALIZABLE_EXCEPTION);
519 mv.visitInsn(DUP);
520 mv.visitLdcInsn("Non-serializable lambda");
521 mv.visitMethodInsn(INVOKESPECIAL, NAME_NOT_SERIALIZABLE_EXCEPTION, NAME_CTOR,
522 DESCR_CTOR_NOT_SERIALIZABLE_EXCEPTION, false);
523 mv.visitInsn(ATHROW);
524 mv.visitMaxs(-1, -1);
525 mv.visitEnd();
526 }
527
528 /**
529 * This class generates a method body which calls the lambda implementation
530 * method, converting arguments, as needed.
531 */
532 private class ForwardingMethodGenerator extends TypeConvertingMethodAdapter {
533
534 ForwardingMethodGenerator(MethodVisitor mv) {
535 super(mv);
536 }
537
538 void generate(MethodType methodType) {
539 visitCode();
540
541 if (implKind == MethodHandleInfo.REF_newInvokeSpecial) {
542 visitTypeInsn(NEW, implMethodClassName);
543 visitInsn(DUP);
544 }
545 if (useImplMethodHandle) {
546 visitLdcInsn(implMethodCondy);
547 }
548 for (int i = 0; i < argNames.length; i++) {
549 visitVarInsn(ALOAD, 0);
550 visitFieldInsn(GETFIELD, lambdaClassName, argNames[i], argDescs[i]);
551 }
552
553 convertArgumentTypes(methodType);
554
555 if (useImplMethodHandle) {
556 MethodType mtype = implInfo.getMethodType();
557 if (implKind != MethodHandleInfo.REF_invokeStatic) {
558 mtype = mtype.insertParameterTypes(0, implClass);
559 }
560 visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandle",
561 "invokeExact", mtype.descriptorString(), false);
562 } else {
563 // Invoke the method we want to forward to
564 visitMethodInsn(invocationOpcode(), implMethodClassName,
565 implMethodName, implMethodDesc,
566 implClass.isInterface());
567 }
568 // Convert the return value (if any) and return it
569 // Note: if adapting from non-void to void, the 'return'
570 // instruction will pop the unneeded result
571 Class<?> implReturnClass = implMethodType.returnType();
572 Class<?> samReturnClass = methodType.returnType();
573 convertType(implReturnClass, samReturnClass, samReturnClass);
574 visitInsn(getReturnOpcode(samReturnClass));
575 // Maxs computed by ClassWriter.COMPUTE_MAXS,these arguments ignored
576 visitMaxs(-1, -1);
577 visitEnd();
578 }
579
580 private void convertArgumentTypes(MethodType samType) {
581 int lvIndex = 0;
582 int samParametersLength = samType.parameterCount();
583 int captureArity = factoryType.parameterCount();
584 for (int i = 0; i < samParametersLength; i++) {
585 Class<?> argType = samType.parameterType(i);
586 visitVarInsn(getLoadOpcode(argType), lvIndex + 1);
587 lvIndex += getParameterSize(argType);
588 convertType(argType, implMethodType.parameterType(captureArity + i), dynamicMethodType.parameterType(i));
589 }
590 }
591
592 private int invocationOpcode() throws InternalError {
593 return switch (implKind) {
594 case MethodHandleInfo.REF_invokeStatic -> INVOKESTATIC;
595 case MethodHandleInfo.REF_newInvokeSpecial -> INVOKESPECIAL;
596 case MethodHandleInfo.REF_invokeVirtual -> INVOKEVIRTUAL;
597 case MethodHandleInfo.REF_invokeInterface -> INVOKEINTERFACE;
598 case MethodHandleInfo.REF_invokeSpecial -> INVOKESPECIAL;
599 default -> throw new InternalError("Unexpected invocation kind: " + implKind);
600 };
601 }
602 }
603
604 /*
605 * Preload attribute builder
606 */
607 static class PreloadAttributeBuilder {
608 private final Set<Class<?>> preloadClasses = new HashSet<>();
609 PreloadAttributeBuilder(Class<?> targetClass) {
610 if (requiresPreload(targetClass)) {
611 preloadClasses.add(targetClass);
612 }
613 }
614
615 /*
616 * Add the value types referenced in the given MethodType.
617 */
618 PreloadAttributeBuilder add(MethodType mt) {
619 // parameter types
620 for (Class<?> paramType : mt.ptypes()) {
621 if (requiresPreload(paramType)) {
622 preloadClasses.add(paramType);
623 }
624 }
625 // return type
626 if (requiresPreload(mt.returnType())) {
627 preloadClasses.add(mt.returnType());
628 }
629 return this;
630 }
631
632 PreloadAttributeBuilder add(MethodType... mtypes) {
633 for (MethodType mt : mtypes) {
634 add(mt);
635 }
636 return this;
637 }
638
639 boolean requiresPreload(Class<?> cls) {
640 Class<?> c = cls;
641 while (c.isArray()) {
642 c = c.getComponentType();
643 }
644 return (c.isValue() && !c.isPrimitiveClass()) || c.isPrimitiveValueType();
645 }
646
647 boolean isEmpty() {
648 return preloadClasses.isEmpty();
649 }
650
651 Attribute build() {
652 return new Attribute("Preload") {
653 @Override
654 protected ByteVector write(ClassWriter cw,
655 byte[] code,
656 int len,
657 int maxStack,
658 int maxLocals) {
659 ByteVector attr = new ByteVector();
660 attr.putShort(preloadClasses.size());
661 for (Class<?> c : preloadClasses) {
662 attr.putShort(cw.newClass(Type.getInternalName(c)));
663 }
664 return attr;
665 }
666 };
667 }
668 }
669
670 static int getParameterSize(Class<?> c) {
671 if (c == Void.TYPE) {
672 return 0;
673 } else if (c == Long.TYPE || c == Double.TYPE) {
674 return 2;
675 }
676 return 1;
677 }
678
679 static int getLoadOpcode(Class<?> c) {
680 if(c == Void.TYPE) {
681 throw new InternalError("Unexpected void type of load opcode");
682 }
683 return ILOAD + getOpcodeOffset(c);
684 }
685
686 static int getReturnOpcode(Class<?> c) {
687 if(c == Void.TYPE) {
688 return RETURN;
689 }
690 return IRETURN + getOpcodeOffset(c);
691 }
692
693 private static int getOpcodeOffset(Class<?> c) {
694 if (c.isPrimitive()) {
695 if (c == Long.TYPE) {
696 return 1;
697 } else if (c == Float.TYPE) {
698 return 2;
699 } else if (c == Double.TYPE) {
700 return 3;
701 }
702 return 0;
703 } else {
704 return 4;
705 }
706 }
707
708 }