[GR-35724] HotSpot to Native calls pass exception using ForeignException.

PullRequest: graal/11258

Author: tzezula

compiler/docs/NativeBridgeProcessor.md

@@ -235,17 +235,22 @@ The `Complex` type is unknown to the annotation processor. We need to provide a
 final class ComplexMarshaller implements BinaryMarshaller<Complex> {
 
     @Override
-    public Complex read(BinaryInput input) throws IOException {
+    public Complex read(BinaryInput input) {
         int re = input.readInt();
         int img = input.readInt();
         return new Complex(re, img);
     }
 
     @Override
-    public void write(BinaryOutput output, Complex complex) throws IOException {
+    public void write(BinaryOutput output, Complex complex) {
         output.writeInt(complex.re);
         output.writeInt(complex.img);
     }
+
+    @Override
+    public int inferSize(Complex complex) {
+        return Integer.BYTES * 2;
+    }
 }
 ```
 

compiler/src/org.graalvm.jniutils/src/org/graalvm/jniutils/JNIExceptionWrapper.java

@@ -220,7 +220,7 @@ public static JThrowable createHSException(JNIEnv env, Throwable original) {
                 StackTraceElement[] mergedStack = mergeStackTraces(hsStack, nativeStack,
                                 hasSameExceptionType ? 0 : 1, // exception with same exception
                                 // type has no factory method
-                                0, false);
+                                getIndexOfPropagateJNIExceptionFrame(nativeStack), false);
                 hsThrowable = updateStackTrace(env, hsThrowable, mergedStack);
             }
         }
@@ -345,6 +345,25 @@ public void handleException(ExceptionHandlerContext context) {
         void handleException(ExceptionHandlerContext context);
     }
 
+    public static StackTraceElement[] mergeStackTraces(
+                    StackTraceElement[] hotSpotStackTrace,
+                    StackTraceElement[] nativeStackTrace,
+                    boolean originatedInHotSpot) {
+        if (originatedInHotSpot) {
+            if (containsHotSpotCall(hotSpotStackTrace)) {
+                // Already merged
+                return hotSpotStackTrace;
+            }
+        } else {
+            if (containsHotSpotCall(nativeStackTrace)) {
+                // Already merged
+                return nativeStackTrace;
+            }
+        }
+        return mergeStackTraces(hotSpotStackTrace, nativeStackTrace, originatedInHotSpot ? 0 : getIndexOfTransitionFromHotSpotFrame(hotSpotStackTrace),
+                        getIndexOfPropagateJNIExceptionFrame(nativeStackTrace), originatedInHotSpot);
+    }
+
     /**
      * Merges {@code hotSpotStackTrace} with {@code nativeStackTrace}.
      *
@@ -390,7 +409,7 @@ private static StackTraceElement[] mergeStackTraces(
      * Gets the stack trace from a JNI exception.
      *
      * @param env the {@link JNIEnv}
-     * @param throwableHandle the JNI exception to get the stack trace from
+     * @param throwableHandle the JNI exception to get the stack trace from.
      * @return the stack trace
      */
     private static StackTraceElement[] getJNIExceptionStackTrace(JNIEnv env, JObject throwableHandle) {
@@ -480,33 +499,45 @@ private static int getIndexOfPropagateJNIExceptionFrame(StackTraceElement[] stac
         return 0;
     }
 
+    /**
+     * Gets the index of the first frame denoting the native method call.
+     *
+     * @returns {@code 0} if no caller found
+     */
+    private static int getIndexOfTransitionFromHotSpotFrame(StackTraceElement[] stackTrace) {
+        for (int i = 0; i < stackTrace.length; i++) {
+            if (stackTrace[i].isNativeMethod()) {
+                return i;
+            }
+        }
+        return 0;
+    }
+
     private static boolean isStackFrame(StackTraceElement stackTraceElement, Class<?> clazz, String methodName) {
         return clazz.getName().equals(stackTraceElement.getClassName()) && methodName.equals(stackTraceElement.getMethodName());
     }
 
-    private static <T extends JObject> T createExceptionOfSameType(JNIEnv env, Throwable original) {
-        WordFactory.nullPointer();
-        String className = original.getClass().getTypeName();
+    private static JThrowable createExceptionOfSameType(JNIEnv env, Throwable original) {
+        Class<? extends Throwable> originalType = original.getClass();
+        String className = originalType.getTypeName();
         JClass exceptionClass = JNIUtil.findClass(env, WordFactory.nullPointer(), getBinaryName(className), false);
         if (exceptionClass.isNonNull()) {
             JNIMethod constructor = JNIMethod.findMethod(env, exceptionClass, false, false, "<init>", encodeMethodSignature(void.class, String.class));
             if (constructor != null) {
                 JNI.JValue args = StackValue.get(1, JNI.JValue.class);
                 args.addressOf(0).setJObject(createHSString(env, original.getMessage()));
-                T res = HotSpotCalls.getDefault().callNewObject(env, exceptionClass, constructor, args);
-                return res;
+                return HotSpotCalls.getDefault().callNewObject(env, exceptionClass, constructor, args);
             }
             constructor = JNIMethod.findMethod(env, exceptionClass, false, false, "<init>", encodeMethodSignature(void.class));
             if (constructor != null) {
-                T res = HotSpotCalls.getDefault().callNewObject(env, exceptionClass, constructor, WordFactory.nullPointer());
-                return res;
+                return HotSpotCalls.getDefault().callNewObject(env, exceptionClass, constructor, WordFactory.nullPointer());
             }
         }
         return WordFactory.nullPointer();
     }
 
     // JNI calls
-    private static <T extends JObject> T callCreateException(JNIEnv env, JObject p0) {
+    private static JThrowable callCreateException(JNIEnv env, JObject p0) {
         JNI.JValue args = StackValue.get(1, JNI.JValue.class);
         args.addressOf(0).setJObject(p0);
         return HotSpotCalls.getDefault().callStaticJObject(env, getHotSpotEntryPoints(env), CreateException.resolve(env), args);

compiler/src/org.graalvm.nativebridge/src/org/graalvm/nativebridge/ExceptionHandler.java renamed to compiler/src/org.graalvm.nativebridge.processor.test/src/org/graalvm/nativebridge/processor/test/CustomMarshallerService.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 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
@@ -22,19 +22,14 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
-package org.graalvm.nativebridge;
+package org.graalvm.nativebridge.processor.test;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.util.List;
+import java.util.Map;
 
-/**
- * Marks a method as an exception handler. The method is used by the annotation processor to handle
- * exceptions passing over the isolate boundary. The method returns {@code true} if it has handled
- * the given exception or {@code false} to perform the default exception handling.
- */
-@Retention(RetentionPolicy.CLASS)
-@Target(ElementType.METHOD)
-public @interface ExceptionHandler {
+public interface CustomMarshallerService {
+
+    Map<String, String> createMap(List<String> keys, List<String> values);
+
+    Map<String, String> getProperties();
 }