[GR-70176] [GR-66234] Refactor standalone points-to analysis feature for project Terminus

PullRequest: graal/22252

Author: d-kozak

substratevm/mx.substratevm/mx_substratevm.py

@@ -2745,6 +2745,8 @@ def apply(self, config):
         vmArgs, mainClass, mainClassArgs = config
 
         vmArgs.extend(['--add-exports=jdk.graal.compiler/jdk.graal.compiler.options=ALL-UNNAMED'])
+        # need to access jdk.graal.compiler.phases.util.Providers
+        vmArgs.extend(['--add-exports=jdk.graal.compiler/jdk.graal.compiler.phases.util=ALL-UNNAMED'])
 
         # JVMCI is dynamically exported to Graal when JVMCI is initialized. This is too late
         # for the junit harness which uses reflection to find @Test methods. In addition, the

substratevm/src/com.oracle.graal.pointsto.standalone.test/src/com/oracle/graal/pointsto/standalone/test/PointstoAnalyzerTester.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2022, 2022, Alibaba Group Holding Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -56,12 +56,10 @@
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.graal.pointsto.standalone.PointsToAnalyzer;
-import com.oracle.graal.pointsto.util.AnalysisError;
 
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
-import jdk.vm.ci.meta.ResolvedJavaType;
 
 public class PointstoAnalyzerTester {
     private Set<Executable> expectedReachableMethods = new HashSet<>();
@@ -153,7 +151,12 @@ public void runAnalysisAndAssert() {
      *            analysis is supposed to fail.
      */
     public void runAnalysisAndAssert(boolean expectPass) {
-        PointsToAnalyzer pointstoAnalyzer = PointsToAnalyzer.createAnalyzer(arguments);
+        /*
+         * Use the same class loader that has loaded the test classes to prevent from loading the
+         * same classes twice and having to convert between them.
+         */
+        PointsToAnalyzer.HostClassLoaderAccess classLoaderAccess = new PointsToAnalyzer.HostClassLoaderAccess(testClass.getClassLoader());
+        PointsToAnalyzer pointstoAnalyzer = PointsToAnalyzer.createAnalyzer(arguments, classLoaderAccess);
         UnsupportedFeatureException unsupportedFeatureException = null;
         try {
             try {
@@ -166,7 +169,6 @@ public void runAnalysisAndAssert(boolean expectPass) {
             } catch (UnsupportedFeatureException e) {
                 unsupportedFeatureException = e;
             }
-            ClassLoader analysisClassLoader = pointstoAnalyzer.getClassLoader();
             if (!expectPass) {
                 return;
             }
@@ -175,39 +177,19 @@ public void runAnalysisAndAssert(boolean expectPass) {
             assertNotNull(universe);
 
             assertReachable("Method", expectedReachableMethods, expectedUnreachableMethods, reflectionMethod -> {
-                try {
-                    Executable actualMethod = reflectionMethod;
-                    Class<?> declaringClass = reflectionMethod.getDeclaringClass();
-                    if (!analysisClassLoader.equals(declaringClass.getClassLoader())) {
-                        Class<?> c = Class.forName(declaringClass.getName(), false, analysisClassLoader);
-                        actualMethod = c.getDeclaredMethod(reflectionMethod.getName(), reflectionMethod.getParameterTypes());
-                    }
-                    ResolvedJavaMethod m = universe.getOriginalMetaAccess().lookupJavaMethod(actualMethod);
-                    return universe.getMethod(m);
-                } catch (ReflectiveOperationException e) {
-                    throw AnalysisError.shouldNotReachHere(e);
-                }
+                ResolvedJavaMethod m = universe.getOriginalMetaAccess().lookupJavaMethod(reflectionMethod);
+                return universe.getMethod(m);
             },
                             reflectionMethod -> reflectionMethod.getDeclaringClass().getName() + "." + reflectionMethod.getName());
             assertReachable("<clinit>", expectedReachableClinits, expectedUnreachableClinits, clazz -> {
-                AnalysisType t = classToAnalysisType(analysisClassLoader, universe, originalMetaAccess, clazz);
+                AnalysisType t = classToAnalysisType(universe, originalMetaAccess, clazz);
                 return t.getClassInitializer();
             }, clazz -> clazz.getName() + ".<clinit>");
-            assertReachable("Type", expectedReachableTypes, expectedUnreachableTypes, clazz -> classToAnalysisType(analysisClassLoader, universe, originalMetaAccess, clazz),
+            assertReachable("Type", expectedReachableTypes, expectedUnreachableTypes, clazz -> classToAnalysisType(universe, originalMetaAccess, clazz),
                             clazz -> clazz.getName());
             assertReachable("Field", expectedReachableFields, expectedUnreachableFields, reflectionField -> {
-                try {
-                    Field actualField = reflectionField;
-                    Class<?> declaringClass = actualField.getDeclaringClass();
-                    if (!analysisClassLoader.equals(declaringClass.getClassLoader())) {
-                        Class<?> c = Class.forName(declaringClass.getName(), false, analysisClassLoader);
-                        actualField = c.getDeclaredField(reflectionField.getName());
-                    }
-                    ResolvedJavaField resolvedJavaField = originalMetaAccess.lookupJavaField(actualField);
-                    return universe.getField(resolvedJavaField);
-                } catch (ReflectiveOperationException e) {
-                    throw AnalysisError.shouldNotReachHere(e);
-                }
+                ResolvedJavaField resolvedJavaField = originalMetaAccess.lookupJavaField(reflectionField);
+                return universe.getField(resolvedJavaField);
             },
                             reflectionField -> reflectionField.getDeclaringClass().getName() + "." + reflectionField.getName());
 
@@ -221,17 +203,8 @@ public void runAnalysisAndAssert(boolean expectPass) {
         }
     }
 
-    private static AnalysisType classToAnalysisType(ClassLoader analysisClassLoader, AnalysisUniverse universe, MetaAccessProvider originalMetaAccess, Class<?> clazz) {
-        try {
-            Class<?> actualClass = clazz;
-            if (!analysisClassLoader.equals(clazz.getClassLoader())) {
-                actualClass = Class.forName(clazz.getName(), false, analysisClassLoader);
-            }
-            ResolvedJavaType resolvedJavaType = originalMetaAccess.lookupJavaType(actualClass);
-            return universe.optionalLookup(resolvedJavaType);
-        } catch (ReflectiveOperationException e) {
-            throw AnalysisError.shouldNotReachHere(e);
-        }
+    private static AnalysisType classToAnalysisType(AnalysisUniverse universe, MetaAccessProvider originalMetaAccess, Class<?> clazz) {
+        return universe.optionalLookup(originalMetaAccess.lookupJavaType(clazz));
     }
 
     public Object runAnalysisForFeatureResult(Class<? extends Feature> feature) {

substratevm/src/com.oracle.graal.pointsto.standalone/src/com/oracle/graal/pointsto/standalone/MethodConfigReader.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2022, 2022, Alibaba Group Holding Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -47,7 +47,6 @@
 import jdk.graal.compiler.debug.DebugContext;
 import jdk.graal.compiler.debug.DebugOptions;
 import jdk.graal.compiler.debug.MethodFilter;
-import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
@@ -68,10 +67,10 @@ public class MethodConfigReader {
      *
      * @param file the configuration file to read.
      * @param bigbang
-     * @param classLoader analysis classloader
+     * @param classLoaderAccess for loading classes
      * @param actionForEachMethod the action to take for each resolved method.
      */
-    public static void readMethodFromFile(String file, BigBang bigbang, ClassLoader classLoader, Consumer<AnalysisMethod> actionForEachMethod) {
+    public static void readMethodFromFile(String file, BigBang bigbang, PointsToAnalyzer.ClassLoaderAccess classLoaderAccess, Consumer<AnalysisMethod> actionForEachMethod) {
         List<String> methodNameList = new ArrayList<>();
         Path entryFilePath = Paths.get(file);
         File entryFile = entryFilePath.toFile();
@@ -85,7 +84,7 @@ public static void readMethodFromFile(String file, BigBang bigbang, ClassLoader
             AnalysisError.shouldNotReachHere(e);
         }
         int totalSize = methodNameList.size();
-        int num = forMethodList(bigbang.getDebug(), methodNameList, bigbang, classLoader, actionForEachMethod);
+        int num = forMethodList(bigbang.getDebug(), methodNameList, bigbang, classLoaderAccess, actionForEachMethod);
         StringBuilder sb = new StringBuilder();
         sb.append("==Reading analysis entry points status==").append(System.lineSeparator());
         sb.append(num).append(" out of ").append(totalSize).append(" methods are read from ").append(file).append(System.lineSeparator());
@@ -97,13 +96,13 @@ public static void readMethodFromFile(String file, BigBang bigbang, ClassLoader
     }
 
     @SuppressWarnings("try")
-    public static int forMethodList(DebugContext debug, List<String> methods, BigBang bigbang, ClassLoader classLoader, Consumer<AnalysisMethod> actionForEachMethod) {
+    public static int forMethodList(DebugContext debug, List<String> methods, BigBang bigbang, PointsToAnalyzer.ClassLoaderAccess classLoaderAccess, Consumer<AnalysisMethod> actionForEachMethod) {
         AtomicInteger validMethodsNum = new AtomicInteger(0);
         try (DebugContext.Scope s = debug.scope(READ_ENTRY_POINTS)) {
             methods.stream().forEach(method -> {
                 if (!method.isBlank()) {
                     try {
-                        workWithMethod(method, bigbang, classLoader, actionForEachMethod);
+                        workWithMethod(method, bigbang, classLoaderAccess, actionForEachMethod);
                         validMethodsNum.incrementAndGet();
                     } catch (Throwable t) {
                         // Checkstyle: Allow raw info or warning printing - begin
@@ -116,7 +115,8 @@ public static int forMethodList(DebugContext debug, List<String> methods, BigBan
         return validMethodsNum.get();
     }
 
-    private static void workWithMethod(String method, BigBang bigbang, ClassLoader classLoader, Consumer<AnalysisMethod> actionForEachMethod) throws ClassNotFoundException {
+    private static void workWithMethod(String method, BigBang bigbang, PointsToAnalyzer.ClassLoaderAccess classLoaderAccess, Consumer<AnalysisMethod> actionForEachMethod)
+                    throws ClassNotFoundException {
         int pos = method.indexOf('(');
         int dotAfterClassNamePos;
         if (pos == -1) {
@@ -128,12 +128,13 @@ private static void workWithMethod(String method, BigBang bigbang, ClassLoader c
             AnalysisError.shouldNotReachHere("The the given method's name " + method + " doesn't contain the declaring class name.");
         }
         String className = method.substring(0, dotAfterClassNamePos);
-        Class<?> c = Class.forName(className, false, classLoader);
+        ResolvedJavaType t = classLoaderAccess.forName(className);
+        if (t == null) {
+            throw new ClassNotFoundException(className);
+        }
         // MethodFilter.parse requires ResolvedJavaMethod as input
-        MetaAccessProvider originalMetaAccess = bigbang.getUniverse().getOriginalMetaAccess();
-        List<ResolvedJavaMethod> methodCandidates = Arrays.stream(c.getDeclaredMethods()).map(m -> originalMetaAccess.lookupJavaMethod(m)).filter(m -> !m.isNative()).collect(Collectors.toList());
-        methodCandidates.addAll(Arrays.stream(c.getDeclaredConstructors()).map(m -> originalMetaAccess.lookupJavaMethod(m)).collect(Collectors.toList()));
-        ResolvedJavaType t = originalMetaAccess.lookupJavaType(c);
+        List<ResolvedJavaMethod> methodCandidates = Arrays.stream(t.getDeclaredMethods()).filter(m -> !m.isNative()).collect(Collectors.toList());
+        methodCandidates.addAll(Arrays.stream(t.getDeclaredConstructors()).toList());
         if (t.getClassInitializer() != null) {
             methodCandidates.add(t.getClassInitializer());
         }