[GR-64246] Limit Truffle installed code name length and avoid metadata reference in InvokeJavaMethodStub.

PullRequest: graal/20568

Author: dougxc

compiler/ci/ci_common/gate.jsonnet

@@ -271,7 +271,7 @@
     "daily-compiler-ctw_economy-labsjdk-latest-darwin-amd64": {},
     "daily-compiler-ctw_economy-labsjdk-latest-darwin-aarch64": {},
 
-    "daily-compiler-bootstrap_lite-labsjdk-latest-darwin-amd64": t("1:00:00"),
+    "daily-compiler-bootstrap_lite-labsjdk-latest-darwin-amd64": {},
 
     "daily-compiler-bootstrap_full-labsjdk-latest-linux-amd64": s.many_cores,
     "daily-compiler-bootstrap_full_zgc-labsjdk-latest-linux-amd64": s.many_cores
@@ -298,17 +298,18 @@
       notify_emails: ["[email protected]"],
     },
 
-    "weekly-compiler-benchmarktest-labsjdk-latestDebug-linux-amd64": t("3:00:00"),
+    "weekly-compiler-benchmarktest-labsjdk-latestDebug-linux-amd64": t("6:00:00"),
+    "weekly-compiler-benchmarktest-labsjdk-latestDebug-darwin-aarch64": t("6:00:00"),
 
     "weekly-compiler-coverage*": {},
 
-    "weekly-compiler-test_serialgc-labsjdk-latest-linux-amd64": t("1:30:00"),
-    "weekly-compiler-test_serialgc-labsjdk-latest-linux-aarch64": t("1:50:00"),
-    "weekly-compiler-test_serialgc-labsjdk-latest-darwin-amd64": t("1:30:00"),
-    "weekly-compiler-test_serialgc-labsjdk-latest-darwin-aarch64": t("1:30:00"),
+    "weekly-compiler-test_serialgc-labsjdk-latest-linux-amd64": {},
+    "weekly-compiler-test_serialgc-labsjdk-latest-linux-aarch64": {},
+    "weekly-compiler-test_serialgc-labsjdk-latest-darwin-amd64": {},
+    "weekly-compiler-test_serialgc-labsjdk-latest-darwin-aarch64": {},
 
-    "weekly-compiler-truffle_xcomp_serialgc-labsjdk-latest-linux-amd64": t("1:30:00"),
-    "weekly-compiler-truffle_xcomp_serialgc-labsjdk-latest-linux-aarch64": t("1:30:00"),
+    "weekly-compiler-truffle_xcomp_serialgc-labsjdk-latest-linux-amd64": {},
+    "weekly-compiler-truffle_xcomp_serialgc-labsjdk-latest-linux-aarch64": {},
   },
 
   # This map defines overrides and field extensions for monthly builds.
@@ -502,9 +503,13 @@
   }],
 
   # Builds run on only on linux-amd64-jdk-latestDebug
-  local linux_amd64_jdk_latestDebug_builds = [self.make_build("LatestDebug", "linux-amd64", task).build
+  local jdk_latestDebug_builds = [self.make_build("LatestDebug", os_arch, task).build
     for task in [
-      "benchmarktest",
+      "benchmarktest"
+    ]
+    for os_arch in [
+      "linux-amd64",
+      "darwin-aarch64"
     ]
   ],
 
@@ -517,7 +522,7 @@
     style_builds +
     jdk_21_version_check_builds +
     linux_amd64_jdk_latest_builds +
-    linux_amd64_jdk_latestDebug_builds,
+    jdk_latestDebug_builds,
 
   local _builds = if
       self.check_manifest(gates,     all_builds, std.thisFile, "gates").result &&

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/common/test/UtilTest.java

@@ -0,0 +1,77 @@
+/*
+ * 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.core.common.test;
+
+import jdk.graal.compiler.core.common.util.Util;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Tests for {@link jdk.graal.compiler.core.common.util.Util}.
+ */
+public class UtilTest {
+
+    @Test
+    public void truncateStringTest1() {
+        for (int max = 1; max < 1024; max++) {
+
+            String[] inputs = {
+                            "X".repeat(max - 1),
+                            "X".repeat(max),
+                            "X".repeat(max + 1),
+            };
+            for (String s : inputs) {
+                if (max <= Util.TRUNCATION_PLACEHOLDER.length()) {
+                    try {
+                        Util.truncateString(s, max);
+                        throw new AssertionError("expected " + IllegalArgumentException.class.getName());
+                    } catch (IllegalArgumentException e) {
+                        // expected
+                    }
+                } else {
+                    String cs = Util.truncateString(s, max);
+                    if (s.length() <= max) {
+                        Assert.assertEquals(s, cs);
+                    } else {
+                        Assert.assertNotEquals(s, cs);
+                        Assert.assertTrue(cs, cs.contains("<truncated"));
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    public void truncateStringTest2() {
+        int max = 40;
+
+        // Tests example from javadoc
+        String s = "123456789_123456789_123456789_123456789_123456789_";
+        String cs = Util.truncateString(s, max);
+        Assert.assertEquals(50, s.length());
+        Assert.assertEquals(32, cs.length());
+        Assert.assertEquals("123<truncated(43, c285d1fd)>789_", cs);
+    }
+}

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/test/HotSpotInvokeJavaMethodTest.java

@@ -24,17 +24,20 @@
  */
 package jdk.graal.compiler.hotspot.test;
 
+import static jdk.graal.compiler.replacements.SnippetTemplate.AbstractTemplates.findMethod;
+
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Test;
+
 import jdk.graal.compiler.hotspot.meta.HotSpotForeignCallDescriptor;
 import jdk.graal.compiler.hotspot.meta.HotSpotHostForeignCallsProvider.TestForeignCalls;
+import jdk.graal.compiler.nodes.ConstantNode;
 import jdk.graal.compiler.nodes.ValueNode;
 import jdk.graal.compiler.nodes.extended.ForeignCallNode;
 import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext;
 import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugin;
 import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugins;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.Test;
-
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
@@ -45,12 +48,14 @@ protected void registerInvocationPlugins(InvocationPlugins invocationPlugins) {
         for (JavaKind kind : TestForeignCalls.KINDS) {
             HotSpotForeignCallDescriptor desc = TestForeignCalls.createStubCallDescriptor(kind);
             String name = desc.getName();
-            Class<?> argType = desc.getSignature().getArgumentTypes()[0];
+            Class<?> argType = desc.getSignature().getArgumentTypes()[1];
             invocationPlugins.register(HotSpotInvokeJavaMethodTest.class, new InvocationPlugin(name, argType) {
                 @Override
                 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode arg) {
-                    ForeignCallNode node = new ForeignCallNode(desc, arg);
-                    b.addPush(kind, node);
+                    ResolvedJavaMethod javaMethod = findMethod(b.getMetaAccess(), HotSpotInvokeJavaMethodTest.class, desc.getName());
+                    ValueNode method = ConstantNode.forConstant(b.getStampProvider().createMethodStamp(), javaMethod.getEncoding(), b.getMetaAccess(), b.getGraph());
+                    ForeignCallNode node = new ForeignCallNode(desc, method, arg);
+                    b.add(node);
                     return true;
                 }
             });
@@ -63,132 +68,137 @@ public void before() {
         Assume.assumeTrue("Invoke stub helper is missing", runtime().getVMConfig().invokeJavaMethodAddress != 0);
     }
 
+    static Object passedArg;
+
     static boolean[] booleanValues = new boolean[]{Boolean.TRUE, Boolean.FALSE};
 
-    static boolean booleanReturnsBoolean(boolean arg) {
-        return arg;
+    static void passingBoolean(boolean arg) {
+        passedArg = arg;
     }
 
-    public static boolean booleanReturnsBooleanSnippet(boolean arg) {
-        return booleanReturnsBoolean(arg);
+    public static boolean passingBooleanSnippet(boolean arg) {
+        passedArg = null;
+        passingBoolean(arg);
+        return (boolean) passedArg;
     }
 
     @Test
-    public void testBooleanReturnsBoolean() {
+    public void testPassingBoolean() {
         for (boolean value : booleanValues) {
-            test("booleanReturnsBooleanSnippet", value);
+            test("passingBooleanSnippet", value);
         }
     }
 
     static byte[] byteValues = new byte[]{Byte.MAX_VALUE, -1, 0, 1, Byte.MIN_VALUE};
 
-    static byte byteReturnsByte(byte arg) {
-        return arg;
+    static void passingByte(byte arg) {
+        passedArg = arg;
     }
 
-    public static byte byteReturnsByteSnippet(byte arg) {
-        return byteReturnsByte(arg);
+    public static void passingByteSnippet(byte arg) {
+        passedArg = null;
+        passingByte(arg);
     }
 
     @Test
-    public void testByteReturnsByte() {
+    public void testPassingByte() {
         for (byte value : byteValues) {
-            test("byteReturnsByteSnippet", value);
+            test("passingByteSnippet", value);
         }
     }
 
     static short[] shortValues = new short[]{Short.MAX_VALUE, -1, 0, 1, Short.MIN_VALUE};
 
-    static short shortReturnsShort(short arg) {
-        return arg;
+    static void passingShort(short arg) {
+        passedArg = arg;
     }
 
-    public static short shortReturnsShortSnippet(short arg) {
-        return shortReturnsShort(arg);
+    public static short passingShortSnippet(short arg) {
+        passedArg = null;
+        passingShort(arg);
+        return (short) passedArg;
     }
 
     @Test
-    public void testShortReturnsShort() {
+    public void testPassingShort() {
         for (short value : shortValues) {
-            test("shortReturnsShortSnippet", value);
+            test("passingShortSnippet", value);
         }
     }
 
     static char[] charValues = new char[]{Character.MAX_VALUE, 1, Character.MIN_VALUE};
 
-    static char charReturnsChar(char arg) {
-        return arg;
+    static void passingChar(char arg) {
+        passedArg = arg;
     }
 
-    public static char charReturnsCharSnippet(char arg) {
-        return charReturnsChar(arg);
+    public static char passingCharSnippet(char arg) {
+        passedArg = null;
+        passingChar(arg);
+        return (char) passedArg;
     }
 
     @Test
-    public void testCharReturnsChar() {
+    public void testPassingChar() {
         for (char value : charValues) {
-            test("charReturnsCharSnippet", value);
+            test("passingCharSnippet", value);
         }
     }
 
     static int[] intValues = new int[]{Integer.MAX_VALUE, -1, 0, 1, Integer.MIN_VALUE};
 
-    static int intReturnsInt(int arg) {
-        return arg;
+    static void passingInt(int arg) {
+        passedArg = arg;
     }
 
-    public static int intReturnsIntSnippet(int arg) {
-        return intReturnsInt(arg);
+    public static int passingIntSnippet(int arg) {
+        passedArg = null;
+        passingInt(arg);
+        return (int) passedArg;
     }
 
     @Test
-    public void testIntReturnsInt() {
+    public void testPassingInt() {
         for (int value : intValues) {
-            test("intReturnsIntSnippet", value);
+            test("passingIntSnippet", value);
         }
     }
 
     static long[] longValues = new long[]{Long.MAX_VALUE, -1, 0, 1, Long.MIN_VALUE};
 
-    static long longReturnsLong(long arg) {
-        return arg;
+    static void passingLong(long arg) {
+        passedArg = arg;
     }
 
-    public static long longReturnsLongSnippet(long arg) {
-        return longReturnsLong(arg);
+    public static long passingLongSnippet(long arg) {
+        passedArg = null;
+        passingLong(arg);
+        return (long) passedArg;
     }
 
     @Test
-    public void testLongReturnsLong() {
+    public void testPassingLong() {
         for (long value : longValues) {
-            test("longReturnsLongSnippet", value);
+            test("passingLongSnippet", value);
         }
     }
 
-    static float[] floatValues = new float[]{Float.MAX_VALUE, -1, 0, 1, Float.MIN_VALUE};
-
-    static float floatReturnsFloat(float arg) {
-        return arg;
-    }
-
-    public static float floatReturnsFloatSnippet(float arg) {
-        return floatReturnsFloat(arg);
-    }
-
     static Object[] objectValues = new Object[]{null, "String", Integer.valueOf(-1)};
 
-    static Object objectReturnsObject(Object arg) {
-        return arg;
+    static void passingObject(Object arg) {
+        passedArg = arg;
     }
 
-    public static Object objectReturnsObjectSnippet(Object arg) {
-        return objectReturnsObject(arg);
+    public static Object passingObjectSnippet(Object arg) {
+        passedArg = null;
+        passingObject(arg);
+        return passedArg;
     }
 
     @Test
-    public void testObjectReturnsObject() {
+    public void testPassingObject() {
         for (Object value : objectValues) {
-            test("objectReturnsObjectSnippet", value);
+            test("passingObjectSnippet", value);
         }
     }
 }