V2

Author: TobiHartmann

src/hotspot/share/opto/callGenerator.cpp

@@ -725,6 +725,8 @@ void CallGenerator::do_late_inline_helper() {
     ciType* return_type = inline_method->return_type();
     if (!call->tf()->returns_inline_type_as_fields() &&
         return_type->is_inlinetype() && return_type->as_inline_klass()->can_be_returned_as_fields()) {
+      assert(is_mh_late_inline(), "Unexpected return type");
+
       // Allocate a buffer for the inline type returned as fields because the caller expects an oop return.
       // Do this before the method handle call in case the buffer allocation triggers deoptimization and
       // we need to "re-execute" the call in the interpreter (to make sure the call is only executed once).

test/hotspot/jtreg/compiler/valhalla/inlinetypes/TestCallingConvention.java

@@ -167,6 +167,9 @@ public class TestCallingConvention {
 
             mt = MethodType.methodType(MyValue2.class, boolean.class);
             test56_mh = lookup.findVirtual(clazz, "test56_callee", mt);
+
+            mt = MethodType.methodType(MyValue2.class, MyValue2.class);
+            test59_mh = lookup.findStatic(clazz, "test59_callee", mt);
         } catch (NoSuchMethodException | IllegalAccessException e) {
             e.printStackTrace();
             throw new RuntimeException("Method handle lookup failed");
@@ -1476,4 +1479,28 @@ public MyValue58C test58(MyValue58A arg1, MyValue58B arg2, MyValue58C arg3) {
     public void test58_verifier() {
         Asserts.assertEQ(test58(new MyValue58A(), new MyValue58B(), new MyValue58C()), new MyValue58C());
     }
+
+    static MethodHandle test59_mh;
+
+    public static MyValue2 test59_callee(MyValue2 arg) {
+        int div = 0;
+        int res = 42 / div; // Always throws an ArithmeticException
+        return arg;
+    }
+
+    // Method handle with a scalarized return that will always throw an exception
+    @Test
+    public static MyValue2 test59(MyValue2 val) throws Throwable {
+        return (MyValue2)test59_mh.invokeExact(val);
+    }
+
+    @Run(test = "test59")
+    @Warmup(10000) // Trigger compilation of LambdaForm method
+    public void test59_verifier() throws Throwable {
+        try {
+            test59(null);
+        } catch (ArithmeticException e) {
+            // Expected
+        }
+    }
 }

test/hotspot/jtreg/compiler/valhalla/inlinetypes/TestValueConstruction.java

@@ -1726,23 +1726,6 @@ public static MyValue1 testOsrLarvalLocal(int x) throws Throwable {
         return (MyValue1) OSR_LARVAL_LOCAL.invokeExact(dummy, x);
     }
 
-    // Method handle with a scalarized return that will always throw an exception
-    private static final MethodHandle TEST_THROWING_MH = InstructionHelper.buildMethodHandle(MethodHandles.lookup(),
-            "throwingMH",
-            MethodType.methodType(MyValue1.class, MyValue1.class),
-            CODE -> {
-                CODE.
-                        iconst_0().
-                        iconst_0().
-                        idiv(). // Division by zero
-                        aload(0).
-                        areturn();
-            });
-
-    public static MyValue1 testThrowingMethodHandle() throws Throwable {
-        return (MyValue1) TEST_THROWING_MH.invokeExact((MyValue1)null);
-    }
-
     public static void main(String[] args) throws Throwable {
         Random rand = Utils.getRandomInstance();
 
@@ -1872,11 +1855,6 @@ private static void run(int x, boolean doCheck) throws Throwable {
         check(testBackAndForthAbstract2(x), new MyValue16(x), doCheck);
         check(testMultipleOccurrencesInJVMS(x), new MyValue1(x), doCheck);
         check(testOsrLarvalLocal(x), new MyValue1(x), doCheck);
-        try {
-            testThrowingMethodHandle();
-        } catch (ArithmeticException e) {
-            // Expected
-        }
     }
 
     private static void check(Object testResult, Object expectedResult, boolean check) {