Simplify root fields registration.

Author: cstancu

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

@@ -25,11 +25,9 @@
 package com.oracle.graal.pointsto;
 
 import static com.oracle.graal.pointsto.meta.AnalysisUniverse.ESTIMATED_NUMBER_OF_TYPES;
-import static jdk.vm.ci.common.JVMCIError.shouldNotReachHere;
 
 import java.io.PrintWriter;
 import java.lang.reflect.Executable;
-import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -47,7 +45,6 @@
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatures;
 import com.oracle.graal.pointsto.flow.AlwaysEnabledPredicateFlow;
 import com.oracle.graal.pointsto.flow.AnyPrimitiveSourceTypeFlow;
-import com.oracle.graal.pointsto.flow.FieldTypeFlow;
 import com.oracle.graal.pointsto.flow.FormalParamTypeFlow;
 import com.oracle.graal.pointsto.flow.InvokeTypeFlow;
 import com.oracle.graal.pointsto.flow.MethodFlowsGraph;
@@ -77,6 +74,7 @@
 import com.oracle.svm.common.meta.MultiMethod;
 import com.oracle.svm.util.AnnotationUtil;
 import com.oracle.svm.util.ClassUtil;
+import com.oracle.svm.util.JVMCIReflectionUtil;
 
 import jdk.graal.compiler.api.replacements.Fold;
 import jdk.graal.compiler.api.replacements.SnippetReflectionProvider;
@@ -266,26 +264,9 @@ public void forceUnsafeUpdate() {
     }
 
     @Override
-    public void registerAsJNIAccessed(AnalysisField f, boolean writable) {
-        PointsToAnalysisField field = (PointsToAnalysisField) f;
-        // Same as addRootField() and addRootStaticField():
-        // create type flows for any subtype of the field's declared type
-        TypeFlow<?> declaredTypeFlow = field.getType().getTypeFlow(this, true);
-        if (isSupportedJavaKind(field.getStorageKind())) {
-            if (field.isStatic()) {
-                if (field.getStorageKind().isObject()) {
-                    declaredTypeFlow.addUse(this, field.getStaticFieldFlow());
-                } else {
-                    field.saturatePrimitiveField();
-                }
-            } else {
-                FieldTypeFlow instanceFieldFlow = field.getDeclaringClass().getContextInsensitiveAnalysisObject().getInstanceFieldFlow(this, field, writable);
-                if (field.getStorageKind().isObject()) {
-                    declaredTypeFlow.addUse(this, instanceFieldFlow);
-                } else {
-                    field.saturatePrimitiveField();
-                }
-            }
+    public void registerAsJNIAccessed(AnalysisField field, boolean writable) {
+        if (writable && isSupportedJavaKind(field.getStorageKind())) {
+            field.injectDeclaredType();
         }
     }
 
@@ -519,7 +500,7 @@ public AnalysisType addRootClass(AnalysisType type, boolean addFields, boolean a
             if (addFields) {
                 field.registerAsAccessed("field of root class");
             }
-            processRootField(type, field);
+            processRootField(field);
         }
         if (type.getSuperclass() != null) {
             addRootClass(type.getSuperclass(), addFields, addArrayClass);
@@ -531,77 +512,23 @@ public AnalysisType addRootClass(AnalysisType type, boolean addFields, boolean a
     }
 
     @Override
-    @SuppressWarnings("try")
     public AnalysisType addRootField(Class<?> clazz, String fieldName) {
-        AnalysisType type = addRootClass(clazz, false, false);
-        for (ResolvedJavaField javaField : type.getInstanceFields(true)) {
-            var field = (PointsToAnalysisField) javaField;
-            if (field.getName().equals(fieldName)) {
-                return addRootField(type, field);
-            }
-        }
-        throw shouldNotReachHere("field not found: " + fieldName);
+        AnalysisType type = metaAccess.lookupJavaType(clazz);
+        addRootClass(type, false, false);
+        return addRootField((AnalysisField) JVMCIReflectionUtil.getDeclaredField(type, fieldName));
     }
 
     @Override
-    public AnalysisType addRootField(AnalysisField f) {
-        var field = (PointsToAnalysisField) f;
-        if (field.isStatic()) {
-            return addRootStaticField(field);
-        } else {
-            return addRootField(field.getDeclaringClass(), field);
-        }
-    }
-
-    private AnalysisType addRootField(AnalysisType type, PointsToAnalysisField field) {
-        field.registerAsAccessed("root field");
-        processRootField(type, field);
+    public AnalysisType addRootField(AnalysisField field) {
+        field.registerAsAccessed((field.isStatic() ? "static" : "instance") + " root field");
+        processRootField(field);
         return field.getType();
     }
 
-    private void processRootField(AnalysisType type, PointsToAnalysisField field) {
-        JavaKind storageKind = field.getStorageKind();
-        if (isSupportedJavaKind(storageKind)) {
-            var fieldFlow = type.getContextInsensitiveAnalysisObject().getInstanceFieldFlow(this, field, true);
-            if (storageKind.isObject()) {
-                /*
-                 * For system classes any instantiated (sub)type of the declared field type can be
-                 * written to the field flow.
-                 */
-                TypeFlow<?> fieldDeclaredTypeFlow = field.getType().getTypeFlow(this, true);
-                fieldDeclaredTypeFlow.addUse(this, fieldFlow);
-            } else {
-                fieldFlow.addState(this, TypeState.anyPrimitiveState());
-            }
-        }
-    }
-
-    @SuppressWarnings({"try", "unused"})
-    public AnalysisType addRootStaticField(Class<?> clazz, String fieldName) {
-        addRootClass(clazz, false, false);
-        Field reflectField;
-        try {
-            reflectField = clazz.getField(fieldName);
-            var field = (PointsToAnalysisField) metaAccess.lookupJavaField(reflectField);
-            return addRootStaticField(field);
-
-        } catch (NoSuchFieldException e) {
-            throw shouldNotReachHere("field not found: " + fieldName);
-        }
-    }
-
-    private AnalysisType addRootStaticField(PointsToAnalysisField field) {
-        field.registerAsAccessed("static root field");
-        JavaKind storageKind = field.getStorageKind();
-        if (isSupportedJavaKind(storageKind)) {
-            if (storageKind.isObject()) {
-                TypeFlow<?> fieldFlow = field.getType().getTypeFlow(this, true);
-                fieldFlow.addUse(this, field.getStaticFieldFlow());
-            } else {
-                field.getStaticFieldFlow().addState(this, TypeState.anyPrimitiveState());
-            }
+    private void processRootField(AnalysisField field) {
+        if (isSupportedJavaKind(field.getStorageKind())) {
+            field.injectDeclaredType();
         }
-        return field.getType();
     }
 
     @Override

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

@@ -40,8 +40,12 @@ public PointsToCustomTypeFieldHandler(BigBang bb, AnalysisMetaAccess metaAccess)
     }
 
     /**
-     * Inject custom types for an analysis field. These fields usually have lazily computed values
-     * which are not available during analysis.
+     * 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) {
@@ -73,11 +77,11 @@ public void injectFieldTypes(AnalysisField aField, List<AnalysisType> customType
                     fieldComponentType.getTypeFlow(analysis, false).addUse(analysis, elementsFlow);
 
                     /*
-                     * In the current implementation it is not necessary to do it it recursively for
+                     * 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 a n-dimensional array that value is another
-                     * array, n-1 dimensional).
+                     * value is non-null (in the case of an n-dimensional array that value is
+                     * another array, n-1 dimensional).
                      */
                 }
             }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIAccessFeature.java

@@ -513,7 +513,7 @@ private void addField(Field reflField, boolean preserved, boolean writable, Duri
         JNIAccessibleClass jniClass = addClass(reflField.getDeclaringClass(), preserved, access);
         AnalysisField field = access.getMetaAccess().lookupJavaField(reflField);
         jniClass.addOrUpdateField(field.getName(), preserved, _ -> new JNIAccessibleField(jniClass, field.getJavaKind(), field.getModifiers(), preserved));
-        field.registerAsRead("it is registered for as JNI accessed");
+        field.registerAsRead("it is registered as JNI accessed");
         if (writable) {
             field.registerAsWritten("it is registered as JNI writable");
             AnalysisType fieldType = field.getType();