Disallow MethodPointer for null targets entirely.

Author: peter-hofer

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/InvalidMethodPointerHandler.java

@@ -50,8 +50,8 @@ public final class InvalidMethodPointerHandler {
     public static final Method INVALID_VTABLE_ENTRY_HANDLER_METHOD = ReflectionUtil.lookupMethod(InvalidMethodPointerHandler.class, "invalidVTableEntryHandler");
     public static final String INVALID_VTABLE_ENTRY_MSG = "Fatal error: Virtual method call used an illegal vtable entry that was seen as unused by the static analysis";
 
-    public static final Method METHOD_POINTER_INVALID_HANDLER_METHOD = ReflectionUtil.lookupMethod(InvalidMethodPointerHandler.class, "methodPointerInvalidHandler");
-    public static final String METHOD_POINTER_INVALID_MSG = "Fatal error: Method pointer invoked on a method that is null, was not registered for compilation, or was not seen as invoked by the static analysis";
+    public static final Method METHOD_POINTER_NOT_COMPILED_HANDLER_METHOD = ReflectionUtil.lookupMethod(InvalidMethodPointerHandler.class, "methodPointerNotCompiledHandler");
+    public static final String METHOD_POINTER_NOT_COMPILED_MSG = "Fatal error: Method pointer invoked on a method that was not compiled because it was not seen as invoked by the static analysis nor was it directly registered for compilation";
 
     @StubCallingConvention
     @NeverInline("We need a separate frame that stores all registers")
@@ -63,10 +63,10 @@ private static void invalidVTableEntryHandler() {
 
     @StubCallingConvention
     @NeverInline("We need a separate frame that stores all registers")
-    private static void methodPointerInvalidHandler() {
+    private static void methodPointerNotCompiledHandler() {
         Pointer callerSP = KnownIntrinsics.readCallerStackPointer();
         CodePointer callerIP = KnownIntrinsics.readReturnAddress();
-        failFatally(callerSP, callerIP, METHOD_POINTER_INVALID_MSG);
+        failFatally(callerSP, callerIP, METHOD_POINTER_NOT_COMPILED_MSG);
     }
 
     private static void failFatally(Pointer callerSP, CodePointer callerIP, String message) {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImage.java

@@ -571,15 +571,10 @@ private void markFunctionRelocationSite(final ProgbitsSectionImpl sectionImpl, f
         assert info.getRelocationSize() == functionPointerRelocationSize : "Function relocation: " + info.getRelocationSize() + " should be " + functionPointerRelocationSize + " bytes.";
         // References to functions are via relocations to the symbol for the function.
         MethodPointer methodPointer = (MethodPointer) info.getTargetObject();
-        HostedMethod target = null;
-        boolean valid = methodPointer.isValid();
-        if (valid) {
-            ResolvedJavaMethod method = methodPointer.getMethod();
-            target = (method instanceof HostedMethod) ? (HostedMethod) method : heap.getUniverse().lookup(method);
-            valid = target.isCompiled();
-        }
-        if (!valid) {
-            target = metaAccess.lookupJavaMethod(InvalidMethodPointerHandler.METHOD_POINTER_INVALID_HANDLER_METHOD);
+        ResolvedJavaMethod method = methodPointer.getMethod();
+        HostedMethod target = (method instanceof HostedMethod) ? (HostedMethod) method : heap.getUniverse().lookup(method);
+        if (!target.isCompiled()) {
+            target = metaAccess.lookupJavaMethod(InvalidMethodPointerHandler.METHOD_POINTER_NOT_COMPILED_HANDLER_METHOD);
         }
         // A reference to a method. Mark the relocation site using the symbol name.
         sectionImpl.markRelocationSite(offset, RelocationKind.getDirect(functionPointerRelocationSize), localSymbolNameForMethod(target), false, 0L);

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageHeapWriter.java

@@ -250,14 +250,10 @@ private void addNonDataRelocation(RelocatableBuffer buffer, int index, Relocated
 
         RelocatedPointer target = pointer;
         MethodPointer methodPointer = ((MethodPointer) target);
-        boolean valid = methodPointer.isValid();
-        if (valid) {
-            ResolvedJavaMethod method = methodPointer.getMethod();
-            HostedMethod hMethod = (method instanceof HostedMethod) ? (HostedMethod) method : heap.getUniverse().lookup(method);
-            valid = hMethod.isCompiled();
-        }
-        if (!valid) {
-            target = ImageSingletons.lookup(MethodPointerInvalidHandlerFeature.class).getHandler();
+        ResolvedJavaMethod method = methodPointer.getMethod();
+        HostedMethod hMethod = (method instanceof HostedMethod) ? (HostedMethod) method : heap.getUniverse().lookup(method);
+        if (!hMethod.isCompiled()) {
+            target = ImageSingletons.lookup(MethodPointerNotCompiledHandlerFeature.class).getHandler();
         }
         int pointerSize = ConfigurationValues.getTarget().wordSize;
         addDirectRelocationWithoutAddend(buffer, index, pointerSize, target);
@@ -411,13 +407,13 @@ private void writeObject(ObjectInfo info, RelocatableBuffer buffer) {
 }
 
 @AutomaticFeature
-final class MethodPointerInvalidHandlerFeature implements Feature {
+final class MethodPointerNotCompiledHandlerFeature implements Feature {
     private CFunctionPointer handler;
 
     @Override
     public void beforeAnalysis(BeforeAnalysisAccess a) {
         FeatureImpl.BeforeAnalysisAccessImpl access = (FeatureImpl.BeforeAnalysisAccessImpl) a;
-        AnalysisMethod notCompiledMethod = access.getMetaAccess().lookupJavaMethod(InvalidMethodPointerHandler.METHOD_POINTER_INVALID_HANDLER_METHOD);
+        AnalysisMethod notCompiledMethod = access.getMetaAccess().lookupJavaMethod(InvalidMethodPointerHandler.METHOD_POINTER_NOT_COMPILED_HANDLER_METHOD);
         access.registerAsCompiled(notCompiledMethod);
         handler = MethodPointer.factory(notCompiledMethod);
     }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/MethodPointer.java

@@ -29,48 +29,38 @@
 import org.graalvm.nativeimage.c.function.CFunctionPointer;
 import org.graalvm.word.ComparableWord;
 
-import com.oracle.svm.core.InvalidMethodPointerHandler;
+import com.oracle.svm.core.util.VMError;
 
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 /**
  * A pointer to the compiled code of a method.
  */
 public class MethodPointer implements CFunctionPointer {
-    private static final MethodPointer INVALID = new MethodPointer(null);
-
     private final ResolvedJavaMethod method;
 
     public static CFunctionPointer factory(ResolvedJavaMethod method) {
-        return (method != null) ? new MethodPointer(method) : INVALID;
+        VMError.guarantee(method != null, "MethodPointer cannot have null target method");
+        return new MethodPointer(method);
     }
 
     protected MethodPointer(ResolvedJavaMethod method) {
+        assert method != null;
         this.method = method;
     }
 
-    public boolean isValid() {
-        return (method != null);
-    }
-
     public ResolvedJavaMethod getMethod() {
-        assert isValid();
         return method;
     }
 
-    /**
-     * Always {@code false} because even a pointer to {@code null} or to a method that is not
-     * compiled will eventually be replaced by
-     * {@link InvalidMethodPointerHandler#METHOD_POINTER_INVALID_HANDLER_METHOD}.
-     */
     @Override
     public boolean isNull() {
         return false;
     }
 
     @Override
     public boolean isNonNull() {
-        return !isNull();
+        return true;
     }
 
     @Override