[GR-58546] [GR-59428] [GR-59422] [GR-59440] Allow coverage collection for espresso.

gilles-duboscq · gilles-duboscq · commit 08df97d80000 · 2024-11-01T07:40:46.000Z
PullRequest: graal/19131
diff --git a/espresso/ci/ci_common/common.jsonnet b/espresso/ci/ci_common/common.jsonnet
@@ -170,18 +170,26 @@ local benchmark_suites = ['dacapo', 'renaissance', 'scala-dacapo'];
   // LD_DEBUG=unused is a workaround for: symbol lookup error: jre/lib/amd64/libnio.so: undefined symbol: fstatat64
   maybe_set_ld_debug_flag(env): if std.startsWith(env, 'jvm') then [['set-export', 'LD_DEBUG', 'unused']] else [],
 
-  espresso_gate(allow_warnings, tags, ld_debug=false, mx_args=[], imports=null, gate_args=[], timelimit='15:00', name=null): {
+  espresso_gate(allow_warnings, tags, ld_debug=false, mx_args=[], imports=null, gate_args=[], timelimit='15:00', name=null, coverage=false): {
     local mx_cmd =
       ['mx']
       + mx_args
       + (if imports != null then ['--dynamicimports=' + imports] else []),
     run+: [
       if ld_debug then ['set-export', 'LD_DEBUG', 'unused'] else ['unset', 'LD_DEBUG'],
-      mx_cmd + ['--strict-compliance', 'gate', '--strict-mode', '--tags', tags] + ( if allow_warnings then ['--no-warning-as-error'] else []) + gate_args,
+      mx_cmd + ['--strict-compliance', 'gate', '--strict-mode', '--tags', tags]
+             + (if allow_warnings then ['--no-warning-as-error'] else [])
+             + (if coverage then ['--jacoco-omit-excluded', '--jacoco-relativize-paths', '--jacoco-omit-src-gen', '--jacocout=coverage', '--jacoco-format=lcov'] else [])
+             + gate_args,
     ],
   }
   + (if timelimit != null then {timelimit: timelimit} else {})
-  + (if name != null then {name: name} else {}),
+  + (if name != null then {name: name} else {})
+  + (if coverage then {
+    teardown+: [
+      ['mx', 'sversions', '--print-repositories', '--json', '|', 'coverage-uploader.py', '--associated-repos', '-'],
+    ],
+  } else {}),
 
   host_jvm(env, java_version): 'graalvm-espresso-' + _base_env(env),
   host_jvm_config(env): if std.startsWith(env, 'jvm') then 'jvm' else 'native',
diff --git a/espresso/mx.espresso/mx_espresso.py b/espresso/mx.espresso/mx_espresso.py
@@ -34,6 +34,7 @@
 import mx_pomdistribution
 import mx_subst
 import mx_util
+import mx_gate
 import mx_espresso_benchmarks  # pylint: disable=unused-import
 import mx_sdk_vm
 import mx_sdk_vm_impl
@@ -59,23 +60,29 @@ def _espresso_command(launcher, args):
 
 def _espresso_launcher_command(args):
     """Espresso launcher embedded in GraalVM + arguments"""
-    return _espresso_command('espresso', args)
+    jacoco_args = ['--vm.' + arg for arg in mx_gate.get_jacoco_agent_args() or []]
+    return _espresso_command('espresso', jacoco_args + args)
 
 
 def _java_truffle_command(args):
     """Java launcher using libjavavm in GraalVM + arguments"""
     return _espresso_command('java', ['-truffle'] + args)
 
 
-def _espresso_standalone_command(args, use_optimized_runtime=False, with_sulong=False):
+def _espresso_standalone_command(args, use_optimized_runtime=False, with_sulong=False, allow_jacoco=True):
     """Espresso standalone command from distribution jars + arguments"""
     vm_args, args = mx.extract_VM_args(args, useDoubleDash=True, defaultAllVMArgs=False)
     distributions = ['ESPRESSO', 'ESPRESSO_LAUNCHER', 'ESPRESSO_LIBS_RESOURCES', 'ESPRESSO_RUNTIME_RESOURCES', 'TRUFFLE_NFI_LIBFFI']
     if with_sulong:
         distributions += ['SULONG_NFI', 'SULONG_NATIVE']
+    if allow_jacoco:
+        jacoco_args = ['--vm.' + arg for arg in mx_gate.get_jacoco_agent_args() or []]
+    else:
+        jacoco_args = []
     return (
         vm_args
         + mx.get_runtime_jvm_args(distributions, jdk=mx.get_jdk())
+        + jacoco_args
         # We are not adding the truffle runtime
         + ['-Dpolyglot.engine.WarnInterpreterOnly=false']
         + [mx.distribution('ESPRESSO_LAUNCHER').mainClass] + args
@@ -124,7 +131,7 @@ def _run_espresso_meta(args, nonZeroIsFatal=True, timeout=None):
     """Run Espresso (standalone) on Espresso (launcher)"""
     return _run_espresso_launcher([
         '--vm.Xss4m',
-    ] + _espresso_standalone_command(args), nonZeroIsFatal=nonZeroIsFatal, timeout=timeout)
+    ] + _espresso_standalone_command(args, allow_jacoco=False), nonZeroIsFatal=nonZeroIsFatal, timeout=timeout)
 
 
 class EspressoTags:
diff --git a/espresso/mx.espresso/suite.py b/espresso/mx.espresso/suite.py
@@ -147,6 +147,7 @@
                 "com.oracle.truffle.espresso.ffi.NativeAccess.Provider",
             ],
             "annotationProcessors": ["truffle:TRUFFLE_DSL_PROCESSOR", "ESPRESSO_PROCESSOR"],
+            "jacoco" : "include",
             "javaCompliance" : "17+",
             "checkstyle": "com.oracle.truffle.espresso",
             "checkstyleVersion": "10.7.0",
@@ -180,6 +181,7 @@
                 "sdk:POLYGLOT",
                 "sdk:LAUNCHER_COMMON",
             ],
+            "jacoco" : "include",
             "javaCompliance" : "17+",
             "checkstyle": "com.oracle.truffle.espresso",
         },
diff --git a/espresso/src/com.oracle.truffle.espresso.classfile/src/com/oracle/truffle/espresso/classfile/descriptors/Symbol.java b/espresso/src/com.oracle.truffle.espresso.classfile/src/com/oracle/truffle/espresso/classfile/descriptors/Symbol.java
@@ -453,6 +453,11 @@ public static void ensureInitialized() {
         public static final Symbol<Name> SIG_IGN = StaticSymbols.putName("SIG_IGN");
         // sun.misc.NativeSignalHandler
         public static final Symbol<Name> handler = StaticSymbols.putName("handler");
+        // sun.nio.ch.NativeThread
+        public static final Symbol<Name> isNativeThread = StaticSymbols.putName("isNativeThread");
+        public static final Symbol<Name> current0 = StaticSymbols.putName("current0");
+        public static final Symbol<Name> signal = StaticSymbols.putName("signal");
+        public static final Symbol<Name> init = StaticSymbols.putName("init");
 
         // jdk.internal.util.ArraysSupport
         public static final Symbol<Name> vectorizedMismatch = StaticSymbols.putName("vectorizedMismatch");
@@ -688,6 +693,7 @@ public static void ensureInitialized() {
         public static final Symbol<Type> java_nio_file_Path = StaticSymbols.putType("Ljava/nio/file/Path;");
         public static final Symbol<Type> java_nio_file_Path_array = StaticSymbols.putType("[Ljava/nio/file/Path;");
         public static final Symbol<Type> java_nio_file_Paths = StaticSymbols.putType("Ljava/nio/file/Paths;");
+        public static final Symbol<Type> sun_nio_ch_NativeThread = StaticSymbols.putType("Lsun/nio/ch/NativeThread;");
 
         public static final Symbol<Type> jdk_internal_loader_ClassLoaders = StaticSymbols.putType("Ljdk/internal/loader/ClassLoaders;");
         public static final Symbol<Type> jdk_internal_loader_ClassLoaders$PlatformClassLoader = StaticSymbols.putType("Ljdk/internal/loader/ClassLoaders$PlatformClassLoader;");
@@ -1131,6 +1137,7 @@ public static void ensureInitialized() {
         public static final Symbol<Signature> _void_long_long = StaticSymbols.putSignature(Type._void, Type._long, Type._long);
         public static final Symbol<Signature> _boolean_int = StaticSymbols.putSignature(Type._boolean, Type._int);
         public static final Symbol<Signature> _boolean_int_int = StaticSymbols.putSignature(Type._boolean, Type._int, Type._int);
+        public static final Symbol<Signature> _boolean_long = StaticSymbols.putSignature(Type._boolean, Type._long);
         public static final Symbol<Signature> _int_int_int = StaticSymbols.putSignature(Type._int, Type._int, Type._int);
         public static final Symbol<Signature> _void_char_array = StaticSymbols.putSignature(Type._void, Type._char_array);
         public static final Symbol<Signature> _void_byte_array = StaticSymbols.putSignature(Type._void, Type._byte_array);
diff --git a/espresso/src/com.oracle.truffle.espresso.native/src/nespresso.c b/espresso/src/com.oracle.truffle.espresso.native/src/nespresso.c
@@ -458,6 +458,10 @@ jint GetJavaVM(JNIEnv *env, JavaVM **vmPtr) {
   if (vmPtr == NULL) {
     return JNI_ERR;
   }
+  if (env == NULL) {
+    fprintf(stderr, "GetJavaVM: Passed JNIEnv* is NULL" OS_NEWLINE_STR);
+    return JNI_ERR;
+  }
 
   moka_env = (MokapotEnv*) (*env)->reserved1;
   if (moka_env == NULL) {
@@ -494,16 +498,17 @@ JNIEXPORT JNIEnv* JNICALL initializeNativeContext(void* (*fetch_by_name)(const c
   struct JNINativeInterface_* jni_impl = malloc(sizeof(*jni_impl));
   struct NespressoEnv* nespresso_env = (struct NespressoEnv*) malloc(sizeof(*nespresso_env));
 
+  jni_impl->reserved0 = nespresso_env;
+  jni_impl->reserved1 = NULL;
+  jni_impl->reserved2 = NULL;
+  jni_impl->reserved3 = NULL;
   int fnCount = sizeof(*jni_impl) / sizeof(void*);
-  int i;
-  for (i = 0; i < fnCount; ++i) {
+  for (int i = 4; i < fnCount; ++i) {
     ((void**)jni_impl)[i] = &unset_function_error;
   }
 
   *env = jni_impl;
 
-  jni_impl->reserved0 = nespresso_env;
-
   // Fetch Java ... varargs methods.
   #define INIT_VARARGS_METHOD__(fn_name) \
     *(void**)(&nespresso_env->fn_name) = fetch_by_name(#fn_name);
diff --git a/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/ffi/NativeAccess.java b/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/ffi/NativeAccess.java
@@ -35,8 +35,8 @@
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.interop.UnsupportedTypeException;
 import com.oracle.truffle.espresso.EspressoOptions;
-import com.oracle.truffle.espresso.meta.EspressoError;
 import com.oracle.truffle.espresso.classfile.JavaKind;
+import com.oracle.truffle.espresso.meta.EspressoError;
 import com.oracle.truffle.espresso.runtime.EspressoProperties;
 
 /**
diff --git a/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/meta/Meta.java b/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/meta/Meta.java
@@ -378,6 +378,18 @@ public Meta(EspressoContext context) {
         java_nio_file_Paths = knownKlass(Type.java_nio_file_Paths);
         java_nio_file_Paths_get = java_nio_file_Paths.requireDeclaredMethod(Name.get, Signature.Path_String_String_array);
 
+        ObjectKlass nioNativeThreadKlass = knownKlass(Type.sun_nio_ch_NativeThread);
+        sun_nio_ch_NativeThread_init = nioNativeThreadKlass.lookupDeclaredMethod(Name.init, Signature._void);
+        if (getJavaVersion().java21OrLater()) {
+            sun_nio_ch_NativeThread_isNativeThread = nioNativeThreadKlass.requireDeclaredMethod(Name.isNativeThread, Signature._boolean_long);
+            sun_nio_ch_NativeThread_current0 = nioNativeThreadKlass.requireDeclaredMethod(Name.current0, Signature._long);
+            sun_nio_ch_NativeThread_signal = null;
+        } else {
+            sun_nio_ch_NativeThread_isNativeThread = null;
+            sun_nio_ch_NativeThread_current0 = null;
+            sun_nio_ch_NativeThread_signal = nioNativeThreadKlass.requireDeclaredMethod(Name.signal, Signature._void_long);
+        }
+
         sun_launcher_LauncherHelper = knownKlass(Type.sun_launcher_LauncherHelper);
         sun_launcher_LauncherHelper_printHelpMessage = sun_launcher_LauncherHelper.requireDeclaredMethod(Name.printHelpMessage, Signature._void_boolean);
         sun_launcher_LauncherHelper_ostream = sun_launcher_LauncherHelper.requireDeclaredField(Name.ostream, Type.java_io_PrintStream);
@@ -1554,6 +1566,11 @@ private DiffVersionLoadHelper diff() {
     public final ObjectKlass java_nio_file_Paths;
     public final Method java_nio_file_Paths_get;
 
+    public final Method sun_nio_ch_NativeThread_isNativeThread;
+    public final Method sun_nio_ch_NativeThread_current0;
+    public final Method sun_nio_ch_NativeThread_signal;
+    public final Method sun_nio_ch_NativeThread_init;
+
     // Array support.
     public final ObjectKlass java_lang_Cloneable;
     public final ObjectKlass java_io_Serializable;
diff --git a/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/nodes/AbstractInstrumentableBytecodeNode.java b/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/nodes/AbstractInstrumentableBytecodeNode.java
@@ -22,6 +22,9 @@
  */
 package com.oracle.truffle.espresso.nodes;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.frame.Frame;
 import com.oracle.truffle.api.frame.MaterializedFrame;
@@ -35,18 +38,15 @@
 import com.oracle.truffle.api.library.ExportMessage;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.espresso.EspressoScope;
+import com.oracle.truffle.espresso.classfile.attributes.Local;
 import com.oracle.truffle.espresso.classfile.descriptors.ByteSequence;
 import com.oracle.truffle.espresso.classfile.descriptors.Signatures;
 import com.oracle.truffle.espresso.classfile.descriptors.Symbol;
 import com.oracle.truffle.espresso.classfile.descriptors.Symbol.Name;
 import com.oracle.truffle.espresso.classfile.descriptors.Symbol.Type;
 import com.oracle.truffle.espresso.impl.Method;
-import com.oracle.truffle.espresso.classfile.attributes.Local;
 import com.oracle.truffle.espresso.vm.continuation.UnwindContinuationException;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-
 @GenerateWrapper(yieldExceptions = UnwindContinuationException.class, resumeMethodPrefix = "resumeContinuation")
 @ExportLibrary(NodeLibrary.class)
 abstract class AbstractInstrumentableBytecodeNode extends EspressoInstrumentableNode {
@@ -83,14 +83,15 @@ public final boolean hasScope(@SuppressWarnings("unused") Frame frame) {
 
     @ExportMessage
     public final Object getScope(Frame frame, @SuppressWarnings("unused") boolean nodeEnter) {
-        return getScopeSlowPath(frame != null ? frame.materialize() : null);
+        return getScopeSlowPath(frame != null ? frame.materialize() : null, getMethod(), getBci(frame));
     }
 
     @TruffleBoundary
-    private Object getScopeSlowPath(MaterializedFrame frame) {
-        // construct the current scope with valid local variables information
-        Method method = getMethodVersion().getMethod();
-        Local[] liveLocals = method.getLocalVariableTable().getLocalsAt(getBci(frame));
+    private static Object getScopeSlowPath(MaterializedFrame frame, Method method, int bci) {
+        // NOTE: this might be called while the thread is not entered into the context so
+        // don't use things like a LanguageReference
+        // Construct the current scope with valid local variables information
+        Local[] liveLocals = method.getLocalVariableTable().getLocalsAt(bci);
         boolean allParamsIncluded = checkLocals(liveLocals, method);
         if (!allParamsIncluded) {
             ArrayList<Local> constructedLiveLocals = new ArrayList<>();
@@ -120,7 +121,7 @@ private Object getScopeSlowPath(MaterializedFrame frame) {
             for (int i = startslot; i < localCount; i++) {
                 Symbol<Type> paramType = hasReceiver ? Signatures.parameterType(parsedSignature, i - 1) : Signatures.parameterType(parsedSignature, i);
                 if (!slotToLocal.containsKey(i)) {
-                    Symbol<Name> localName = getLanguage().getNames().getOrCreate(ByteSequence.create("arg_" + i));
+                    Symbol<Name> localName = method.getLanguage().getNames().getOrCreate(ByteSequence.create("arg_" + i));
                     constructedLiveLocals.add(new Local(localName, paramType, null, 0, 0xffff, i));
                     slotToLocal.remove(i);
                 }
diff --git a/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/substitutions/Target_sun_nio_ch_NativeThread.java b/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/substitutions/Target_sun_nio_ch_NativeThread.java
@@ -22,15 +22,82 @@
  */
 package com.oracle.truffle.espresso.substitutions;
 
-/**
- * This substitution is only needed when using the Sulong backend, since installing signal handlers
- * is not supported. See GR-29359.
- */
+import com.oracle.truffle.api.dsl.Bind;
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.nodes.DirectCallNode;
+import com.oracle.truffle.espresso.EspressoOptions;
+import com.oracle.truffle.espresso.ffi.nfi.NFISulongNativeAccess;
+import com.oracle.truffle.espresso.runtime.EspressoContext;
+import com.oracle.truffle.espresso.substitutions.VersionFilter.Java17OrEarlier;
+import com.oracle.truffle.espresso.substitutions.VersionFilter.Java21OrLater;
+
 @EspressoSubstitutions
 public final class Target_sun_nio_ch_NativeThread {
-
+    /*
+     * This doesn't exist on Windows, it just won't match
+     */
     @Substitution
-    public static void init() {
-        // nop
+    abstract static class Init extends SubstitutionNode {
+        abstract void execute();
+
+        @Specialization
+        static void doDefault(@Bind("getContext()") EspressoContext context,
+                        @Cached("create(context.getMeta().sun_nio_ch_NativeThread_init.getCallTargetNoSubstitution())") DirectCallNode original) {
+            // avoid the installation of a signal handler except on SVM and not with llvm
+            if (EspressoOptions.RUNNING_ON_SVM && !(context.getNativeAccess() instanceof NFISulongNativeAccess)) {
+                original.call();
+            }
+        }
+    }
+
+    @Substitution(versionFilter = Java21OrLater.class)
+    abstract static class IsNativeThread extends SubstitutionNode {
+        abstract boolean execute(long tid);
+
+        @Specialization
+        static boolean doDefault(long tid,
+                        @Bind("getContext()") EspressoContext context,
+                        @Cached("create(context.getMeta().sun_nio_ch_NativeThread_isNativeThread.getCallTargetNoSubstitution())") DirectCallNode original) {
+            if (context.getNativeAccess() instanceof NFISulongNativeAccess) {
+                // sulong virtualizes pthread_self but not ptrhead_kill
+                // signal to the JDK that we don't support signaling
+                return false;
+            } else {
+                return (boolean) original.call(tid);
+            }
+        }
+    }
+
+    @Substitution(versionFilter = Java21OrLater.class)
+    abstract static class Current0 extends SubstitutionNode {
+        abstract long execute();
+
+        @Specialization
+        static long doDefault(@Bind("getContext()") EspressoContext context,
+                        @Cached("create(context.getMeta().sun_nio_ch_NativeThread_current0.getCallTargetNoSubstitution())") DirectCallNode original) {
+            if (context.getNativeAccess() instanceof NFISulongNativeAccess) {
+                // sulong virtualizes pthread_self but not ptrhead_kill
+                // signal to the JDK that we don't support signaling
+                return 0;
+            } else {
+                return (long) original.call();
+            }
+        }
+    }
+
+    @Substitution(versionFilter = Java17OrEarlier.class)
+    abstract static class Signal extends SubstitutionNode {
+        abstract void execute(long nt);
+
+        @Specialization
+        static void doDefault(long nt,
+                        @Bind("getContext()") EspressoContext context,
+                        @Cached("create(context.getMeta().sun_nio_ch_NativeThread_signal.getCallTargetNoSubstitution())") DirectCallNode original) {
+            // sulong virtualizes pthread_self but not ptrhead_kill
+            if (!(context.getNativeAccess() instanceof NFISulongNativeAccess)) {
+                original.call(nt);
+            }
+        }
     }
 }
diff --git a/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/substitutions/VersionFilter.java b/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/substitutions/VersionFilter.java
@@ -89,6 +89,18 @@ public boolean isValidFor(JavaVersion version) {
         }
     }
 
+    final class Java17OrEarlier implements VersionFilter {
+        public static final Java17OrEarlier INSTANCE = new Java17OrEarlier();
+
+        private Java17OrEarlier() {
+        }
+
+        @Override
+        public boolean isValidFor(JavaVersion version) {
+            return version.java17OrEarlier();
+        }
+    }
+
     final class Java18OrEarlier implements VersionFilter {
         public static final Java18OrEarlier INSTANCE = new Java18OrEarlier();
 
@@ -124,4 +136,16 @@ public boolean isValidFor(JavaVersion version) {
             return version.java20OrLater();
         }
     }
+
+    final class Java21OrLater implements VersionFilter {
+        public static final Java21OrLater INSTANCE = new Java21OrLater();
+
+        private Java21OrLater() {
+        }
+
+        @Override
+        public boolean isValidFor(JavaVersion version) {
+            return version.java21OrLater();
+        }
+    }
 }
diff --git a/sdk/mx.sdk/vm/launcher_template.cmd b/sdk/mx.sdk/vm/launcher_template.cmd
@@ -187,6 +187,9 @@ exit /b %errorlevel%
     ) else if "!vm_arg:~0,10!"=="classpath=" (
         call :unquote_arg %vm_arg:~10%
         set "absolute_cp=%absolute_cp%;!arg!"
+    ) else if "!vm_arg:~0,1!"=="@" (
+        if %arg_quoted%==true ( set "arg="%vm_arg%"" ) else ( set "arg=%vm_arg%" )
+        set "jvm_args=%jvm_args% !arg!"
     ) else (
         if %arg_quoted%==true ( set "arg="-%vm_arg%"" ) else ( set "arg=-%vm_arg%" )
         set "jvm_args=%jvm_args% !arg!"
diff --git a/sdk/mx.sdk/vm/launcher_template.sh b/sdk/mx.sdk/vm/launcher_template.sh
diff --git a/sulong/mx.sulong/mx_sulong.py b/sulong/mx.sulong/mx_sulong.py
