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