[GR-45250][GR-45734] Use strict constant analysis for automatic serialization registrations.

Author: Aca-S

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/SubstrateGraphBuilderPlugins.java

@@ -38,6 +38,9 @@
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import java.util.stream.Stream;
 
+import com.oracle.svm.hosted.strictconstantanalysis.ConstantExpressionRegistry;
+import com.oracle.svm.hosted.strictconstantanalysis.InferredDynamicAccessLoggingFeature;
+import com.oracle.svm.hosted.strictconstantanalysis.StrictConstantAnalysisFeature;
 import org.graalvm.nativeimage.AnnotationAccess;
 import org.graalvm.nativeimage.ImageInfo;
 import org.graalvm.nativeimage.ImageSingletons;
@@ -239,6 +242,12 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec
 
     private static void registerSerializationPlugins(ImageClassLoader loader, InvocationPlugins plugins, ParsingReason reason) {
         if (reason.duringAnalysis() && reason != ParsingReason.JITCompilation) {
+
+            StrictConstantAnalysisFeature.Options.Mode analysisMode = StrictConstantAnalysisFeature.Options.StrictConstantAnalysis.getValue();
+            ConstantExpressionRegistry registry = ImageSingletons.contains(ConstantExpressionRegistry.class)
+                            ? ImageSingletons.lookup(ConstantExpressionRegistry.class)
+                            : null;
+
             Registration serializationFilter = new Registration(plugins, ObjectInputFilter.Config.class);
             serializationFilter.register(new RequiredInvocationPlugin("createFilter", String.class) {
                 @Override
@@ -248,10 +257,22 @@ public boolean isDecorator() {
 
                 @Override
                 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode patternNode) {
-                    String pattern = asConstantObject(b, String.class, patternNode);
-                    if (pattern != null) {
-                        b.add(ReachabilityRegistrationNode.create(() -> parsePatternAndRegister(loader, pattern), reason));
-                        return true;
+                    if (analysisMode != StrictConstantAnalysisFeature.Options.Mode.Disable) {
+                        assert registry != null;
+                        String pattern = registry.getArgument(b.getMethod(), b.bci(), targetMethod, 0, String.class);
+                        if (pattern != null) {
+                            b.add(ReachabilityRegistrationNode.create(() -> parsePatternAndRegister(loader, pattern), reason));
+                            InferredDynamicAccessLoggingFeature.logRegistration(b, reason, targetMethod, null, new Object[]{pattern});
+                            return true;
+                        }
+                    }
+                    if (analysisMode != StrictConstantAnalysisFeature.Options.Mode.Enforce) {
+                        String pattern = asConstantObject(b, String.class, patternNode);
+                        if (pattern != null) {
+                            b.add(ReachabilityRegistrationNode.create(() -> parsePatternAndRegister(loader, pattern), reason));
+                            InferredDynamicAccessLoggingFeature.logRegistration(b, reason, targetMethod, null, new Object[]{pattern});
+                            return true;
+                        }
                     }
                     return false;
                 }
@@ -267,10 +288,22 @@ public boolean isDecorator() {
 
                     @Override
                     public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode clazzNode) {
-                        Class<?> clazz = asConstantObject(b, Class.class, clazzNode);
-                        if (clazz != null) {
-                            b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.register(clazz), reason));
-                            return true;
+                        if (analysisMode != StrictConstantAnalysisFeature.Options.Mode.Disable) {
+                            assert registry != null;
+                            Class<?> clazz = registry.getArgument(b.getMethod(), b.bci(), targetMethod, 0, Class.class);
+                            if (clazz != null) {
+                                b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.register(clazz), reason));
+                                InferredDynamicAccessLoggingFeature.logRegistration(b, reason, targetMethod, null, new Object[]{clazz});
+                                return true;
+                            }
+                        }
+                        if (analysisMode != StrictConstantAnalysisFeature.Options.Mode.Enforce) {
+                            Class<?> clazz = asConstantObject(b, Class.class, clazzNode);
+                            if (clazz != null) {
+                                b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.register(clazz), reason));
+                                InferredDynamicAccessLoggingFeature.logRegistration(b, reason, targetMethod, null, new Object[]{clazz});
+                                return true;
+                            }
                         }
                         return false;
                     }
@@ -284,11 +317,24 @@ public boolean isDecorator() {
 
                     @Override
                     public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode clazzNode, ValueNode constructorNode) {
-                        var clazz = asConstantObject(b, Class.class, clazzNode);
-                        var constructor = asConstantObject(b, Constructor.class, constructorNode);
-                        if (clazz != null && constructor != null) {
-                            b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.register(clazz), reason));
-                            return true;
+                        if (analysisMode != StrictConstantAnalysisFeature.Options.Mode.Disable) {
+                            assert registry != null;
+                            Class<?> clazz = registry.getArgument(b.getMethod(), b.bci(), targetMethod, 0, Class.class);
+                            Constructor<?> constructor = registry.getArgument(b.getMethod(), b.bci(), targetMethod, 1, Constructor.class);
+                            if (clazz != null && constructor != null) {
+                                b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.register(clazz), reason));
+                                InferredDynamicAccessLoggingFeature.logRegistration(b, reason, targetMethod, null, new Object[]{clazz, constructor});
+                                return true;
+                            }
+                        }
+                        if (analysisMode != StrictConstantAnalysisFeature.Options.Mode.Enforce) {
+                            var clazz = asConstantObject(b, Class.class, clazzNode);
+                            var constructor = asConstantObject(b, Constructor.class, constructorNode);
+                            if (clazz != null && constructor != null) {
+                                b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.register(clazz), reason));
+                                InferredDynamicAccessLoggingFeature.logRegistration(b, reason, targetMethod, null, new Object[]{clazz, constructor});
+                                return true;
+                            }
                         }
                         return false;
                     }
@@ -686,6 +732,8 @@ private static FixedNode unwrapNode(FixedNode node) {
             } else if (successor instanceof AbstractBeginNode) {
                 /* Useless block begins can occur during parsing or graph decoding. */
                 successor = ((AbstractBeginNode) successor).next();
+            } else if (successor instanceof ReachabilityRegistrationNode) {
+                successor = ((ReachabilityRegistrationNode) successor).next();
             } else {
                 return successor;
             }