GR-74455: restore error message for not-compiled method of AoT class.

Author: rakachan

substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterFeature.java

@@ -45,6 +45,7 @@
 
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
+import com.oracle.svm.core.InvalidMethodPointerHandler;
 import com.oracle.svm.core.ParsingReason;
 import com.oracle.svm.core.UninterruptibleAnnotationUtils;
 import com.oracle.svm.core.feature.InternalFeature;
@@ -256,6 +257,7 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
 
         ImageSingletons.add(InterpreterSupport.class, new InterpreterSupportImpl(bciSlot, interpreterMethodSlot, interpreterFrameSlot, intrinsicMethodSlot, intrinsicFrameSlot));
         ImageSingletons.add(InterpreterDirectivesSupport.class, new InterpreterDirectivesSupportImpl());
+        ImageSingletons.add(InterpreterNotCompiledMethodPointerHolder.class, new InterpreterNotCompiledMethodPointerHolder());
 
         // Locals must be available at runtime to retrieve BCI, interpreted method and interpreter
         // frame.
@@ -273,7 +275,12 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
     public void beforeCompilation(BeforeCompilationAccess access) {
         FeatureImpl.BeforeCompilationAccessImpl accessImpl = (FeatureImpl.BeforeCompilationAccessImpl) access;
 
+        /* required so that it can hold a relocatable pointer */
+        accessImpl.registerAsImmutable(InterpreterNotCompiledMethodPointerHolder.singleton());
         accessImpl.registerAsImmutable(InterpreterSupport.singleton());
+
+        HostedMethod methodNotCompiledHandler = accessImpl.getMetaAccess().lookupJavaMethod(InvalidMethodPointerHandler.METHOD_POINTER_NOT_COMPILED_HANDLER_METHOD);
+        InterpreterNotCompiledMethodPointerHolder.setMethodNotCompiledHandler(InterpreterResolvedJavaMethod.createMethodRef(methodNotCompiledHandler));
     }
 
     /**

substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterNotCompiledMethodPointerHolder.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2024, 2026, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.svm.interpreter;
+
+import org.graalvm.nativeimage.ImageSingletons;
+import org.graalvm.nativeimage.Platform;
+import org.graalvm.nativeimage.Platforms;
+import org.graalvm.nativeimage.c.function.CFunctionPointer;
+
+import com.oracle.svm.core.BuildPhaseProvider;
+import com.oracle.svm.core.MethodRefHolder;
+import com.oracle.svm.core.heap.UnknownObjectField;
+import com.oracle.svm.core.meta.MethodRef;
+import com.oracle.svm.shared.singletons.traits.BuiltinTraits.AllAccess;
+import com.oracle.svm.shared.singletons.traits.BuiltinTraits.Disallowed;
+import com.oracle.svm.shared.singletons.traits.BuiltinTraits.NoLayeredCallbacks;
+import com.oracle.svm.shared.singletons.traits.SingletonTraits;
+
+import jdk.graal.compiler.api.replacements.Fold;
+
+@SingletonTraits(access = AllAccess.class, layeredCallbacks = NoLayeredCallbacks.class, other = Disallowed.class)
+public class InterpreterNotCompiledMethodPointerHolder {
+    @Fold
+    public static InterpreterNotCompiledMethodPointerHolder singleton() {
+        return ImageSingletons.lookup(InterpreterNotCompiledMethodPointerHolder.class);
+    }
+
+    @UnknownObjectField(availability = BuildPhaseProvider.AfterCompilation.class) //
+    private MethodRefHolder methodNotCompiledFtnPtr;
+
+    public static <T extends CFunctionPointer> T getMethodNotCompiledHandler() {
+        T ptr = singleton().methodNotCompiledFtnPtr.getFunctionPointer();
+        assert ptr.rawValue() != 0;
+        return ptr;
+    }
+
+    @Platforms(Platform.HOSTED_ONLY.class)
+    public static void setMethodNotCompiledHandler(MethodRef ftnptr) {
+        assert singleton().methodNotCompiledFtnPtr == null;
+        singleton().methodNotCompiledFtnPtr = new MethodRefHolder(ftnptr);
+    }
+}

substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterToVM.java

@@ -850,8 +850,11 @@ private static InterpreterResolvedJavaMethod resolveCallSiteTarget(InterpreterRe
     }
 
     private static boolean shouldCallAOTEntryPoint(boolean forceStayInInterpreter, boolean preferStayInInterpreter, InterpreterResolvedJavaMethod target, boolean quiet) {
-        boolean canBeInterpreterInvoked = target.hasBytecodes() || (RuntimeClassLoading.isSupported() && target.isSignaturePolymorphicIntrinsic());
-        boolean canBeAOTCalled = target.hasNativeEntryPoint() && target.getNativeEntryPoint().isNonNull();
+        boolean canBeInterpreterInvoked = target.hasBytecodes() ||
+                        (RuntimeClassLoading.isSupported() && target.isSignaturePolymorphicIntrinsic());
+        boolean canBeAOTCalled = target.hasNativeEntryPoint() &&
+                        target.getNativeEntryPoint().isNonNull() &&
+                        !target.getNativeEntryPoint().equal(InterpreterNotCompiledMethodPointerHolder.getMethodNotCompiledHandler());
 
         if (!canBeInterpreterInvoked && !canBeAOTCalled) {
             String source;
@@ -864,9 +867,14 @@ private static boolean shouldCallAOTEntryPoint(boolean forceStayInInterpreter, b
                 }
             } else {
                 source = "AOT";
+                String dotPkg = target.getDeclaringClass().getSymbolicRuntimePackage().toString().replace('/', '.');
                 if (!DynamicHub.fromClass(target.getDeclaringClass().getJavaClass()).isPreserved()) {
-                    String dotPkg = target.getDeclaringClass().getSymbolicRuntimePackage().toString().replace('/', '.');
-                    reason = MetadataUtil.fmt("Class was not preserved during image build. Consider using '-H:Preserve=package=%s'.", dotPkg);
+                    reason = MetadataUtil.fmt("Class %s was not preserved during image build.%nConsider using '-H:Preserve=package=%s'.", target.getDeclaringClass().toClassName(), dotPkg);
+                }
+                if (target.getNativeEntryPoint().equal(InterpreterNotCompiledMethodPointerHolder.getMethodNotCompiledHandler())) {
+                    reason = MetadataUtil.fmt(
+                                    "Trying to dispatch to compiled code for AOT method %s but it was not compiled because it was not seen as reachable by analysis.%nConsider using '-H:Preserve=package=%s'",
+                                    target, dotPkg);
                 }
             }
             InterpreterUtil.guarantee(false, "Unable to call %s method: %s%n%s", source, target, reason);