Merge to tag jdk-28+16

make/RunTests.gmk

@@ -666,7 +666,7 @@ define SetupRunMicroTestBody
 	        $$($1_MICRO_ITER) $$($1_MICRO_FORK) $$($1_MICRO_TIME) \
 	        $$($1_MICRO_WARMUP_ITER) $$($1_MICRO_WARMUP_TIME) \
 	        $$($1_MICRO_VM_OPTIONS) $$($1_MICRO_BASIC_OPTIONS) $$(MICRO_OPTIONS) \
-	        $$($1_TEST_NAME) \
+	        $$(call ShellQuote,$$($1_TEST_NAME)) \
 	        > >($(TEE) $$($1_TEST_RESULTS_DIR)/micro.txt) \
 	    && $$(ECHO) $$$$? > $$($1_EXITCODE) \
 	    || $$(ECHO) $$$$? > $$($1_EXITCODE) \
@@ -1293,7 +1293,7 @@ UseSpecialTestHandler = \
 
 # Now process each test to run and setup a proper make rule
 $(foreach test, $(TESTS_TO_RUN), \
-  $(eval TEST_ID := $(shell $(ECHO) $(strip $(test)) | \
+  $(eval TEST_ID := $(shell $(ECHO) $(call ShellQuote,$(strip $(test))) | \
       $(TR) -cs '[a-z][A-Z][0-9]\n' '_')) \
   $(eval ALL_TEST_IDS += $(TEST_ID)) \
   $(if $(call UseCustomTestHandler, $(test)), \
@@ -1373,10 +1373,10 @@ run-test-report: post-run-test
 	$(PRINTF) >> $(TEST_SUMMARY) "%2s %-49s %5s %5s %5s %5s %5s %2s\n" "  " \
 	    TEST TOTAL PASS FAIL ERROR SKIP " "
 	$(foreach test, $(TESTS_TO_RUN), \
-	  $(eval TEST_ID := $(shell $(ECHO) $(strip $(test)) | \
+	  $(eval TEST_ID := $(shell $(ECHO) $(call ShellQuote,$(strip $(test))) | \
 	      $(TR) -cs '[a-z][A-Z][0-9]\n' '_')) \
 	    $(ECHO) >> $(TEST_LAST_IDS) $(TEST_ID) $(NEWLINE) \
-	  $(eval NAME_PATTERN := $(shell $(ECHO) $(test) | $(TR) -c '\n' '_')) \
+	  $(eval NAME_PATTERN := $(shell $(ECHO) $(call ShellQuote,$(test)) | $(TR) -c '\n' '_')) \
 	  $(if $(filter __________________________________________________%, $(NAME_PATTERN)), \
 	    $(eval TEST_NAME := ) \
 	    $(PRINTF) >> $(TEST_SUMMARY) "%2s %-49s\n" "  " "$(test)"  $(NEWLINE) \

make/hotspot/lib/CompileJvm.gmk

@@ -211,6 +211,7 @@ $(eval $(call SetupJdkLibrary, BUILD_LIBJVM, \
     DISABLED_WARNINGS_gcc_safepointMechanism.cpp := stringop-overflow, \
     DISABLED_WARNINGS_gcc_shenandoahGenerationalHeap.cpp := stringop-overflow, \
     DISABLED_WARNINGS_gcc_shenandoahHeap.cpp := stringop-overflow, \
+    DISABLED_WARNINGS_gcc_shenandoahInPlacePromoter.cpp := stringop-overflow, \
     DISABLED_WARNINGS_gcc_shenandoahLock.cpp := stringop-overflow, \
     DISABLED_WARNINGS_gcc_stubGenerator_s390.cpp := unused-const-variable, \
     DISABLED_WARNINGS_gcc_synchronizer.cpp := stringop-overflow, \

make/modules/java.base/Lib.gmk

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2011, 2025, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2011, 2026, 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
@@ -43,10 +43,9 @@ include lib/CoreLibraries.gmk
 $(eval $(call SetupJdkLibrary, BUILD_LIBNET, \
     NAME := net, \
     OPTIMIZATION := LOW, \
-    DISABLED_WARNINGS_gcc_net_util_md.c := format-nonliteral unused-variable, \
+    DISABLED_WARNINGS_gcc_net_util_md.c := format-nonliteral, \
     DISABLED_WARNINGS_gcc_NetworkInterface.c := unused-function, \
-    DISABLED_WARNINGS_clang_net_util_md.c := format-nonliteral \
-        unused-variable, \
+    DISABLED_WARNINGS_clang_net_util_md.c := format-nonliteral, \
     DISABLED_WARNINGS_clang_NetworkInterface.c := unused-function, \
     DISABLED_WARNINGS_clang_aix_DefaultProxySelector.c := \
         deprecated-non-prototype, \
@@ -78,8 +77,7 @@ $(eval $(call SetupJdkLibrary, BUILD_LIBNIO, \
         libnio/ch \
         libnio/fs \
         libjvm, \
-    DISABLED_WARNINGS_clang_Net.c := unused-function unused-variable, \
-    DISABLED_WARNINGS_clang_UnixNativeDispatcher.c := unused-variable, \
+    DISABLED_WARNINGS_clang_Net.c := unused-function, \
     JDK_LIBS := libjava libnet, \
     LIBS_linux := $(LIBDL) $(LIBPTHREAD), \
     LIBS_aix := $(LIBDL), \

make/test/JtregNativeJdk.gmk

@@ -75,6 +75,7 @@ else
   # java.lang.foreign tests
   BUILD_JDK_JTREG_LIBRARIES_LDFLAGS_libAsyncStackWalk := -pthread
   BUILD_JDK_JTREG_LIBRARIES_LDFLAGS_libAsyncInvokers := -pthread
+  BUILD_JDK_JTREG_LIBRARIES_LDFLAGS_libDetachAfterExit := -pthread
   BUILD_JDK_JTREG_LIBRARIES_LDFLAGS_libLinkerInvokerUnnamed := -pthread
   BUILD_JDK_JTREG_LIBRARIES_LDFLAGS_libLinkerInvokerModule := -pthread
   BUILD_JDK_JTREG_LIBRARIES_LDFLAGS_libLoaderLookupInvoker := -pthread

src/hotspot/cpu/aarch64/aarch64.ad

@@ -1810,10 +1810,6 @@ void MachPrologNode::emit(C2_MacroAssembler *masm, PhaseRegAlloc *ra_) const {
     __ bind(*_verified_entry);
   }
 
-  if (VerifyStackAtCalls) {
-    Unimplemented();
-  }
-
   C->output()->set_frame_complete(__ offset());
 
   if (C->has_mach_constant_base_node()) {
@@ -3679,10 +3675,6 @@ encode %{
   %}
 
   enc_class aarch64_enc_call_epilog() %{
-    if (VerifyStackAtCalls) {
-      // Check that stack depth is unchanged: find majik cookie on stack
-      __ call_Unimplemented();
-    }
     if (tf()->returns_value_type_as_fields() && !_method->is_method_handle_intrinsic() && _method->return_type()->is_loaded()) {
       // The last return value is not set by the callee but used to pass the null marker to compiled code.
       // Search for the corresponding projection, get the register and emit code that initializes it.

src/hotspot/cpu/aarch64/assembler_aarch64.hpp

@@ -477,8 +477,8 @@ class Address {
   // Verify the value is trivially destructible regardless of mode, so our
   // destructor can also be trivial, and so our assignment operator doesn't
   // need to destruct the old value before copying over it.
-  static_assert(std::is_trivially_destructible<Literal>::value, "must be");
-  static_assert(std::is_trivially_destructible<Nonliteral>::value, "must be");
+  static_assert(std::is_trivially_destructible<Literal>::value);
+  static_assert(std::is_trivially_destructible<Nonliteral>::value);
 
   Address& operator=(const Address& a) {
     _mode = a._mode;

src/hotspot/cpu/aarch64/c1_Runtime1_aarch64.cpp

@@ -778,7 +778,7 @@ OopMapSet* Runtime1::generate_code_for(StubId id, StubAssembler* sasm) {
           case StubId::c1_new_null_free_array_id:
             __ cmpw(t0, Klass::_lh_array_tag_flat_value);  // the array can be a flat array.
             __ br(Assembler::EQ, ok);
-            __ cmpw(t0, Klass::_lh_array_tag_ref_value); // the array cannot be a flat array (due to the InlineArrayElementMaxFlatSize, etc.)
+            __ cmpw(t0, Klass::_lh_array_tag_ref_value); // the array cannot be a flat array.
             __ br(Assembler::EQ, ok);
             __ stop("assert(is an object or value type array klass)");
             break;

src/hotspot/cpu/aarch64/continuationFreezeThaw_aarch64.inline.hpp

@@ -63,12 +63,13 @@ inline frame FreezeBase::sender(const frame& f) {
   frame::CompiledFramePointers cfp = f.compiled_frame_details();
 
   int slot = 0;
-  CodeBlob* sender_cb = CodeCache::find_blob_and_oopmap(*cfp.sender_pc_addr, slot);
+  address sender_pc = ContinuationHelper::return_address_at((intptr_t*)cfp.sender_pc_addr);
+  CodeBlob* sender_cb = CodeCache::find_blob_and_oopmap(sender_pc, slot);
 
   return sender_cb != nullptr
-    ? frame(cfp.sender_sp, cfp.sender_sp, *cfp.saved_fp_addr, *cfp.sender_pc_addr, sender_cb,
-            slot == -1 ? nullptr : sender_cb->oop_map_for_slot(slot, *cfp.sender_pc_addr), false)
-    : frame(cfp.sender_sp, cfp.sender_sp, *cfp.saved_fp_addr, *cfp.sender_pc_addr);
+    ? frame(cfp.sender_sp, cfp.sender_sp, *cfp.saved_fp_addr, sender_pc, sender_cb,
+            slot == -1 ? nullptr : sender_cb->oop_map_for_slot(slot, sender_pc), false)
+    : frame(cfp.sender_sp, cfp.sender_sp, *cfp.saved_fp_addr, sender_pc);
 }
 
 template<typename FKind>

src/hotspot/cpu/aarch64/frame_aarch64.cpp

@@ -632,7 +632,9 @@ void frame::describe_pd(FrameValues& values, int frame_no) {
       ret_pc_loc = (intptr_t*)cfp.sender_pc_addr;
       fp_loc = (intptr_t*)cfp.saved_fp_addr;
     }
-    address ret_pc = *(address*)ret_pc_loc;
+    // Strip without authenticating: describe may see unsigned or broken LRs,
+    // and is_return_barrier_entry() compares against a raw stub address.
+    address ret_pc = pauth_strip_pointer(*(address*)ret_pc_loc);
     values.describe(frame_no, ret_pc_loc,
       Continuation::is_return_barrier_entry(ret_pc) ? "return address (return barrier)" : "return address");
     values.describe(-1, fp_loc, "saved fp", 0); // "unowned" as value belongs to sender

src/hotspot/cpu/aarch64/gc/shared/barrierSetAssembler_aarch64.cpp

@@ -258,7 +258,7 @@ void BarrierSetAssembler::copy_store_at(MacroAssembler* masm,
 void BarrierSetAssembler::try_resolve_jobject_in_native(MacroAssembler* masm, Register jni_env,
                                                         Register obj, Register tmp, Label& slowpath) {
   // If mask changes we need to ensure that the inverse is still encodable as an immediate
-  STATIC_ASSERT(JNIHandles::tag_mask == 0b11);
+  static_assert(JNIHandles::tag_mask == 0b11);
   __ andr(obj, obj, ~JNIHandles::tag_mask);
   __ ldr(obj, Address(obj, 0));             // *obj
 }

src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.cpp

@@ -31,10 +31,13 @@
 #include "gc/shenandoah/shenandoahBarrierSetAssembler.hpp"
 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 #include "gc/shenandoah/shenandoahHeapRegion.hpp"
+#include "gc/shenandoah/shenandoahNMethod.inline.hpp"
 #include "gc/shenandoah/shenandoahRuntime.hpp"
 #include "gc/shenandoah/shenandoahThreadLocalData.hpp"
 #include "interpreter/interp_masm.hpp"
 #include "interpreter/interpreter.hpp"
+#include "nativeInst_aarch64.hpp"
+#include "runtime/icache.hpp"
 #include "runtime/javaThread.hpp"
 #include "runtime/sharedRuntime.hpp"
 #ifdef COMPILER1
@@ -493,6 +496,47 @@ void ShenandoahBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssemb
 
 #undef __
 
+address ShenandoahBarrierSetAssembler::parse_jump_address(address pc) {
+  NativeInstruction* ni = nativeInstruction_at(pc);
+  assert(ni->is_jump(), "Initial code version: GC barrier fastpath must be a jump");
+  NativeJump* jmp = nativeJump_at(pc);
+  return jmp->jump_destination();
+}
+
+static uint32_t encode_patchable_nop() {
+  return 0xD503201F;
+}
+
+static uint32_t encode_patchable_jump(address pc, address target_pc) {
+  int32_t disp = checked_cast<int32_t>((intptr_t)target_pc - (intptr_t)pc);
+  int64_t imm26 = disp >> 2;
+  guarantee(Assembler::is_simm(imm26, 26), "Maximum offset is 128MiB");
+  return 0x14000000 | (imm26 & 0x03FFFFFF);
+}
+
+void ShenandoahBarrierSetAssembler::insert_patchable_nop(address pc) {
+  *((uint32_t*)pc) = encode_patchable_nop();
+  assert(nativeInstruction_at(pc)->is_nop(), "Sanity");
+  if (!UseSingleICacheInvalidation) {
+    ICache::invalidate_word(pc);
+  }
+}
+
+void ShenandoahBarrierSetAssembler::insert_patchable_jump(address pc, address target_pc) {
+  *((uint32_t*)pc) = encode_patchable_jump(pc, target_pc);
+  if (!UseSingleICacheInvalidation) {
+    ICache::invalidate_word(pc);
+  }
+}
+
+bool ShenandoahBarrierSetAssembler::is_patchable_nop(address pc) {
+  return *((uint32_t*)pc) == encode_patchable_nop();
+}
+
+bool ShenandoahBarrierSetAssembler::is_patchable_jump(address pc, address target_pc) {
+  return *((uint32_t*)pc) == encode_patchable_jump(pc, target_pc);
+}
+
 #ifdef COMPILER1
 
 #define __ ce->masm()->
@@ -707,27 +751,70 @@ void ShenandoahBarrierStubC2::cardtable(MacroAssembler& masm, Address address, R
   }
 }
 
-void ShenandoahBarrierStubC2::enter_if_gc_state(MacroAssembler& masm, const char test_state, Register tmp) {
-  Assembler::InlineSkippedInstructionsCounter skip_counter(&masm);
+void ShenandoahBarrierStubC2::patchable_jump(MacroAssembler& masm, const char gc_state, bool jump_when_state, Register tmp1, Register tmp2, Label* L_target) {
+  const size_t check_size = 8;
+
   PhaseOutput* const output = Compile::current()->output();
-  Address gc_state_fast(rthread, in_bytes(ShenandoahThreadLocalData::gc_state_fast_array_offset(test_state)));
+  if (output->in_scratch_emit_size()) {
+    // Avoid binding L_target and emitting more branches in scratch emits.
+    // We know the patched check is exactly 1 instruction long in release,
+    // and verification adds more instructions.
+    const int nops = 1 DEBUG_ONLY(+ check_size);
+    for (size_t c = 0; c < nops; c++) {
+      __ nop();
+    }
+    return;
+  }
 
-  // We piggyback on scratch_emit_size mode to compute the slowpath stub size.
-  // We'll use that information to decide whether we need a far jump to the
-  // stub entry point or not. In scratch_emit_size mode we don't bind entry()
-  // because otherwise it will be rebound when we later emit the instructions
-  // for real.
-  if (_needs_far_jump) {
-    __ ldrb(tmp, gc_state_fast);
-    __ cbz(tmp, *continuation());
-    __ b(output->in_scratch_emit_size() ? *continuation() : *entry());
+#ifdef ASSERT
+  Label L_fake_entry, L_skip;
+  Address gc_state_addr(rthread, in_bytes(ShenandoahThreadLocalData::gc_state_offset()));
+
+  address check_start = __ pc();
+
+  __ ldrb(tmp1, gc_state_addr);
+  __ mov(tmp2, gc_state);
+  __ andr(tmp2, tmp1, tmp2);
+
+  // Emit the secondary jump and use it to cross-check against the actual GC state.
+  // This also checks that all interesting GC state transitions are done non-racily
+  // from the perspective of the thread executing the nmethod.
+  __ relocate(patchable_barrier_Relocation::spec(ShenandoahNMethod::encode_to_reloc(gc_state, jump_when_state)));
+  __ b(L_fake_entry);
+
+  // Currently hot-patched to NOP.
+  if (jump_when_state) {
+    __ cbz(tmp2, L_skip);
   } else {
-    __ ldrb(tmp, gc_state_fast);
-    __ cbnz(tmp, output->in_scratch_emit_size() ? *continuation() : *entry());
+    __ cbnz(tmp2, L_skip);
   }
+  __ hlt(0);
 
-  // This is were the slowpath stub will return to or the code above will
-  // jump to if the checks are false
+  // Currently hot-patched to JUMP.
+  __ bind(L_fake_entry);
+  if (jump_when_state) {
+    __ cbnz(tmp2, L_skip);
+  } else {
+    __ cbz(tmp2, L_skip);
+  }
+  __ hlt(0);
+
+  __ bind(L_skip);
+
+  address check_end = __ pc();
+  size_t actual_check_size = pointer_delta(check_end, check_start, Assembler::instruction_size);
+  assert(check_size == actual_check_size, "Must match: %zu != %zu", check_size, actual_check_size);
+#endif
+
+  // Emit the unconditional branch in the first version of the method.
+  // Let the rest of runtime figure out how to manage it.
+  __ relocate(patchable_barrier_Relocation::spec(ShenandoahNMethod::encode_to_reloc(gc_state, jump_when_state)));
+  __ b(*L_target);
+}
+
+void ShenandoahBarrierStubC2::enter_if_gc_state(MacroAssembler& masm, const char test_state, Register tmp1, Register tmp2) {
+  Assembler::InlineSkippedInstructionsCounter skip_counter(&masm);
+  patchable_jump_if_gc_state(masm, test_state, tmp1, tmp2, entry());
   __ bind(*continuation());
 }
 
@@ -801,16 +888,15 @@ void ShenandoahBarrierStubC2::maybe_far_jump_if_zero(MacroAssembler& masm, Regis
 }
 
 void ShenandoahBarrierStubC2::keepalive(MacroAssembler& masm, Label* L_done) {
-  Address gcstate(rthread, in_bytes(ShenandoahThreadLocalData::gc_state_fast_array_offset(ShenandoahHeap::MARKING)));
   Address index(rthread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_index_offset()));
   Address buffer(rthread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_buffer_offset()));
   Label L_through, L_slowpath;
 
-  // If another barrier is enabled as well, do a runtime check for a specific barrier.
+  // If another barrier is enabled as well, do a check for a specific barrier.
   if (_needs_load_ref_barrier) {
-    assert(L_done == nullptr, "L_done is always null when _needs_load_ref_barrier is true");
-    __ ldrb(_tmp1, gcstate);
-    __ cbz(_tmp1, L_through);
+    assert(L_done == nullptr, "Should be");
+    char state_to_check = ShenandoahHeap::MARKING;
+    patchable_jump_if_not_gc_state(masm, state_to_check, _tmp1, _tmp2, &L_through);
   }
 
   // Fast-path: put object into buffer.
@@ -860,20 +946,17 @@ void ShenandoahBarrierStubC2::keepalive(MacroAssembler& masm, Label* L_done) {
 void ShenandoahBarrierStubC2::lrb(MacroAssembler& masm) {
   Label L_slow;
 
-  // If another barrier is enabled as well, do a runtime check for a specific barrier.
+  // If another barrier is enabled as well, do a check for a specific barrier.
   if (_needs_keep_alive_barrier) {
     char state_to_check = ShenandoahHeap::HAS_FORWARDED | (_needs_load_ref_weak_barrier ? ShenandoahHeap::WEAK_ROOTS : 0);
-    Address gc_state_fast(rthread, in_bytes(ShenandoahThreadLocalData::gc_state_fast_array_offset(state_to_check)));
-    __ ldrb(_tmp1, gc_state_fast);
-    maybe_far_jump_if_zero(masm, _tmp1);
+    patchable_jump_if_not_gc_state(masm, state_to_check, _tmp1, _tmp2, continuation());
   }
 
   // If weak references are being processed, weak/phantom loads need to go slow,
   // regardless of their cset status.
   if (_needs_load_ref_weak_barrier) {
-    Address gc_state_fast(rthread, in_bytes(ShenandoahThreadLocalData::gc_state_fast_array_offset(ShenandoahHeap::WEAK_ROOTS)));
-    __ ldrb(_tmp1, gc_state_fast);
-    __ cbnz(_tmp1, L_slow);
+    char state_to_check = ShenandoahHeap::WEAK_ROOTS;
+    patchable_jump_if_gc_state(masm, state_to_check, _tmp1, _tmp2, &L_slow);
   }
 
   // Cset-check. Fall-through to slow if in collection set.

src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.hpp

@@ -76,6 +76,13 @@ class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
                                                Register tmp, Label& slow_path);
   virtual void check_oop(MacroAssembler* masm, Register obj, Register tmp1, Register tmp2, Label& L_error);
 
+  // Jumps hotpatching
+  static address parse_jump_address(address pc);
+  static void insert_patchable_nop(address pc);
+  static bool is_patchable_nop(address pc);
+  static void insert_patchable_jump(address pc, address target_pc);
+  static bool is_patchable_jump(address pc, address target_pc);
+
 #ifdef COMPILER1
   void keepalive_barrier_c1_stub(LIR_Assembler* ce, ShenandoahKeepaliveBarrierStub* stub);
   void keepalive_barrier_c1_runtime_stub(StubAssembler* sasm);

src/hotspot/cpu/aarch64/interpreterRT_aarch64.cpp

@@ -168,7 +168,7 @@ void InterpreterRuntime::SignatureHandlerGenerator::pass_object() {
     __ cbnz(temp(), L);
     __ mov(r0, zr);
     __ bind(L);
-    static_assert(sizeof(jobject) == wordSize, "");
+    static_assert(sizeof(jobject) == wordSize);
     __ str(r0, Address(to(), next_stack_offset(sizeof(jobject))));
   }
 }