Partial evaluation method info uses JFR state.

tzezula · tzezula · commit 46592f2041a7 · 2025-10-31T08:30:33.000+01:00
diff --git a/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/HSTruffleCompilerRuntime.java b/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/HSTruffleCompilerRuntime.java
@@ -69,6 +69,7 @@
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 import jdk.vm.ci.meta.UnresolvedJavaType;
+import org.graalvm.nativeimage.c.type.CCharPointer;
 
 public final class HSTruffleCompilerRuntime extends HSObject implements TruffleCompilerRuntime {
 
@@ -78,14 +79,16 @@ public final class HSTruffleCompilerRuntime extends HSObject implements TruffleC
     private static final Class<?> TRANSLATED_EXCEPTION = LibGraalFeature.lookupClass("jdk.internal.vm.TranslatedException");
 
     private final ResolvedJavaType classLoaderDelegate;
+    private final CCharPointer javaInstrumentationActive;
     final TruffleFromLibGraalCalls calls;
 
-    HSTruffleCompilerRuntime(JNIEnv env, JObject handle, ResolvedJavaType classLoaderDelegate, JClass peer) {
+    HSTruffleCompilerRuntime(JNIEnv env, JObject handle, ResolvedJavaType classLoaderDelegate, JClass peer, CCharPointer javaInstrumentationActive) {
         /*
          * Note global duplicates may happen if the compiler is initialized by a host compilation.
          */
         super(env, handle, true, false);
         this.classLoaderDelegate = classLoaderDelegate;
+        this.javaInstrumentationActive = javaInstrumentationActive;
         this.calls = new TruffleFromLibGraalCalls(env, peer);
     }
 
@@ -212,4 +215,9 @@ public boolean isSuppressedFailure(TruffleCompilable compilable, Supplier<String
     public void notifyShutdown(JNIEnv env) {
         HSTruffleCompilerRuntimeGen.callOnIsolateShutdown(calls, env, IsolateUtil.getIsolateID());
     }
+
+    @Override
+    public boolean isJavaInstrumentationActive() {
+        return javaInstrumentationActive.isNonNull() && javaInstrumentationActive.read() != 0;
+    }
 }
diff --git a/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/LibGraalTruffleEntryPoints.java b/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/LibGraalTruffleEntryPoints.java
@@ -43,6 +43,7 @@
 import org.graalvm.nativeimage.ObjectHandles;
 import org.graalvm.nativeimage.c.function.CEntryPoint;
 import org.graalvm.nativeimage.c.function.CEntryPoint.IsolateThreadContext;
+import org.graalvm.nativeimage.c.type.CCharPointer;
 import org.graalvm.nativeimage.c.type.CLongPointer;
 import org.graalvm.word.PointerBase;
 
@@ -104,10 +105,12 @@ public static void initializeIsolate(JNIEnv env, JClass hsClazz, @IsolateThreadC
     @SuppressWarnings({"unused", "try"})
     @CEntryPoint(name = "Java_com_oracle_truffle_runtime_hotspot_libgraal_TruffleToLibGraalCalls_registerRuntime", include = LibGraalFeature.IsEnabled.class)
     @TruffleToLibGraal(Id.RegisterRuntime)
-    public static boolean registerRuntime(JNIEnv env, JClass hsClazz, @IsolateThreadContext long isolateThreadAddress, JObject truffleRuntime) {
+    public static boolean registerRuntime(JNIEnv env, JClass hsClazz, @IsolateThreadContext long isolateThreadAddress, JObject truffleRuntime,
+                    JObject javaInstrumentationActive) {
         try (JNIMethodScope s = openScope(Id.RegisterRuntime, env)) {
             long truffleRuntimeWeakRef = JNIUtil.NewWeakGlobalRef(env, truffleRuntime, "TruffleCompilerRuntime").rawValue();
-            return LibGraalTruffleHostEnvironmentLookup.registerRuntime(truffleRuntimeWeakRef);
+            long activeAddress = JNIUtil.GetDirectBufferAddress(env, javaInstrumentationActive).rawValue();
+            return LibGraalTruffleHostEnvironmentLookup.registerRuntime(truffleRuntimeWeakRef, activeAddress);
         } catch (Throwable t) {
             JNIExceptionWrapper.throwInHotSpot(env, t);
             return false;
@@ -118,10 +121,11 @@ public static boolean registerRuntime(JNIEnv env, JClass hsClazz, @IsolateThread
     @CEntryPoint(name = "Java_com_oracle_truffle_runtime_hotspot_libgraal_TruffleToLibGraalCalls_initializeRuntime", include = LibGraalFeature.IsEnabled.class)
     @TruffleToLibGraal(Id.InitializeRuntime)
     public static long initializeRuntime(JNIEnv env, JClass hsClazz, @IsolateThreadContext long isolateThreadAddress,
-                    JObject truffleRuntime, JClass hsClassLoaderDelegate) {
+                    JObject truffleRuntime, JClass hsClassLoaderDelegate, JObject javaInstrumentationActive) {
         try (JNIMethodScope s = openScope(Id.InitializeRuntime, env)) {
             ResolvedJavaType classLoaderDelegate = HotSpotJVMCIRuntime.runtime().asResolvedJavaType(hsClassLoaderDelegate.rawValue());
-            HSTruffleCompilerRuntime hsTruffleRuntime = new HSTruffleCompilerRuntime(env, truffleRuntime, classLoaderDelegate, hsClassLoaderDelegate);
+            CCharPointer activeAddress = (CCharPointer) JNIUtil.GetDirectBufferAddress(env, javaInstrumentationActive);
+            HSTruffleCompilerRuntime hsTruffleRuntime = new HSTruffleCompilerRuntime(env, truffleRuntime, classLoaderDelegate, hsClassLoaderDelegate, activeAddress);
             LibGraalSupportImpl.registerTruffleCompilerRuntime(hsTruffleRuntime);
             return LibGraalObjectHandles.create(hsTruffleRuntime);
         } catch (Throwable t) {
diff --git a/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/LibGraalTruffleHostEnvironmentLookup.java b/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/LibGraalTruffleHostEnvironmentLookup.java
@@ -36,6 +36,7 @@
 import org.graalvm.jniutils.JNI.JObject;
 import org.graalvm.jniutils.JNIMethodScope;
 import org.graalvm.jniutils.JNIUtil;
+import org.graalvm.word.WordFactory;
 
 /**
  * This handles the Truffle host environment lookup on HotSpot with Libgraal.
@@ -54,6 +55,7 @@ public final class LibGraalTruffleHostEnvironmentLookup implements TruffleHostEn
 
     private static final int NO_TRUFFLE_REGISTERED = 0;
     private static final GlobalAtomicLong WEAK_TRUFFLE_RUNTIME_INSTANCE = new GlobalAtomicLong("WEAK_TRUFFLE_RUNTIME_INSTANCE", NO_TRUFFLE_REGISTERED);
+    private static final GlobalAtomicLong JAVA_INSTRUMENTATION_ACTIVE_ADDRESS = new GlobalAtomicLong("JAVA_INSTRUMENTATION_ACTIVE_ADDRESS", NO_TRUFFLE_REGISTERED);
 
     private TruffleHostEnvironment previousRuntime;
 
@@ -89,7 +91,7 @@ public TruffleHostEnvironment lookup(ResolvedJavaType forType) {
          * per type. So in theory multiple truffle runtimes can be loaded.
          */
         try (TruffleRuntimeScope truffleRuntimeScope = LibGraalTruffleHostEnvironment.openTruffleRuntimeScopeImpl()) {
-            HSTruffleCompilerRuntime runtime = new HSTruffleCompilerRuntime(env, runtimeLocalRef, runtimeType, runtimeClass);
+            HSTruffleCompilerRuntime runtime = new HSTruffleCompilerRuntime(env, runtimeLocalRef, runtimeType, runtimeClass, WordFactory.pointer(JAVA_INSTRUMENTATION_ACTIVE_ADDRESS.get()));
             this.previousRuntime = environment = new LibGraalTruffleHostEnvironment(runtime, HotSpotJVMCIRuntime.runtime().getHostJVMCIBackend().getMetaAccess());
             assert JNIUtil.IsSameObject(env, hsRuntime(environment).getHandle(), runtimeLocalRef);
             return environment;
@@ -100,8 +102,12 @@ private static HSTruffleCompilerRuntime hsRuntime(TruffleHostEnvironment environ
         return (HSTruffleCompilerRuntime) environment.runtime();
     }
 
-    public static boolean registerRuntime(long truffleRuntimeWeakRef) {
+    public static boolean registerRuntime(long truffleRuntimeWeakRef, long javaInstrumentationActiveAddress) {
         // TODO GR-44222 support multiple runtimes.
-        return WEAK_TRUFFLE_RUNTIME_INSTANCE.compareAndSet(0, truffleRuntimeWeakRef);
+        boolean registered = WEAK_TRUFFLE_RUNTIME_INSTANCE.compareAndSet(0, truffleRuntimeWeakRef);
+        if (registered) {
+            JAVA_INSTRUMENTATION_ACTIVE_ADDRESS.set(javaInstrumentationActiveAddress);
+        }
+        return registered;
     }
 }
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/FlightRecorderInstrumentation.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/FlightRecorderInstrumentation.java
@@ -24,14 +24,14 @@
  */
 package jdk.graal.compiler.truffle;
 
+import com.oracle.truffle.compiler.TruffleCompilerRuntime;
 import jdk.vm.ci.meta.JavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
 import java.util.LinkedHashSet;
 import java.util.Set;
 
-// TODO: Handle FlightRecorder enabling/disabling.
 final class FlightRecorderInstrumentation {
 
     private static final Set<InstrumentedMethodPattern> instrumentedMethodPatterns = createInstrumentedPatterns();
@@ -50,7 +50,10 @@ private static Set<InstrumentedMethodPattern> createInstrumentedPatterns() {
     private FlightRecorderInstrumentation() {
     }
 
-    static boolean isInstrumented(ResolvedJavaMethod method, KnownTruffleTypes types) {
+    static boolean isInstrumented(TruffleCompilerRuntime runtime, ResolvedJavaMethod method, KnownTruffleTypes types) {
+        if (!runtime.isJavaInstrumentationActive()) {
+            return false;
+        }
         if (("traceThrowable".equals(method.getName()) || "traceError".equals(method.getName())) && "Ljdk/jfr/internal/instrument/ThrowableTracer;".equals(method.getDeclaringClass().getName())) {
             return true;
         }
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/PartialEvaluator.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/PartialEvaluator.java
@@ -83,8 +83,6 @@
 import jdk.vm.ci.meta.ResolvedJavaType;
 import jdk.vm.ci.meta.SpeculationLog.SpeculationReason;
 
-import static jdk.graal.compiler.annotation.AnnotationValueSupport.getDeclaredAnnotationValues;
-
 /**
  * Class performing the partial evaluation starting from the root node of an AST.
  */
@@ -203,7 +201,8 @@ public static ConstantFieldInfo computeConstantFieldInfo(ResolvedJavaField field
         return null;
     }
 
-    public static PartialEvaluationMethodInfo computePartialEvaluationMethodInfo(ResolvedJavaMethod method,
+    public static PartialEvaluationMethodInfo computePartialEvaluationMethodInfo(TruffleCompilerRuntime runtime,
+                    ResolvedJavaMethod method,
                     Map<ResolvedJavaType, AnnotationValue> declaredAnnotationValues,
                     KnownTruffleTypes types) {
         AnnotationValue truffleBoundary = declaredAnnotationValues.get(types.CompilerDirectives_TruffleBoundary);
@@ -212,8 +211,8 @@ public static PartialEvaluationMethodInfo computePartialEvaluationMethodInfo(Res
         AnnotationValue explodeLoop = declaredAnnotationValues.get(types.ExplodeLoop);
 
         return new PartialEvaluationMethodInfo(getLoopExplosionKind(explodeLoop),
-                        getInlineKind(truffleBoundary, truffleCallBoundary, method, true, types),
-                        getInlineKind(truffleBoundary, truffleCallBoundary, method, false, types),
+                        getInlineKind(runtime, truffleBoundary, truffleCallBoundary, method, true, types),
+                        getInlineKind(runtime, truffleBoundary, truffleCallBoundary, method, false, types),
                         method.canBeInlined(),
                         specialization);
     }
@@ -233,7 +232,7 @@ private static LoopExplosionKind getLoopExplosionKind(AnnotationValue value) {
         };
     }
 
-    private static InlineKind getInlineKind(AnnotationValue truffleBoundary, AnnotationValue truffleCallBoundary,
+    private static InlineKind getInlineKind(TruffleCompilerRuntime runtime, AnnotationValue truffleBoundary, AnnotationValue truffleCallBoundary,
                     ResolvedJavaMethod method, boolean duringPartialEvaluation,
                     KnownTruffleTypes types) {
         if (truffleBoundary != null) {
@@ -252,7 +251,7 @@ private static InlineKind getInlineKind(AnnotationValue truffleBoundary, Annotat
             }
         } else if (truffleCallBoundary != null) {
             return InlineKind.DO_NOT_INLINE_WITH_EXCEPTION;
-        } else if (FlightRecorderInstrumentation.isInstrumented(method, types)) {
+        } else if (FlightRecorderInstrumentation.isInstrumented(runtime, method, types)) {
             return InlineKind.DO_NOT_INLINE_WITH_EXCEPTION;
         }
         return InlineKind.INLINE;
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/hotspot/HotSpotPartialEvaluator.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/hotspot/HotSpotPartialEvaluator.java
@@ -180,7 +180,7 @@ protected Object createKey(ResolvedJavaMethod method) {
         @Override
         protected PartialEvaluationMethodInfo computeValue(ResolvedJavaMethod method) {
             Map<ResolvedJavaType, AnnotationValue> declaredAnnotationValues = AnnotationValueSupport.getDeclaredAnnotationValues(method);
-            PartialEvaluationMethodInfo methodInfo = computePartialEvaluationMethodInfo(method, declaredAnnotationValues, getTypes());
+            PartialEvaluationMethodInfo methodInfo = computePartialEvaluationMethodInfo(config.runtime(), method, declaredAnnotationValues, getTypes());
             /*
              * We can canonicalize the instances to reduce space required in the cache. There are
              * only a small number of possible instances of PartialEvaluationMethodInfo as it just
diff --git a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/api/SubstrateTruffleUniverseFactory.java b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/api/SubstrateTruffleUniverseFactory.java
@@ -92,7 +92,7 @@ static PartialEvaluationMethodInfo createPartialEvaluationMethodInfo(TruffleComp
                     KnownTruffleTypes types) {
         SubstrateAnnotationExtractor extractor = (SubstrateAnnotationExtractor) ImageSingletons.lookup(AnnotationExtractor.class);
         Map<ResolvedJavaType, AnnotationValue> annotations = extractor.getDeclaredAnnotationValues((Annotated) method);
-        var info = PartialEvaluator.computePartialEvaluationMethodInfo(method, annotations, types);
+        var info = PartialEvaluator.computePartialEvaluationMethodInfo(runtime, method, annotations, types);
         if (Uninterruptible.Utils.isUninterruptible(method)) {
             Uninterruptible uninterruptibleAnnotation = Uninterruptible.Utils.getAnnotation(method);
             if (uninterruptibleAnnotation == null || !uninterruptibleAnnotation.mayBeInlined()) {
diff --git a/truffle/src/com.oracle.truffle.compiler/src/com/oracle/truffle/compiler/TruffleCompilerRuntime.java b/truffle/src/com.oracle.truffle.compiler/src/com/oracle/truffle/compiler/TruffleCompilerRuntime.java
@@ -358,4 +358,12 @@ default ResolvedJavaType resolveType(MetaAccessProvider metaAccess, String class
      * silent.
      */
     boolean isSuppressedFailure(TruffleCompilable compilable, Supplier<String> serializedException);
+
+    /**
+     * Returns {@code true} if Java VM level instrumentation, such as Java Flight Recorder, is
+     * enabled.
+     */
+    default boolean isJavaInstrumentationActive() {
+        return false;
+    }
 }
diff --git a/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedTruffleRuntime.java b/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedTruffleRuntime.java
@@ -1158,6 +1158,11 @@ public boolean isSuppressedFailure(TruffleCompilable compilable, Supplier<String
         return floodControlHandler != null && floodControlHandler.isSuppressedFailure(compilable, serializedException);
     }
 
+    @Override
+    public boolean isJavaInstrumentationActive() {
+        return JFRListener.isActive();
+    }
+
     /**
      * Allows {@link OptimizedTruffleRuntime} subclasses to suppress exceptions such as an exception
      * thrown during VM exit. Unlike {@link #isSuppressedFailure(TruffleCompilable, Supplier)} this
diff --git a/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/debug/JFRListener.java b/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/debug/JFRListener.java
@@ -40,6 +40,7 @@
  */
 package com.oracle.truffle.runtime.debug;
 
+import java.nio.ByteBuffer;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
@@ -79,6 +80,7 @@ public final class JFRListener extends AbstractGraalTruffleRuntimeListener {
     // Support for JFRListener#isInstrumented
     private static final Set<InstrumentedMethodPattern> instrumentedMethodPatterns = createInstrumentedPatterns();
     private static final AtomicReference<InstrumentedFilterState> instrumentedFilterState = new AtomicReference<>(InstrumentedFilterState.NEW);
+    private static final ByteBuffer nativeInstrumentedFilterState = ByteBuffer.allocateDirect(1);
     private static volatile ResolvedJavaType resolvedJfrEventClass;
 
     private final ThreadLocal<CompilationData> currentCompilation = new ThreadLocal<>();
@@ -106,12 +108,29 @@ public static void install(OptimizedTruffleRuntime runtime) {
     }
 
     public static boolean isInstrumented(ResolvedJavaMethod method) {
-        // Initialization must be deferred into the image execution time
+        if (!isActive()) {
+            return false;
+        }
+        return isInstrumentedImpl(method);
+    }
+
+    public static boolean isActive() {
         InstrumentedFilterState currentState = instrumentedFilterState.get();
         if (currentState == InstrumentedFilterState.INACTIVE) {
             return false;
         }
-        return isInstrumentedImpl(method, currentState);
+        if (currentState == InstrumentedFilterState.NEW) {
+            currentState = initializeInstrumentedFilter();
+        }
+        // If JFR is not active or we are in the image build time return false
+        return currentState != InstrumentedFilterState.NEW && currentState != InstrumentedFilterState.INACTIVE;
+    }
+
+    public static ByteBuffer nativeState() {
+        if (instrumentedFilterState.get() == InstrumentedFilterState.NEW) {
+            initializeInstrumentedFilter();
+        }
+        return nativeInstrumentedFilterState;
     }
 
     @Override
@@ -281,18 +300,7 @@ private static boolean isPermanentFailure(boolean bailout, boolean permanentBail
     }
 
     // Support for JFRListener#isInstrumented
-    private static boolean isInstrumentedImpl(ResolvedJavaMethod method, InstrumentedFilterState state) {
-
-        InstrumentedFilterState currentState = state;
-        if (currentState == InstrumentedFilterState.NEW) {
-            currentState = initializeInstrumentedFilter();
-        }
-
-        // If JFR is not active or we are in the image build time return false
-        if (currentState == InstrumentedFilterState.NEW || currentState == InstrumentedFilterState.INACTIVE) {
-            return false;
-        }
-
+    private static boolean isInstrumentedImpl(ResolvedJavaMethod method) {
         /*
          * Between JDK-11 and JDK-21, JFR utilizes instrumentation to inject calls to
          * jdk.jfr.internal.instrument.ThrowableTracer into constructors of Throwable and Error.
@@ -330,9 +338,12 @@ private static InstrumentedFilterState initializeInstrumentedFilter() {
             if (FACTORY != null) {
                 FACTORY.addInitializationListener(() -> {
                     instrumentedFilterState.set(InstrumentedFilterState.ACTIVE);
+                    nativeInstrumentedFilterState.put(0, (byte) 1);
                 });
                 InstrumentedFilterState currentState = FACTORY.isInitialized() ? InstrumentedFilterState.ACTIVE : InstrumentedFilterState.INACTIVE;
-                instrumentedFilterState.compareAndSet(InstrumentedFilterState.NEW, currentState);
+                if (instrumentedFilterState.compareAndSet(InstrumentedFilterState.NEW, currentState)) {
+                    nativeInstrumentedFilterState.put(0, (byte) (currentState == InstrumentedFilterState.ACTIVE ? 1 : 0));
+                }
             } else {
                 instrumentedFilterState.set(InstrumentedFilterState.INACTIVE);
             }
diff --git a/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/hotspot/libgraal/LibGraalTruffleCompilationSupport.java b/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/hotspot/libgraal/LibGraalTruffleCompilationSupport.java
@@ -48,6 +48,7 @@
 import com.oracle.truffle.compiler.TruffleCompilerOptionDescriptor;
 import com.oracle.truffle.compiler.TruffleCompilerOptionDescriptor.Type;
 import com.oracle.truffle.compiler.TruffleCompilerRuntime;
+import com.oracle.truffle.runtime.debug.JFRListener;
 import com.oracle.truffle.runtime.hotspot.HotSpotTruffleRuntime;
 import com.oracle.truffle.runtime.hotspot.libgraal.LibGraalScope.DetachAction;
 
@@ -107,7 +108,7 @@ public TruffleCompiler createCompiler(TruffleCompilerRuntime runtime) {
     public void registerRuntime(TruffleCompilerRuntime runtime) {
         try (LibGraalScope scope = new LibGraalScope(DetachAction.DETACH_RUNTIME_AND_RELEASE)) {
             runtime().registerNativeMethods(TruffleToLibGraalCalls.class);
-            if (!TruffleToLibGraalCalls.registerRuntime(getIsolateThread(), runtime)) {
+            if (!TruffleToLibGraalCalls.registerRuntime(getIsolateThread(), runtime, JFRListener.nativeState())) {
                 throw new IllegalStateException("Truffle with libgraal cannot be loaded in multiple class loaders. Make sure Truffle is loaded with the system class loader.");
             }
         }
@@ -173,7 +174,7 @@ public boolean isSuppressedCompilationFailure(Throwable throwable) {
     static long handle(TruffleCompilerRuntime runtime) {
         try (LibGraalScope scope = new LibGraalScope()) {
             return scope.getIsolate().getSingleton(Handle.class, () -> {
-                return new Handle(TruffleToLibGraalCalls.initializeRuntime(getIsolateThread(), runtime, runtime.getClass()));
+                return new Handle(TruffleToLibGraalCalls.initializeRuntime(getIsolateThread(), runtime, runtime.getClass(), JFRListener.nativeState()));
             }).getHandle();
         }
     }
diff --git a/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/hotspot/libgraal/TruffleToLibGraalCalls.java b/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/hotspot/libgraal/TruffleToLibGraalCalls.java
