Merge branch 'master' into ag/GR-36219-fix-class-redefine-jck-test

Author: javeleon

compiler/src/org.graalvm.compiler.api.directives.test/src/org/graalvm/compiler/api/directives/test/DeoptimizeDirectiveTest.java

@@ -32,13 +32,19 @@
 
 import org.graalvm.compiler.api.directives.GraalDirectives;
 import org.graalvm.compiler.core.test.GraalCompilerTest;
+import org.graalvm.compiler.phases.OptimisticOptimizations;
 
 public class DeoptimizeDirectiveTest extends GraalCompilerTest {
 
     public static boolean inCompiledCode() {
         return GraalDirectives.inCompiledCode();
     }
 
+    @Override
+    protected OptimisticOptimizations getOptimisticOptimizations() {
+        return OptimisticOptimizations.ALL;
+    }
+
     @Test
     public void testInCompiledCode() {
         ResolvedJavaMethod method = getResolvedJavaMethod("inCompiledCode");

compiler/src/org.graalvm.compiler.asm.aarch64/src/org/graalvm/compiler/asm/aarch64/AArch64ASIMDAssembler.java

@@ -2199,6 +2199,7 @@ public void mlsVVV(ASIMDSize size, ElementSize eSize, Register dst, Register src
      * @param imm long value to move. If size is 128, then this value is copied twice
      */
     public void moviVI(ASIMDSize size, Register dst, long imm) {
+        assert dst.getRegisterCategory().equals(SIMD);
         modifiedImmEncoding(ImmediateOp.MOVI, size, dst, imm);
     }
 

compiler/src/org.graalvm.compiler.asm.aarch64/src/org/graalvm/compiler/asm/aarch64/AArch64MacroAssembler.java

@@ -1573,8 +1573,8 @@ public void fmov(int size, Register dst, Register src) {
     public void fmov(int size, Register dst, double imm) {
         assert size == 32 || size == 64;
         if (imm == 0.0) {
-            assert Double.doubleToRawLongBits(imm) == 0L : "-0.0 is no valid immediate.";
-            fmovCpu2Fpu(size, dst, zr);
+            assert Double.doubleToRawLongBits(imm) == 0L : "-0.0 is not a valid immediate.";
+            neon.moviVI(ASIMDSize.HalfReg, dst, 0);
         } else {
             super.fmov(size, dst, imm);
         }

compiler/src/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/GraalCompilerTest.java

@@ -110,6 +110,7 @@
 import org.graalvm.compiler.phases.OptimisticOptimizations;
 import org.graalvm.compiler.phases.Phase;
 import org.graalvm.compiler.phases.PhaseSuite;
+import org.graalvm.compiler.phases.OptimisticOptimizations.Optimization;
 import org.graalvm.compiler.phases.common.CanonicalizerPhase;
 import org.graalvm.compiler.phases.common.inlining.InliningPhase;
 import org.graalvm.compiler.phases.common.inlining.info.InlineInfo;
@@ -592,9 +593,14 @@ protected final Providers getProviders() {
      * all the paths where the value is set so it is the proper place for a test override. Setting
      * it in other places can result in inconsistent values being used in other parts of the
      * compiler.
+     *
+     * This method returns settings such that all optimizations except
+     * {@link Optimization#RemoveNeverExecutedCode} are enabled. The latter is removed to reduce a
+     * major source of indeterminism in tests caused by profiles. Most tests should ignore profiles
+     * as they can differ wildly depending on the set of tests being run.
      */
     protected OptimisticOptimizations getOptimisticOptimizations() {
-        return OptimisticOptimizations.ALL;
+        return OptimisticOptimizations.ALL.remove(Optimization.RemoveNeverExecutedCode);
     }
 
     protected final HighTierContext getDefaultHighTierContext() {

compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/meta/UnimplementedGraalIntrinsics.java

@@ -169,12 +169,14 @@ public UnimplementedGraalIntrinsics(GraalHotSpotVMConfig config, Architecture ar
                         "java/lang/Long.numberOfTrailingZeros(J)I");
 
         // Relevant for Java flight recorder
-        add(toBeInvestigated,
+        // [GR-10106] These JFR intrinsics are used for firing socket/file events via Java
+        // instrumentation and are of low priority.
+        add(ignore,
                         "oracle/jrockit/jfr/Timing.counterTime()J",
                         "oracle/jrockit/jfr/VMJFR.classID0(Ljava/lang/Class;)J",
                         "oracle/jrockit/jfr/VMJFR.threadID()I");
 
-        add(toBeInvestigated,
+        add(ignore,
                         "jdk/jfr/internal/JVM.counterTime()J",
                         "jdk/jfr/internal/JVM.getClassId(Ljava/lang/Class;)J",
                         "jdk/jfr/internal/JVM.getEventWriter()Ljava/lang/Object;");

compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/IfNode.java

@@ -958,6 +958,21 @@ private boolean removeOrMaterializeIf(SimplifierTool tool) {
                         removeThroughFalseBranch(tool, merge);
                         return true;
                     }
+                    /*-
+                     * Remove this pattern:
+                     * if (a == null)
+                     *     return null
+                     * else
+                     *     return a
+                     */
+                    if (condition instanceof IsNullNode && trueValue.isJavaConstant() && trueValue.asJavaConstant().isDefaultForKind() && merge instanceof MergeNode) {
+                        ValueNode value = ((IsNullNode) condition).getValue();
+                        if (falseValue == value && singlePhi.stamp(NodeView.DEFAULT).equals(value.stamp(NodeView.DEFAULT))) {
+                            singlePhi.setValueAt(trueEnd, falseValue);
+                            removeThroughFalseBranch(tool, merge);
+                            return true;
+                        }
+                    }
                 }
             }
         }

compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/ConditionalNode.java

@@ -33,8 +33,6 @@
 import org.graalvm.compiler.core.common.type.Stamp;
 import org.graalvm.compiler.core.common.type.StampFactory;
 import org.graalvm.compiler.graph.NodeClass;
-import org.graalvm.compiler.nodes.spi.Canonicalizable;
-import org.graalvm.compiler.nodes.spi.CanonicalizerTool;
 import org.graalvm.compiler.lir.gen.ArithmeticLIRGeneratorTool.RoundingMode;
 import org.graalvm.compiler.nodeinfo.InputType;
 import org.graalvm.compiler.nodeinfo.NodeInfo;
@@ -45,6 +43,8 @@
 import org.graalvm.compiler.nodes.NodeView;
 import org.graalvm.compiler.nodes.StructuredGraph;
 import org.graalvm.compiler.nodes.ValueNode;
+import org.graalvm.compiler.nodes.spi.Canonicalizable;
+import org.graalvm.compiler.nodes.spi.CanonicalizerTool;
 import org.graalvm.compiler.nodes.spi.LIRLowerable;
 import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
 
@@ -277,6 +277,11 @@ public static ValueNode canonicalizeConditional(LogicNode condition, ValueNode t
         }
         // @formatter:on
 
+        if (condition instanceof IsNullNode && trueValue.isJavaConstant() && trueValue.asJavaConstant().isDefaultForKind() &&
+                        falseValue == ((IsNullNode) condition).getValue()) {
+            return falseValue;
+        }
+
         return null;
     }
 

compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/DeoptimizeOnVolatileReadTest.java

@@ -26,6 +26,7 @@
 
 import org.graalvm.compiler.api.directives.GraalDirectives;
 import org.graalvm.compiler.core.test.GraalCompilerTest;
+import org.graalvm.compiler.phases.OptimisticOptimizations;
 import org.junit.Test;
 
 import jdk.vm.ci.code.InstalledCode;
@@ -43,6 +44,11 @@ static class Dummy {
         volatile boolean f2 = false;
     }
 
+    @Override
+    protected OptimisticOptimizations getOptimisticOptimizations() {
+        return OptimisticOptimizations.ALL;
+    }
+
     public static int test1Snippet(Dummy dummy) {
         if (GraalDirectives.injectBranchProbability(0, GraalDirectives.inCompiledCode() & dummy.f1)) {
             return 1;

compiler/src/org.graalvm.compiler.serviceprovider/src/org/graalvm/compiler/serviceprovider/SpeculationReasonGroup.java

@@ -46,10 +46,15 @@ public final class SpeculationReasonGroup {
     private static final AtomicInteger nextId = new AtomicInteger(1);
 
     /**
-     * Creates speculation group whose context will always match {@code signature}.
+     * Creates a speculation group whose context will always match {@code signature}.
+     *
+     * This constructor is deleted in libgraal to ensure group ids are allocated during build time.
+     * Without this invariant, it would possible for 2 different groups to have the same id if the
+     * groups are allocated in different libgraal isolates (since static variables are
+     * isolate-local).
      */
     public SpeculationReasonGroup(String name, Class<?>... signature) {
-        this.id = nextId.get();
+        this.id = nextId.getAndIncrement();
         this.name = name;
         this.signature = signature;
         for (Class<?> c : signature) {

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

@@ -32,8 +32,6 @@
 import static org.graalvm.jniutils.JNIUtil.GetStaticMethodID;
 import static org.graalvm.jniutils.JNIUtil.IsSameObject;
 import static org.graalvm.jniutils.JNIUtil.NewGlobalRef;
-import static org.graalvm.jniutils.JNIUtil.NewObjectArray;
-import static org.graalvm.jniutils.JNIUtil.SetObjectArrayElement;
 import static org.graalvm.jniutils.JNIUtil.Throw;
 import static org.graalvm.jniutils.JNIUtil.createHSString;
 import static org.graalvm.jniutils.JNIUtil.createString;
@@ -48,17 +46,20 @@
 import org.graalvm.jniutils.JNI.JClass;
 import org.graalvm.jniutils.JNI.JNIEnv;
 import org.graalvm.jniutils.JNI.JObject;
-import org.graalvm.jniutils.JNI.JObjectArray;
 import org.graalvm.jniutils.JNI.JString;
 import org.graalvm.jniutils.JNI.JThrowable;
 import org.graalvm.nativeimage.StackValue;
 import org.graalvm.nativeimage.c.type.CTypeConversion;
 import org.graalvm.word.WordFactory;
 
 import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
+import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.Objects;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
 
 /**
  * Wraps an exception thrown by a JNI call into HotSpot. If the exception propagates up to an native
@@ -73,7 +74,7 @@ public final class JNIExceptionWrapper extends RuntimeException {
     private static final JNIMethodResolver GetClassName = JNIMethodResolver.create("getClassName", String.class, Class.class);
     private static final JNIMethodResolver GetStackTrace = JNIMethodResolver.create("getStackTrace", byte[].class, Throwable.class);
     private static final JNIMethodResolver GetThrowableMessage = JNIMethodResolver.create("getThrowableMessage", String.class, Throwable.class);
-    private static final JNIMethodResolver UpdateStackTrace = JNIMethodResolver.create("updateStackTrace", Throwable.class, Throwable.class, String[].class);
+    private static final JNIMethodResolver UpdateStackTrace = JNIMethodResolver.create("updateStackTrace", Throwable.class, Throwable.class, byte[].class);
 
     private static volatile JNI.JClass entryPointsClass;
 
@@ -94,7 +95,7 @@ private JNIExceptionWrapper(JNIEnv env, JThrowable throwableHandle) {
     private void throwInHotSpot(JNIEnv env) {
         JThrowable toThrow;
         if (throwableRequiresStackTraceUpdate) {
-            toThrow = updateStackTrace(env, throwableHandle, encode(getStackTrace()));
+            toThrow = updateStackTrace(env, throwableHandle, getStackTrace());
         } else {
             toThrow = throwableHandle;
         }
@@ -201,7 +202,7 @@ public static JThrowable createHSException(JNIEnv env, Throwable original) {
             JNIExceptionWrapper jniExceptionWrapper = (JNIExceptionWrapper) original;
             hsThrowable = jniExceptionWrapper.throwableHandle;
             if (jniExceptionWrapper.throwableRequiresStackTraceUpdate) {
-                hsThrowable = updateStackTrace(env, hsThrowable, encode(jniExceptionWrapper.getStackTrace()));
+                hsThrowable = updateStackTrace(env, hsThrowable, jniExceptionWrapper.getStackTrace());
             }
         } else {
             hsThrowable = createExceptionOfSameType(env, original);
@@ -217,11 +218,11 @@ public static JThrowable createHSException(JNIEnv env, Throwable original) {
                 // For exceptions which override fillInStackTrace merging stack traces only adds
                 // useless JNI calls.
                 StackTraceElement[] hsStack = getJNIExceptionStackTrace(env, hsThrowable);
-                String[] merged = encode(mergeStackTraces(hsStack, nativeStack,
+                StackTraceElement[] mergedStack = mergeStackTraces(hsStack, nativeStack,
                                 hasSameExceptionType ? 0 : 1, // exception with same exception
                                 // type has no factory method
-                                0, false));
-                hsThrowable = updateStackTrace(env, hsThrowable, merged);
+                                0, false);
+                hsThrowable = updateStackTrace(env, hsThrowable, mergedStack);
             }
         }
         return hsThrowable;
@@ -386,29 +387,6 @@ private static StackTraceElement[] mergeStackTraces(
         return merged;
     }
 
-    /**
-     * Encodes {@code stackTrace} into a string representation. Each stack trace element has the
-     * form {@code className|methodName|fileName|lineNumber}. A missing {@code fileName} is encoded
-     * as an empty string. A {@code '|'} in {@code className}, {@code methodName} or
-     * {@code fileName} is replaced with a {@code '!'}. Given how rare this is, a complicated
-     * escaping mechanism is not warranted.
-     */
-    private static String[] encode(StackTraceElement[] stackTrace) {
-        String[] res = new String[stackTrace.length];
-        for (int i = 0; i < stackTrace.length; i++) {
-            String className = stackTrace[i].getClassName();
-            String methodName = stackTrace[i].getMethodName();
-            String fileName = stackTrace[i].getFileName();
-            int lineNumber = stackTrace[i].getLineNumber();
-            res[i] = String.format("%s|%s|%s|%d",
-                            className == null ? "" : className.replace('|', '!'),
-                            methodName == null ? "" : methodName.replace('|', '!'),
-                            fileName == null ? "" : fileName.replace('|', '!'),
-                            lineNumber);
-        }
-        return res;
-    }
-
     /**
      * Gets the stack trace from a JNI exception.
      *
@@ -418,7 +396,7 @@ private static String[] encode(StackTraceElement[] stackTrace) {
      */
     private static StackTraceElement[] getJNIExceptionStackTrace(JNIEnv env, JObject throwableHandle) {
         byte[] serializedStackTrace = JNIUtil.createArray(env, (JByteArray) callGetStackTrace(env, throwableHandle));
-        try (DataInputStream in = new DataInputStream(new ByteArrayInputStream(serializedStackTrace))) {
+        try (DataInputStream in = new DataInputStream(new GZIPInputStream(new ByteArrayInputStream(serializedStackTrace)))) {
             int len = in.readInt();
             StackTraceElement[] res = new StackTraceElement[len];
             for (int i = 0; i < len; i++) {
@@ -447,14 +425,22 @@ private static boolean containsHotSpotCall(StackTraceElement[] stackTrace) {
         return false;
     }
 
-    private static JThrowable updateStackTrace(JNIEnv env, JThrowable throwableHandle, String[] encodedStackTrace) {
-        JClass string = findClass(env, getBinaryName(String.class.getName()));
-        JObjectArray stackTraceHandle = NewObjectArray(env, encodedStackTrace.length, string, WordFactory.nullPointer());
-        for (int i = 0; i < encodedStackTrace.length; i++) {
-            JString element = createHSString(env, encodedStackTrace[i]);
-            SetObjectArrayElement(env, stackTraceHandle, i, element);
+    private static JThrowable updateStackTrace(JNIEnv env, JThrowable throwableHandle, StackTraceElement[] mergedStackTrace) {
+        ByteArrayOutputStream bout = new ByteArrayOutputStream();
+        try (DataOutputStream out = new DataOutputStream(new GZIPOutputStream(bout))) {
+            out.writeInt(mergedStackTrace.length);
+            for (int i = 0; i < mergedStackTrace.length; i++) {
+                StackTraceElement stackTraceElement = mergedStackTrace[i];
+                out.writeUTF(stackTraceElement.getClassName());
+                out.writeUTF(stackTraceElement.getMethodName());
+                String fileName = stackTraceElement.getFileName();
+                out.writeUTF(fileName == null ? "" : fileName);
+                out.writeInt(stackTraceElement.getLineNumber());
+            }
+        } catch (IOException ioe) {
+            throw new RuntimeException(ioe);
         }
-        return callUpdateStackTrace(env, throwableHandle, stackTraceHandle);
+        return callUpdateStackTrace(env, throwableHandle, JNIUtil.createHSArray(env, bout.toByteArray()));
     }
 
     private static String getMessage(JNIEnv env, JThrowable throwableHandle) {
@@ -527,7 +513,7 @@ private static <T extends JObject> T callCreateException(JNIEnv env, JObject p0)
         return HotSpotCalls.getDefault().callStaticJObject(env, getHotSpotEntryPoints(env), CreateException.resolve(env), args);
     }
 
-    private static <T extends JObject> T callUpdateStackTrace(JNIEnv env, JObject p0, JObject p1) {
+    private static <T extends JObject> T callUpdateStackTrace(JNIEnv env, JObject p0, JByteArray p1) {
         JNI.JValue args = StackValue.get(2, JNI.JValue.class);
         args.addressOf(0).setJObject(p0);
         args.addressOf(1).setJObject(p1);