Bytecode round 9

src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeLift.java

@@ -82,13 +82,11 @@ public final class BytecodeLift {
     private static final JavaType MHS_LOOKUP = JavaType.type(ConstantDescs.CD_MethodHandles_Lookup);
     private static final JavaType MH = JavaType.type(ConstantDescs.CD_MethodHandle);
     private static final JavaType MT = JavaType.type(ConstantDescs.CD_MethodType);
-    private static final JavaType ARRAYLIST = JavaType.type(ArrayList.class.describeConstable().get());
-    private static final FunctionType ARRAYLIST_INIT = FunctionType.functionType(ARRAYLIST);
+    private static final JavaType CLASS_ARRAY = JavaType.array(JavaType.J_L_CLASS);
     private static final MethodRef LCMP = MethodRef.method(JavaType.J_L_LONG, "compare", JavaType.INT, JavaType.LONG, JavaType.LONG);
     private static final MethodRef FCMP = MethodRef.method(JavaType.J_L_FLOAT, "compare", JavaType.INT, JavaType.FLOAT, JavaType.FLOAT);
     private static final MethodRef DCMP = MethodRef.method(JavaType.J_L_DOUBLE, "compare", JavaType.INT, JavaType.DOUBLE, JavaType.DOUBLE);
     private static final MethodRef LOOKUP = MethodRef.method(JavaType.type(ConstantDescs.CD_MethodHandles), "lookup", MHS_LOOKUP);
-    private static final MethodRef ARRAYLIST_ADD = MethodRef.method(ARRAYLIST, "add", JavaType.BOOLEAN, JavaType.J_L_OBJECT);
     private static final MethodRef FIND_STATIC = MethodRef.method(MHS_LOOKUP, "findStatic", MH, JavaType.J_L_CLASS, JavaType.J_L_STRING, MT);
     private static final MethodRef FIND_VIRTUAL = MethodRef.method(MHS_LOOKUP, "findVirtual", MH, JavaType.J_L_CLASS, JavaType.J_L_STRING, MT);
     private static final MethodRef FIND_CONSTRUCTOR = MethodRef.method(MHS_LOOKUP, "findConstructor", MH, JavaType.J_L_CLASS, MT);
@@ -98,7 +96,7 @@ public final class BytecodeLift {
     private static final MethodRef FIND_STATIC_SETTER = MethodRef.method(MHS_LOOKUP, "findStaticSetter", MH, JavaType.J_L_CLASS, JavaType.J_L_STRING, JavaType.J_L_CLASS);
     private static final MethodRef METHOD_TYPE_0 = MethodRef.method(MT, "methodType", MT, JavaType.J_L_CLASS);
     private static final MethodRef METHOD_TYPE_1 = MethodRef.method(MT, "methodType", MT, JavaType.J_L_CLASS, JavaType.J_L_CLASS);
-    private static final MethodRef METHOD_TYPE_L = MethodRef.method(MT, "methodType", MT, JavaType.J_L_CLASS, JavaType.J_U_LIST);
+    private static final MethodRef METHOD_TYPE_L = MethodRef.method(MT, "methodType", MT, JavaType.J_L_CLASS, CLASS_ARRAY);
 
     private final Block.Builder entryBlock;
     private final ClassModel classModel;
@@ -610,18 +608,30 @@ yield op(CoreOp._new(
                         MethodTypeDesc mtd = inst.typeSymbol();
 
                         //bootstrap
-                        List<Value> bootstrapArgs = new ArrayList<>();
-                        bootstrapArgs.add(lookup());
-                        bootstrapArgs.add(liftConstant(inst.name().toString()));
-                        bootstrapArgs.add(liftConstant(mtd));
-                        for (ConstantDesc barg : inst.bootstrapArgs()) {
-                            bootstrapArgs.add(liftConstant(barg));
-                        }
                         MethodTypeDesc bsmDesc = bsm.invocationType();
                         MethodRef bsmRef = MethodRef.method(JavaType.type(bsmOwner),
                                                             bsm.methodName(),
                                                             JavaType.type(bsmDesc.returnType()),
                                                             bsmDesc.parameterList().stream().map(JavaType::type).toArray(TypeElement[]::new));
+                        Value[] bootstrapArgs = new Value[bsmDesc.parameterCount()];
+                        bootstrapArgs[0] = lookup();
+                        bootstrapArgs[1] = liftConstant(inst.name().toString());
+                        bootstrapArgs[2] = liftConstant(mtd);
+                        ClassDesc lastArgType = bsmDesc.parameterType(bsmDesc.parameterCount() - 1);
+                        List<ConstantDesc> bsmArgs = inst.bootstrapArgs();
+                        if (lastArgType.isArray()) {
+                            for (int ai = 0; ai < bootstrapArgs.length - 4; ai++) {
+                                bootstrapArgs[ai + 3] = liftConstant(bsmArgs.get(ai));
+                            }
+                            // Vararg tail of the bootstrap method parameters
+                            bootstrapArgs[bootstrapArgs.length - 1] =
+                                    liftConstantsIntoArray(JavaType.type(lastArgType),
+                                                           bsmArgs.subList(bootstrapArgs.length - 4, bsmArgs.size()).toArray());
+                        } else {
+                            for (int ai = 0; ai < bootstrapArgs.length - 3; ai++) {
+                                bootstrapArgs[ai + 3] = liftConstant(bsmArgs.get(ai));
+                            }
+                        }
                         Value methodHandle = op(CoreOp.invoke(MethodRef.method(CallSite.class, "dynamicInvoker", MethodHandle.class),
                                                     op(CoreOp.invoke(JavaType.type(ConstantDescs.CD_CallSite), bsmRef, bootstrapArgs))));
 
@@ -795,6 +805,14 @@ private Op.Result lookup() {
         return constantCache.computeIfAbsent(LOOKUP, _ -> op(CoreOp.invoke(LOOKUP)));
     }
 
+    private Op.Result liftConstantsIntoArray(TypeElement arrayType, Object... constants) {
+        Op.Result array = op(CoreOp.newArray(arrayType, liftConstant(constants.length)));
+        for (int i = 0; i < constants.length; i++) {
+            op(CoreOp.arrayStoreOp(array, liftConstant(i), liftConstant(constants[i])));
+        }
+        return array;
+    }
+
     private Op.Result liftConstant(Object c) {
         Op.Result res = constantCache.get(c);
         if (res == null) {
@@ -834,13 +852,7 @@ yield op(switch (dmh.kind()) {
                 case MethodTypeDesc mt -> op(switch (mt.parameterCount()) {
                     case 0 -> CoreOp.invoke(METHOD_TYPE_0, liftConstant(mt.returnType()));
                     case 1 -> CoreOp.invoke(METHOD_TYPE_1, liftConstant(mt.returnType()), liftConstant(mt.parameterType(0)));
-                    default -> {
-                        Op.Result list = op(CoreOp._new(ARRAYLIST_INIT));
-                        for (ClassDesc p : mt.parameterList()) {
-                            op(CoreOp.invoke(ARRAYLIST_ADD, list, liftConstant(p)));
-                        }
-                        yield CoreOp.invoke(METHOD_TYPE_L, liftConstant(mt.returnType()), list);
-                    }
+                    default -> CoreOp.invoke(METHOD_TYPE_L, liftConstant(mt.returnType()), liftConstantsIntoArray(CLASS_ARRAY, (Object[])mt.parameterArray()));
                 });
                 case DynamicConstantDesc<?> v when v.bootstrapMethod().owner().equals(ConstantDescs.CD_ConstantBootstraps)
                                              && v.bootstrapMethod().methodName().equals("nullConstant")

test/jdk/java/lang/reflect/code/bytecode/TestSmallCorpus.java

@@ -94,7 +94,7 @@ public void testDoubleRoundtripStability() throws Exception {
         }
 
         // @@@ There is still several failing cases and a lot of errors
-        Assert.assertTrue(passed > 33700, String.format("""
+        Assert.assertTrue(passed > 33750, String.format("""
 
                     passed: %d
                     not matching: %d