Merge to tag jdk-28+9

make/langtools/test/crules/DefinedByAnalyzer/Test.java

@@ -12,14 +12,10 @@
 
 public class Test implements SourcePositions, TaskListener {
     @Override @DefinedBy(Api.COMPILER_TREE)
-    public long getStartPosition(CompilationUnitTree file, Tree tree) {
+    public long getStartPosition(Tree tree) {
         return 0;
     }
-    @Override
-    public long getEndPosition(CompilationUnitTree file, Tree tree) {
-        return 0;
-    }
-    @DefinedBy(Api.COMPILER_TREE)
+    @Override @DefinedBy(Api.COMPILER_TREE)
     public long getEndPosition(Tree tree) {
         return 0;
     }

src/hotspot/cpu/aarch64/aarch64.ad

@@ -1662,19 +1662,19 @@ bool needs_acquiring_load_exclusive(const Node *n)
 //       from the start of the call to the point where the return address
 //       will point.
 
-int MachCallStaticJavaNode::ret_addr_offset()
+int MachCallStaticJavaNode::ret_addr_offset() const
 {
   // call should be a simple bl
   int off = 4;
   return off;
 }
 
-int MachCallDynamicJavaNode::ret_addr_offset()
+int MachCallDynamicJavaNode::ret_addr_offset() const
 {
   return 16; // movz, movk, movk, bl
 }
 
-int MachCallRuntimeNode::ret_addr_offset() {
+int MachCallRuntimeNode::ret_addr_offset() const {
   // for generated stubs the call will be
   //   bl(addr)
   // or with far branches

src/hotspot/cpu/aarch64/c2_MacroAssembler_aarch64.cpp

@@ -219,6 +219,10 @@ void C2_MacroAssembler::fast_lock(Register obj, Register box, Register t1,
     bind(inflated);
 
     const Register t1_monitor = t1;
+    // Offsets into the current thread's object monitor cache (omc).
+    const ByteSize thr_omc_offset     = JavaThread::om_cache_offset();
+    const ByteSize omc_monitor_offset = OMCache::monitor_offset();
+    const ByteSize omc_obj_offset     = OMCache::obj_offset();
 
     if (!UseObjectMonitorTable) {
       assert(t1_monitor == t1_mark, "should be the same here");
@@ -229,18 +233,12 @@ void C2_MacroAssembler::fast_lock(Register obj, Register box, Register t1,
       // Save the mark, we might need it to extract the hash.
       mov(t3, t1_mark);
 
-      // Look for the monitor in the om_cache.
-
-      ByteSize cache_offset   = JavaThread::om_cache_oops_offset();
-      ByteSize monitor_offset = OMCache::oop_to_monitor_difference();
-      const int num_unrolled  = OMCache::CAPACITY;
-      for (int i = 0; i < num_unrolled; i++) {
-        ldr(t1_monitor, Address(rthread, cache_offset + monitor_offset));
-        ldr(t2, Address(rthread, cache_offset));
-        cmp(obj, t2);
-        br(Assembler::EQ, monitor_found);
-        cache_offset = cache_offset + OMCache::oop_to_oop_difference();
-      }
+      // Look for the monitor in the current thread's object monitor cache (omc).
+
+      ldr(t1_monitor, Address(rthread, thr_omc_offset + omc_monitor_offset));
+      ldr(t2, Address(rthread, thr_omc_offset + omc_obj_offset));
+      cmp(obj, t2);
+      br(Assembler::EQ, monitor_found);
 
       // Look for the monitor in the table.
 
@@ -268,6 +266,10 @@ void C2_MacroAssembler::fast_lock(Register obj, Register box, Register t1,
       cmp(t3, obj);
       br(Assembler::NE, slow_path);
 
+      // Store the monitor in the current thread's object monitor cache (omc).
+      str(t1_monitor, Address(rthread, thr_omc_offset + omc_monitor_offset));
+      str(obj, Address(rthread, thr_omc_offset + omc_obj_offset));
+
       bind(monitor_found);
     }
 
@@ -296,6 +298,7 @@ void C2_MacroAssembler::fast_lock(Register obj, Register box, Register t1,
 
     bind(monitor_locked);
     if (UseObjectMonitorTable) {
+      // Cache the monitor for unlock.
       str(t1_monitor, Address(box, BasicLock::object_monitor_cache_offset_in_bytes()));
     }
   }
@@ -1506,9 +1509,9 @@ void C2_MacroAssembler::sve_vmask_fromlong(FloatRegister dst, Register src,
   // Expected:  dst = 0x00 01 01 00 00 01 00 01 01 00 00 00 01 01 00 01
 
   // Put long value from general purpose register into the first lane of vector.
+  // The higher lanes are set to zero.
   // vtmp = 0x0000000000000000 | 0x000000000000658D
-  sve_dup(vtmp, B, 0);
-  mov(vtmp, D, 0, src);
+  fmovd(vtmp, src);
 
   // Transform the value in the first lane which is mask in bit now to the mask in
   // byte, which can be done by SVE2's BDEP instruction.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 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
@@ -215,7 +215,8 @@ inline intptr_t* AnchorMark::anchor_mark_set_pd() {
     if (sp != _last_sp_from_frame) {
       // We need to move up return pc and fp. They will be read next in
       // set_anchor() and set as _last_Java_pc and _last_Java_fp respectively.
-      _last_sp_from_frame[-1] = (intptr_t)_top_frame.pc();
+      ContinuationHelper::patch_return_address_at(&_last_sp_from_frame[-1],
+                                                  _top_frame.pc());
       _last_sp_from_frame[-2] = (intptr_t)_top_frame.fp();
     }
     _is_interpreted = true;
@@ -230,7 +231,7 @@ inline void AnchorMark::anchor_mark_clear_pd() {
     _top_frame.interpreter_frame_set_last_sp(_last_sp_from_frame);
     intptr_t* sp = _top_frame.sp();
     if (sp != _last_sp_from_frame) {
-      sp[-1] = (intptr_t)_top_frame.pc();
+      ContinuationHelper::patch_return_address_at(&sp[-1], _top_frame.pc());
     }
   }
 }
@@ -340,7 +341,8 @@ inline intptr_t* ThawBase::push_cleanup_continuation() {
   intptr_t* sp = enterSpecial.sp();
 
   // We only need to set the return pc. rfp will be restored back in gen_continuation_enter().
-  sp[-1] = (intptr_t)ContinuationEntry::cleanup_pc();
+  ContinuationHelper::patch_return_address_at(&sp[-1],
+                                              ContinuationEntry::cleanup_pc());
   return sp;
 }
 
@@ -349,7 +351,8 @@ inline intptr_t* ThawBase::push_preempt_adapter() {
   intptr_t* sp = enterSpecial.sp();
 
   // We only need to set the return pc. rfp will be restored back in generate_cont_preempt_stub().
-  sp[-1] = (intptr_t)StubRoutines::cont_preempt_stub();
+  ContinuationHelper::patch_return_address_at(&sp[-1],
+                                              StubRoutines::cont_preempt_stub());
   return sp;
 }
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 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
@@ -47,7 +47,8 @@ static inline void patch_return_pc_with_preempt_stub(frame& f) {
     // Instead, we will patch the return from the runtime stub back to the
     // compiled method so that the target returns to the preempt cleanup stub.
     intptr_t* caller_sp = f.sp() + f.cb()->frame_size();
-    caller_sp[-1] = (intptr_t)StubRoutines::cont_preempt_stub();
+    ContinuationHelper::patch_return_address_at(&caller_sp[-1],
+                                                StubRoutines::cont_preempt_stub());
   } else {
     // The target will check for preemption once it returns to the interpreter
     // or the native wrapper code and will manually jump to the preempt stub.

src/hotspot/cpu/arm/arm_32.ad

@@ -430,18 +430,18 @@ OptoRegPair c2::return_value(int ideal_reg) {
 //       from the start of the call to the point where the return address
 //       will point.
 
-int MachCallStaticJavaNode::ret_addr_offset() {
+int MachCallStaticJavaNode::ret_addr_offset() const {
   bool far = (_method == nullptr) ? maybe_far_call(this) : !cache_reachable();
   return (far ? 3 : 1) * NativeInstruction::instruction_size;
 }
 
-int MachCallDynamicJavaNode::ret_addr_offset() {
+int MachCallDynamicJavaNode::ret_addr_offset() const {
   bool far = !cache_reachable();
   // mov_oop is always 2 words
   return (2 + (far ? 3 : 1)) * NativeInstruction::instruction_size;
 }
 
-int MachCallRuntimeNode::ret_addr_offset() {
+int MachCallRuntimeNode::ret_addr_offset() const {
   // bl or movw; movt; blx
   bool far = maybe_far_call(this);
   return (far ? 3 : 1) * NativeInstruction::instruction_size;

src/hotspot/cpu/ppc/macroAssembler_ppc.cpp

@@ -2763,6 +2763,11 @@ void MacroAssembler::compiler_fast_lock_object(ConditionRegister flag, Register
     const Register monitor    = UseObjectMonitorTable ? tmp1 : noreg;
     const Register owner_addr = tmp2;
     const Register thread_id  = UseObjectMonitorTable ? tmp3 : tmp1;
+    // Offsets into the current thread's object monitor cache (omc).
+    const ByteSize thr_omc_offset     = JavaThread::om_cache_offset();
+    const ByteSize omc_monitor_offset = OMCache::monitor_offset();
+    const ByteSize omc_obj_offset     = OMCache::obj_offset();
+
     Label monitor_locked;
 
     if (!UseObjectMonitorTable) {
@@ -2777,18 +2782,12 @@ void MacroAssembler::compiler_fast_lock_object(ConditionRegister flag, Register
       // Save the mark, we might need it to extract the hash.
       mr(tmp2_hash, mark);
 
-      // Look for the monitor in the om_cache.
-
-      ByteSize cache_offset   = JavaThread::om_cache_oops_offset();
-      ByteSize monitor_offset = OMCache::oop_to_monitor_difference();
-      const int num_unrolled  = OMCache::CAPACITY;
-      for (int i = 0; i < num_unrolled; i++) {
-        ld(R0, in_bytes(cache_offset), R16_thread);
-        ld(monitor, in_bytes(cache_offset + monitor_offset), R16_thread);
-        cmpd(CR0, R0, obj);
-        beq(CR0, monitor_found);
-        cache_offset = cache_offset + OMCache::oop_to_oop_difference();
-      }
+      // Look for the monitor in the current thread's object monitor cache (omc).
+
+      ld(R0, in_bytes(thr_omc_offset + omc_obj_offset), R16_thread);
+      ld(monitor, in_bytes(thr_omc_offset + omc_monitor_offset), R16_thread);
+      cmpd(CR0, R0, obj);
+      beq(CR0, monitor_found);
 
       // Look for the monitor in the table.
 
@@ -2817,6 +2816,10 @@ void MacroAssembler::compiler_fast_lock_object(ConditionRegister flag, Register
       cmpd(CR0, tmp3, obj);
       bne(CR0, slow_path);
 
+      // Store the monitor in the current thread's object monitor cache (omc).
+      std(monitor, in_bytes(thr_omc_offset + omc_monitor_offset), R16_thread);
+      std(obj, in_bytes(thr_omc_offset + omc_obj_offset), R16_thread);
+
       bind(monitor_found);
 
       // Compute owner address.
@@ -2854,6 +2857,7 @@ void MacroAssembler::compiler_fast_lock_object(ConditionRegister flag, Register
 
     bind(monitor_locked);
     if (UseObjectMonitorTable) {
+      // Cache the monitor for unlock.
       std(monitor, BasicLock::object_monitor_cache_offset_in_bytes(), box);
     }
   }

src/hotspot/cpu/ppc/ppc.ad

@@ -1171,16 +1171,16 @@ bool followed_by_acquire(const Node *load) {
 
 // PPC port: Removed use of lazy constant construct.
 
-int MachCallStaticJavaNode::ret_addr_offset() {
+int MachCallStaticJavaNode::ret_addr_offset() const {
   // It's only a single branch-and-link instruction.
   return 4;
 }
 
-int MachCallDynamicJavaNode::ret_addr_offset() {
+int MachCallDynamicJavaNode::ret_addr_offset() const {
   return 12;
 }
 
-int MachCallRuntimeNode::ret_addr_offset() {
+int MachCallRuntimeNode::ret_addr_offset() const {
   if (rule() == CallRuntimeDirect_rule) {
     // CallRuntimeDirectNode uses call_c.
 #if defined(ABI_ELFv2)

src/hotspot/cpu/riscv/c2_MacroAssembler_riscv.cpp

@@ -121,6 +121,10 @@ void C2_MacroAssembler::fast_lock(Register obj, Register box,
     bind(inflated);
 
     const Register tmp1_monitor = tmp1;
+    // Offsets into the current thread's object monitor cache (omc).
+    const ByteSize thr_omc_offset     = JavaThread::om_cache_offset();
+    const ByteSize omc_monitor_offset = OMCache::monitor_offset();
+    const ByteSize omc_obj_offset     = OMCache::obj_offset();
 
     if (!UseObjectMonitorTable) {
       assert(tmp1_monitor == tmp1_mark, "should be the same here");
@@ -132,17 +136,11 @@ void C2_MacroAssembler::fast_lock(Register obj, Register box,
       // Save the mark, we might need it to extract the hash.
       mv(tmp2_hash, tmp1_mark);
 
-      // Look for the monitor in the om_cache.
+      // Look for the monitor in the current thread's object monitor cache (omc).
 
-      ByteSize cache_offset   = JavaThread::om_cache_oops_offset();
-      ByteSize monitor_offset = OMCache::oop_to_monitor_difference();
-      const int num_unrolled  = OMCache::CAPACITY;
-      for (int i = 0; i < num_unrolled; i++) {
-        ld(tmp1_monitor, Address(xthread, cache_offset + monitor_offset));
-        ld(tmp4, Address(xthread, cache_offset));
-        beq(obj, tmp4, monitor_found);
-        cache_offset = cache_offset + OMCache::oop_to_oop_difference();
-      }
+      ld(tmp1_monitor, Address(xthread, thr_omc_offset + omc_monitor_offset));
+      ld(tmp4, Address(xthread, thr_omc_offset + omc_obj_offset));
+      beq(obj, tmp4, monitor_found);
 
       // Look for the monitor in the table.
 
@@ -170,6 +168,10 @@ void C2_MacroAssembler::fast_lock(Register obj, Register box,
       bs_asm->try_peek_weak_handle_in_nmethod(this, tmp3, tmp3, tmp2, slow_path);
       bne(tmp3, obj, slow_path);
 
+      // Store the monitor in the current thread's object monitor cache (omc).
+      sd(tmp1_monitor, Address(xthread, thr_omc_offset + omc_monitor_offset));
+      sd(obj, Address(xthread, thr_omc_offset + omc_obj_offset));
+
       bind(monitor_found);
     }
 
@@ -200,6 +202,7 @@ void C2_MacroAssembler::fast_lock(Register obj, Register box,
 
     bind(monitor_locked);
     if (UseObjectMonitorTable) {
+      // Cache the monitor for unlock.
       sd(tmp1_monitor, Address(box, BasicLock::object_monitor_cache_offset_in_bytes()));
     }
   }
@@ -3295,6 +3298,17 @@ void C2_MacroAssembler::extract_v(Register dst, VectorRegister src,
   }
 }
 
+// Extract a scalar element from a vector at position 'idx'.
+// The input elements in src are expected to be of integral type.
+void C2_MacroAssembler::extract_v(Register dst, VectorRegister src,
+                                  BasicType bt, Register idx, VectorRegister vtmp) {
+  assert(is_integral_type(bt), "unsupported element type");
+  // Only need the first element after vector slidedown
+  vsetvli_helper(bt, 1);
+  vslidedown_vx(vtmp, src, idx);
+  vmv_x_s(dst, vtmp);
+}
+
 // Extract a scalar element from an vector at position 'idx'.
 // The input elements in src are expected to be of floating point type.
 void C2_MacroAssembler::extract_fp_v(FloatRegister dst, VectorRegister src,

src/hotspot/cpu/riscv/c2_MacroAssembler_riscv.hpp

@@ -299,6 +299,9 @@
   void extract_v(Register dst, VectorRegister src,
                  BasicType bt, int idx, VectorRegister vtmp);
 
+  void extract_v(Register dst, VectorRegister src,
+                 BasicType bt, Register idx, VectorRegister vtmp);
+
   void extract_fp_v(FloatRegister dst, VectorRegister src,
                     BasicType bt, int idx, VectorRegister vtmp);
 

src/hotspot/cpu/riscv/gc/g1/g1BarrierSetAssembler_riscv.cpp

@@ -108,30 +108,29 @@ void G1BarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* mas
 
   __ srli(start, start, CardTable::card_shift());
   __ srli(count, count, CardTable::card_shift());
-  __ sub(count, count, start);                            // Number of bytes to mark - 1.
 
-  // Add card table base offset to start.
+  // Add card table base offset to get card addresses directly.
   Address card_table_address(xthread, G1ThreadLocalData::card_table_base_offset());
   __ ld(tmp, card_table_address);
-  __ add(start, start, tmp);
+  __ add(start, start, tmp);                              // start := first card address
+  __ add(count, count, tmp);                              // count := last card address
 
+  // Iterate from start card to end card (inclusive).
   __ bind(loop);
   if (UseCondCardMark) {
-    __ add(tmp, start, count);
-    __ lbu(tmp, Address(tmp, 0));
+    __ lbu(tmp, Address(start, 0));
     static_assert((uint)G1CardTable::clean_card_val() == 0xff, "must be");
     __ subi(tmp, tmp, G1CardTable::clean_card_val()); // Convert to clean_card_value() to a comparison
                                                       // against zero to avoid use of an extra temp.
     __ bnez(tmp, next);
   }
 
-  __ add(tmp, start, count);
   static_assert(G1CardTable::dirty_card_val() == 0, "must be to use zr");
-  __ sb(zr, Address(tmp, 0));
+  __ sb(zr, Address(start, 0));
 
   __ bind(next);
-  __ subi(count, count, 1);
-  __ bgez(count, loop);
+  __ addi(start, start, 1);
+  __ ble(start, count, loop);
 
   __ bind(done);
 }