[GR-70562] Load instantiated subtypes of loaded base layer types, even if the type is already instantiated

Author: Zeavee

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/imagelayer/SVMImageLayerLoader.java

@@ -739,24 +739,29 @@ private void initializeBaseLayerTypeBeforePublishing(AnalysisType type, Persiste
     public void initializeBaseLayerType(AnalysisType type) {
         VMError.guarantee(type.isInBaseLayer());
         PersistedAnalysisType.Reader td = findType(getBaseLayerTypeId(type));
-        registerFlag(td.getIsInstantiated(), _ -> type.registerAsInstantiated(PERSISTED));
-        registerFlag(td.getIsUnsafeAllocated(), _ -> type.registerAsUnsafeAllocated(PERSISTED));
-        registerFlag(td.getIsReachable(), _ -> type.registerAsReachable(PERSISTED));
+        postTask(td.getIsInstantiated(), _ -> type.registerAsInstantiated(PERSISTED));
+        postTask(td.getIsUnsafeAllocated(), _ -> type.registerAsUnsafeAllocated(PERSISTED));
+        postTask(td.getIsReachable(), _ -> type.registerAsReachable(PERSISTED));
 
-        if (!td.getIsInstantiated() && td.getIsAnySubtypeInstantiated()) {
+        if (td.getIsAnySubtypeInstantiated()) {
+            /*
+             * Once a base layer type is loaded, loading all its instantiated subtypes ensures that
+             * the application layer typestate is coherent with the base layer typestate. Otherwise,
+             * unwanted optimizations could occur as the typestate would not contain some missed
+             * types from the base layer.
+             */
             var subTypesReader = td.getSubTypes();
             for (int i = 0; i < subTypesReader.size(); ++i) {
                 int tid = subTypesReader.get(i);
                 var subTypeReader = findType(tid);
-                if (subTypeReader.getIsInstantiated()) {
-                    registerFlag(true, _ -> getAnalysisTypeForBaseLayerId(subTypeReader.getId()));
-                }
+                /* Only load instantiated subtypes. */
+                postTask(subTypeReader.getIsInstantiated(), _ -> getAnalysisTypeForBaseLayerId(subTypeReader.getId()));
             }
         }
     }
 
-    private void registerFlag(boolean flag, DebugContextRunnable task) {
-        if (flag) {
+    private void postTask(boolean condition, DebugContextRunnable task) {
+        if (condition) {
             if (universe.getBigbang() != null) {
                 universe.getBigbang().postTask(task);
             } else {
@@ -1022,11 +1027,11 @@ public void addBaseLayerMethod(AnalysisMethod analysisMethod) {
         methods.putIfAbsent(analysisMethod.getId(), analysisMethod);
 
         PersistedAnalysisMethod.Reader md = getMethodData(analysisMethod);
-        registerFlag(md.getIsVirtualRootMethod(), _ -> analysisMethod.registerAsVirtualRootMethod(PERSISTED));
-        registerFlag(md.getIsDirectRootMethod(), _ -> analysisMethod.registerAsDirectRootMethod(PERSISTED));
-        registerFlag(md.getIsInvoked(), _ -> analysisMethod.registerAsInvoked(PERSISTED));
-        registerFlag(md.getIsImplementationInvoked(), _ -> analysisMethod.registerAsImplementationInvoked(PERSISTED));
-        registerFlag(md.getIsIntrinsicMethod(), _ -> analysisMethod.registerAsIntrinsicMethod(PERSISTED));
+        postTask(md.getIsVirtualRootMethod(), _ -> analysisMethod.registerAsVirtualRootMethod(PERSISTED));
+        postTask(md.getIsDirectRootMethod(), _ -> analysisMethod.registerAsDirectRootMethod(PERSISTED));
+        postTask(md.getIsInvoked(), _ -> analysisMethod.registerAsInvoked(PERSISTED));
+        postTask(md.getIsImplementationInvoked(), _ -> analysisMethod.registerAsImplementationInvoked(PERSISTED));
+        postTask(md.getIsIntrinsicMethod(), _ -> analysisMethod.registerAsIntrinsicMethod(PERSISTED));
 
         AnalysisMethod.CompilationBehavior compilationBehavior = AnalysisMethod.CompilationBehavior.values()[md.getCompilationBehaviorOrdinal()];
         analysisMethod.setCompilationBehavior(compilationBehavior);
@@ -1309,17 +1314,17 @@ public void initializeBaseLayerField(AnalysisField analysisField) {
         if (!analysisField.isStatic() && (isAccessed || isRead)) {
             analysisField.getDeclaringClass().getInstanceFields(true);
         }
-        registerFlag(isAccessed, _ -> {
+        postTask(isAccessed, _ -> {
             analysisField.injectDeclaredType();
             analysisField.registerAsAccessed(PERSISTED);
         });
-        registerFlag(isRead, _ -> analysisField.registerAsRead(PERSISTED));
-        registerFlag(fieldData.getIsWritten(), _ -> {
+        postTask(isRead, _ -> analysisField.registerAsRead(PERSISTED));
+        postTask(fieldData.getIsWritten(), _ -> {
             analysisField.injectDeclaredType();
             analysisField.registerAsWritten(PERSISTED);
         });
-        registerFlag(fieldData.getIsFolded(), _ -> analysisField.registerAsFolded(PERSISTED));
-        registerFlag(fieldData.getIsUnsafeAccessed(), _ -> analysisField.registerAsUnsafeAccessed(PERSISTED));
+        postTask(fieldData.getIsFolded(), _ -> analysisField.registerAsFolded(PERSISTED));
+        postTask(fieldData.getIsUnsafeAccessed(), _ -> analysisField.registerAsUnsafeAccessed(PERSISTED));
 
         /*
          * Inject the base layer position. If the position computed for this layer, either before