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.constant.ClassOrInterfaceDescImpl;
29 import jdk.internal.misc.CDS;
30 import jdk.internal.util.ClassFileDumper;
31 import sun.invoke.util.VerifyAccess;
32
33 import java.io.Serializable;
34 import java.lang.classfile.ClassBuilder;
35 import java.lang.classfile.ClassFile;
36 import java.lang.classfile.CodeBuilder;
37 import java.lang.classfile.MethodBuilder;
38 import java.lang.classfile.Opcode;
39 import java.lang.classfile.TypeKind;
40 import java.lang.constant.ClassDesc;
41 import java.lang.constant.MethodTypeDesc;
42 import java.lang.reflect.Modifier;
43 import java.util.LinkedHashSet;
44 import java.util.List;
45 import java.util.Set;
46 import java.util.function.Consumer;
47
48 import static java.lang.classfile.ClassFile.*;
49 import java.lang.classfile.attribute.ExceptionsAttribute;
50 import java.lang.classfile.constantpool.ClassEntry;
51 import java.lang.classfile.constantpool.ConstantPoolBuilder;
52
53 import static java.lang.constant.ConstantDescs.*;
54 import static java.lang.invoke.MethodHandleNatives.Constants.NESTMATE_CLASS;
55 import static java.lang.invoke.MethodHandleNatives.Constants.STRONG_LOADER_LINK;
56 import jdk.internal.constant.ConstantUtils;
57 import jdk.internal.constant.MethodTypeDescImpl;
58 import jdk.internal.vm.annotation.Stable;
59 import sun.invoke.util.Wrapper;
60
61 /**
62 * Lambda metafactory implementation which dynamically creates an
63 * inner-class-like class per lambda callsite.
64 *
65 * @see LambdaMetafactory
66 */
67 /* package */ final class InnerClassLambdaMetafactory extends AbstractValidatingLambdaMetafactory {
68 private static final String LAMBDA_INSTANCE_FIELD = "LAMBDA_INSTANCE$";
69 private static final @Stable String[] ARG_NAME_CACHE = {"arg$1", "arg$2", "arg$3", "arg$4", "arg$5", "arg$6", "arg$7", "arg$8"};
70 private static final ClassDesc[] EMPTY_CLASSDESC_ARRAY = ConstantUtils.EMPTY_CLASSDESC;
71
72 // For dumping generated classes to disk, for debugging purposes
73 private static final ClassFileDumper lambdaProxyClassFileDumper;
74
75 private static final boolean disableEagerInitialization;
76
77 static {
78 // To dump the lambda proxy classes, set this system property:
79 // -Djdk.invoke.LambdaMetafactory.dumpProxyClassFiles
80 // or -Djdk.invoke.LambdaMetafactory.dumpProxyClassFiles=true
81 final String dumpProxyClassesKey = "jdk.invoke.LambdaMetafactory.dumpProxyClassFiles";
82 lambdaProxyClassFileDumper = ClassFileDumper.getInstance(dumpProxyClassesKey, "DUMP_LAMBDA_PROXY_CLASS_FILES");
83
84 final String disableEagerInitializationKey = "jdk.internal.lambda.disableEagerInitialization";
85 disableEagerInitialization = Boolean.getBoolean(disableEagerInitializationKey);
86 }
87
88 // See context values in AbstractValidatingLambdaMetafactory
89 private final ClassDesc implMethodClassDesc; // Name of type containing implementation "CC"
90 private final String implMethodName; // Name of implementation method "impl"
91 private final MethodTypeDesc implMethodDesc; // Type descriptor for implementation methods "(I)Ljava/lang/String;"
92 private final MethodType constructorType; // Generated class constructor type "(CC)void"
93 private final MethodTypeDesc constructorTypeDesc;// Type descriptor for the generated class constructor type "(CC)void"
94 private final ClassDesc[] argDescs; // Type descriptors for the constructor arguments
95 private final String lambdaClassName; // Generated name for the generated class "X$$Lambda$1"
96 private final ConstantPoolBuilder pool = ConstantPoolBuilder.of();
125 * substituted with their instantiation from
126 * the capture site
127 * @param isSerializable Should the lambda be made serializable? If set,
128 * either the target type or one of the additional SAM
129 * types must extend {@code Serializable}.
130 * @param altInterfaces Additional interfaces which the lambda object
131 * should implement.
132 * @param altMethods Method types for additional signatures to be
133 * implemented by invoking the implementation method
134 * @throws LambdaConversionException If any of the meta-factory protocol
135 * invariants are violated
136 */
137 public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,
138 MethodType factoryType,
139 String interfaceMethodName,
140 MethodType interfaceMethodType,
141 MethodHandle implementation,
142 MethodType dynamicMethodType,
143 boolean isSerializable,
144 Class<?>[] altInterfaces,
145 MethodType[] altMethods)
146 throws LambdaConversionException {
147 super(caller, factoryType, interfaceMethodName, interfaceMethodType,
148 implementation, dynamicMethodType,
149 isSerializable, altInterfaces, altMethods);
150 implMethodClassDesc = implClassDesc(implClass);
151 implMethodName = implInfo.getName();
152 implMethodDesc = methodDesc(implInfo.getMethodType());
153 constructorType = factoryType.changeReturnType(Void.TYPE);
154 lambdaClassName = lambdaClassName(targetClass);
155 lambdaClassEntry = pool.classEntry(ConstantUtils.internalNameToDesc(lambdaClassName));
156 // If the target class invokes a protected method inherited from a
157 // superclass in a different package, or does 'invokespecial', the
158 // lambda class has no access to the resolved method, or does
159 // 'invokestatic' on a hidden class which cannot be resolved by name.
160 // Instead, we need to pass the live implementation method handle to
161 // the proxy class to invoke directly. (javac prefers to avoid this
162 // situation by generating bridges in the target class)
163 useImplMethodHandle = (Modifier.isProtected(implInfo.getModifiers()) &&
164 !VerifyAccess.isSamePackage(targetClass, implInfo.getDeclaringClass())) ||
165 implKind == MethodHandleInfo.REF_invokeSpecial ||
166 implKind == MethodHandleInfo.REF_invokeStatic && implClass.isHidden();
167 int parameterCount = factoryType.parameterCount();
168 ClassDesc[] argDescs;
169 MethodTypeDesc constructorTypeDesc;
300 // Assure no duplicate interfaces (ClassFormatError)
301 Set<ClassDesc> itfs = LinkedHashSet.newLinkedHashSet(altInterfaces.length + 1);
302 itfs.add(interfaceDesc);
303 for (Class<?> i : altInterfaces) {
304 itfs.add(classDesc(i));
305 accidentallySerializable |= !isSerializable && Serializable.class.isAssignableFrom(i);
306 }
307 interfaces = List.copyOf(itfs);
308 }
309 final boolean finalAccidentallySerializable = accidentallySerializable;
310 final byte[] classBytes = ClassFile.of().build(lambdaClassEntry, pool, new Consumer<ClassBuilder>() {
311 @Override
312 public void accept(ClassBuilder clb) {
313 clb.withFlags(ACC_SUPER | ACC_FINAL | ACC_SYNTHETIC)
314 .withInterfaceSymbols(interfaces);
315 // Generate final fields to be filled in by constructor
316 for (int i = 0; i < argDescs.length; i++) {
317 clb.withField(argName(i), argDescs[i], ACC_PRIVATE | ACC_FINAL);
318 }
319
320 generateConstructor(clb);
321
322 if (factoryType.parameterCount() == 0 && disableEagerInitialization) {
323 generateClassInitializer(clb);
324 }
325
326 // Forward the SAM method
327 clb.withMethodBody(interfaceMethodName,
328 methodDesc(interfaceMethodType),
329 ACC_PUBLIC,
330 forwardingMethod(interfaceMethodType));
331
332 // Forward the bridges
333 if (altMethods != null) {
334 for (MethodType mt : altMethods) {
335 clb.withMethodBody(interfaceMethodName,
336 methodDesc(mt),
337 ACC_PUBLIC | ACC_BRIDGE,
338 forwardingMethod(mt));
339 }
340 }
341
342 if (isSerializable)
343 generateSerializationFriendlyMethods(clb);
344 else if (finalAccidentallySerializable)
345 generateSerializationHostileMethods(clb);
346 }
347 });
348
349 // Define the generated class in this VM.
350
351 try {
352 // this class is linked at the indy callsite; so define a hidden nestmate
353 var classdata = useImplMethodHandle? implementation : null;
354 return caller.makeHiddenClassDefiner(lambdaClassName, classBytes, lambdaProxyClassFileDumper, NESTMATE_CLASS | STRONG_LOADER_LINK)
355 .defineClass(!disableEagerInitialization, classdata);
356
357 } catch (Throwable t) {
358 throw new InternalError(t);
359 }
360 }
361
362 /**
363 * Generate a static field and a static initializer that sets this field to an instance of the lambda
364 */
365 private void generateClassInitializer(ClassBuilder clb) {
366 ClassDesc lambdaTypeDescriptor = classDesc(factoryType.returnType());
367
368 // Generate the static final field that holds the lambda singleton
369 clb.withField(LAMBDA_INSTANCE_FIELD, lambdaTypeDescriptor, ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
370
371 // Instantiate the lambda and store it to the static final field
372 clb.withMethodBody(CLASS_INIT_NAME, MTD_void, ACC_STATIC, new Consumer<>() {
373 @Override
382 });
383 }
384
385 /**
386 * Generate the constructor for the class
387 */
388 private void generateConstructor(ClassBuilder clb) {
389 // Generate constructor
390 clb.withMethodBody(INIT_NAME, constructorTypeDesc, ACC_PRIVATE,
391 new Consumer<>() {
392 @Override
393 public void accept(CodeBuilder cob) {
394 cob.aload(0)
395 .invokespecial(CD_Object, INIT_NAME, MTD_void);
396 int parameterCount = factoryType.parameterCount();
397 for (int i = 0; i < parameterCount; i++) {
398 cob.aload(0)
399 .loadLocal(TypeKind.from(factoryType.parameterType(i)), cob.parameterSlot(i))
400 .putfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
401 }
402 cob.return_();
403 }
404 });
405 }
406
407 private static class SerializationSupport {
408 // Serialization support
409 private static final ClassDesc CD_SerializedLambda = ClassOrInterfaceDescImpl.ofValidated("Ljava/lang/invoke/SerializedLambda;");
410 private static final ClassDesc CD_ObjectOutputStream = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/ObjectOutputStream;");
411 private static final ClassDesc CD_ObjectInputStream = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/ObjectInputStream;");
412 private static final MethodTypeDesc MTD_Object = MethodTypeDescImpl.ofValidated(CD_Object);
413 private static final MethodTypeDesc MTD_void_ObjectOutputStream = MethodTypeDescImpl.ofValidated(CD_void, CD_ObjectOutputStream);
414 private static final MethodTypeDesc MTD_void_ObjectInputStream = MethodTypeDescImpl.ofValidated(CD_void, CD_ObjectInputStream);
415
416 private static final String NAME_METHOD_WRITE_REPLACE = "writeReplace";
417 private static final String NAME_METHOD_READ_OBJECT = "readObject";
418 private static final String NAME_METHOD_WRITE_OBJECT = "writeObject";
419
420 static final ClassDesc CD_NotSerializableException = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/NotSerializableException;");
421 static final MethodTypeDesc MTD_CTOR_NOT_SERIALIZABLE_EXCEPTION = MethodTypeDescImpl.ofValidated(CD_void, CD_String);
422 static final MethodTypeDesc MTD_CTOR_SERIALIZED_LAMBDA = MethodTypeDescImpl.ofValidated(CD_void,
423 CD_Class, CD_String, CD_String, CD_String, CD_int, CD_String, CD_String, CD_String, CD_String, ConstantUtils.CD_Object_array);
424
425 }
426
443 .ldc(implInfo.getName())
444 .ldc(implInfo.getMethodType().toMethodDescriptorString())
445 .ldc(dynamicMethodType.toMethodDescriptorString())
446 .loadConstant(argDescs.length)
447 .anewarray(CD_Object);
448 for (int i = 0; i < argDescs.length; i++) {
449 cob.dup()
450 .loadConstant(i)
451 .aload(0)
452 .getfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
453 TypeConvertingMethodAdapter.boxIfTypePrimitive(cob, TypeKind.from(argDescs[i]));
454 cob.aastore();
455 }
456 cob.invokespecial(SerializationSupport.CD_SerializedLambda, INIT_NAME,
457 SerializationSupport.MTD_CTOR_SERIALIZED_LAMBDA)
458 .areturn();
459 }
460 });
461 }
462
463 /**
464 * Generate a readObject/writeObject method that is hostile to serialization
465 */
466 private void generateSerializationHostileMethods(ClassBuilder clb) {
467 var hostileMethod = new Consumer<MethodBuilder>() {
468 @Override
469 public void accept(MethodBuilder mb) {
470 ConstantPoolBuilder cp = mb.constantPool();
471 ClassEntry nseCE = cp.classEntry(SerializationSupport.CD_NotSerializableException);
472 mb.with(ExceptionsAttribute.of(nseCE))
473 .withCode(new Consumer<CodeBuilder>() {
474 @Override
475 public void accept(CodeBuilder cob) {
476 cob.new_(nseCE)
477 .dup()
478 .ldc("Non-serializable lambda")
479 .invokespecial(cp.methodRefEntry(nseCE, cp.nameAndTypeEntry(INIT_NAME,
480 SerializationSupport.MTD_CTOR_NOT_SERIALIZABLE_EXCEPTION)))
481 .athrow();
482 }
486 clb.withMethod(SerializationSupport.NAME_METHOD_WRITE_OBJECT, SerializationSupport.MTD_void_ObjectOutputStream,
487 ACC_PRIVATE + ACC_FINAL, hostileMethod);
488 clb.withMethod(SerializationSupport.NAME_METHOD_READ_OBJECT, SerializationSupport.MTD_void_ObjectInputStream,
489 ACC_PRIVATE + ACC_FINAL, hostileMethod);
490 }
491
492 /**
493 * This method generates a method body which calls the lambda implementation
494 * method, converting arguments, as needed.
495 */
496 Consumer<CodeBuilder> forwardingMethod(MethodType methodType) {
497 return new Consumer<>() {
498 @Override
499 public void accept(CodeBuilder cob) {
500 if (implKind == MethodHandleInfo.REF_newInvokeSpecial) {
501 cob.new_(implMethodClassDesc)
502 .dup();
503 }
504 if (useImplMethodHandle) {
505 ConstantPoolBuilder cp = cob.constantPool();
506 cob.ldc(cp.constantDynamicEntry(cp.bsmEntry(cp.methodHandleEntry(BSM_CLASS_DATA), List.of()),
507 cp.nameAndTypeEntry(DEFAULT_NAME, CD_MethodHandle)));
508 }
509 for (int i = 0; i < argDescs.length; i++) {
510 cob.aload(0)
511 .getfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
512 }
513
514 convertArgumentTypes(cob, methodType);
515
516 if (useImplMethodHandle) {
517 MethodType mtype = implInfo.getMethodType();
518 if (implKind != MethodHandleInfo.REF_invokeStatic) {
519 mtype = mtype.insertParameterTypes(0, implClass);
520 }
521 cob.invokevirtual(CD_MethodHandle, "invokeExact", methodDesc(mtype));
522 } else {
523 // Invoke the method we want to forward to
524 cob.invoke(invocationOpcode(), implMethodClassDesc, implMethodName, implMethodDesc, implClass.isInterface());
525 }
526 // Convert the return value (if any) and return it
|
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.constant.ClassOrInterfaceDescImpl;
29 import jdk.internal.misc.CDS;
30 import jdk.internal.util.ClassFileDumper;
31 import sun.invoke.util.VerifyAccess;
32
33 import java.io.Serializable;
34 import java.lang.classfile.ClassBuilder;
35 import java.lang.classfile.ClassFile;
36 import java.lang.classfile.CodeBuilder;
37 import java.lang.classfile.MethodBuilder;
38 import java.lang.classfile.Opcode;
39 import java.lang.classfile.TypeKind;
40 import java.lang.classfile.constantpool.MethodHandleEntry;
41 import java.lang.classfile.constantpool.NameAndTypeEntry;
42 import java.lang.constant.ClassDesc;
43 import java.lang.constant.MethodTypeDesc;
44 import java.lang.invoke.MethodHandles.Lookup;
45 import java.lang.module.Configuration;
46 import java.lang.module.ModuleFinder;
47 import java.lang.reflect.Modifier;
48 import java.util.LinkedHashSet;
49 import java.util.List;
50 import java.util.Set;
51 import java.util.function.Consumer;
52
53 import static java.lang.classfile.ClassFile.*;
54 import java.lang.classfile.attribute.ExceptionsAttribute;
55 import java.lang.classfile.constantpool.ClassEntry;
56 import java.lang.classfile.constantpool.ConstantPoolBuilder;
57
58 import static java.lang.constant.ConstantDescs.*;
59 import static java.lang.invoke.MethodHandleNatives.Constants.NESTMATE_CLASS;
60 import static java.lang.invoke.MethodHandleNatives.Constants.STRONG_LOADER_LINK;
61 import static java.lang.invoke.MethodType.methodType;
62 import jdk.internal.constant.ConstantUtils;
63 import jdk.internal.constant.MethodTypeDescImpl;
64 import jdk.internal.vm.annotation.Stable;
65 import sun.invoke.util.Wrapper;
66
67 /**
68 * Lambda metafactory implementation which dynamically creates an
69 * inner-class-like class per lambda callsite.
70 *
71 * @see LambdaMetafactory
72 */
73 /* package */ final class InnerClassLambdaMetafactory extends AbstractValidatingLambdaMetafactory {
74 private static final String LAMBDA_INSTANCE_FIELD = "LAMBDA_INSTANCE$";
75 private static final @Stable String[] ARG_NAME_CACHE = {"arg$1", "arg$2", "arg$3", "arg$4", "arg$5", "arg$6", "arg$7", "arg$8"};
76 private static final ClassDesc[] EMPTY_CLASSDESC_ARRAY = ConstantUtils.EMPTY_CLASSDESC;
77
78 // Static builders to avoid lambdas
79 record MethodBody(Consumer<CodeBuilder> code) implements Consumer<MethodBuilder> {
80 @Override
81 public void accept(MethodBuilder mb) {
82 mb.withCode(code);
83 }
84 };
85
86 // For dumping generated classes to disk, for debugging purposes
87 private static final ClassFileDumper lambdaProxyClassFileDumper;
88
89 private static final boolean disableEagerInitialization;
90
91 private static final String NAME_METHOD_QUOTED = "__internal_quoted";
92 private static final String quotedInstanceFieldName = "quoted";
93
94 static {
95 // To dump the lambda proxy classes, set this system property:
96 // -Djdk.invoke.LambdaMetafactory.dumpProxyClassFiles
97 // or -Djdk.invoke.LambdaMetafactory.dumpProxyClassFiles=true
98 final String dumpProxyClassesKey = "jdk.invoke.LambdaMetafactory.dumpProxyClassFiles";
99 lambdaProxyClassFileDumper = ClassFileDumper.getInstance(dumpProxyClassesKey, "DUMP_LAMBDA_PROXY_CLASS_FILES");
100
101 final String disableEagerInitializationKey = "jdk.internal.lambda.disableEagerInitialization";
102 disableEagerInitialization = Boolean.getBoolean(disableEagerInitializationKey);
103 }
104
105 // See context values in AbstractValidatingLambdaMetafactory
106 private final ClassDesc implMethodClassDesc; // Name of type containing implementation "CC"
107 private final String implMethodName; // Name of implementation method "impl"
108 private final MethodTypeDesc implMethodDesc; // Type descriptor for implementation methods "(I)Ljava/lang/String;"
109 private final MethodType constructorType; // Generated class constructor type "(CC)void"
110 private final MethodTypeDesc constructorTypeDesc;// Type descriptor for the generated class constructor type "(CC)void"
111 private final ClassDesc[] argDescs; // Type descriptors for the constructor arguments
112 private final String lambdaClassName; // Generated name for the generated class "X$$Lambda$1"
113 private final ConstantPoolBuilder pool = ConstantPoolBuilder.of();
142 * substituted with their instantiation from
143 * the capture site
144 * @param isSerializable Should the lambda be made serializable? If set,
145 * either the target type or one of the additional SAM
146 * types must extend {@code Serializable}.
147 * @param altInterfaces Additional interfaces which the lambda object
148 * should implement.
149 * @param altMethods Method types for additional signatures to be
150 * implemented by invoking the implementation method
151 * @throws LambdaConversionException If any of the meta-factory protocol
152 * invariants are violated
153 */
154 public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,
155 MethodType factoryType,
156 String interfaceMethodName,
157 MethodType interfaceMethodType,
158 MethodHandle implementation,
159 MethodType dynamicMethodType,
160 boolean isSerializable,
161 Class<?>[] altInterfaces,
162 MethodType[] altMethods,
163 MethodHandle reflectiveField)
164 throws LambdaConversionException {
165 super(caller, factoryType, interfaceMethodName, interfaceMethodType,
166 implementation, dynamicMethodType,
167 isSerializable, altInterfaces, altMethods, reflectiveField);
168 implMethodClassDesc = implClassDesc(implClass);
169 implMethodName = implInfo.getName();
170 implMethodDesc = methodDesc(implInfo.getMethodType());
171 constructorType = factoryType.changeReturnType(Void.TYPE);
172 lambdaClassName = lambdaClassName(targetClass);
173 lambdaClassEntry = pool.classEntry(ConstantUtils.internalNameToDesc(lambdaClassName));
174 // If the target class invokes a protected method inherited from a
175 // superclass in a different package, or does 'invokespecial', the
176 // lambda class has no access to the resolved method, or does
177 // 'invokestatic' on a hidden class which cannot be resolved by name.
178 // Instead, we need to pass the live implementation method handle to
179 // the proxy class to invoke directly. (javac prefers to avoid this
180 // situation by generating bridges in the target class)
181 useImplMethodHandle = (Modifier.isProtected(implInfo.getModifiers()) &&
182 !VerifyAccess.isSamePackage(targetClass, implInfo.getDeclaringClass())) ||
183 implKind == MethodHandleInfo.REF_invokeSpecial ||
184 implKind == MethodHandleInfo.REF_invokeStatic && implClass.isHidden();
185 int parameterCount = factoryType.parameterCount();
186 ClassDesc[] argDescs;
187 MethodTypeDesc constructorTypeDesc;
318 // Assure no duplicate interfaces (ClassFormatError)
319 Set<ClassDesc> itfs = LinkedHashSet.newLinkedHashSet(altInterfaces.length + 1);
320 itfs.add(interfaceDesc);
321 for (Class<?> i : altInterfaces) {
322 itfs.add(classDesc(i));
323 accidentallySerializable |= !isSerializable && Serializable.class.isAssignableFrom(i);
324 }
325 interfaces = List.copyOf(itfs);
326 }
327 final boolean finalAccidentallySerializable = accidentallySerializable;
328 final byte[] classBytes = ClassFile.of().build(lambdaClassEntry, pool, new Consumer<ClassBuilder>() {
329 @Override
330 public void accept(ClassBuilder clb) {
331 clb.withFlags(ACC_SUPER | ACC_FINAL | ACC_SYNTHETIC)
332 .withInterfaceSymbols(interfaces);
333 // Generate final fields to be filled in by constructor
334 for (int i = 0; i < argDescs.length; i++) {
335 clb.withField(argName(i), argDescs[i], ACC_PRIVATE | ACC_FINAL);
336 }
337
338 // if quotable, generate the field that will hold the value of quoted
339 if (quotableOpGetter != null) {
340 clb.withField(quotedInstanceFieldName, CodeReflectionSupport.CD_Quoted, ACC_PRIVATE + ACC_FINAL);
341 }
342
343 generateConstructor(clb);
344
345 if (factoryType.parameterCount() == 0 && disableEagerInitialization) {
346 generateClassInitializer(clb);
347 }
348
349 // Forward the SAM method
350 clb.withMethodBody(interfaceMethodName,
351 methodDesc(interfaceMethodType),
352 ACC_PUBLIC,
353 forwardingMethod(interfaceMethodType));
354
355 // Forward the bridges
356 if (altMethods != null) {
357 for (MethodType mt : altMethods) {
358 clb.withMethodBody(interfaceMethodName,
359 methodDesc(mt),
360 ACC_PUBLIC | ACC_BRIDGE,
361 forwardingMethod(mt));
362 }
363 }
364
365 if (isSerializable)
366 generateSerializationFriendlyMethods(clb);
367 else if (finalAccidentallySerializable)
368 generateSerializationHostileMethods(clb);
369
370 if (quotableOpGetter != null) {
371 generateQuotedMethod(clb);
372 }
373 }
374 });
375
376 // Define the generated class in this VM.
377
378 try {
379 // this class is linked at the indy callsite; so define a hidden nestmate
380 List<?> classdata;
381 if (useImplMethodHandle || quotableOpGetter != null) {
382 classdata = quotableOpGetter == null ?
383 List.of(implementation) :
384 List.of(implementation, quotableOpGetter, CodeReflectionSupport.HANDLE_MAKE_QUOTED);
385 } else {
386 classdata = null;
387 }
388 return caller.makeHiddenClassDefiner(lambdaClassName, classBytes, lambdaProxyClassFileDumper, NESTMATE_CLASS | STRONG_LOADER_LINK)
389 .defineClass(!disableEagerInitialization, classdata);
390
391 } catch (Throwable t) {
392 throw new InternalError(t);
393 }
394 }
395
396 /**
397 * Generate a static field and a static initializer that sets this field to an instance of the lambda
398 */
399 private void generateClassInitializer(ClassBuilder clb) {
400 ClassDesc lambdaTypeDescriptor = classDesc(factoryType.returnType());
401
402 // Generate the static final field that holds the lambda singleton
403 clb.withField(LAMBDA_INSTANCE_FIELD, lambdaTypeDescriptor, ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
404
405 // Instantiate the lambda and store it to the static final field
406 clb.withMethodBody(CLASS_INIT_NAME, MTD_void, ACC_STATIC, new Consumer<>() {
407 @Override
416 });
417 }
418
419 /**
420 * Generate the constructor for the class
421 */
422 private void generateConstructor(ClassBuilder clb) {
423 // Generate constructor
424 clb.withMethodBody(INIT_NAME, constructorTypeDesc, ACC_PRIVATE,
425 new Consumer<>() {
426 @Override
427 public void accept(CodeBuilder cob) {
428 cob.aload(0)
429 .invokespecial(CD_Object, INIT_NAME, MTD_void);
430 int parameterCount = factoryType.parameterCount();
431 for (int i = 0; i < parameterCount; i++) {
432 cob.aload(0)
433 .loadLocal(TypeKind.from(factoryType.parameterType(i)), cob.parameterSlot(i))
434 .putfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
435 }
436 if (quotableOpGetter != null) {
437 generateQuotedFieldInitializer(cob);
438 }
439 cob.return_();
440 }
441 });
442 }
443
444 private void generateQuotedFieldInitializer(CodeBuilder cob) {
445 ConstantPoolBuilder cp = cob.constantPool();
446 MethodHandleEntry bsmDataAt = cp.methodHandleEntry(BSM_CLASS_DATA_AT);
447 NameAndTypeEntry natMH = cp.nameAndTypeEntry(DEFAULT_NAME, CD_MethodHandle);
448 // push the receiver on the stack for operand of put field instruction
449 cob.aload(0)
450 // load class data: CodeReflectionSupport.HANDLE_MAKE_QUOTED and quotableOpGetter
451 .ldc(cp.constantDynamicEntry(cp.bsmEntry(bsmDataAt, List.of(cp.intEntry(2))), natMH))
452 .ldc(cp.constantDynamicEntry(cp.bsmEntry(bsmDataAt, List.of(cp.intEntry(1))), natMH));
453 MethodType mtype = quotableOpGetterInfo.getMethodType();
454 if (quotableOpGetterInfo.getReferenceKind() != MethodHandleInfo.REF_invokeStatic) {
455 mtype = mtype.insertParameterTypes(0, implClass);
456 }
457 // load arguments to quotableOpGetter: ExtendedOp.FACTORY and CORE_TYPE_FACTORY
458 cob.fieldAccess(Opcode.GETSTATIC, CodeReflectionSupport.EXTENDED_OP_CLASS.describeConstable().get(),
459 "FACTORY", CodeReflectionSupport.OP_FACTORY_CLASS.describeConstable().get());
460 cob.fieldAccess(Opcode.GETSTATIC, CodeReflectionSupport.CORE_TYPE_FACTORY_CLASS.describeConstable().get(),
461 "CORE_TYPE_FACTORY",
462 CodeReflectionSupport.TYPE_ELEMENT_FACTORY_CLASS.describeConstable().get());
463 cob.invokevirtual(CD_MethodHandle, "invokeExact", mtype.describeConstable().get());
464 cob.checkcast(CodeReflectionSupport.FUNC_OP_CLASS.describeConstable().get());
465
466 // load captured args in array
467
468 int capturedArity = factoryType.parameterCount();
469 cob.loadConstant(capturedArity)
470 .anewarray(CD_Object);
471 // initialize quoted captures
472 for (int i = 0; i < capturedArity; i++) {
473 cob.dup()
474 .loadConstant(i)
475 .aload(0)
476 .getfield(lambdaClassEntry.asSymbol(), argName(i), argDescs[i]);
477 TypeConvertingMethodAdapter.boxIfTypePrimitive(cob, TypeKind.from(argDescs[i]));
478 cob.aastore();
479 }
480
481 // Create a Quoted from FuncOp and captured args Object[]
482
483 cob.invokevirtual(CD_MethodHandle, "invokeExact", methodDesc(CodeReflectionSupport.HANDLE_MAKE_QUOTED.type()))
484 .putfield(lambdaClassEntry.asSymbol(), quotedInstanceFieldName, CodeReflectionSupport.CD_Quoted);
485 }
486
487 static class CodeReflectionSupport {
488 static final Class<?> QUOTED_CLASS;
489 static final Class<?> QUOTABLE_CLASS;
490 static final MethodHandle HANDLE_MAKE_QUOTED;
491 static final Class<?> EXTENDED_OP_CLASS;
492 static final Class<?> OP_FACTORY_CLASS;
493 static final Class<?> CORE_TYPE_FACTORY_CLASS;
494 static final Class<?> TYPE_ELEMENT_FACTORY_CLASS;
495 static final Class<?> FUNC_OP_CLASS;
496
497 static {
498 try {
499 ModuleLayer layer = codeLayer();
500 ClassLoader cl = layer.findLoader("jdk.incubator.code");
501 QUOTED_CLASS = cl.loadClass("jdk.incubator.code.Quoted");
502 QUOTABLE_CLASS = cl.loadClass("jdk.incubator.code.Quotable");
503 Class<?> quotedHelper = cl.loadClass("jdk.incubator.code.internal.QuotedHelper");
504 FUNC_OP_CLASS = cl.loadClass("jdk.incubator.code.op.CoreOp$FuncOp");
505 MethodHandle makeQuoted = Lookup.IMPL_LOOKUP.findStatic(quotedHelper, "makeQuoted",
506 MethodType.methodType(QUOTED_CLASS, MethodHandles.Lookup.class, FUNC_OP_CLASS, Object[].class));
507 HANDLE_MAKE_QUOTED = makeQuoted.bindTo(Lookup.IMPL_LOOKUP);
508 EXTENDED_OP_CLASS = cl.loadClass("jdk.incubator.code.op.ExtendedOp");
509 OP_FACTORY_CLASS = cl.loadClass("jdk.incubator.code.op.OpFactory");
510 CORE_TYPE_FACTORY_CLASS = cl.loadClass("jdk.incubator.code.type.CoreTypeFactory");
511 TYPE_ELEMENT_FACTORY_CLASS = cl.loadClass("jdk.incubator.code.type.TypeElementFactory");
512 } catch (Throwable ex) {
513 throw new ExceptionInInitializerError(ex);
514 }
515 }
516
517 static ModuleLayer codeLayer() {
518 final ModuleLayer codeLayer;
519 if (ModuleLayer.boot().findModule("jdk.incubator.code").isPresent()) {
520 // we are in an exploded build, so just use the boot layer
521 return ModuleLayer.boot();
522 } else if (java.lang.module.ModuleFinder.ofSystem().find("jdk.incubator.code").isPresent()) {
523 // the code module is installed, but not in the boot layer, create a new layer which contains it
524 ModuleLayer parent = ModuleLayer.boot();
525 Configuration cf = parent.configuration()
526 .resolve(ModuleFinder.of(), ModuleFinder.ofSystem(), Set.of("jdk.incubator.code"));
527 ClassLoader scl = ClassLoader.getSystemClassLoader();
528 return parent.defineModulesWithOneLoader(cf, scl);
529 } else {
530 throw new IllegalStateException("jdk.incubator.code module not found");
531 }
532 }
533
534 static final ClassDesc CD_Quoted = QUOTED_CLASS.describeConstable().get();
535 static final MethodTypeDesc MTD_Quoted = MethodTypeDescImpl.ofValidated(CD_Quoted);
536 }
537
538 private static class SerializationSupport {
539 // Serialization support
540 private static final ClassDesc CD_SerializedLambda = ClassOrInterfaceDescImpl.ofValidated("Ljava/lang/invoke/SerializedLambda;");
541 private static final ClassDesc CD_ObjectOutputStream = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/ObjectOutputStream;");
542 private static final ClassDesc CD_ObjectInputStream = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/ObjectInputStream;");
543 private static final MethodTypeDesc MTD_Object = MethodTypeDescImpl.ofValidated(CD_Object);
544 private static final MethodTypeDesc MTD_void_ObjectOutputStream = MethodTypeDescImpl.ofValidated(CD_void, CD_ObjectOutputStream);
545 private static final MethodTypeDesc MTD_void_ObjectInputStream = MethodTypeDescImpl.ofValidated(CD_void, CD_ObjectInputStream);
546
547 private static final String NAME_METHOD_WRITE_REPLACE = "writeReplace";
548 private static final String NAME_METHOD_READ_OBJECT = "readObject";
549 private static final String NAME_METHOD_WRITE_OBJECT = "writeObject";
550
551 static final ClassDesc CD_NotSerializableException = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/NotSerializableException;");
552 static final MethodTypeDesc MTD_CTOR_NOT_SERIALIZABLE_EXCEPTION = MethodTypeDescImpl.ofValidated(CD_void, CD_String);
553 static final MethodTypeDesc MTD_CTOR_SERIALIZED_LAMBDA = MethodTypeDescImpl.ofValidated(CD_void,
554 CD_Class, CD_String, CD_String, CD_String, CD_int, CD_String, CD_String, CD_String, CD_String, ConstantUtils.CD_Object_array);
555
556 }
557
574 .ldc(implInfo.getName())
575 .ldc(implInfo.getMethodType().toMethodDescriptorString())
576 .ldc(dynamicMethodType.toMethodDescriptorString())
577 .loadConstant(argDescs.length)
578 .anewarray(CD_Object);
579 for (int i = 0; i < argDescs.length; i++) {
580 cob.dup()
581 .loadConstant(i)
582 .aload(0)
583 .getfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
584 TypeConvertingMethodAdapter.boxIfTypePrimitive(cob, TypeKind.from(argDescs[i]));
585 cob.aastore();
586 }
587 cob.invokespecial(SerializationSupport.CD_SerializedLambda, INIT_NAME,
588 SerializationSupport.MTD_CTOR_SERIALIZED_LAMBDA)
589 .areturn();
590 }
591 });
592 }
593
594 /**
595 * Generate method #quoted()
596 */
597 private void generateQuotedMethod(ClassBuilder clb) {
598 clb.withMethod(NAME_METHOD_QUOTED, CodeReflectionSupport.MTD_Quoted, ACC_PUBLIC + ACC_FINAL, new MethodBody(new Consumer<CodeBuilder>() {
599 @Override
600 public void accept(CodeBuilder cob) {
601 cob.aload(0)
602 .getfield(lambdaClassEntry.asSymbol(), quotedInstanceFieldName, CodeReflectionSupport.CD_Quoted)
603 .areturn();
604 }
605 }));
606 }
607
608 /**
609 * Generate a readObject/writeObject method that is hostile to serialization
610 */
611 private void generateSerializationHostileMethods(ClassBuilder clb) {
612 var hostileMethod = new Consumer<MethodBuilder>() {
613 @Override
614 public void accept(MethodBuilder mb) {
615 ConstantPoolBuilder cp = mb.constantPool();
616 ClassEntry nseCE = cp.classEntry(SerializationSupport.CD_NotSerializableException);
617 mb.with(ExceptionsAttribute.of(nseCE))
618 .withCode(new Consumer<CodeBuilder>() {
619 @Override
620 public void accept(CodeBuilder cob) {
621 cob.new_(nseCE)
622 .dup()
623 .ldc("Non-serializable lambda")
624 .invokespecial(cp.methodRefEntry(nseCE, cp.nameAndTypeEntry(INIT_NAME,
625 SerializationSupport.MTD_CTOR_NOT_SERIALIZABLE_EXCEPTION)))
626 .athrow();
627 }
631 clb.withMethod(SerializationSupport.NAME_METHOD_WRITE_OBJECT, SerializationSupport.MTD_void_ObjectOutputStream,
632 ACC_PRIVATE + ACC_FINAL, hostileMethod);
633 clb.withMethod(SerializationSupport.NAME_METHOD_READ_OBJECT, SerializationSupport.MTD_void_ObjectInputStream,
634 ACC_PRIVATE + ACC_FINAL, hostileMethod);
635 }
636
637 /**
638 * This method generates a method body which calls the lambda implementation
639 * method, converting arguments, as needed.
640 */
641 Consumer<CodeBuilder> forwardingMethod(MethodType methodType) {
642 return new Consumer<>() {
643 @Override
644 public void accept(CodeBuilder cob) {
645 if (implKind == MethodHandleInfo.REF_newInvokeSpecial) {
646 cob.new_(implMethodClassDesc)
647 .dup();
648 }
649 if (useImplMethodHandle) {
650 ConstantPoolBuilder cp = cob.constantPool();
651 cob.ldc(cp.constantDynamicEntry(cp.bsmEntry(cp.methodHandleEntry(BSM_CLASS_DATA_AT), List.of(cp.intEntry(0))),
652 cp.nameAndTypeEntry(DEFAULT_NAME, CD_MethodHandle)));
653 }
654 for (int i = 0; i < argDescs.length; i++) {
655 cob.aload(0)
656 .getfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
657 }
658
659 convertArgumentTypes(cob, methodType);
660
661 if (useImplMethodHandle) {
662 MethodType mtype = implInfo.getMethodType();
663 if (implKind != MethodHandleInfo.REF_invokeStatic) {
664 mtype = mtype.insertParameterTypes(0, implClass);
665 }
666 cob.invokevirtual(CD_MethodHandle, "invokeExact", methodDesc(mtype));
667 } else {
668 // Invoke the method we want to forward to
669 cob.invoke(invocationOpcode(), implMethodClassDesc, implMethodName, implMethodDesc, implClass.isInterface());
670 }
671 // Convert the return value (if any) and return it
|