[GR-68014] Fix native-image on espresso.

PullRequest: graal/21624

Author: gilles-duboscq

espresso-compiler-stub/mx.espresso-compiler-stub/suite.py

@@ -79,7 +79,7 @@
                     "jdk.vm.ci.runtime",
                 ],
             },
-            "javaCompliance": "8+",
+            "javaCompliance": "21+",
             "checkstyle": "com.oracle.truffle.espresso",
         },
     },

espresso-compiler-stub/src/com.oracle.truffle.espresso.graal/src/com/oracle/truffle/espresso/graal/DummyEspressoGraalJVMCICompiler.java

@@ -30,7 +30,6 @@
 import jdk.vm.ci.runtime.JVMCIRuntime;
 
 public final class DummyEspressoGraalJVMCICompiler implements GraalJVMCICompiler {
-
     private final EspressoGraalRuntime runtime;
 
     private DummyEspressoGraalJVMCICompiler(JVMCIRuntime jvmciRuntime) {

espresso-compiler-stub/src/com.oracle.truffle.espresso.graal/src/com/oracle/truffle/espresso/graal/DummyLoweringProvider.java

@@ -36,6 +36,12 @@
 import jdk.vm.ci.meta.JavaKind;
 
 public final class DummyLoweringProvider implements LoweringProvider {
+    private final TargetDescription target;
+
+    public DummyLoweringProvider(TargetDescription target) {
+        this.target = target;
+    }
+
     @Override
     public void lower(Node n, LoweringTool tool) {
         throw GraalError.unimplementedOverride();
@@ -48,6 +54,7 @@ public ValueNode reconstructArrayIndex(JavaKind elementKind, AddressNode address
 
     @Override
     public Integer smallestCompareWidth() {
+        SuspiciousHostAccessCollector.onSuspiciousHostAccess();
         // used at least by AutomaticUnsafeTransformationSupport.getStaticInitializerGraph
         return null;
     }
@@ -69,13 +76,16 @@ public boolean supportsImplicitNullChecks() {
 
     @Override
     public boolean writesStronglyOrdered() {
+        SuspiciousHostAccessCollector.onSuspiciousHostAccess();
         // used at least by AutomaticUnsafeTransformationSupport.getStaticInitializerGraph
         return false;
     }
 
     @Override
     public TargetDescription getTarget() {
-        throw GraalError.unimplementedOverride();
+        SuspiciousHostAccessCollector.onSuspiciousHostAccess();
+        // used at least by AutomaticUnsafeTransformationSupport.getStaticInitializerGraph
+        return target;
     }
 
     @Override
@@ -85,6 +95,7 @@ public BarrierSet getBarrierSet() {
 
     @Override
     public boolean divisionOverflowIsJVMSCompliant() {
+        SuspiciousHostAccessCollector.onSuspiciousHostAccess();
         // used at least by AutomaticUnsafeTransformationSupport.getStaticInitializerGraph
         return false;
     }

espresso-compiler-stub/src/com.oracle.truffle.espresso.graal/src/com/oracle/truffle/espresso/graal/EspressoGraalRuntime.java

@@ -62,7 +62,7 @@ private static Providers createProviders(JVMCIRuntime jvmciRuntime) {
         EspressoConstantReflectionProvider constantReflection = (EspressoConstantReflectionProvider) hostJVMCIBackend.getConstantReflection();
         ConstantFieldProvider constantFieldProvider = new EspressoConstantFieldProvider(metaAccess);
         ForeignCallsProvider foreignCalls = new DummyForeignCallsProvider();
-        LoweringProvider lowerer = new DummyLoweringProvider();
+        LoweringProvider lowerer = new DummyLoweringProvider(target);
         StampProvider stampProvider = new DummyStampProvider();
         PlatformConfigurationProvider platformConfigurationProvider = new DummyPlatformConfigurationProvider();
         MetaAccessExtensionProvider metaAccessExtensionProvider = new EspressoMetaAccessExtensionProvider(constantReflection);

espresso-compiler-stub/src/com.oracle.truffle.espresso.graal/src/com/oracle/truffle/espresso/graal/SuspiciousHostAccessCollector.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.espresso.graal;
+
+import java.io.PrintStream;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Helps collect stack traces of calls to some methods that probably shouldn't be called. For
+ * example when using {@link EspressoGraalRuntime} in the context of running native-image on top of
+ * espresso, we shouldn't expect any calls to methods that query machine-specific details.
+ * <p>
+ * Such methods should call {@link #onSuspiciousHostAccess}.
+ * <p>
+ * Setting {@code suspicious.host.access.collector.enabled} to {@code true} will enable collection
+ * of the call-sites of those methods and report the tree of stack traces reaching them on exit.
+ */
+final class SuspiciousHostAccessCollector {
+    private static final boolean ENABLED = Boolean.getBoolean("suspicious.host.access.collector.enabled");
+    private static final Node ROOT = new Node();
+    static {
+        if (ENABLED) {
+            Runtime.getRuntime().addShutdownHook(new Thread() {
+                @Override
+                public void run() {
+                    dumpSuspiciousAccesses(System.out);
+                }
+            });
+        }
+    }
+
+    static void onSuspiciousHostAccess() {
+        if (!ENABLED) {
+            return;
+        }
+        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+        add(stackTrace);
+    }
+
+    static void dumpSuspiciousAccesses(PrintStream out) {
+        out.println("Suspicious host accesses:");
+        ROOT.dump(out, 0);
+    }
+
+    private static void add(StackTraceElement[] stackTrace) {
+        Node currentNode = ROOT;
+        int currentIndex = 2;
+        while (currentIndex < stackTrace.length) {
+            StackTraceElement element = stackTrace[currentIndex];
+            currentNode = currentNode.add(element);
+            currentIndex++;
+        }
+    }
+
+    private static final class Node {
+        Map<StackTraceElement, Node> children;
+
+        synchronized Node add(StackTraceElement element) {
+            if (children == null) {
+                Node child = new Node();
+                children = Map.of(element, child);
+                return child;
+            }
+            Node existing = children.get(element);
+            if (existing != null) {
+                return existing;
+            }
+            Node newChild = new Node();
+            if (children.size() == 1) {
+                Map.Entry<StackTraceElement, Node> oldEntry = children.entrySet().iterator().next();
+                children = HashMap.newHashMap(2);
+                children.put(oldEntry.getKey(), oldEntry.getValue());
+            }
+            children.put(element, newChild);
+            return newChild;
+        }
+
+        void dump(PrintStream out, int indent) {
+            if (children == null) {
+                return;
+            }
+            int nextIndent = children.size() > 1 ? indent + 1 : indent;
+            for (Map.Entry<StackTraceElement, Node> entry : children.entrySet()) {
+                StringBuilder sb = new StringBuilder();
+                sb.repeat("  ", indent);
+                sb.append("* ");
+                sb.append(entry.getKey());
+                out.println(sb);
+                entry.getValue().dump(out, nextIndent);
+            }
+        }
+    }
+}

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/EspressoLanguage.java

@@ -147,6 +147,7 @@ public final class EspressoLanguage extends TruffleLanguage<EspressoContext> imp
     @CompilationFinal private boolean useEspressoLibs;
     @CompilationFinal private boolean continuum;
     @CompilationFinal private boolean useTRegex;
+    @CompilationFinal private int maxStackTraceDepth;
     // endregion Options
 
     // region Allocation
@@ -246,6 +247,7 @@ private void initializeOptions(final TruffleLanguage.Env env) {
         whiteBoxEnabled = env.getOptions().get(EspressoOptions.WhiteBoxAPI);
         internalJvmciEnabled = env.getOptions().get(EspressoOptions.EnableJVMCI);
         continuum = env.getOptions().get(EspressoOptions.Continuum);
+        maxStackTraceDepth = env.getOptions().get(EspressoOptions.MaxJavaStackTraceDepth);
 
         useTRegex = env.getOptions().get(EspressoOptions.UseTRegex);
         if (useTRegex && !env.getInternalLanguages().containsKey("regex")) {
@@ -351,7 +353,8 @@ protected boolean areOptionsCompatible(OptionValues oldOptions, OptionValues new
                         isOptionCompatible(newOptions, oldOptions, EspressoOptions.Continuum) &&
                         isOptionCompatible(newOptions, oldOptions, EspressoOptions.UseTRegex) &&
                         isOptionCompatible(newOptions, oldOptions, EspressoOptions.GuestFieldOffsetStrategy) &&
-                        isOptionCompatible(newOptions, oldOptions, EspressoOptions.UseEspressoLibs);
+                        isOptionCompatible(newOptions, oldOptions, EspressoOptions.UseEspressoLibs) &&
+                        isOptionCompatible(newOptions, oldOptions, EspressoOptions.MaxJavaStackTraceDepth);
     }
 
     private static boolean isOptionCompatible(OptionValues oldOptions, OptionValues newOptions, OptionKey<?> option) {
@@ -748,6 +751,10 @@ public DisableSingleStepping disableStepping() {
         return new DisableSingleStepping();
     }
 
+    public int getMaxStackTraceDepth() {
+        return maxStackTraceDepth;
+    }
+
     public final class DisableSingleStepping implements AutoCloseable {
 
         private final boolean steppingDisabled;

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/EspressoOptions.java

@@ -769,6 +769,13 @@ public enum MemoryAccessOption {
                     usageSyntax = "false|true") //
     public static final OptionKey<Boolean> EnableAdvancedRedefinition = new OptionKey<>(false);
 
+    @Option(help = "The maximum number of lines in the stack trace for Java exceptions", //
+                    category = OptionCategory.EXPERT, //
+                    stability = OptionStability.EXPERIMENTAL, //
+                    usageSyntax = "<depth>>") //
+    // HotSpot's MaxJavaStackTraceDepth is 1024 by default
+    public static final OptionKey<Integer> MaxJavaStackTraceDepth = new OptionKey<>(32);
+
     /**
      * Property used to force liveness analysis to also be applied by the interpreter. For testing
      * purpose only. Use a host property rather than an option. An option would slow interpreter

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/runtime/EspressoContext.java

@@ -129,10 +129,7 @@
 
 import sun.misc.SignalHandler;
 
-public final class EspressoContext
-                implements RuntimeAccess<Klass, Method, Field> {
-    // MaxJavaStackTraceDepth is 1024 by default
-    public static final int DEFAULT_STACK_SIZE = 32;
+public final class EspressoContext implements RuntimeAccess<Klass, Method, Field> {
 
     private static final DebugTimer SPAWN_VM = DebugTimer.create("spawnVM");
     private static final DebugTimer SYSTEM_INIT = DebugTimer.create("system init", SPAWN_VM);

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/vm/InterpreterToVM.java

@@ -614,7 +614,8 @@ public static StaticObject fillInStackTraceLazy(@JavaType(Throwable.class) Stati
 
     // Recursion depth = 4
     public static StaticObject fillInStackTrace(@JavaType(Throwable.class) StaticObject throwable, Meta meta) {
-        VM.StackTrace frames = getStackTrace(new FillInStackTraceFramesFilter(), EspressoContext.DEFAULT_STACK_SIZE);
+        int maxDepth = meta.getLanguage().getMaxStackTraceDepth();
+        VM.StackTrace frames = getStackTrace(new FillInStackTraceFramesFilter(), maxDepth);
         meta.HIDDEN_FRAMES.setHiddenObject(throwable, frames);
         meta.java_lang_Throwable_backtrace.setObject(throwable, throwable);
         if (meta.getJavaVersion().java9OrLater()) {

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/vm/VM.java

@@ -32,7 +32,6 @@
 import static com.oracle.truffle.espresso.jni.JniEnv.JNI_OK;
 import static com.oracle.truffle.espresso.meta.EspressoError.cat;
 import static com.oracle.truffle.espresso.runtime.Classpath.JAVA_BASE;
-import static com.oracle.truffle.espresso.runtime.EspressoContext.DEFAULT_STACK_SIZE;
 import static com.oracle.truffle.espresso.substitutions.standard.Target_java_lang_invoke_MethodHandleNatives.Constants.ACCESS_VM_ANNOTATIONS;
 import static com.oracle.truffle.espresso.substitutions.standard.Target_java_lang_invoke_MethodHandleNatives.Constants.HIDDEN_CLASS;
 import static com.oracle.truffle.espresso.substitutions.standard.Target_java_lang_invoke_MethodHandleNatives.Constants.NESTMATE_CLASS;
@@ -1784,7 +1783,7 @@ public static class StackTrace {
         private boolean hiddenTop;
 
         public StackTrace() {
-            this(DEFAULT_STACK_SIZE);
+            this(32);
         }
 
         private StackTrace(int size) {