Merge to tag jdk-21.0.9+4

src/hotspot/share/opto/loopnode.cpp

@@ -701,14 +701,24 @@ SafePointNode* PhaseIdealLoop::find_safepoint(Node* back_control, Node* x, Ideal
 
     // We can only use that safepoint if there's no side effect between the backedge and the safepoint.
 
-    // mm is used for book keeping
+    // mm is the memory state at the safepoint (when it's a MergeMem)
+    // no_side_effect_since_safepoint() goes over the memory state at the backedge. It resets the mm input for each
+    // component of the memory state it encounters so it points to the base memory. Once no_side_effect_since_safepoint()
+    // is done, if no side effect after the safepoint was found, mm should transform to the base memory: the states at
+    // the backedge and safepoint are the same so all components of the memory state at the safepoint should have been
+    // reset.
     MergeMemNode* mm = nullptr;
 #ifdef ASSERT
     if (mem->is_MergeMem()) {
       mm = mem->clone()->as_MergeMem();
       _igvn._worklist.push(mm);
       for (MergeMemStream mms(mem->as_MergeMem()); mms.next_non_empty(); ) {
-        if (mms.alias_idx() != Compile::AliasIdxBot && loop != get_loop(ctrl_or_self(mms.memory()))) {
+        // Loop invariant memory state won't be reset by no_side_effect_since_safepoint(). Do it here.
+        // Escape Analysis can add state to mm that it doesn't add to the backedge memory Phis, breaking verification
+        // code that relies on mm. Clear that extra state here.
+        if (mms.alias_idx() != Compile::AliasIdxBot &&
+            (loop != get_loop(ctrl_or_self(mms.memory())) ||
+             (mms.adr_type()->isa_oop_ptr() && mms.adr_type()->is_known_instance()))) {
           mm->set_memory_at(mms.alias_idx(), mem->as_MergeMem()->base_memory());
         }
       }

src/hotspot/share/opto/type.cpp

@@ -3125,8 +3125,8 @@ const TypeRawPtr *TypeRawPtr::make( enum PTR ptr ) {
   return (TypeRawPtr*)(new TypeRawPtr(ptr,0))->hashcons();
 }
 
-const TypeRawPtr *TypeRawPtr::make( address bits ) {
-  assert( bits, "Use TypePtr for null" );
+const TypeRawPtr *TypeRawPtr::make(address bits) {
+  assert(bits != nullptr, "Use TypePtr for null");
   return (TypeRawPtr*)(new TypeRawPtr(Constant,bits))->hashcons();
 }
 
@@ -3215,15 +3215,21 @@ const TypePtr* TypeRawPtr::add_offset(intptr_t offset) const {
   case TypePtr::BotPTR:
   case TypePtr::NotNull:
     return this;
-  case TypePtr::Null:
   case TypePtr::Constant: {
-    address bits = _bits+offset;
-    if ( bits == 0 ) return TypePtr::NULL_PTR;
-    return make( bits );
+    uintptr_t bits = (uintptr_t)_bits;
+    uintptr_t sum = bits + offset;
+    if (( offset < 0 )
+        ? ( sum > bits )        // Underflow?
+        : ( sum < bits )) {     // Overflow?
+      return BOTTOM;
+    } else if ( sum == 0 ) {
+      return TypePtr::NULL_PTR;
+    } else {
+      return make( (address)sum );
+    }
   }
   default:  ShouldNotReachHere();
   }
-  return nullptr;                  // Lint noise
 }
 
 //------------------------------eq---------------------------------------------

src/java.base/share/classes/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java

@@ -277,6 +277,40 @@ private static void signalNextIfShared(Node h) {
         }
     }
 
+    /**
+     * Repeatedly invokes acquire, if its execution throws an Error or a Runtime Exception,
+     * using an Unsafe.park-based backoff
+     * @param node which to reacquire
+     * @param arg the acquire argument
+     */
+    private final void reacquire(Node node, long arg) {
+        try {
+            acquire(node, arg, false, false, false, 0L);
+        } catch (Error | RuntimeException firstEx) {
+            // While we currently do not emit an JFR events in this situation, mainly
+            // because the conditions under which this happens are such that it
+            // cannot be presumed to be possible to actually allocate an event, and
+            // using a preconstructed one would have limited value in serviceability.
+            // Having said that, the following place would be the more appropriate
+            // place to put such logic:
+            //     emit JFR event
+
+            for (long nanos = 1L;;) {
+                U.park(false, nanos); // must use Unsafe park to sleep
+                if (nanos < 1L << 30)            // max about 1 second
+                    nanos <<= 1;
+
+                try {
+                    acquire(node, arg, false, false, false, 0L);
+                } catch (Error | RuntimeException ignored) {
+                    continue;
+                }
+
+                throw firstEx;
+            }
+        }
+    }
+
     /**
      * Main acquire method, invoked by all exported acquire methods.
      *
@@ -1294,7 +1328,7 @@ else if ((node.status & COND) != 0) {
             }
             LockSupport.setCurrentBlocker(null);
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (interrupted)
                 Thread.currentThread().interrupt();
         }
@@ -1341,7 +1375,7 @@ public final void await() throws InterruptedException {
             }
             LockSupport.setCurrentBlocker(null);
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (interrupted) {
                 if (cancelled) {
                     unlinkCancelledWaiters(node);
@@ -1384,7 +1418,7 @@ public final long awaitNanos(long nanosTimeout)
                     LockSupport.parkNanos(this, nanos);
             }
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (cancelled) {
                 unlinkCancelledWaiters(node);
                 if (interrupted)
@@ -1428,7 +1462,7 @@ public final boolean awaitUntil(Date deadline)
                     LockSupport.parkUntil(this, abstime);
             }
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (cancelled) {
                 unlinkCancelledWaiters(node);
                 if (interrupted)
@@ -1473,7 +1507,7 @@ public final boolean await(long time, TimeUnit unit)
                     LockSupport.parkNanos(this, nanos);
             }
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (cancelled) {
                 unlinkCancelledWaiters(node);
                 if (interrupted)

src/java.base/share/classes/java/util/concurrent/locks/AbstractQueuedSynchronizer.java

@@ -656,6 +656,40 @@ private static void signalNextIfShared(Node h) {
         }
     }
 
+    /**
+     * Repeatedly invokes acquire, if its execution throws an Error or a Runtime Exception,
+     * using an Unsafe.park-based backoff
+     * @param node which to reacquire
+     * @param arg the acquire argument
+     */
+    private final void reacquire(Node node, int arg) {
+        try {
+            acquire(node, arg, false, false, false, 0L);
+        } catch (Error | RuntimeException firstEx) {
+            // While we currently do not emit an JFR events in this situation, mainly
+            // because the conditions under which this happens are such that it
+            // cannot be presumed to be possible to actually allocate an event, and
+            // using a preconstructed one would have limited value in serviceability.
+            // Having said that, the following place would be the more appropriate
+            // place to put such logic:
+            //     emit JFR event
+
+            for (long nanos = 1L;;) {
+                U.park(false, nanos); // must use Unsafe park to sleep
+                if (nanos < 1L << 30)            // max about 1 second
+                    nanos <<= 1;
+
+                try {
+                    acquire(node, arg, false, false, false, 0L);
+                } catch (Error | RuntimeException ignored) {
+                    continue;
+                }
+
+                throw firstEx;
+            }
+        }
+    }
+
     /**
      * Main acquire method, invoked by all exported acquire methods.
      *
@@ -1673,7 +1707,7 @@ else if ((node.status & COND) != 0) {
             }
             LockSupport.setCurrentBlocker(null);
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (interrupted)
                 Thread.currentThread().interrupt();
         }
@@ -1720,7 +1754,7 @@ public final void await() throws InterruptedException {
             }
             LockSupport.setCurrentBlocker(null);
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (interrupted) {
                 if (cancelled) {
                     unlinkCancelledWaiters(node);
@@ -1763,7 +1797,7 @@ public final long awaitNanos(long nanosTimeout)
                     LockSupport.parkNanos(this, nanos);
             }
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (cancelled) {
                 unlinkCancelledWaiters(node);
                 if (interrupted)
@@ -1807,7 +1841,7 @@ public final boolean awaitUntil(Date deadline)
                     LockSupport.parkUntil(this, abstime);
             }
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (cancelled) {
                 unlinkCancelledWaiters(node);
                 if (interrupted)
@@ -1852,7 +1886,7 @@ public final boolean await(long time, TimeUnit unit)
                     LockSupport.parkNanos(this, nanos);
             }
             node.clearStatus();
-            acquire(node, savedState, false, false, false, 0L);
+            reacquire(node, savedState);
             if (cancelled) {
                 unlinkCancelledWaiters(node);
                 if (interrupted)

src/java.base/share/classes/sun/security/ssl/Alert.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2024, 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
@@ -123,13 +123,13 @@ SSLException createSSLException(String reason, Throwable cause) {
         }
 
         if (cause instanceof IOException) {
-            return new SSLException(reason, cause);
+            return new SSLException("(" + description + ") " + reason, cause);
         } else if ((this == UNEXPECTED_MESSAGE)) {
-            return new SSLProtocolException(reason, cause);
+            return new SSLProtocolException("(" + description + ") " + reason, cause);
         } else if (handshakeOnly) {
-            return new SSLHandshakeException(reason, cause);
+            return new SSLHandshakeException("(" + description + ") " + reason, cause);
         } else {
-            return new SSLException(reason, cause);
+            return new SSLException("(" + description + ") " + reason, cause);
         }
     }
 

src/java.base/share/classes/sun/security/ssl/CertificateMessage.java

@@ -381,7 +381,7 @@ private void onCertificate(ServerHandshakeContext shc,
                 if (shc.sslConfig.clientAuthType !=
                         ClientAuthType.CLIENT_AUTH_REQUESTED) {
                     // unexpected or require client authentication
-                    throw shc.conContext.fatal(Alert.BAD_CERTIFICATE,
+                    throw shc.conContext.fatal(Alert.HANDSHAKE_FAILURE,
                         "Empty client certificate chain");
                 } else {
                     return;
@@ -1163,7 +1163,7 @@ private void onConsumeCertificate(ServerHandshakeContext shc,
                 shc.handshakeConsumers.remove(
                         SSLHandshake.CERTIFICATE_VERIFY.id);
                 if (shc.sslConfig.clientAuthType == CLIENT_AUTH_REQUIRED) {
-                    throw shc.conContext.fatal(Alert.BAD_CERTIFICATE,
+                    throw shc.conContext.fatal(Alert.CERTIFICATE_REQUIRED,
                         "Empty client certificate chain");
                 } else {
                     // optional client authentication
@@ -1187,7 +1187,7 @@ private void onConsumeCertificate(ClientHandshakeContext chc,
                 T13CertificateMessage certificateMessage )throws IOException {
             if (certificateMessage.certEntries == null ||
                     certificateMessage.certEntries.isEmpty()) {
-                throw chc.conContext.fatal(Alert.BAD_CERTIFICATE,
+                throw chc.conContext.fatal(Alert.DECODE_ERROR,
                     "Empty server certificate chain");
             }