Simplify root fields registration.

Author: cstancu

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/PointsToAnalysis.java

@@ -655,6 +655,53 @@ public void onTypeInstantiated(AnalysisType type) {
         });
     }
 
+    /**
+     * Inject custom types in the analysis field type state. This utility is used for:
+     * <ul>
+     * <li>root fields - whose state is forced to be that of the declared type</li>
+     * <li>unsafe accessed fields - whose state is conservatively also the declared type</li>
+     * <li>lazily computed fields - for which writes are not visible during analysis</li>
+     * <ul/>
+     */
+    @Override
+    public void injectFieldTypes(AnalysisField aField, List<AnalysisType> customTypes, boolean canBeNull) {
+        assert aField.getStorageKind().isObject();
+        var ptaField = (PointsToAnalysisField) aField;
+
+        /* Link the field with all declared types. */
+        for (AnalysisType type : customTypes) {
+            if (type.isPrimitive() || type.isWordType()) {
+                continue;
+            }
+            type.getTypeFlow(this, canBeNull).addUse(this, ptaField.getInitialFlow());
+
+            if (type.isArray()) {
+                AnalysisType fieldComponentType = type.getComponentType();
+                ptaField.getInitialFlow().addUse(this, ptaField.getSinkFlow());
+                if (!(fieldComponentType.isPrimitive() || fieldComponentType.isWordType())) {
+                    /*
+                     * Write the component type abstract object into the field array elements type
+                     * flow, i.e., the array elements type flow of the abstract object of the field
+                     * declared type.
+                     *
+                     * This is required so that the index loads from this array return all the
+                     * possible objects that can be stored in the array.
+                     */
+                    TypeFlow<?> elementsFlow = type.getContextInsensitiveAnalysisObject().getArrayElementsFlow(this, true);
+                    fieldComponentType.getTypeFlow(this, false).addUse(this, elementsFlow);
+
+                    /*
+                     * In the current implementation it is not necessary to do it recursively for
+                     * multidimensional arrays since we don't model individual array elements, so
+                     * from the point of view of the static analysis the field's array elements
+                     * value is non-null (in the case of an n-dimensional array that value is
+                     * another array, n-1 dimensional).
+                     */
+                }
+            }
+        }
+    }
+
     public static class ConstantObjectsProfiler {
 
         static final ConcurrentHashMap<AnalysisType, MyInteger> constantTypes = new ConcurrentHashMap<>(ESTIMATED_NUMBER_OF_TYPES);

substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/ReachabilityAnalysisEngine.java

@@ -29,6 +29,7 @@
 import java.util.Collections;
 import java.util.Deque;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import com.oracle.graal.pointsto.AbstractAnalysisEngine;
@@ -154,6 +155,15 @@ public AnalysisType addRootField(AnalysisField analysisField) {
         return analysisField.getType();
     }
 
+    @Override
+    public void injectFieldTypes(AnalysisField aField, List<AnalysisType> customTypes, boolean canBeNull) {
+        assert aField.getStorageKind().isObject();
+        aField.registerAsAccessed("@UnknownObjectField annotated field.");
+        for (AnalysisType declaredType : customTypes) {
+            declaredType.registerAsReachable("injected field types for unknown annotated field " + aField.format("%H.%n"));
+        }
+    }
+
     @Override
     public AnalysisMethod addRootMethod(AnalysisMethod m, boolean invokeSpecial, Object reason, MultiMethod.MultiMethodKey... otherRoots) {
         assert otherRoots.length == 0 : otherRoots;

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ameta/CustomTypeFieldHandler.java

@@ -38,8 +38,8 @@
 import com.oracle.graal.pointsto.meta.PointsToAnalysisField;
 import com.oracle.svm.hosted.analysis.FieldValueComputer;
 
-public abstract class CustomTypeFieldHandler {
-    protected final BigBang bb;
+public final class CustomTypeFieldHandler {
+    private final BigBang bb;
     private final AnalysisMetaAccess metaAccess;
     private final FieldValueInterceptionSupport fieldValueInterceptionSupport = FieldValueInterceptionSupport.singleton();
     private Set<AnalysisField> processedFields = ConcurrentHashMap.newKeySet();
@@ -60,7 +60,7 @@ public void handleField(AnalysisField field) {
         assert field.isAccessed();
         if (fieldValueInterceptionSupport.hasFieldValueTransformer(field)) {
             if (field.getStorageKind().isObject() && !fieldValueInterceptionSupport.isValueAvailable(field, null, !field.isStatic())) {
-                injectFieldTypes(field, List.of(field.getType()), true);
+                bb.injectFieldTypes(field, List.of(field.getType()), true);
             } else if (bb.trackPrimitiveValues() && field.getStorageKind().isPrimitive() && field instanceof PointsToAnalysisField ptaField) {
                 ptaField.saturatePrimitiveField();
             }
@@ -71,15 +71,13 @@ public void handleField(AnalysisField field) {
                     assert !type.isPrimitive() : type + " for " + field;
                     type.registerAsInstantiated("Is declared as the type of an unknown object field.");
                 }
-                injectFieldTypes(field, types, fieldValueComputer.canBeNull());
+                bb.injectFieldTypes(field, types, fieldValueComputer.canBeNull());
             } else if (bb.trackPrimitiveValues() && field.getStorageKind().isPrimitive() && field instanceof PointsToAnalysisField ptaField) {
                 ptaField.saturatePrimitiveField();
             }
         }
     }
 
-    public abstract void injectFieldTypes(AnalysisField aField, List<AnalysisType> customTypes, boolean canBeNull);
-
     private List<AnalysisType> transformTypes(AnalysisField field, List<Class<?>> types) {
         List<AnalysisType> customTypes = new ArrayList<>();
         AnalysisType declaredType = field.getType();

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/analysis/NativeImagePointsToAnalysis.java

@@ -27,7 +27,6 @@
 import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
 
 import com.oracle.graal.pointsto.ClassInclusionPolicy;
@@ -87,7 +86,7 @@ public NativeImagePointsToAnalysis(OptionValues options, AnalysisUniverse univer
         this.annotationSubstitutionProcessor = annotationSubstitutionProcessor;
 
         dynamicHubInitializer = new DynamicHubInitializer(this);
-        customTypeFieldHandler = new PointsToCustomTypeFieldHandler(this, metaAccess);
+        customTypeFieldHandler = new CustomTypeFieldHandler(this, metaAccess);
         callChecker = new CallChecker();
     }
 
@@ -128,11 +127,6 @@ public void onFieldAccessed(AnalysisField field) {
         postTask(() -> customTypeFieldHandler.handleField(field));
     }
 
-    @Override
-    public void injectFieldTypes(AnalysisField aField, List<AnalysisType> customTypes, boolean canBeNull) {
-        customTypeFieldHandler.injectFieldTypes(aField, customTypes, canBeNull);
-    }
-
     @Override
     public void onTypeReachable(AnalysisType type) {
         postTask(_ -> {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/analysis/NativeImageReachabilityAnalysisEngine.java

@@ -24,8 +24,6 @@
  */
 package com.oracle.svm.hosted.analysis;
 
-import java.util.List;
-
 import com.oracle.graal.pointsto.ClassInclusionPolicy;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
@@ -58,16 +56,7 @@ public NativeImageReachabilityAnalysisEngine(OptionValues options, AnalysisUnive
                         reachabilityMethodProcessingHandler, classInclusionPolicy);
         this.annotationSubstitutionProcessor = annotationSubstitutionProcessor;
         this.dynamicHubInitializer = new DynamicHubInitializer(this);
-        this.unknownFieldHandler = new CustomTypeFieldHandler(this, metaAccess) {
-            @Override
-            public void injectFieldTypes(AnalysisField aField, List<AnalysisType> declaredTypes, boolean canBeNull) {
-                assert aField.getStorageKind().isObject();
-                aField.registerAsAccessed("@UnknownObjectField annotated field.");
-                for (AnalysisType declaredType : declaredTypes) {
-                    declaredType.registerAsReachable("injected field types for unknown annotated field " + aField.format("%H.%n"));
-                }
-            }
-        };
+        this.unknownFieldHandler = new CustomTypeFieldHandler(this, metaAccess);
     }
 
     @Override