[GR-55686] GuestGraal: Add EE support.

PullRequest: graal/18368

Author: dougxc

compiler/mx.compiler/mx_compiler.py

@@ -605,7 +605,7 @@ def compiler_gate_benchmark_runner(tasks, extraVMarguments=None, prefix='', task
     # ensure we can run with --enable-preview
     with Task(prefix + 'DaCapo_enable-preview:fop', tasks, tags=GraalTags.test, report=task_report_component) as t:
         if t:
-            _gate_dacapo('fop', 8, ['--enable-preview', '-Djdk.graal.CompilationFailureAction=ExitVM'])
+            _gate_dacapo('fop', 8, benchVmArgs + ['--enable-preview', '-Djdk.graal.CompilationFailureAction=ExitVM'])
 
     # run Scala DaCapo benchmarks #
     ###############################

compiler/mx.compiler/suite.py

@@ -190,11 +190,14 @@
         ],
       },
       "uses" : [
+        "jdk.graal.compiler.hotspot.meta.DefaultHotSpotLoweringProvider.Extensions",
         "jdk.graal.compiler.hotspot.meta.HotSpotInvocationPluginProvider",
         "jdk.graal.compiler.lir.LIRInstructionVerifier",
         "jdk.graal.compiler.core.common.CompilerProfiler",
         "jdk.graal.compiler.truffle.substitutions.GraphBuilderInvocationPluginProvider",
         "jdk.graal.compiler.truffle.phases.inlining.InliningPolicyProvider",
+        "jdk.graal.compiler.truffle.host.TruffleHostEnvironment.Lookup",
+        "jdk.graal.compiler.truffle.substitutions.GraphDecoderInvocationPluginProvider"
       ],
       "annotationProcessors" : [
         "GRAAL_PROCESSOR"
@@ -557,7 +560,6 @@
           "jdk.graal.compiler.debug.DebugHandlersFactory",
           "jdk.graal.compiler.debug.TTYStreamProvider",
           "jdk.graal.compiler.debug.PathUtilitiesProvider",
-          "jdk.graal.compiler.hotspot.HotSpotCodeCacheListener",
           "jdk.graal.compiler.hotspot.HotSpotBackendFactory",
           "jdk.graal.compiler.hotspot.meta.HotSpotInvocationPluginProvider",
           "jdk.graal.compiler.nodes.graphbuilderconf.GeneratedPluginFactory",

compiler/src/jdk.graal.compiler.processor/src/jdk/graal/compiler/replacements/processor/PluginGenerator.java

@@ -110,10 +110,20 @@ private static void disambiguateNames(List<GeneratedPlugin> plugins) {
         disambiguateWith(plugins, plugin -> plugin.getPluginName() + "__" + nextId[0]++);
     }
 
+    /**
+     * Map from an architecture's name as it appears in a package name to its name returned by
+     * {@code jdk.vm.ci.code.Architecture.getName()}.
+     */
+    private static final Map<String, String> SUPPORTED_JVMCI_ARCHITECTURES = Map.of(
+                    "amd64", "AMD64",
+                    "aarch64", "aarch64",
+                    "riscv64", "riscv64");
+
     private static void createPluginFactory(AbstractProcessor processor, Element topLevelClass, List<GeneratedPlugin> plugins) {
         PackageElement pkg = (PackageElement) topLevelClass.getEnclosingElement();
 
         String genClassName = "PluginFactory_" + topLevelClass.getSimpleName();
+        String arch = SUPPORTED_JVMCI_ARCHITECTURES.get(pkg.getSimpleName().toString());
 
         String qualifiedGenClassName = pkg.getQualifiedName() + "." + genClassName;
         try {
@@ -131,7 +141,15 @@ private static void createPluginFactory(AbstractProcessor processor, Element top
                     plugin.generate(processor, out);
                     out.printf("\n");
                 }
-                out.printf("public class %s implements GeneratedPluginFactory {\n", genClassName);
+                if (arch != null) {
+                    out.printf("public class %s implements GeneratedPluginFactory, jdk.graal.compiler.core.ArchitectureSpecific {\n", genClassName);
+                    out.printf("    @Override\n");
+                    out.printf("    public String getArchitecture() {\n");
+                    out.printf("        return \"%s\";\n", arch);
+                    out.printf("    }\n");
+                } else {
+                    out.printf("public class %s implements GeneratedPluginFactory {\n", genClassName);
+                }
                 createPluginFactoryMethod(out, plugins);
                 out.printf("}\n");
             }

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/VerifyFoldableMethods.java

@@ -25,10 +25,12 @@
 package jdk.graal.compiler.core.test;
 
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
 import jdk.graal.compiler.api.replacements.Fold;
+import jdk.graal.compiler.nodes.PluginReplacementNode;
 import jdk.graal.compiler.nodes.StructuredGraph;
 import jdk.graal.compiler.nodes.graphbuilderconf.GeneratedInvocationPlugin;
 import jdk.graal.compiler.nodes.java.MethodCallTargetNode;
@@ -39,7 +41,9 @@
 import jdk.vm.ci.meta.ResolvedJavaType;
 
 /**
- * Verifies that all {@link Fold} annotated methods have at least one caller.
+ * Verifies that all {@link Fold} annotated methods have at least one caller from non-generated
+ * code. Ideally, the class should verify that foldable methods are only called from snippets but
+ * that requires a more global analysis (i.e., to know whether a caller is used within a snippet).
  */
 public class VerifyFoldableMethods extends VerifyPhase<CoreProviders> {
 
@@ -48,32 +52,59 @@ public boolean checkContract() {
         return false;
     }
 
-    private final Map<ResolvedJavaMethod, Boolean> foldables = new ConcurrentHashMap<>();
-    ResolvedJavaType generatedInvocationPluginType;
+    /**
+     * Map from a foldable method to one of its callers. The absence of a caller is represented a
+     * foldable method mapping to itself.
+     */
+    private final Map<ResolvedJavaMethod, ResolvedJavaMethod> foldableCallers = new ConcurrentHashMap<>();
+
+    /*
+     * Super types or interfaces for generated classes. Calls from methods in these classes are
+     * ignored.
+     */
+    Set<ResolvedJavaType> generatedClassSupertypes;
+
+    /**
+     * Determines if {@code method} is in a generated class.
+     */
+    private boolean isGenerated(ResolvedJavaMethod method, CoreProviders context) {
+        if (generatedClassSupertypes == null) {
+            generatedClassSupertypes = Set.of(
+                            context.getMetaAccess().lookupJavaType(GeneratedInvocationPlugin.class),
+                            context.getMetaAccess().lookupJavaType(PluginReplacementNode.ReplacementFunction.class));
+        }
+        ResolvedJavaType declaringClass = method.getDeclaringClass();
+        for (ResolvedJavaType t : generatedClassSupertypes) {
+            if (t.isAssignableFrom(declaringClass)) {
+                return true;
+            }
+        }
+        return false;
+    }
 
     @Override
     protected void verify(StructuredGraph graph, CoreProviders context) {
         ResolvedJavaMethod method = graph.method();
         if (method.getAnnotation(Fold.class) != null) {
-            foldables.putIfAbsent(method, false);
+            foldableCallers.putIfAbsent(method, method);
         } else {
-            if (generatedInvocationPluginType == null) {
-                generatedInvocationPluginType = context.getMetaAccess().lookupJavaType(GeneratedInvocationPlugin.class);
-            }
-            if (!generatedInvocationPluginType.isAssignableFrom(method.getDeclaringClass())) {
+            if (!isGenerated(method, context)) {
                 for (MethodCallTargetNode t : graph.getNodes(MethodCallTargetNode.TYPE)) {
                     ResolvedJavaMethod callee = t.targetMethod();
                     if (callee.getAnnotation(Fold.class) != null) {
-                        foldables.put(callee, true);
+                        foldableCallers.put(callee, method);
                     }
                 }
             }
         }
     }
 
     public void finish() {
-        String uncalled = foldables.entrySet().stream().filter(e -> e.getValue() == false).map(e -> e.getKey().format("%H.%n(%p)")).collect(Collectors.joining(System.lineSeparator() + "  "));
-        if (uncalled.length() != 0) {
+        String uncalled = foldableCallers.entrySet().stream()//
+                        .filter(e -> e.getValue() == e.getKey())//
+                        .map(e -> e.getKey().format("%H.%n(%p)"))//
+                        .collect(Collectors.joining(System.lineSeparator() + "  "));
+        if (!uncalled.isEmpty()) {
             throw new VerificationError(String.format("Methods annotated with @" + Fold.class.getSimpleName() + " appear to have no usages:%n  %s", uncalled));
         }
     }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/code/DisassemblerProvider.java

@@ -24,13 +24,15 @@
  */
 package jdk.graal.compiler.code;
 
+import jdk.graal.compiler.serviceprovider.LibGraalService;
 import jdk.vm.ci.code.CodeCacheProvider;
 import jdk.vm.ci.code.InstalledCode;
 import jdk.graal.compiler.options.OptionValues;
 
 /**
  * Interface providing capability for disassembling machine code.
  */
+@LibGraalService
 public interface DisassemblerProvider {
 
     /**

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/ArchitectureSpecific.java

@@ -30,7 +30,8 @@
 public interface ArchitectureSpecific {
     /**
      * Gets the {@linkplain Architecture#getName() name} of the architecture this Graal component is
-     * associated with.
+     * associated with. Note that the JVMCI architecture names are somewhat inconsistent wrt case
+     * (i.e., "AMD64", "aarch64" and "riscv64").
      */
     String getArchitecture();
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/common/CompilerProfiler.java

@@ -24,12 +24,14 @@
  */
 package jdk.graal.compiler.core.common;
 
+import jdk.graal.compiler.serviceprovider.LibGraalService;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 /**
  * A profiling service that consumes compilation related events. The Java Flight Recorder (JFR) is
  * an example of such a service that can be exposed via this interface.
  */
+@LibGraalService
 public interface CompilerProfiler {
 
     /**

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/match/MatchRuleRegistry.java

@@ -102,7 +102,7 @@ public static synchronized EconomicMap<Class<? extends Node>, List<MatchStatemen
             }
         }
 
-        if (result.size() == 0) {
+        if (result.isEmpty()) {
             return null;
         }
         return result;

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/match/MatchStatementSet.java

@@ -29,7 +29,9 @@
 import jdk.graal.compiler.core.ArchitectureSpecific;
 import jdk.graal.compiler.core.gen.NodeLIRBuilder;
 import jdk.graal.compiler.core.gen.NodeMatchRules;
+import jdk.graal.compiler.serviceprovider.LibGraalService;
 
+@LibGraalService
 public interface MatchStatementSet extends ArchitectureSpecific {
     /**
      * @return the {@link NodeLIRBuilder} subclass which defined this set of {@link MatchStatement}

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/debug/DebugHandlersFactory.java

@@ -29,10 +29,12 @@
 
 import jdk.graal.compiler.options.OptionValues;
 import jdk.graal.compiler.serviceprovider.GraalServices;
+import jdk.graal.compiler.serviceprovider.LibGraalService;
 
 /**
  * Factory for creating {@link DebugHandler}s.
  */
+@LibGraalService
 public interface DebugHandlersFactory {
 
     /**