Crema: Implement Executable parameter reflection

gilles-duboscq · gilles-duboscq · commit a7b97f3054f5 · 2026-04-09T14:39:52.000+02:00
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/RuntimeReflectionMetadata.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/RuntimeReflectionMetadata.java
@@ -130,8 +130,7 @@ private Method fromResolvedMethod(DynamicHub declaringClass, CremaResolvedJavaMe
                         resolvedJavaMethod.getRawParameterAnnotations(),
                         resolvedJavaMethod.getRawAnnotationDefault(),
                         resolvedJavaMethod.getAccessor(receiverType, parameterTypes),
-                        /* (GR-74007) resolvedJavaMethod.getRawParameters() */
-                        null,
+                        resolvedJavaMethod.getParametersAttribute(),
                         resolvedJavaMethod.getRawTypeAnnotations(),
                         declaringClass.getLayerId());
     }
@@ -162,8 +161,7 @@ private Constructor<?> fromResolvedConstructor(DynamicHub declaringClass, CremaR
                         resolvedConstructor.getRawAnnotations(),
                         resolvedConstructor.getRawParameterAnnotations(),
                         resolvedConstructor.getAccessor(DynamicHub.toClass(declaringClass), parameterTypes),
-                        /* (GR-74007) resolvedConstructor.getRawParameters() */
-                        new byte[0],
+                        resolvedConstructor.getParametersAttribute(),
                         resolvedConstructor.getRawTypeAnnotations());
     }
 
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/crema/CremaResolvedJavaMethod.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/crema/CremaResolvedJavaMethod.java
@@ -24,6 +24,8 @@
  */
 package com.oracle.svm.core.hub.crema;
 
+import com.oracle.svm.espresso.classfile.attributes.MethodParametersAttribute;
+
 import jdk.vm.ci.meta.JavaType;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
@@ -37,35 +39,36 @@ public interface CremaResolvedJavaMethod extends ResolvedJavaMethod {
     JavaType[] getDeclaredExceptions();
 
     /**
-     * Retrieves the raw annotation bytes for this field.
+     * Retrieves the raw annotation bytes for this method.
      *
      * @return the raw annotations as a byte array
      */
     byte[] getRawAnnotations();
 
     /**
-     * Retrieves the raw parameter annotation bytes for this field.
+     * Retrieves the raw parameter annotation bytes for this method.
      *
-     * @return the raw paramater annotations as a byte array
+     * @return the raw parameter annotations as a byte array
      */
     byte[] getRawParameterAnnotations();
 
     /**
-     * Retrieves the raw annotation default bytes for this field.
+     * Retrieves the raw annotation default bytes for this method.
      *
-     * @return the raw annotations default as a byte array
+     * @return the raw annotation default as a byte array
      */
     byte[] getRawAnnotationDefault();
 
     /**
-     * Retrieves the raw parameter bytes for this field.
+     * Retrieves the {@code MethodParameters} attribute for this method.
      *
-     * @return the raw parameters as a byte array
+     * @return the {@code MethodParameters} attribute, or {@code null} if the attribute is not
+     *         present
      */
-    byte[] getRawParameters();
+    MethodParametersAttribute getParametersAttribute();
 
     /**
-     * Retrieves the raw type annotation bytes for this field.
+     * Retrieves the raw type annotation bytes for this method.
      *
      * @return the raw type annotations as a byte array
      */
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/crema/CremaSupport.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/crema/CremaSupport.java
@@ -33,14 +33,14 @@
 import com.oracle.svm.core.hub.RuntimeClassLoading.ClassDefinitionInfo;
 import com.oracle.svm.core.hub.registry.SymbolsSupport;
 import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
+import com.oracle.svm.espresso.classfile.ConstantPool;
 import com.oracle.svm.espresso.classfile.ParserKlass;
 import com.oracle.svm.espresso.classfile.descriptors.ByteSequence;
 import com.oracle.svm.espresso.classfile.descriptors.Signature;
 import com.oracle.svm.espresso.classfile.descriptors.Symbol;
 import com.oracle.svm.espresso.classfile.descriptors.Type;
 import com.oracle.svm.espresso.shared.resolver.CallKind;
 
-import jdk.vm.ci.meta.ConstantPool;
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
@@ -158,5 +158,5 @@ static CremaSupport singleton() {
     @Platforms(Platform.HOSTED_ONLY.class)
     void setEnterDirectInterpreterStubEntryPoint(CFunctionPointer stubEntryPoint);
 
-    ConstantPool getConstantPool(DynamicHub hub);
+    <T extends ConstantPool & jdk.vm.ci.meta.ConstantPool> T getConstantPool(DynamicHub hub);
 }
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/target/ReflectionObjectFactory.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/target/ReflectionObjectFactory.java
@@ -52,12 +52,12 @@ public static Field newField(RuntimeDynamicAccessMetadata dynamicAccessMetadata,
 
     public static Method newMethod(RuntimeDynamicAccessMetadata dynamicAccessMetadata, Class<?> declaringClass, String name, Class<?>[] parameterTypes, Class<?> returnType, Class<?>[] exceptionTypes,
                     int modifiers,
-                    String signature, byte[] annotations, byte[] parameterAnnotations, byte[] annotationDefault, Object accessor, byte[] rawParameters,
+                    String signature, byte[] annotations, byte[] parameterAnnotations, byte[] annotationDefault, Object accessor, Object parameterMetadata,
                     byte[] typeAnnotations, int layerId) {
         Target_java_lang_reflect_Method method = new Target_java_lang_reflect_Method();
         method.constructor(declaringClass, name, parameterTypes, returnType, exceptionTypes, modifiers, -1, signature, annotations, parameterAnnotations, annotationDefault);
         method.methodAccessorFromMetadata = (Target_jdk_internal_reflect_MethodAccessor) accessor;
-        SubstrateUtil.cast(method, Target_java_lang_reflect_Executable.class).rawParameters = rawParameters;
+        SubstrateUtil.cast(method, Target_java_lang_reflect_Executable.class).parameterMetadata = parameterMetadata;
         Target_java_lang_reflect_AccessibleObject accessibleObject = SubstrateUtil.cast(method, Target_java_lang_reflect_AccessibleObject.class);
         accessibleObject.typeAnnotations = typeAnnotations;
         accessibleObject.dynamicAccessMetadata = dynamicAccessMetadata;
@@ -67,11 +67,11 @@ public static Method newMethod(RuntimeDynamicAccessMetadata dynamicAccessMetadat
 
     public static Constructor<?> newConstructor(RuntimeDynamicAccessMetadata dynamicAccessMetadata, Class<?> declaringClass, Class<?>[] parameterTypes, Class<?>[] exceptionTypes, int modifiers,
                     String signature,
-                    byte[] annotations, byte[] parameterAnnotations, Object accessor, byte[] rawParameters, byte[] typeAnnotations) {
+                    byte[] annotations, byte[] parameterAnnotations, Object accessor, Object parameterMetadata, byte[] typeAnnotations) {
         Target_java_lang_reflect_Constructor ctor = new Target_java_lang_reflect_Constructor();
         ctor.constructor(declaringClass, parameterTypes, exceptionTypes, modifiers, -1, signature, annotations, parameterAnnotations);
         ctor.constructorAccessorFromMetadata = (Target_jdk_internal_reflect_ConstructorAccessor) accessor;
-        SubstrateUtil.cast(ctor, Target_java_lang_reflect_Executable.class).rawParameters = rawParameters;
+        SubstrateUtil.cast(ctor, Target_java_lang_reflect_Executable.class).parameterMetadata = parameterMetadata;
         Target_java_lang_reflect_AccessibleObject accessibleObject = SubstrateUtil.cast(ctor, Target_java_lang_reflect_AccessibleObject.class);
         accessibleObject.typeAnnotations = typeAnnotations;
         accessibleObject.dynamicAccessMetadata = dynamicAccessMetadata;
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/target/Target_java_lang_reflect_Executable.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/target/Target_java_lang_reflect_Executable.java
@@ -31,15 +31,18 @@
 
 import org.graalvm.nativeimage.ImageSingletons;
 
-import com.oracle.svm.shared.util.SubstrateUtil;
 import com.oracle.svm.core.annotate.Alias;
 import com.oracle.svm.core.annotate.Inject;
 import com.oracle.svm.core.annotate.RecomputeFieldValue;
 import com.oracle.svm.core.annotate.RecomputeFieldValue.Kind;
 import com.oracle.svm.core.annotate.Substitute;
 import com.oracle.svm.core.annotate.TargetClass;
 import com.oracle.svm.core.hub.DynamicHub;
+import com.oracle.svm.core.hub.crema.CremaSupport;
 import com.oracle.svm.core.reflect.RuntimeMetadataDecoder;
+import com.oracle.svm.espresso.classfile.ConstantPool.Tag;
+import com.oracle.svm.espresso.classfile.attributes.MethodParametersAttribute;
+import com.oracle.svm.shared.util.SubstrateUtil;
 
 @TargetClass(value = Executable.class)
 public final class Target_java_lang_reflect_Executable {
@@ -50,22 +53,33 @@ public final class Target_java_lang_reflect_Executable {
     @Alias @RecomputeFieldValue(kind = Kind.Reset)//
     Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
 
+    /**
+     * Backing metadata for {@link Executable#getParameters()}.
+     * <p>
+     * For executables created at image-build-time this contains the encoded {@code byte[]} produced
+     * at image build time. For run-time-loaded Crema executables this contains the
+     * {@link MethodParametersAttribute}. A {@code null} value means there is no
+     * {@code MethodParameters} attribute and reflection must synthesize parameter objects.
+     */
     @Inject @RecomputeFieldValue(kind = Kind.Custom, declClass = RawParametersComputer.class)//
-    byte[] rawParameters;
+    Object parameterMetadata;
 
     @Substitute
     private Parameter[] getParameters0() {
-        if (rawParameters == null) {
+        if (parameterMetadata == null) {
             return null;
         }
-        /*
-         * Note that the rawParameters encoding can also encode a possible IllegalArgumentException.
-         * We want the decoder to throw this exception. Our caller Executable.parameterData catches
-         * it and converts it to a class format error.
-         */
         Executable executable = SubstrateUtil.cast(this, Executable.class);
         DynamicHub declaringClass = DynamicHub.fromClass(executable.getDeclaringClass());
-        return ImageSingletons.lookup(RuntimeMetadataDecoder.class).parseReflectParameters(executable, rawParameters, declaringClass);
+        if (declaringClass.isRuntimeLoaded()) {
+            return RuntimeLoadedExecutableParameterHelper.asReflectParameters(executable, (MethodParametersAttribute) parameterMetadata, declaringClass);
+        }
+        /*
+         * Note that the image-time parameter metadata encoding can also encode a possible
+         * IllegalArgumentException. We want the decoder to throw this exception. Our caller
+         * Executable.parameterData catches it and converts it to a MalformedParametersException.
+         */
+        return ImageSingletons.lookup(RuntimeMetadataDecoder.class).parseReflectParameters(executable, (byte[]) parameterMetadata, declaringClass);
     }
 
     @Substitute
@@ -84,3 +98,34 @@ public Object transform(Object receiver, Object originalValue) {
 @TargetClass(value = Executable.class, innerClass = "ParameterData")
 final class Target_java_lang_reflect_Executable_ParameterData {
 }
+
+final class RuntimeLoadedExecutableParameterHelper {
+    private RuntimeLoadedExecutableParameterHelper() {
+    }
+
+    static Parameter[] asReflectParameters(Executable executable, MethodParametersAttribute methodParameters, DynamicHub declaringClass) {
+        MethodParametersAttribute.Entry[] entries = methodParameters.getEntries();
+        var constantPool = CremaSupport.singleton().getConstantPool(declaringClass);
+        Parameter[] parameters = new Parameter[entries.length];
+        int constantPoolLength = constantPool.length();
+        for (int i = 0; i < entries.length; i++) {
+            MethodParametersAttribute.Entry entry = entries[i];
+            int nameIndex = entry.getNameIndex();
+            int modifiers = entry.getAccessFlags();
+
+            if (nameIndex < 0 || nameIndex >= constantPoolLength) {
+                throw new IllegalArgumentException("Constant pool index out of bounds");
+            }
+
+            String name = null;
+            if (nameIndex != 0) {
+                if (constantPool.tagAt(nameIndex) != Tag.UTF8) {
+                    throw new IllegalArgumentException("Wrong type at constant pool index");
+                }
+                name = constantPool.utf8At(nameIndex, "parameter name").toString();
+            }
+            parameters[i] = ReflectionObjectFactory.newParameter(executable, i, name, modifiers);
+        }
+        return parameters;
+    }
+}
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/target/Target_java_lang_reflect_ReflectAccess.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/target/Target_java_lang_reflect_ReflectAccess.java
@@ -79,7 +79,7 @@ public Target_java_lang_reflect_Constructor copyConstructor(Target_java_lang_ref
 
 class Util_java_lang_reflect_ReflectAccess {
     static void copyExecutable(Target_java_lang_reflect_Executable copy, Target_java_lang_reflect_Executable executable) {
-        copy.rawParameters = executable.rawParameters;
+        copy.parameterMetadata = executable.parameterMetadata;
         copyAccessibleObject(SubstrateUtil.cast(copy, Target_java_lang_reflect_AccessibleObject.class),
                         SubstrateUtil.cast(executable, Target_java_lang_reflect_AccessibleObject.class));
     }
diff --git a/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/CremaResolvedJavaMethodImpl.java b/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/CremaResolvedJavaMethodImpl.java
@@ -36,6 +36,7 @@
 import com.oracle.svm.espresso.classfile.attributes.Attribute;
 import com.oracle.svm.espresso.classfile.attributes.AttributedElement;
 import com.oracle.svm.espresso.classfile.attributes.CodeAttribute;
+import com.oracle.svm.espresso.classfile.attributes.MethodParametersAttribute;
 import com.oracle.svm.espresso.classfile.attributes.SignatureAttribute;
 import com.oracle.svm.espresso.classfile.descriptors.ParserSymbols;
 import com.oracle.svm.espresso.classfile.descriptors.Symbol;
@@ -160,9 +161,8 @@ public byte[] getRawAnnotationDefault() {
     }
 
     @Override
-    public byte[] getRawParameters() {
-        // (GR-74007)
-        throw VMError.unimplemented("getRawParameters");
+    public MethodParametersAttribute getParametersAttribute() {
+        return getAttribute(MethodParametersAttribute.NAME, MethodParametersAttribute.class);
     }
 
     @Override
diff --git a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/CremaSupportImpl.java b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/CremaSupportImpl.java
@@ -1738,9 +1738,10 @@ public void setEnterDirectInterpreterStubEntryPoint(CFunctionPointer stubEntryPo
     }
 
     @Override
-    public jdk.vm.ci.meta.ConstantPool getConstantPool(DynamicHub hub) {
+    @SuppressWarnings("unchecked")
+    public <T extends com.oracle.svm.espresso.classfile.ConstantPool & jdk.vm.ci.meta.ConstantPool> T getConstantPool(DynamicHub hub) {
         InterpreterResolvedObjectType type = (InterpreterResolvedObjectType) hub.getInterpreterType();
         assert type instanceof CremaResolvedObjectType;
-        return type.getConstantPool();
+        return (T) type.getConstantPool();
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ public Target_java_lang_reflect_Constructor copyConstructor(Target_java_lang_ref`
`79`	`79`
`80`	`80`	`class Util_java_lang_reflect_ReflectAccess {`
`81`	`81`	`static void copyExecutable(Target_java_lang_reflect_Executable copy, Target_java_lang_reflect_Executable executable) {`
`82`		`- copy.rawParameters = executable.rawParameters;`
	`82`	`+ copy.parameterMetadata = executable.parameterMetadata;`
`83`	`83`	`copyAccessibleObject(SubstrateUtil.cast(copy, Target_java_lang_reflect_AccessibleObject.class),`
`84`	`84`	`SubstrateUtil.cast(executable, Target_java_lang_reflect_AccessibleObject.class));`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1738,9 +1738,10 @@ public void setEnterDirectInterpreterStubEntryPoint(CFunctionPointer stubEntryPo`
`1738`	`1738`	`}`
`1739`	`1739`
`1740`	`1740`	`@Override`
`1741`		`- public jdk.vm.ci.meta.ConstantPool getConstantPool(DynamicHub hub) {`
	`1741`	`+ @SuppressWarnings("unchecked")`
	`1742`	`+ public <T extends com.oracle.svm.espresso.classfile.ConstantPool & jdk.vm.ci.meta.ConstantPool> T getConstantPool(DynamicHub hub) {`
`1742`	`1743`	`InterpreterResolvedObjectType type = (InterpreterResolvedObjectType) hub.getInterpreterType();`
`1743`	`1744`	`assert type instanceof CremaResolvedObjectType;`
`1744`		`- return type.getConstantPool();`
	`1745`	`+ return (T) type.getConstantPool();`
`1745`	`1746`	`}`
`1746`	`1747`	`}`