WiP

Author: peter-hofer

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/InvalidVTableEntryHandler.java renamed to substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/InvalidMethodPointerHandler.java

@@ -43,33 +43,51 @@
 import com.oracle.svm.util.ReflectionUtil;
 
 /**
- * Provides a stub method that can be used to fill otherwise unused vtable slots. Instead of a
- * segfault, this method provides a full diagnostic output with a stack trace.
+ * Provides stub methods that can be used for uninitialized method pointers. Instead of a segfault,
+ * the stubs provide full diagnostic output with a stack trace.
  */
-public final class InvalidVTableEntryHandler {
-    public static final Method HANDLER_METHOD = ReflectionUtil.lookupMethod(InvalidVTableEntryHandler.class, "invalidVTableEntryHandler");
-    public static final String MSG = "Fatal error: Virtual method call used an illegal vtable entry that was seen as unused by the static analysis";
+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_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 registered for compilation nor seen by the static analysis";
 
     @StubCallingConvention
     @NeverInline("We need a separate frame that stores all registers")
     private static void invalidVTableEntryHandler() {
         VMThreads.StatusSupport.setStatusIgnoreSafepoints();
         StackOverflowCheck.singleton().disableStackOverflowChecksForFatalError();
 
+        Pointer callerSP = KnownIntrinsics.readCallerStackPointer();
+        CodePointer callerIP = KnownIntrinsics.readReturnAddress();
+        failFatally(callerSP, callerIP, INVALID_VTABLE_ENTRY_MSG);
+    }
+
+    @StubCallingConvention
+    @NeverInline("We need a separate frame that stores all registers")
+    private static void methodPointerNotCompiledHandler() {
+        VMThreads.StatusSupport.setStatusIgnoreSafepoints();
+        StackOverflowCheck.singleton().disableStackOverflowChecksForFatalError();
+
+        Pointer callerSP = KnownIntrinsics.readCallerStackPointer();
+        CodePointer callerIP = KnownIntrinsics.readReturnAddress();
+        failFatally(callerSP, callerIP, METHOD_POINTER_NOT_COMPILED_MSG);
+    }
+
+    private static void failFatally(Pointer callerSP, CodePointer callerIP, String message) {
         /*
          * Since this is so far the only use case we have for a fatal error with
          * frameHasCalleeSavedRegisters=true, we inline the usual fatal error handling. Note that
          * this has the added benefit that the instructions printed as part of the crash dump are
          * from the method that has the illegal vtable call. That can be helpful when debugging the
          * cause of the fatal error.
          */
-        Pointer callerSP = KnownIntrinsics.readCallerStackPointer();
-        CodePointer callerIP = KnownIntrinsics.readReturnAddress();
         LogHandler logHandler = ImageSingletons.lookup(LogHandler.class);
-        Log log = Log.enterFatalContext(logHandler, callerIP, MSG, null);
+        Log log = Log.enterFatalContext(logHandler, callerIP, message, null);
         if (log != null) {
             SubstrateDiagnostics.printFatalError(log, callerSP, callerIP, WordFactory.nullPointer(), true);
-            log.string(MSG).newline();
+            log.string(message).newline();
         }
         logHandler.fatalError();
     }

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

@@ -38,19 +38,24 @@
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.c.function.CFunctionPointer;
 import org.graalvm.nativeimage.c.function.RelocatedPointer;
+import org.graalvm.nativeimage.hosted.Feature;
 import org.graalvm.word.WordBase;
 
+import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.util.AnalysisError;
 import com.oracle.objectfile.ObjectFile;
 import com.oracle.svm.core.FrameAccess;
+import com.oracle.svm.core.InvalidMethodPointerHandler;
 import com.oracle.svm.core.StaticFieldsSupport;
+import com.oracle.svm.core.annotate.AutomaticFeature;
 import com.oracle.svm.core.config.ConfigurationValues;
 import com.oracle.svm.core.config.ObjectLayout;
 import com.oracle.svm.core.heap.Heap;
 import com.oracle.svm.core.heap.ObjectHeader;
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.image.ImageHeapLayoutInfo;
 import com.oracle.svm.core.meta.SubstrateObjectConstant;
+import com.oracle.svm.hosted.FeatureImpl;
 import com.oracle.svm.hosted.config.HybridLayout;
 import com.oracle.svm.hosted.image.NativeImageHeap.ObjectInfo;
 import com.oracle.svm.hosted.meta.HostedClass;
@@ -243,13 +248,14 @@ private void addNonDataRelocation(RelocatableBuffer buffer, int index, Relocated
         assert pointer instanceof CFunctionPointer : "unknown relocated pointer " + pointer;
         assert pointer instanceof MethodPointer : "cannot create relocation for unknown FunctionPointer " + pointer;
 
+        RelocatedPointer target = pointer;
         ResolvedJavaMethod method = ((MethodPointer) pointer).getMethod();
         HostedMethod hMethod = method instanceof HostedMethod ? (HostedMethod) method : heap.getUniverse().lookup(method);
-        if (hMethod.isCompiled()) {
-            // Only compiled methods inserted in vtables require relocation.
-            int pointerSize = ConfigurationValues.getTarget().wordSize;
-            addDirectRelocationWithoutAddend(buffer, index, pointerSize, pointer);
+        if (!hMethod.isCompiled()) {
+            target = ImageSingletons.lookup(MethodPointerNotCompiledHandlerFeature.class).getNotCompiledHandler();
         }
+        int pointerSize = ConfigurationValues.getTarget().wordSize;
+        addDirectRelocationWithoutAddend(buffer, index, pointerSize, target);
     }
 
     private static void writePrimitive(RelocatableBuffer buffer, int index, JavaConstant con) {
@@ -398,3 +404,21 @@ private void writeObject(ObjectInfo info, RelocatableBuffer buffer) {
         }
     }
 }
+
+@AutomaticFeature
+final class MethodPointerNotCompiledHandlerFeature implements Feature {
+    private CFunctionPointer notCompiledHandler;
+
+    @Override
+    public void beforeAnalysis(BeforeAnalysisAccess a) {
+        FeatureImpl.BeforeAnalysisAccessImpl access = (FeatureImpl.BeforeAnalysisAccessImpl) a;
+        AnalysisMethod notCompiledMethod = access.getMetaAccess().lookupJavaMethod(InvalidMethodPointerHandler.METHOD_POINTER_NOT_COMPILED_HANDLER_METHOD);
+        access.registerAsCompiled(notCompiledMethod);
+        notCompiledHandler = MethodPointer.factory(notCompiledMethod);
+    }
+
+    CFunctionPointer getNotCompiledHandler() {
+        assert notCompiledHandler != null;
+        return notCompiledHandler;
+    }
+}

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

@@ -29,6 +29,8 @@
 import org.graalvm.nativeimage.c.function.CFunctionPointer;
 import org.graalvm.word.ComparableWord;
 
+import com.oracle.svm.core.util.VMError;
+
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 /**
@@ -39,11 +41,8 @@ public class MethodPointer implements CFunctionPointer {
     private final ResolvedJavaMethod method;
 
     public static CFunctionPointer factory(ResolvedJavaMethod method) {
-        if (method == null) {
-            return null;
-        } else {
-            return new MethodPointer(method);
-        }
+        VMError.guarantee(method != null);
+        return new MethodPointer(method);
     }
 
     protected MethodPointer(ResolvedJavaMethod method) {

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

@@ -63,7 +63,7 @@
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.graal.pointsto.results.AbstractAnalysisResultsBuilder;
 import com.oracle.svm.core.FunctionPointerHolder;
-import com.oracle.svm.core.InvalidVTableEntryHandler;
+import com.oracle.svm.core.InvalidMethodPointerHandler;
 import com.oracle.svm.core.StaticFieldsSupport;
 import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.SubstrateUtil;
@@ -674,7 +674,7 @@ private void buildVTables() {
          * To avoid segfaults when jumping to address 0, all unused vtable entries are filled with a
          * stub that reports a fatal error.
          */
-        HostedMethod invalidVTableEntryHandler = hMetaAccess.lookupJavaMethod(InvalidVTableEntryHandler.HANDLER_METHOD);
+        HostedMethod invalidVTableEntryHandler = hMetaAccess.lookupJavaMethod(InvalidMethodPointerHandler.INVALID_VTABLE_ENTRY_HANDLER_METHOD);
 
         for (HostedType type : hUniverse.getTypes()) {
             if (type.isArray()) {
@@ -999,6 +999,6 @@ final class InvalidVTableEntryFeature implements Feature {
     @Override
     public void beforeAnalysis(BeforeAnalysisAccess a) {
         BeforeAnalysisAccessImpl access = (BeforeAnalysisAccessImpl) a;
-        access.registerAsCompiled(InvalidVTableEntryHandler.HANDLER_METHOD);
+        access.registerAsCompiled(InvalidMethodPointerHandler.INVALID_VTABLE_ENTRY_HANDLER_METHOD);
     }
 }

substratevm/src/com.oracle.svm.jni/src/com/oracle/svm/jni/access/JNINativeLinkage.java

@@ -204,8 +204,4 @@ private static StringBuilder mangleName(String name, int beginIndex, int endInde
         }
         return sb;
     }
-
-    public static String mangle(String s) {
-        return mangleName(s, 0, s.length(), new StringBuilder()).toString();
-    }
 }