Automatic merge of master into galahad

OracleLabsAutomation · OracleLabsAutomation · commit 2d6337015d8b · 2025-08-16T02:09:33.000Z
diff --git a/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/HSTruffleCompilable.java b/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/HSTruffleCompilable.java
@@ -73,6 +73,7 @@ final class HSTruffleCompilable extends HSObject implements TruffleCompilable {
     private static volatile JNIMethod prepareForCompilationNewMethod;
     private static volatile JNIMethod getSuccessfulCompilationCountMethod;
     private static volatile JNIMethod onCompilationSuccessMethod;
+    private static volatile JNIMethod canBeInlinedMethod;
 
     private final TruffleFromLibGraalCalls calls;
     /**
@@ -175,6 +176,31 @@ private int callGetSuccessfulCompilationCountMethod(JNIMethod method, JNIEnv env
         return calls.getJNICalls().callStaticInt(env, calls.getPeer(), method, args);
     }
 
+    @Override
+    public boolean canBeInlined() {
+        JNIEnv env = JNIMethodScope.env();
+        JNIMethod method = findCanBeInlinedMethod(env);
+        if (method != null) {
+            return callCanBeInlinedMethod(method, env, getHandle());
+        }
+        return true;
+    }
+
+    private JNIMethod findCanBeInlinedMethod(JNIEnv env) {
+        JNIMethod res = canBeInlinedMethod;
+        if (res == null) {
+            res = calls.findJNIMethod(env, "canBeInlined", boolean.class, Object.class);
+            canBeInlinedMethod = res;
+        }
+        return res.getJMethodID().isNonNull() ? res : null;
+    }
+
+    private boolean callCanBeInlinedMethod(JNIMethod method, JNIEnv env, JObject p0) {
+        JNI.JValue args = StackValue.get(1, JNI.JValue.class);
+        args.addressOf(0).setJObject(p0);
+        return calls.getJNICalls().callStaticBoolean(env, calls.getPeer(), method, args);
+    }
+
     @TruffleFromLibGraal(IsTrivial)
     @Override
     public boolean isTrivial() {
diff --git a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/GR42688Test.java b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/GR42688Test.java
@@ -173,7 +173,7 @@ public void testDeoptLoopDetected() {
         CountDownLatch calleeCompilationStartLatch = new CountDownLatch(1);
         CountDownLatch calleeCompilationFinishedLatch = new CountDownLatch(1);
         AtomicBoolean intCallerCompilationFailed = new AtomicBoolean();
-        optimizedTruffleRuntime.addListener(new OptimizedTruffleRuntimeListener() {
+        OptimizedTruffleRuntimeListener listener = new OptimizedTruffleRuntimeListener() {
             @Override
             public void onCompilationSuccess(OptimizedCallTarget target, AbstractCompilationTask task, TruffleCompilerListener.GraphInfo graph, TruffleCompilerListener.CompilationResultInfo result) {
                 if (target == calleeRef.get()) {
@@ -198,7 +198,8 @@ public void onCompilationFailed(OptimizedCallTarget target, String reason, boole
                     intCallerCompilationFailed.set(true);
                 }
             }
-        });
+        };
+        optimizedTruffleRuntime.addListener(listener);
         try (Context context = Context.newBuilder().allowExperimentalOptions(true).option("engine.CompileImmediately", "false").option("engine.BackgroundCompilation", "true").option(
                         "engine.DynamicCompilationThresholds", "false").option("engine.MultiTier", "false").option("engine.Splitting", "false").option("engine.SingleTierCompilationThreshold",
                                         "10").option("engine.CompilationFailureAction", "Silent").build()) {
@@ -242,6 +243,8 @@ public void onCompilationFailed(OptimizedCallTarget target, String reason, boole
                 intCaller.call(42, Integer.class);
             }
             Assert.assertTrue(intCallerCompilationFailed.get());
+        } finally {
+            optimizedTruffleRuntime.removeListener(listener);
         }
     }
 }
diff --git a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/NeverInlineFailedTest.java b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/NeverInlineFailedTest.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2025, 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 jdk.graal.compiler.truffle.test;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import org.graalvm.polyglot.Context;
+import org.junit.Assert;
+import org.junit.Assume;
+import org.junit.Test;
+
+import com.oracle.truffle.api.CallTarget;
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.DirectCallNode;
+import com.oracle.truffle.api.nodes.ExplodeLoop;
+import com.oracle.truffle.api.nodes.RootNode;
+import com.oracle.truffle.api.test.SubprocessTestUtils;
+import com.oracle.truffle.api.test.common.NullObject;
+import com.oracle.truffle.compiler.TruffleCompilerListener;
+import com.oracle.truffle.runtime.AbstractCompilationTask;
+import com.oracle.truffle.runtime.OptimizedCallTarget;
+import com.oracle.truffle.runtime.OptimizedTruffleRuntime;
+import com.oracle.truffle.runtime.OptimizedTruffleRuntimeListener;
+
+import jdk.graal.compiler.util.CollectionsUtil;
+
+public class NeverInlineFailedTest {
+
+    static class Caller extends RootNode {
+        @Child private DirectCallNode callNode;
+
+        Caller(CallTarget target) {
+            super(null);
+            this.callNode = Truffle.getRuntime().createDirectCallNode(target);
+        }
+
+        @Override
+        public Object execute(VirtualFrame frame) {
+            return callNode.call(frame.getArguments());
+        }
+
+        @Override
+        public String getName() {
+            return "caller";
+        }
+
+        @Override
+        public String toString() {
+            return getName();
+        }
+    }
+
+    static class Callee extends RootNode {
+
+        Callee() {
+            super(null);
+        }
+
+        @Override
+        public Object execute(VirtualFrame frame) {
+            return NullObject.SINGLETON;
+        }
+
+        @Override
+        protected boolean prepareForCompilation(boolean rootCompilation, int compilationTier, boolean lastTier) {
+            throw new RuntimeException("Intentionally fail compilation");
+        }
+
+        @Override
+        public String getName() {
+            return "callee";
+        }
+
+        @Override
+        public String toString() {
+            return getName();
+        }
+    }
+
+    static class Callee2 extends RootNode {
+
+        private static class MyClass {
+            int[] array = new int[100];
+
+            MyClass() {
+                for (int i = 0; i < array.length; i++) {
+                    array[i] = value();
+                }
+            }
+
+            @CompilerDirectives.TruffleBoundary
+            private static int value() {
+                return 1;
+            }
+
+            public int sum() {
+                int sum = 0;
+                for (int i : array) {
+                    sum += i;
+                }
+                return sum;
+            }
+        }
+
+        @SuppressWarnings("unused") private int global;
+        @SuppressWarnings("unused") private int globalI;
+
+        Callee2() {
+            super(null);
+        }
+
+        @Override
+        public Object execute(VirtualFrame frame) {
+            recurse();
+            foo();
+            return null;
+        }
+
+        @ExplodeLoop
+        private void recurse() {
+            for (int i = 0; i < 1000; i++) {
+                getF().apply(0);
+            }
+        }
+
+        private Function<Integer, Integer> getF() {
+            return new Function<>() {
+                @Override
+                public Integer apply(Integer integer) {
+                    return integer < 500 ? getF().apply(integer + 1) : 0;
+                }
+            };
+        }
+
+        protected void foo() {
+            for (; globalI < 1000; globalI++) {
+                global += new MyClass().sum();
+            }
+        }
+    };
+
+    @Test
+    public void testNeverInlineFailed() throws IOException, InterruptedException {
+        testNeverInlineFailedImpl(Callee::new, CollectionsUtil.mapOfEntries(), "java.lang.RuntimeException: Intentionally fail compilation");
+    }
+
+    @Test
+    public void testNeverInlineFailed2() throws IOException, InterruptedException {
+        testNeverInlineFailedImpl(Callee2::new, CollectionsUtil.mapOf("compiler.CompilationTimeout", "1"), "jdk.graal.compiler.core.common.PermanentBailoutException: Compilation exceeded");
+    }
+
+    private static void testNeverInlineFailedImpl(Supplier<RootNode> calleeSupplier, Map<String, String> extraOptions, String reasonContains) throws IOException, InterruptedException {
+        Assume.assumeTrue(Truffle.getRuntime() instanceof OptimizedTruffleRuntime);
+        Runnable test = () -> {
+            OptimizedTruffleRuntime optimizedTruffleRuntime = (OptimizedTruffleRuntime) Truffle.getRuntime();
+            AtomicReference<CallTarget> calleeRef = new AtomicReference<>();
+            AtomicReference<CallTarget> callerRef = new AtomicReference<>();
+            AtomicReference<String> calleeCompilationFailure = new AtomicReference<>();
+            AtomicInteger callerCompilationInlinedCalls = new AtomicInteger(-1);
+            OptimizedTruffleRuntimeListener listener = new OptimizedTruffleRuntimeListener() {
+                @Override
+                public void onCompilationFailed(OptimizedCallTarget target, String reason, boolean bailout, boolean permanentBailout, int tier, Supplier<String> lazyStackTrace) {
+                    if (target == calleeRef.get()) {
+                        calleeCompilationFailure.set(reason);
+                    }
+                }
+
+                @Override
+                public void onCompilationSuccess(OptimizedCallTarget target, AbstractCompilationTask task, TruffleCompilerListener.GraphInfo graph,
+                                TruffleCompilerListener.CompilationResultInfo result) {
+                    if (target == callerRef.get()) {
+                        callerCompilationInlinedCalls.set(task.countInlinedCalls());
+                    }
+                }
+            };
+            optimizedTruffleRuntime.addListener(listener);
+            try (Context context = Context.newBuilder().allowExperimentalOptions(true).option("engine.CompileImmediately", "true").option("engine.BackgroundCompilation", "false").option(
+                            "engine.CompilationFailureAction", "Silent").options(extraOptions).build()) {
+                context.enter();
+                CallTarget calleeTarget = calleeSupplier.get().getCallTarget();
+                calleeRef.set(calleeTarget);
+                calleeTarget.call();
+                Assert.assertNotNull(calleeCompilationFailure.get());
+                Assert.assertTrue("Unexpected compilation failure reason: " + calleeCompilationFailure.get(),
+                                calleeCompilationFailure.get().contains(reasonContains));
+                CallTarget callerTarget = new Caller(calleeTarget).getCallTarget();
+                callerRef.set(callerTarget);
+                callerTarget.call();
+                Assert.assertEquals(0, callerCompilationInlinedCalls.get());
+                Assert.assertTrue(((OptimizedCallTarget) callerTarget).isValid());
+            } finally {
+                optimizedTruffleRuntime.removeListener(listener);
+            }
+        };
+        SubprocessTestUtils.newBuilder(NeverInlineFailedTest.class, test).postfixVmOption("-Djdk.graal.CompilationFailureAction=Silent").run();
+    }
+}
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/inlining/CallNode.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/inlining/CallNode.java
@@ -285,6 +285,10 @@ public void expand() {
              */
             return;
         }
+        if (getDirectCallTarget() != null && !getDirectCallTarget().canBeInlined()) {
+            state = State.BailedOut;
+            return;
+        }
         assert state == State.Cutoff : "Cannot expand a non-cutoff node. Node is " + state;
         assert getParent() != null;
         state = State.Expanded;
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/inlining/InliningPolicy.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/inlining/InliningPolicy.java
@@ -29,6 +29,7 @@
 import java.util.Map;
 
 import org.graalvm.collections.Pair;
+
 import jdk.graal.compiler.truffle.TruffleCompilerOptions;
 
 @SuppressWarnings("unused")
diff --git a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleFeature.java b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleFeature.java
@@ -104,6 +104,7 @@
 import org.graalvm.nativeimage.AnnotationAccess;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.hosted.Feature;
+import org.graalvm.nativeimage.hosted.FieldValueTransformer;
 
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
@@ -1076,9 +1077,21 @@ final class Target_com_oracle_truffle_runtime_OptimizedCallTarget {
      */
     @Alias @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset) //
     boolean compilationFailed;
+    /*
+     * Re-enable the target for inlining when it was disabled during image generation.
+     */
+    @Alias @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Custom, declClass = TransformToTrue.class) //
+    boolean canBeInlined = true;
     /*
      * The initialized time stamp is not useful when collected during image generation.
      */
     @Alias @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset) //
     long initializedTimestamp;
+
+    private static final class TransformToTrue implements FieldValueTransformer {
+        @Override
+        public Object transform(Object receiver, Object originalValue) {
+            return true;
+        }
+    }
 }
diff --git a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/isolated/IsolatedCompilableTruffleAST.java b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/isolated/IsolatedCompilableTruffleAST.java
@@ -171,6 +171,11 @@ public int getSuccessfulCompilationCount() {
         return getSuccessfulCompilationCount0(IsolatedCompileContext.get().getClient(), handle);
     }
 
+    @Override
+    public boolean canBeInlined() {
+        return canBeInlined0(IsolatedCompileContext.get().getClient(), handle);
+    }
+
     @CEntryPoint(exceptionHandler = IsolatedCompileClient.WordExceptionHandler.class, include = CEntryPoint.NotIncludedAutomatically.class, publishAs = CEntryPoint.Publish.NotPublished)
     @CEntryPointOptions(callerEpilogue = IsolatedCompileClient.ExceptionRethrowCallerEpilogue.class)
     private static ClientHandle<SpeculationLog> getCompilationSpeculationLog0(@SuppressWarnings("unused") ClientIsolateThread client, ClientHandle<SubstrateCompilableTruffleAST> compilableHandle) {
@@ -306,6 +311,13 @@ private static int getSuccessfulCompilationCount0(@SuppressWarnings("unused") Cl
         return compilable.getSuccessfulCompilationCount();
     }
 
+    @CEntryPoint(exceptionHandler = IsolatedCompileClient.BooleanExceptionHandler.class, include = CEntryPoint.NotIncludedAutomatically.class, publishAs = CEntryPoint.Publish.NotPublished)
+    @CEntryPointOptions(callerEpilogue = IsolatedCompileClient.ExceptionRethrowCallerEpilogue.class)
+    private static boolean canBeInlined0(@SuppressWarnings("unused") ClientIsolateThread client, ClientHandle<SubstrateCompilableTruffleAST> handle) {
+        SubstrateCompilableTruffleAST compilable = IsolatedCompileClient.get().unhand(handle);
+        return compilable.canBeInlined();
+    }
+
     private static Map<String, String> readCompilerOptions(Map<String, String> map, BinaryInput in) {
         int size = in.readInt();
         for (int i = 0; i < size; i++) {
diff --git a/truffle/src/com.oracle.truffle.compiler/src/com/oracle/truffle/compiler/TruffleCompilable.java b/truffle/src/com.oracle.truffle.compiler/src/com/oracle/truffle/compiler/TruffleCompilable.java
@@ -221,4 +221,16 @@ static String serializeException(Throwable e) {
     default int getSuccessfulCompilationCount() {
         return 0;
     }
+
+    /**
+     * Returns <code>true</code> if this compilable can be inlined. Please note that this does not
+     * mean it will always be inlined, as inlining is a complex process that takes many factors into
+     * account. If this method returns <code>false</code>, it will never be inlined. This typically
+     * means that compilation with this compilable as the root has failed.
+     * 
+     * 
+     */
+    default boolean canBeInlined() {
+        return true;
+    }
 }
diff --git a/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedCallTarget.java b/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedCallTarget.java
diff --git a/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/hotspot/libgraal/TruffleFromLibGraalEntryPoints.java b/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/hotspot/libgraal/TruffleFromLibGraalEntryPoints.java

Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ public void testDeoptLoopDetected() {`
`173`	`173`	`CountDownLatch calleeCompilationStartLatch = new CountDownLatch(1);`
`174`	`174`	`CountDownLatch calleeCompilationFinishedLatch = new CountDownLatch(1);`
`175`	`175`	`AtomicBoolean intCallerCompilationFailed = new AtomicBoolean();`
`176`		`- optimizedTruffleRuntime.addListener(new OptimizedTruffleRuntimeListener() {`
	`176`	`+ OptimizedTruffleRuntimeListener listener = new OptimizedTruffleRuntimeListener() {`
`177`	`177`	`@Override`
`178`	`178`	`public void onCompilationSuccess(OptimizedCallTarget target, AbstractCompilationTask task, TruffleCompilerListener.GraphInfo graph, TruffleCompilerListener.CompilationResultInfo result) {`
`179`	`179`	`if (target == calleeRef.get()) {`
`@@ -198,7 +198,8 @@ public void onCompilationFailed(OptimizedCallTarget target, String reason, boole`
`198`	`198`	`intCallerCompilationFailed.set(true);`
`199`	`199`	`}`
`200`	`200`	`}`
`201`		`- });`
	`201`	`+ };`
	`202`	`+ optimizedTruffleRuntime.addListener(listener);`
`202`	`203`	`try (Context context = Context.newBuilder().allowExperimentalOptions(true).option("engine.CompileImmediately", "false").option("engine.BackgroundCompilation", "true").option(`
`203`	`204`	`"engine.DynamicCompilationThresholds", "false").option("engine.MultiTier", "false").option("engine.Splitting", "false").option("engine.SingleTierCompilationThreshold",`
`204`	`205`	`"10").option("engine.CompilationFailureAction", "Silent").build()) {`
`@@ -242,6 +243,8 @@ public void onCompilationFailed(OptimizedCallTarget target, String reason, boole`
`242`	`243`	`intCaller.call(42, Integer.class);`
`243`	`244`	`}`
`244`	`245`	`Assert.assertTrue(intCallerCompilationFailed.get());`
	`246`	`+ } finally {`
	`247`	`+ optimizedTruffleRuntime.removeListener(listener);`
`245`	`248`	`}`
`246`	`249`	`}`
`247`	`250`	`}`