Refactor com.oracle.svm.hosted.dynamicaccessinference package classes.

Author: Aca-S

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ResourcesFeature.java

@@ -396,7 +396,6 @@ public void afterRegistration(AfterRegistrationAccess a) {
         ImageSingletons.add(RuntimeResourceSupport.class, resourcesRegistry);
         EmbeddedResourcesInfo embeddedResourcesInfo = new EmbeddedResourcesInfo();
         ImageSingletons.add(EmbeddedResourcesInfo.class, embeddedResourcesInfo);
-        inferenceLog = ImageSingletons.contains(DynamicAccessInferenceLog.class) ? DynamicAccessInferenceLog.singleton() : null;
     }
 
     private static ResourcesRegistryImpl resourceRegistryImpl() {
@@ -489,6 +488,8 @@ public void beforeAnalysis(BeforeAnalysisAccess a) {
         globWorkSet = Set.of();
 
         resourceRegistryImpl().setAnalysisAccess(access);
+
+        inferenceLog = ImageSingletons.contains(DynamicAccessInferenceLog.class) ? DynamicAccessInferenceLog.singleton() : null;
     }
 
     private static final class ResourceCollectorImpl extends ConditionalConfigurationRegistry implements ResourceCollector {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/SVMHost.java

@@ -47,8 +47,8 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import com.oracle.svm.hosted.dynamicaccessinference.ConstantExpressionRegistry;
 import com.oracle.svm.hosted.dynamicaccessinference.StrictDynamicAccessInferenceFeature;
-import com.oracle.svm.hosted.dynamicaccessinference.StrictDynamicAccessInferenceSupport;
 import org.graalvm.nativeimage.AnnotationAccess;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
@@ -221,7 +221,7 @@ public enum UsageKind {
     private final boolean buildingImageLayer = ImageLayerBuildingSupport.buildingImageLayer();
     private final LayeredStaticFieldSupport layeredStaticFieldSupport;
 
-    private final StrictDynamicAccessInferenceSupport strictDynamicAccessInferenceSupport;
+    private final ConstantExpressionRegistry constantExpressionRegistry;
 
     @SuppressWarnings("this-escape")
     public SVMHost(OptionValues options, ImageClassLoader loader, ClassInitializationSupport classInitializationSupport, AnnotationSubstitutionProcessor annotationSubstitutions,
@@ -260,7 +260,7 @@ public SVMHost(OptionValues options, ImageClassLoader loader, ClassInitializatio
         enableReachableInCurrentLayer = ImageLayerBuildingSupport.buildingExtensionLayer();
         layeredStaticFieldSupport = ImageLayerBuildingSupport.buildingImageLayer() ? LayeredStaticFieldSupport.singleton() : null;
 
-        strictDynamicAccessInferenceSupport = StrictDynamicAccessInferenceFeature.isDisabled() ? null : StrictDynamicAccessInferenceSupport.singleton();
+        constantExpressionRegistry = StrictDynamicAccessInferenceFeature.isActive() ? ConstantExpressionRegistry.singleton() : null;
     }
 
     /**
@@ -1277,7 +1277,7 @@ public SimulateClassInitializerSupport createSimulateClassInitializerSupport(Ana
         return new SimulateClassInitializerSupport(aMetaAccess, this);
     }
 
-    public StrictDynamicAccessInferenceSupport getStrictDynamicAccessInferenceSupport() {
-        return strictDynamicAccessInferenceSupport;
+    public ConstantExpressionRegistry getConstantExpressionRegistry() {
+        return constantExpressionRegistry;
     }
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/dynamicaccessinference/ConstantExpressionAnalyzer.java

@@ -86,14 +86,14 @@
  * into the abstract frame, while the inferred value represents the actual Java value which would be
  * observed during the run-time execution of the corresponding instruction.
  */
-public final class ConstantExpressionAnalyzer extends AbstractInterpreter<ConstantExpressionAnalyzer.Value> {
+final class ConstantExpressionAnalyzer extends AbstractInterpreter<ConstantExpressionAnalyzer.Value> {
 
     private static final NotACompileTimeConstant NOT_A_COMPILE_TIME_CONSTANT = new NotACompileTimeConstant();
 
-    private final ImageClassLoader classLoader;
+    private final ClassLoader classLoader;
     private final Map<Method, Function<InvocationData, Value>> propagatingMethods;
 
-    public ConstantExpressionAnalyzer(CoreProviders providers, ImageClassLoader classLoader) {
+    ConstantExpressionAnalyzer(CoreProviders providers, ClassLoader classLoader) {
         super(providers);
         this.classLoader = classLoader;
         this.propagatingMethods = buildPropagatingMethods();
@@ -462,7 +462,7 @@ private Value invokeForNameOne(Context context, List<Value> operands) {
         }
         ClassLoader loader = ClassForNameSupport.respectClassLoader()
                         ? OriginalClassProvider.getJavaClass(context.method().getDeclaringClass()).getClassLoader()
-                        : classLoader.getClassLoader();
+                        : classLoader;
         return findClass(context, className, loader);
     }
 
@@ -480,7 +480,7 @@ private Value invokeForNameThree(Context context, List<Value> operands) {
                 return defaultValue();
             }
         } else {
-            loader = classLoader.getClassLoader();
+            loader = classLoader;
         }
         return findClass(context, className, loader);
     }
@@ -508,9 +508,10 @@ private Value getLookup(Context context) {
 
     /**
      * Looking up constants/types/fields/methods through a {@link WrappedConstantPool} can result in
-     * UnsupportedFeatureException(s) being thrown. To avoid these exceptions, we essentially
-     * simulate the behavior of the WrappedConstantPool when looking up the underlying JVMCI
-     * constant/type/field/method, but skip the analysis (or hosted) universe lookup.
+     * {@link com.oracle.graal.pointsto.constraints.UnsupportedFeatureException
+     * UnsupportedFeatureException(s)} being thrown. To avoid this, we simulate the behavior of the
+     * {@link WrappedConstantPool} when looking up the underlying JVMCI constant/type/field/method,
+     * but skip the analysis (or hosted) universe lookup.
      */
     private static ConstantPool unwrapIfWrapped(ConstantPool constantPool) {
         return constantPool instanceof WrappedConstantPool wrapper
@@ -553,23 +554,23 @@ protected JavaConstant lookupAppendix(ConstantPool constantPool, int cpi, int op
      * Marker interface for abstract values obtained during bytecode-level constant expression
      * inference.
      */
-    public interface Value {
+    interface Value {
 
     }
 
-    public static class NotACompileTimeConstant implements Value {
+    static class NotACompileTimeConstant implements Value {
 
         @Override
         public String toString() {
             return "Not a compile-time constant";
         }
     }
 
-    public abstract static class CompileTimeConstant implements Value {
+    abstract static class CompileTimeConstant implements Value {
 
         private final int sourceBci;
 
-        public CompileTimeConstant(int bci) {
+        CompileTimeConstant(int bci) {
             this.sourceBci = bci;
         }
 
@@ -602,11 +603,11 @@ public int hashCode() {
         }
     }
 
-    public static class CompileTimeValueConstant<T> extends CompileTimeConstant {
+    static class CompileTimeValueConstant<T> extends CompileTimeConstant {
 
         private final T value;
 
-        public CompileTimeValueConstant(int bci, T value) {
+        CompileTimeValueConstant(int bci, T value) {
             super(bci);
             this.value = value;
         }
@@ -622,7 +623,7 @@ public String toString() {
         }
     }
 
-    public static class CompileTimeArrayConstant<T> extends CompileTimeConstant {
+    static class CompileTimeArrayConstant<T> extends CompileTimeConstant {
 
         /*
          * Sparse array representation to avoid possible large memory overheads when analyzing an
@@ -632,14 +633,14 @@ public static class CompileTimeArrayConstant<T> extends CompileTimeConstant {
         private final int size;
         private final Class<T> elementType;
 
-        public CompileTimeArrayConstant(int bci, int size, Class<T> elementType) {
+        CompileTimeArrayConstant(int bci, int size, Class<T> elementType) {
             super(bci);
             this.value = new HashMap<>();
             this.size = size;
             this.elementType = elementType;
         }
 
-        public CompileTimeArrayConstant(int bci, CompileTimeArrayConstant<T> arrayConstant) {
+        CompileTimeArrayConstant(int bci, CompileTimeArrayConstant<T> arrayConstant) {
             super(bci);
             this.value = new HashMap<>(arrayConstant.value);
             this.size = arrayConstant.size;

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/dynamicaccessinference/ConstantExpressionRegistry.java

@@ -27,24 +27,21 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-import org.graalvm.collections.Pair;
 import org.graalvm.nativeimage.ImageSingletons;
 
 import com.oracle.svm.util.LogUtils;
 import com.oracle.svm.hosted.dataflow.AbstractFrame;
 import com.oracle.svm.hosted.dataflow.DataFlowAnalysisException;
 
 import jdk.graal.compiler.bytecode.Bytecode;
-import jdk.graal.compiler.bytecode.BytecodeProvider;
-import jdk.graal.compiler.bytecode.ResolvedJavaMethodBytecodeProvider;
-import jdk.graal.compiler.nodes.graphbuilderconf.IntrinsicContext;
+import jdk.vm.ci.code.BytecodePosition;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 /**
  * Holds information on constant expressions as inferred by {@link ConstantExpressionAnalyzer}.
  */
-public class ConstantExpressionRegistry {
+public final class ConstantExpressionRegistry {
 
     public static ConstantExpressionRegistry singleton() {
         return ImageSingletons.lookup(ConstantExpressionRegistry.class);
@@ -59,32 +56,29 @@ public static ConstantExpressionRegistry singleton() {
      * Maps method and BCI pairs into abstract frames which represent the execution frame right
      * before the corresponding bytecode instruction.
      */
-    private Map<Pair<ResolvedJavaMethod, Integer>, AbstractFrame<ConstantExpressionAnalyzer.Value>> registry;
-    private boolean isSealed;
+    private Map<BytecodePosition, AbstractFrame<ConstantExpressionAnalyzer.Value>> registry = new ConcurrentHashMap<>();
+    private boolean sealed = false;
 
-    public ConstantExpressionRegistry() {
-        registry = new ConcurrentHashMap<>();
-        isSealed = false;
+    private final ConstantExpressionAnalyzer analyzer;
+
+    ConstantExpressionRegistry(ConstantExpressionAnalyzer analyzer) {
+        this.analyzer = analyzer;
     }
 
-    public void analyzeAndStore(ConstantExpressionAnalyzer analyzer, ResolvedJavaMethod method, IntrinsicContext intrinsicContext) {
-        assert !isSealed() : "Cannot store in registry when it is already sealed";
-        Bytecode bytecode = getBytecode(method, intrinsicContext);
+    /**
+     * Analyze the provided {@code bytecode} for constant expressions and store the results in the
+     * registry.
+     */
+    public void store(Bytecode bytecode) {
+        assert !sealed : "Cannot store in registry when it is already sealed";
         try {
             Map<Integer, AbstractFrame<ConstantExpressionAnalyzer.Value>> abstractFrames = analyzer.analyze(bytecode);
-            abstractFrames.forEach((key, value) -> registry.put(Pair.create(method, key), value));
+            abstractFrames.forEach((key, value) -> registry.put(new BytecodePosition(null, bytecode.getMethod(), key), value));
         } catch (DataFlowAnalysisException e) {
-            LogUtils.warning("Constant expression analysis failed for " + method.format("%H.%n(%p)") + ": " + e.getMessage());
+            LogUtils.warning("Constant expression analysis failed for " + bytecode.getMethod().format("%H.%n(%p)") + ": " + e.getMessage());
         }
     }
 
-    private static Bytecode getBytecode(ResolvedJavaMethod method, IntrinsicContext intrinsicContext) {
-        BytecodeProvider bytecodeProvider = intrinsicContext == null
-                        ? ResolvedJavaMethodBytecodeProvider.INSTANCE
-                        : intrinsicContext.getBytecodeProvider();
-        return bytecodeProvider.getBytecode(method);
-    }
-
     /**
      * Attempt to get the inferred receiver of a {@code targetMethod} invocation at the specified
      * code location.
@@ -96,9 +90,12 @@ private static Bytecode getBytecode(ResolvedJavaMethod method, IntrinsicContext
      *         {@code null} value is represented by {@link ConstantExpressionRegistry#NULL_MARKER}.
      */
     public Object getReceiver(ResolvedJavaMethod callerMethod, int bci, ResolvedJavaMethod targetMethod) {
-        assert !isSealed() : "Registry is already sealed";
+        assert !sealed : "Registry is already sealed";
         assert targetMethod.hasReceiver() : "Method " + targetMethod + " does not have receiver";
-        AbstractFrame<ConstantExpressionAnalyzer.Value> frame = registry.get(Pair.create(callerMethod, bci));
+        if (callerMethod == null) {
+            return null;
+        }
+        AbstractFrame<ConstantExpressionAnalyzer.Value> frame = registry.get(new BytecodePosition(null, callerMethod, bci));
         if (frame == null) {
             return null;
         }
@@ -138,10 +135,13 @@ public <T> T getReceiver(ResolvedJavaMethod callerMethod, int bci, ResolvedJavaM
      *         {@code null} value is represented by {@link ConstantExpressionRegistry#NULL_MARKER}.
      */
     public Object getArgument(ResolvedJavaMethod callerMethod, int bci, ResolvedJavaMethod targetMethod, int index) {
-        assert !isSealed() : "Registry is already sealed";
+        assert !sealed : "Registry is already sealed";
         int numOfParameters = targetMethod.getSignature().getParameterCount(false);
         assert 0 <= index && index < numOfParameters : "Argument index " + index + " out of bounds for " + targetMethod;
-        AbstractFrame<ConstantExpressionAnalyzer.Value> frame = registry.get(Pair.create(callerMethod, bci));
+        if (callerMethod == null) {
+            return null;
+        }
+        AbstractFrame<ConstantExpressionAnalyzer.Value> frame = registry.get(new BytecodePosition(null, callerMethod, bci));
         if (frame == null) {
             return null;
         }
@@ -193,12 +193,8 @@ private static <T> T tryToCast(Object value, Class<T> type) {
         return type.cast(value);
     }
 
-    public boolean isSealed() {
-        return isSealed;
-    }
-
-    public void seal() {
-        isSealed = true;
+    void seal() {
+        sealed = true;
         registry = null;
     }