TruffleHostEnvironment does not call TruffleCompilerRuntime#getHostMethodInfo.

Author: tzezula

compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/LibGraalTruffleHostEnvironment.java

@@ -28,6 +28,7 @@
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.util.Map;
+import java.util.function.Function;
 
 import com.oracle.truffle.compiler.HostMethodInfo;
 import com.oracle.truffle.compiler.TruffleCompilable;
@@ -41,7 +42,6 @@
 import jdk.graal.compiler.truffle.TruffleCompilerImpl;
 import jdk.graal.compiler.truffle.TruffleElementCache;
 import jdk.graal.compiler.truffle.host.TruffleHostEnvironment;
-import jdk.graal.compiler.truffle.host.TruffleKnownHostTypes;
 import jdk.graal.compiler.truffle.hotspot.HotSpotTruffleCompilerImpl;
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
@@ -101,14 +101,8 @@ protected Object createKey(ResolvedJavaMethod method) {
 
         @Override
         protected HostMethodInfo computeValue(ResolvedJavaMethod method) {
-            TruffleKnownHostTypes hostTypes = types();
             Map<ResolvedJavaType, AnnotationValue> annotations = AnnotationValueSupport.getDeclaredAnnotationValues(method);
-            boolean isTruffleBoundary = annotations.containsKey(hostTypes.TruffleBoundary);
-            boolean isBytecodeInterpreterSwitch = annotations.containsKey(hostTypes.BytecodeInterpreterSwitch);
-            boolean isBytecodeInterpreterSwitchBoundary = annotations.containsKey(hostTypes.BytecodeInterpreterSwitchBoundary);
-            boolean isInliningCutoff = annotations.containsKey(hostTypes.InliningCutoff);
-            boolean isInliningRoot = annotations.containsKey(hostTypes.InliningRoot);
-            return new HostMethodInfo(isTruffleBoundary, isBytecodeInterpreterSwitch, isBytecodeInterpreterSwitchBoundary, isInliningCutoff, isInliningRoot);
+            return computeHostMethodInfo(annotations, Function.identity());
         }
 
     }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/host/TruffleHostEnvironment.java

@@ -24,6 +24,7 @@
  */
 package jdk.graal.compiler.truffle.host;
 
+import jdk.graal.compiler.annotation.AnnotationValue;
 import jdk.graal.compiler.debug.GraalError;
 import jdk.graal.compiler.serviceprovider.GraalServices;
 import jdk.graal.compiler.serviceprovider.LibGraalService;
@@ -39,6 +40,9 @@
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
+import java.util.Map;
+import java.util.function.Function;
+
 /**
  * This class manages Truffle resources used during host Java compilation. A host environment is
  * only available if the Truffle runtime was fully initialized. In practice this means that several
@@ -162,6 +166,31 @@ public TruffleRuntimeScope openTruffleRuntimeScope() {
         return null;
     }
 
+    /**
+     * Computes a {@link HostMethodInfo} instance based on the annotations present on a given
+     * method.
+     *
+     * @param declaredAnnotationValues a map of method annotations keyed by their declaring
+     *            {@link ResolvedJavaType}
+     * @param unwrapType a function that unwraps a {@link ResolvedJavaType} obtained from
+     *            {@code hostTypes} to its underlying host {@link ResolvedJavaType}. In
+     *            native-image, known Truffle types are represented as {@code AnalysisType}, while
+     *            the keys in {@code declaredAnnotationValues} correspond to host JVMCI types.
+     *            Therefore, each {@code AnalysisType} must be unwrapped via
+     *            {@code OriginalClassProvider.getOriginalType(JavaType)} to correctly access the
+     *            corresponding annotation entries in {@code declaredAnnotationValues}.
+     */
+    protected final HostMethodInfo computeHostMethodInfo(Map<ResolvedJavaType, AnnotationValue> declaredAnnotationValues,
+                    Function<ResolvedJavaType, ResolvedJavaType> unwrapType) {
+        TruffleKnownHostTypes hostTypes = types();
+        boolean isTruffleBoundary = declaredAnnotationValues.containsKey(unwrapType.apply(hostTypes.TruffleBoundary));
+        boolean isBytecodeInterpreterSwitch = declaredAnnotationValues.containsKey(unwrapType.apply(hostTypes.BytecodeInterpreterSwitch));
+        boolean isBytecodeInterpreterSwitchBoundary = declaredAnnotationValues.containsKey(unwrapType.apply(hostTypes.BytecodeInterpreterSwitchBoundary));
+        boolean isInliningCutoff = declaredAnnotationValues.containsKey(unwrapType.apply(hostTypes.InliningCutoff));
+        boolean isInliningRoot = declaredAnnotationValues.containsKey(unwrapType.apply(hostTypes.InliningRoot));
+        return new HostMethodInfo(isTruffleBoundary, isBytecodeInterpreterSwitch, isBytecodeInterpreterSwitchBoundary, isInliningCutoff, isInliningRoot);
+    }
+
     @LibGraalService
     public interface Lookup {
 

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/hotspot/HotSpotTruffleHostEnvironment.java

@@ -24,6 +24,8 @@
  */
 package jdk.graal.compiler.truffle.hotspot;
 
+import jdk.graal.compiler.annotation.AnnotationValue;
+import jdk.graal.compiler.annotation.AnnotationValueSupport;
 import jdk.graal.compiler.debug.GraalError;
 import jdk.graal.compiler.truffle.host.TruffleHostEnvironment;
 import jdk.graal.compiler.truffle.TruffleCompilerImpl;
@@ -35,6 +37,10 @@
 
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
+import jdk.vm.ci.meta.ResolvedJavaType;
+
+import java.util.Map;
+import java.util.function.Function;
 
 final class HotSpotTruffleHostEnvironment extends TruffleHostEnvironment {
 
@@ -80,7 +86,8 @@ protected Object createKey(ResolvedJavaMethod method) {
 
         @Override
         protected HostMethodInfo computeValue(ResolvedJavaMethod method) {
-            return runtime().getHostMethodInfo(method);
+            Map<ResolvedJavaType, AnnotationValue> annotations = AnnotationValueSupport.getDeclaredAnnotationValues(method);
+            return computeHostMethodInfo(annotations, Function.identity());
         }
 
     }

substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/SubstrateTruffleHostEnvironment.java

@@ -24,6 +24,11 @@
  */
 package com.oracle.svm.truffle;
 
+import com.oracle.svm.hosted.annotation.SubstrateAnnotationExtractor;
+import com.oracle.svm.util.OriginalClassProvider;
+import jdk.graal.compiler.annotation.AnnotationValue;
+import jdk.vm.ci.meta.ResolvedJavaType;
+import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
 
@@ -37,6 +42,9 @@
 import jdk.graal.compiler.truffle.host.TruffleHostEnvironment;
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
+import org.graalvm.nativeimage.impl.AnnotationExtractor;
+
+import java.util.Map;
 
 @Platforms(Platform.HOSTED_ONLY.class)
 final class SubstrateTruffleHostEnvironment extends TruffleHostEnvironment {
@@ -74,7 +82,9 @@ protected Object createKey(ResolvedJavaMethod method) {
 
         @Override
         protected HostMethodInfo computeValue(ResolvedJavaMethod method) {
-            return runtime().getHostMethodInfo(method);
+            SubstrateAnnotationExtractor extractor = (SubstrateAnnotationExtractor) ImageSingletons.lookup(AnnotationExtractor.class);
+            Map<ResolvedJavaType, AnnotationValue> annotations = extractor.getDeclaredAnnotationValues(method);
+            return computeHostMethodInfo(annotations, OriginalClassProvider::getOriginalType);
         }
 
     }

substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/api/SubstrateTruffleRuntime.java

@@ -184,19 +184,19 @@ protected EngineCacheSupport loadEngineCacheSupport(List<OptionDescriptors> opti
     @Override
     @Platforms(Platform.HOSTED_ONLY.class)
     public PartialEvaluationMethodInfo getPartialEvaluationMethodInfo(ResolvedJavaMethod method) {
-        return super.getPartialEvaluationMethodInfo(method);
+        throw new UnsupportedOperationException();
     }
 
     @Override
     @Platforms(Platform.HOSTED_ONLY.class)
     public HostMethodInfo getHostMethodInfo(ResolvedJavaMethod method) {
-        return super.getHostMethodInfo(method);
+        throw new UnsupportedOperationException();
     }
 
     @Override
     @Platforms(Platform.HOSTED_ONLY.class)
     public ConstantFieldInfo getConstantFieldInfo(ResolvedJavaField field) {
-        return super.getConstantFieldInfo(field);
+        throw new UnsupportedOperationException();
     }
 
     private void teardownCompilerIsolate() {