Remove reflection

Author: Christian Wimmer

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/IntrinsifyMethodHandlesInvocationPlugin.java

@@ -27,6 +27,7 @@
 import static org.graalvm.compiler.nodes.graphbuilderconf.InlineInvokePlugin.InlineInfo.createStandardInlineInfo;
 
 import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Arrays;
@@ -96,7 +97,6 @@
 import org.graalvm.compiler.phases.common.CanonicalizerPhase;
 import org.graalvm.compiler.phases.util.Providers;
 import org.graalvm.compiler.replacements.MethodHandlePlugin;
-import org.graalvm.compiler.serviceprovider.JavaVersionUtil;
 import org.graalvm.compiler.word.WordOperationPlugin;
 import org.graalvm.nativeimage.ImageSingletons;
 
@@ -160,6 +160,19 @@
  */
 public class IntrinsifyMethodHandlesInvocationPlugin implements NodePlugin {
 
+    private static final Field varHandleVFormField;
+    private static final Method varFormInitMethod;
+
+    static {
+        varHandleVFormField = ReflectionUtil.lookupField(VarHandle.class, "vform");
+        try {
+            Class<?> varFormClass = Class.forName("java.lang.invoke.VarForm");
+            varFormInitMethod = ReflectionUtil.lookupMethod(varFormClass, "getMethodType_V", int.class);
+        } catch (ClassNotFoundException ex) {
+            throw VMError.shouldNotReachHere(ex);
+        }
+    }
+
     public static class IntrinsificationRegistry extends IntrinsificationPluginRegistry {
     }
 
@@ -174,14 +187,7 @@ public static class IntrinsificationRegistry extends IntrinsificationPluginRegis
     private final IntrinsificationRegistry intrinsificationRegistry;
 
     private final ResolvedJavaType methodHandleType;
-
-    private final Class<?> varHandleClass;
-    private final Class<?> varHandleAccessModeClass;
     private final ResolvedJavaType varHandleType;
-    private final Field varHandleVFormField;
-    private final Method varFormInitMethod;
-    private final Method varHandleIsAccessModeSupportedMethod;
-    private final Method varHandleAccessModeTypeMethod;
 
     public IntrinsifyMethodHandlesInvocationPlugin(ParsingReason reason, Providers providers, AnalysisUniverse aUniverse, HostedUniverse hUniverse) {
         this.reason = reason;
@@ -201,30 +207,8 @@ public IntrinsifyMethodHandlesInvocationPlugin(ParsingReason reason, Providers p
             intrinsificationRegistry = ImageSingletons.lookup(IntrinsificationRegistry.class);
         }
 
-        methodHandleType = universeProviders.getMetaAccess().lookupJavaType(java.lang.invoke.MethodHandle.class);
-
-        if (JavaVersionUtil.JAVA_SPEC >= 11) {
-            try {
-                varHandleClass = Class.forName("java.lang.invoke.VarHandle");
-                varHandleAccessModeClass = Class.forName("java.lang.invoke.VarHandle$AccessMode");
-                varHandleType = universeProviders.getMetaAccess().lookupJavaType(varHandleClass);
-                varHandleVFormField = ReflectionUtil.lookupField(varHandleClass, "vform");
-                Class<?> varFormClass = Class.forName("java.lang.invoke.VarForm");
-                varFormInitMethod = ReflectionUtil.lookupMethod(varFormClass, "getMethodType_V", int.class);
-                varHandleIsAccessModeSupportedMethod = ReflectionUtil.lookupMethod(varHandleClass, "isAccessModeSupported", varHandleAccessModeClass);
-                varHandleAccessModeTypeMethod = ReflectionUtil.lookupMethod(varHandleClass, "accessModeType", varHandleAccessModeClass);
-            } catch (ClassNotFoundException ex) {
-                throw VMError.shouldNotReachHere(ex);
-            }
-        } else {
-            varHandleClass = null;
-            varHandleAccessModeClass = null;
-            varHandleType = null;
-            varHandleVFormField = null;
-            varFormInitMethod = null;
-            varHandleIsAccessModeSupportedMethod = null;
-            varHandleAccessModeTypeMethod = null;
-        }
+        methodHandleType = universeProviders.getMetaAccess().lookupJavaType(MethodHandle.class);
+        varHandleType = universeProviders.getMetaAccess().lookupJavaType(VarHandle.class);
     }
 
     @Override
@@ -332,7 +316,7 @@ private boolean isVarHandleMethod(ResolvedJavaMethod method, ValueNode[] args) {
                  * initialization has happened. We force initialization by invoking the method
                  * VarHandle.vform.getMethodType_V(0).
                  */
-                Object varHandle = SubstrateObjectConstant.asObject(args[0].asJavaConstant());
+                VarHandle varHandle = (VarHandle) SubstrateObjectConstant.asObject(args[0].asJavaConstant());
                 Object varForm = varHandleVFormField.get(varHandle);
                 varFormInitMethod.invoke(varForm, 0);
 
@@ -342,17 +326,17 @@ private boolean isVarHandleMethod(ResolvedJavaMethod method, ValueNode[] args) {
                  * method. Initializing all AccessMode enum values is easier than trying to extract
                  * the actual AccessMode.
                  */
-                for (Object accessMode : varHandleAccessModeClass.getEnumConstants()) {
+                for (VarHandle.AccessMode accessMode : VarHandle.AccessMode.values()) {
                     /*
                      * Force initialization of the @Stable field VarHandle.vform.memberName_table.
                      * Starting with JDK 17, this field is lazily initialized.
                      */
-                    varHandleIsAccessModeSupportedMethod.invoke(varHandle, accessMode);
+                    varHandle.isAccessModeSupported(accessMode);
                     /*
                      * Force initialization of the @Stable field
                      * VarHandle.typesAndInvokers.methodType_table.
                      */
-                    varHandleAccessModeTypeMethod.invoke(varHandle, accessMode);
+                    varHandle.accessModeType(accessMode);
                 }
             } catch (ReflectiveOperationException ex) {
                 throw VMError.shouldNotReachHere(ex);

substratevm/src/com.oracle.svm.reflect/src/com/oracle/svm/reflect/serialize/hosted/SerializationFeature.java

@@ -65,6 +65,8 @@
 import com.oracle.svm.reflect.serialize.SerializationSupport;
 import com.oracle.svm.util.ReflectionUtil;
 
+import jdk.internal.reflect.ReflectionFactory;
+
 @AutomaticFeature
 public class SerializationFeature implements Feature {
     private SerializationBuilder serializationBuilder;
@@ -167,11 +169,9 @@ public boolean isAllowed(Class<?> clazz) {
 
 final class SerializationBuilder extends ConditionalConfigurationRegistry implements RuntimeSerializationSupport {
 
-    private final Object reflectionFactory;
-    private final Method newConstructorForSerializationMethod1;
-    private final Method newConstructorForSerializationMethod2;
-    private final Method getConstructorAccessorMethod;
-    private final Method getExternalizableConstructorMethod;
+    private static final Method getConstructorAccessorMethod = ReflectionUtil.lookupMethod(Constructor.class, "getConstructorAccessor");
+    private static final Method getExternalizableConstructorMethod = ReflectionUtil.lookupMethod(ObjectStreamClass.class, "getExternalizableConstructor", Class.class);
+
     private final Constructor<?> stubConstructor;
 
     private final SerializationSupport serializationSupport;
@@ -181,17 +181,6 @@ final class SerializationBuilder extends ConditionalConfigurationRegistry implem
     private boolean sealed;
 
     SerializationBuilder(SerializationDenyRegistry serializationDenyRegistry, ConfigurationTypeResolver typeResolver) {
-        try {
-            Class<?> reflectionFactoryClass = jdk.internal.reflect.ReflectionFactory.class;
-            Method getReflectionFactoryMethod = ReflectionUtil.lookupMethod(reflectionFactoryClass, "getReflectionFactory");
-            reflectionFactory = getReflectionFactoryMethod.invoke(null);
-            newConstructorForSerializationMethod1 = ReflectionUtil.lookupMethod(reflectionFactoryClass, "newConstructorForSerialization", Class.class);
-            newConstructorForSerializationMethod2 = ReflectionUtil.lookupMethod(reflectionFactoryClass, "newConstructorForSerialization", Class.class, Constructor.class);
-            getConstructorAccessorMethod = ReflectionUtil.lookupMethod(Constructor.class, "getConstructorAccessor");
-            getExternalizableConstructorMethod = ReflectionUtil.lookupMethod(ObjectStreamClass.class, "getExternalizableConstructor", Class.class);
-        } catch (ReflectiveOperationException e) {
-            throw VMError.shouldNotReachHere(e);
-        }
         stubConstructor = newConstructorForSerialization(SerializationSupport.StubForAbstractClass.class, null);
         this.denyRegistry = serializationDenyRegistry;
         this.typeResolver = typeResolver;
@@ -300,27 +289,23 @@ private static void registerFields(Class<?> serializationTargetClass) {
         RuntimeReflection.register(serializationTargetClass.getDeclaredFields());
     }
 
-    private Constructor<?> newConstructorForSerialization(Class<?> serializationTargetClass, Constructor<?> customConstructorToCall) {
-        try {
-            if (customConstructorToCall == null) {
-                return (Constructor<?>) newConstructorForSerializationMethod1.invoke(reflectionFactory, serializationTargetClass);
-            } else {
-                return (Constructor<?>) newConstructorForSerializationMethod2.invoke(reflectionFactory, serializationTargetClass, customConstructorToCall);
-            }
-        } catch (ReflectiveOperationException e) {
-            throw VMError.shouldNotReachHere(e);
+    private static Constructor<?> newConstructorForSerialization(Class<?> serializationTargetClass, Constructor<?> customConstructorToCall) {
+        if (customConstructorToCall == null) {
+            return ReflectionFactory.getReflectionFactory().newConstructorForSerialization(serializationTargetClass);
+        } else {
+            return ReflectionFactory.getReflectionFactory().newConstructorForSerialization(serializationTargetClass, customConstructorToCall);
         }
     }
 
-    private Object getConstructorAccessor(Constructor<?> constructor) {
+    private static Object getConstructorAccessor(Constructor<?> constructor) {
         try {
             return getConstructorAccessorMethod.invoke(constructor);
         } catch (ReflectiveOperationException e) {
             throw VMError.shouldNotReachHere(e);
         }
     }
 
-    private Constructor<?> getExternalizableConstructor(Class<?> serializationTargetClass) {
+    private static Constructor<?> getExternalizableConstructor(Class<?> serializationTargetClass) {
         try {
             return (Constructor<?>) getExternalizableConstructorMethod.invoke(null, serializationTargetClass);
         } catch (ReflectiveOperationException e) {