Track preserved state through serialization

Author: DSouzaM

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/serialize/SerializationSupport.java

@@ -219,11 +219,12 @@ public int getTypeID() {
     private final EconomicMap<String, RuntimeConditionSet> lambdaCapturingClasses = EconomicMap.create();
 
     @Platforms(Platform.HOSTED_ONLY.class)
-    public void registerSerializationTargetClass(AccessCondition cnd, DynamicHub hub) {
+    public void registerSerializationTargetClass(AccessCondition cnd, DynamicHub hub, boolean preserved) {
         synchronized (classes) {
-            var previous = classes.putIfAbsent(BuildPhaseProvider.isHostedUniverseBuilt() ? hub.getTypeID() : new DynamicHubKey(hub), RuntimeConditionSet.createHosted(cnd, false));
+            var previous = classes.putIfAbsent(BuildPhaseProvider.isHostedUniverseBuilt() ? hub.getTypeID() : new DynamicHubKey(hub), RuntimeConditionSet.createHosted(cnd, preserved));
             if (previous != null) {
                 previous.addCondition(cnd);
+                previous.reportReregistered(preserved);
             }
         }
     }
@@ -313,4 +314,14 @@ public boolean isRegisteredForSerialization0(DynamicHub dynamicHub) {
         var conditionSet = classes.get(dynamicHub.getTypeID());
         return conditionSet != null && conditionSet.satisfied();
     }
+
+    public static boolean isPreservedForSerialization(DynamicHub dynamicHub) {
+        for (SerializationSupport singleton : SerializationSupport.layeredSingletons()) {
+            var conditionSet = singleton.classes.get(dynamicHub.getTypeID());
+            if (conditionSet != null) {
+                return conditionSet.preserved();
+            }
+        }
+        return false;
+    }
 }

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

@@ -155,8 +155,8 @@ private static void registerLambdasFromConstantNodesInGraph(StructuredGraph grap
 
             if (lambdaClass != null && Serializable.class.isAssignableFrom(lambdaClass)) {
                 RuntimeReflection.register(ReflectionUtil.lookupMethod(lambdaClass, "writeReplace"));
-                SerializationBuilder.registerSerializationUIDElements(lambdaClass, false);
-                serializationBuilder.serializationSupport.registerSerializationTargetClass(AccessCondition.unconditional(), serializationBuilder.getHostVM().dynamicHub(lambdaClass));
+                SerializationBuilder.registerSerializationUIDElements(lambdaClass, false, false);
+                serializationBuilder.serializationSupport.registerSerializationTargetClass(AccessCondition.unconditional(), serializationBuilder.getHostVM().dynamicHub(lambdaClass), false);
             }
         }
     }
@@ -423,10 +423,10 @@ public void register(AccessCondition condition, boolean preserved, Class<?> seri
              * Making this class reachable as it will end up in the image heap without the analysis
              * knowing.
              */
-            RuntimeReflection.register(java.io.ObjectOutputStream.class);
+            ImageSingletons.lookup(RuntimeReflectionSupport.class).register(AccessCondition.unconditional(), false, preserved, java.io.ObjectOutputStream.class);
 
             if (denyRegistry.isAllowed(serializationTargetClass)) {
-                addOrQueueConstructorAccessors(cnd, serializationTargetClass, getHostVM().dynamicHub(serializationTargetClass));
+                addOrQueueConstructorAccessors(cnd, serializationTargetClass, getHostVM().dynamicHub(serializationTargetClass), preserved);
 
                 Class<?> superclass = serializationTargetClass.getSuperclass();
                 if (superclass != null) {
@@ -435,35 +435,35 @@ public void register(AccessCondition condition, boolean preserved, Class<?> seri
                     ImageSingletons.lookup(RuntimeReflectionSupport.class).registerMethodLookup(AccessCondition.unconditional(), preserved, superclass, "readResolve");
                 }
 
-                registerForSerialization(cnd, serializationTargetClass);
-                registerForDeserialization(cnd, serializationTargetClass);
+                registerForSerialization(cnd, preserved, serializationTargetClass);
+                registerForDeserialization(cnd, preserved, serializationTargetClass);
 
             }
         });
     }
 
-    private void addOrQueueConstructorAccessors(AccessCondition cnd, Class<?> serializationTargetClass, DynamicHub hub) {
+    private void addOrQueueConstructorAccessors(AccessCondition cnd, Class<?> serializationTargetClass, DynamicHub hub, boolean preserved) {
         if (pendingConstructorRegistrations != null) {
             // cannot yet create constructor accessor -> add to pending
-            pendingConstructorRegistrations.add(() -> registerConstructorAccessors(cnd, serializationTargetClass, hub));
+            pendingConstructorRegistrations.add(() -> registerConstructorAccessors(cnd, serializationTargetClass, hub, preserved));
         } else {
             // can already run the registration
-            registerConstructorAccessors(cnd, serializationTargetClass, hub);
+            registerConstructorAccessors(cnd, serializationTargetClass, hub, preserved);
         }
     }
 
-    private void registerConstructorAccessors(AccessCondition cnd, Class<?> serializationTargetClass, DynamicHub hub) {
-        serializationSupport.registerSerializationTargetClass(cnd, hub);
-        registerConstructorAccessor(cnd, serializationTargetClass, null);
+    private void registerConstructorAccessors(AccessCondition cnd, Class<?> serializationTargetClass, DynamicHub hub, boolean preserved) {
+        serializationSupport.registerSerializationTargetClass(cnd, hub, preserved);
+        registerConstructorAccessor(cnd, serializationTargetClass, null, preserved);
         for (Class<?> superclass = serializationTargetClass; superclass != null; superclass = superclass.getSuperclass()) {
-            registerConstructorAccessor(cnd, serializationTargetClass, superclass);
+            registerConstructorAccessor(cnd, serializationTargetClass, superclass, preserved);
         }
     }
 
-    private void registerConstructorAccessor(AccessCondition cnd, Class<?> serializationTargetClass, Class<?> targetConstructorClass) {
+    private void registerConstructorAccessor(AccessCondition cnd, Class<?> serializationTargetClass, Class<?> targetConstructorClass, boolean preserved) {
         Optional.ofNullable(addConstructorAccessor(serializationTargetClass, targetConstructorClass))
                         .map(ReflectionUtil::lookupConstructor)
-                        .ifPresent(methods -> ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, false, methods));
+                        .ifPresent(methods -> ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, preserved, methods));
     }
 
     void beforeAnalysis(Feature.BeforeAnalysisAccess beforeAnalysisAccess) {
@@ -474,37 +474,37 @@ void beforeAnalysis(Feature.BeforeAnalysisAccess beforeAnalysisAccess) {
         serializationSupport.setStubConstructor(stubConstructor);
     }
 
-    private static void registerQueriesForInheritableMethod(Class<?> clazz, String methodName, Class<?>... args) {
+    private static void registerQueriesForInheritableMethod(boolean preserved, Class<?> clazz, String methodName, Class<?>... args) {
         Class<?> iter = clazz;
         while (iter != null) {
-            RuntimeReflection.registerMethodLookup(iter, methodName, args);
+            ImageSingletons.lookup(RuntimeReflectionSupport.class).registerMethodLookup(AccessCondition.unconditional(), preserved, iter, methodName, args);
             Method method = ReflectionUtil.lookupMethod(true, clazz, methodName, args);
             if (method != null) {
-                RuntimeReflection.register(method);
+                registerMethod(AccessCondition.unconditional(), preserved, clazz, methodName, args);
                 break;
             }
             iter = iter.getSuperclass();
         }
     }
 
-    private static void registerMethod(AccessCondition cnd, Class<?> clazz, String methodName, Class<?>... args) {
+    private static void registerMethod(AccessCondition cnd, boolean preserved, Class<?> clazz, String methodName, Class<?>... args) {
         Method method = ReflectionUtil.lookupMethod(true, clazz, methodName, args);
         if (method != null) {
-            ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, false, method);
+            ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, preserved, method);
         } else {
-            RuntimeReflection.registerMethodLookup(clazz, methodName, args);
+            ImageSingletons.lookup(RuntimeReflectionSupport.class).registerMethodLookup(AccessCondition.unconditional(), preserved, clazz, methodName, args);
         }
     }
 
-    private void registerForSerialization(AccessCondition cnd, Class<?> serializationTargetClass) {
+    private void registerForSerialization(AccessCondition cnd, boolean preserved, Class<?> serializationTargetClass) {
 
         if (Serializable.class.isAssignableFrom(serializationTargetClass)) {
             /*
              * ObjectStreamClass.computeDefaultSUID is always called at runtime to verify
              * serialization class consistency, so need to register all constructors, methods and
              * fields.
              */
-            registerSerializationUIDElements(serializationTargetClass, true); // if MRE
+            registerSerializationUIDElements(serializationTargetClass, true, preserved); // if MRE
 
             /*
              * Required by jdk.internal.reflect.ReflectionFactory.newConstructorForSerialization
@@ -513,7 +513,7 @@ private void registerForSerialization(AccessCondition cnd, Class<?> serializatio
             boolean initClValid = true;
             while (Serializable.class.isAssignableFrom(initCl)) {
                 Class<?> prev = initCl;
-                RuntimeReflection.registerAllDeclaredConstructors(initCl);
+                registerAllDeclaredConstructors(preserved, initCl);
                 if ((initCl = initCl.getSuperclass()) == null || (!disableSerialConstructorChecks() &&
                                 !prev.isArray() && !superHasAccessibleConstructor(prev))) {
                     initClValid = false;
@@ -522,18 +522,18 @@ private void registerForSerialization(AccessCondition cnd, Class<?> serializatio
             }
 
             if (initClValid) {
-                RuntimeReflection.registerAllDeclaredConstructors(initCl);
+                registerAllDeclaredConstructors(preserved, initCl);
             }
 
             Class<?> iter = serializationTargetClass;
             while (iter != null) {
-                RuntimeReflection.registerAllDeclaredFields(iter);
+                registerAllDeclaredFields(preserved, iter);
                 try {
                     Arrays.stream(iter.getDeclaredFields())
                                     .map(Field::getType).forEach(type -> {
-                                        RuntimeReflection.registerAllDeclaredMethods(type);
-                                        RuntimeReflection.registerAllDeclaredFields(type);
-                                        RuntimeReflection.registerAllDeclaredConstructors(type);
+                                        registerAllDeclaredMethods(preserved, type);
+                                        registerAllDeclaredFields(preserved, type);
+                                        registerAllDeclaredConstructors(preserved, type);
                                     });
                 } catch (LinkageError l) {
                     /* Handled with registration above */
@@ -542,37 +542,49 @@ private void registerForSerialization(AccessCondition cnd, Class<?> serializatio
             }
         }
 
-        registerQueriesForInheritableMethod(serializationTargetClass, "writeReplace");
-        registerQueriesForInheritableMethod(serializationTargetClass, "readResolve");
-        registerMethod(cnd, serializationTargetClass, "writeObject", ObjectOutputStream.class);
-        registerMethod(cnd, serializationTargetClass, "readObjectNoData");
-        registerMethod(cnd, serializationTargetClass, "readObject", ObjectInputStream.class);
+        registerQueriesForInheritableMethod(preserved, serializationTargetClass, "writeReplace");
+        registerQueriesForInheritableMethod(preserved, serializationTargetClass, "readResolve");
+        registerMethod(cnd, preserved, serializationTargetClass, "writeObject", ObjectOutputStream.class);
+        registerMethod(cnd, preserved, serializationTargetClass, "readObjectNoData");
+        registerMethod(cnd, preserved, serializationTargetClass, "readObject", ObjectInputStream.class);
     }
 
     @SuppressWarnings("unused")
-    static void registerSerializationUIDElements(Class<?> serializationTargetClass, boolean fullyRegister) {
-        RuntimeReflection.registerAllDeclaredConstructors(serializationTargetClass);
-        RuntimeReflection.registerAllDeclaredMethods(serializationTargetClass);
-        RuntimeReflection.registerAllDeclaredFields(serializationTargetClass);
+    static void registerSerializationUIDElements(Class<?> serializationTargetClass, boolean fullyRegister, boolean preserved) {
+        registerAllDeclaredConstructors(preserved, serializationTargetClass);
+        registerAllDeclaredMethods(preserved, serializationTargetClass);
+        registerAllDeclaredFields(preserved, serializationTargetClass);
         if (fullyRegister) {
             try {
                 /* This is here a legacy that we can't remove as it is a breaking change */
-                RuntimeReflection.register(serializationTargetClass.getDeclaredConstructors());
-                RuntimeReflection.register(serializationTargetClass.getDeclaredMethods());
-                RuntimeReflection.register(serializationTargetClass.getDeclaredFields());
+                ImageSingletons.lookup(RuntimeReflectionSupport.class).register(AccessCondition.unconditional(), false, preserved, serializationTargetClass.getDeclaredConstructors());
+                ImageSingletons.lookup(RuntimeReflectionSupport.class).register(AccessCondition.unconditional(), false, preserved, serializationTargetClass.getDeclaredMethods());
+                ImageSingletons.lookup(RuntimeReflectionSupport.class).register(AccessCondition.unconditional(), false, preserved, serializationTargetClass.getDeclaredFields());
             } catch (LinkageError e) {
                 /* Handled by registrations above */
             }
         }
-        RuntimeReflection.registerFieldLookup(serializationTargetClass, "serialPersistentFields");
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).registerFieldLookup(AccessCondition.unconditional(), preserved, serializationTargetClass, "serialPersistentFields");
+    }
+
+    static void registerAllDeclaredConstructors(boolean preserved, Class<?> declaringClass) {
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).registerAllDeclaredConstructorsQuery(AccessCondition.unconditional(), true, preserved, declaringClass);
+    }
+
+    static void registerAllDeclaredMethods(boolean preserved, Class<?> declaringClass) {
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).registerAllDeclaredMethodsQuery(AccessCondition.unconditional(), true, preserved, declaringClass);
+    }
+
+    static void registerAllDeclaredFields(boolean preserved, Class<?> declaringClass) {
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).registerAllDeclaredFields(AccessCondition.unconditional(), preserved, declaringClass);
     }
 
     public void afterAnalysis() {
         sealed();
     }
 
-    private static void registerForDeserialization(AccessCondition cnd, Class<?> serializationTargetClass) {
-        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, serializationTargetClass);
+    private static void registerForDeserialization(AccessCondition cnd, boolean preserved, Class<?> serializationTargetClass) {
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, preserved, serializationTargetClass);
 
         if (serializationTargetClass.isRecord()) {
             /*
@@ -584,20 +596,20 @@ private static void registerForDeserialization(AccessCondition cnd, Class<?> ser
             try {
                 /* Serialization for records uses the canonical record constructor directly. */
                 Executable[] methods = new Executable[]{RecordUtils.getCanonicalRecordConstructor(serializationTargetClass)};
-                ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, false, methods);
+                ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, preserved, methods);
                 Executable[] methods1 = RecordUtils.getRecordComponentAccessorMethods(serializationTargetClass);
-                ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, false, methods1);
+                ImageSingletons.lookup(RuntimeReflectionSupport.class).register(cnd, false, preserved, methods1);
             } catch (LinkageError le) {
                 /*
                  * Handled by the record component registration above.
                  */
             }
         } else if (Externalizable.class.isAssignableFrom(serializationTargetClass)) {
-            RuntimeReflection.registerConstructorLookup(serializationTargetClass);
+            ImageSingletons.lookup(RuntimeReflectionSupport.class).registerConstructorLookup(AccessCondition.unconditional(), preserved, serializationTargetClass);
         }
 
-        registerMethod(cnd, serializationTargetClass, "readObject", ObjectInputStream.class);
-        registerMethod(cnd, serializationTargetClass, "readResolve");
+        registerMethod(cnd, preserved, serializationTargetClass, "readObject", ObjectInputStream.class);
+        registerMethod(cnd, preserved, serializationTargetClass, "readResolve");
     }
 
     private Constructor<?> newConstructorForSerialization(Class<?> serializationTargetClass, Constructor<?> customConstructorToCall) {