Update to jdk-20+13

27971: failed to build after JDK-8290025
27970: LA port of 8282410: Remove SA ProcDebugger support
27969: LA port of 8292890: Remove PrintTouchedMethodsAtExit and LogTouchedMethods
27968: LA port of 8290025: Remove the Sweeper

Author: loongson-jvm

src/hotspot/cpu/loongarch/c1_MacroAssembler_loongarch_64.cpp

@@ -290,7 +290,7 @@ void C1_MacroAssembler::build_frame(int framesize, int bang_size_in_bytes) {
 
   // Insert nmethod entry barrier into frame.
   BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
-  bs->nmethod_entry_barrier(this);
+  bs->nmethod_entry_barrier(this, NULL /* slow_path */, NULL /* continuation */, NULL /* guard */);
 }
 
 void C1_MacroAssembler::remove_frame(int framesize) {

src/hotspot/cpu/loongarch/c2_MacroAssembler_loongarch.cpp

@@ -1731,3 +1731,17 @@ bool C2_MacroAssembler::in_scratch_emit_size() {
   }
   return MacroAssembler::in_scratch_emit_size();
 }
+
+void C2_MacroAssembler::emit_entry_barrier_stub(C2EntryBarrierStub* stub) {
+  bind(stub->slow_path());
+  call_long(StubRoutines::la::method_entry_barrier());
+  b(stub->continuation());
+
+  bind(stub->guard());
+  relocate(entry_guard_Relocation::spec());
+  emit_int32(0);  // nmethod guard value
+}
+
+int C2_MacroAssembler::entry_barrier_stub_size() {
+  return 5 * 4;
+}

src/hotspot/cpu/loongarch/c2_MacroAssembler_loongarch.hpp

@@ -47,8 +47,8 @@
 #define T8 RT8
 
 public:
-  void emit_entry_barrier_stub(C2EntryBarrierStub* stub) {}
-  static int entry_barrier_stub_size() { return 0; }
+  void emit_entry_barrier_stub(C2EntryBarrierStub* stub);
+  static int entry_barrier_stub_size();
 
   void cmp_branch_short(int flag, Register op1, Register op2, Label& L, bool is_signed);
   void cmp_branch_long(int flag, Register op1, Register op2, Label* L, bool is_signed);

src/hotspot/cpu/loongarch/frame_loongarch.cpp

@@ -162,16 +162,11 @@ bool frame::safe_for_sender(JavaThread *thread) {
     }
 
     // We must always be able to find a recognizable pc
-    CodeBlob* sender_blob = CodeCache::find_blob_unsafe(sender_pc);
+    CodeBlob* sender_blob = CodeCache::find_blob(sender_pc);
     if (sender_pc == NULL ||  sender_blob == NULL) {
       return false;
     }
 
-    // Could be a zombie method
-    if (sender_blob->is_zombie() || sender_blob->is_unloaded()) {
-      return false;
-    }
-
     // Could just be some random pointer within the codeBlob
     if (!sender_blob->code_contains(sender_pc)) {
       return false;

src/hotspot/cpu/loongarch/frame_loongarch.inline.hpp

@@ -112,10 +112,8 @@ inline frame::frame(intptr_t* ptr_sp, intptr_t* ptr_fp) {
   _pc = (address)(ptr_sp[-1]);
 
   // Here's a sticky one. This constructor can be called via AsyncGetCallTrace
-  // when last_Java_sp is non-null but the pc fetched is junk. If we are truly
-  // unlucky the junk value could be to a zombied method and we'll die on the
-  // find_blob call. This is also why we can have no asserts on the validity
-  // of the pc we find here. AsyncGetCallTrace -> pd_get_top_frame_for_signal_handler
+  // when last_Java_sp is non-null but the pc fetched is junk.
+  // AsyncGetCallTrace -> pd_get_top_frame_for_signal_handler
   // -> pd_last_frame should use a specialized version of pd_last_frame which could
   // call a specilaized frame constructor instead of this one.
   // Then we could use the assert below. However this assert is of somewhat dubious

src/hotspot/cpu/loongarch/gc/g1/g1BarrierSetAssembler_loongarch.cpp

@@ -192,12 +192,7 @@ void G1BarrierSetAssembler::g1_write_barrier_pre(MacroAssembler* masm,
   __ b(done);
 
   __ bind(runtime);
-  // save the live input values
-  if (tosca_live) __ push(V0);
-
-  if (obj != noreg && obj != V0) __ push(obj);
-
-  if (pre_val != V0) __ push(pre_val);
+  __ push_call_clobbered_registers();
 
   // Calling the runtime using the regular call_VM_leaf mechanism generates
   // code (generated by InterpreterMacroAssember::call_VM_leaf_base)
@@ -220,14 +215,7 @@ void G1BarrierSetAssembler::g1_write_barrier_pre(MacroAssembler* masm,
     __ call_VM_leaf(CAST_FROM_FN_PTR(address, G1BarrierSetRuntime::write_ref_field_pre_entry), pre_val, thread);
   }
 
-  // save the live input values
-  if (pre_val != V0)
-    __ pop(pre_val);
-
-  if (obj != noreg && obj != V0)
-    __ pop(obj);
-
-  if (tosca_live) __ pop(V0);
+  __ pop_call_clobbered_registers();
 
   __ bind(done);
 }

src/hotspot/cpu/loongarch/gc/shared/barrierSetAssembler_loongarch.cpp

@@ -217,32 +217,97 @@ void BarrierSetAssembler::incr_allocated_bytes(MacroAssembler* masm,
   __ st_d(t1, Address(TREG, JavaThread::allocated_bytes_offset()));
 }
 
-void BarrierSetAssembler::nmethod_entry_barrier(MacroAssembler* masm) {
+static volatile uint32_t _patching_epoch = 0;
+
+address BarrierSetAssembler::patching_epoch_addr() {
+  return (address)&_patching_epoch;
+}
+
+void BarrierSetAssembler::increment_patching_epoch() {
+  Atomic::inc(&_patching_epoch);
+}
+
+void BarrierSetAssembler::clear_patching_epoch() {
+  _patching_epoch = 0;
+}
+
+void BarrierSetAssembler::nmethod_entry_barrier(MacroAssembler* masm, Label* slow_path, Label* continuation, Label* guard) {
   BarrierSetNMethod* bs_nm = BarrierSet::barrier_set()->barrier_set_nmethod();
 
   if (bs_nm == NULL) {
     return;
   }
 
-  Label skip, guard;
-  Address thread_disarmed_addr(TREG, in_bytes(bs_nm->thread_disarmed_offset()));
+  Label local_guard;
+  NMethodPatchingType patching_type = nmethod_patching_type();
 
-  __ lipc(SCR1, guard);
-  __ ld_w(SCR1, SCR1, 0);
+  if (slow_path == NULL) {
+    guard = &local_guard;
+  }
 
-  // Subsequent loads of oops must occur after load of guard value.
-  // BarrierSetNMethod::disarm sets guard with release semantics.
-  __ membar(__ LoadLoad);
-  __ ld_w(SCR2, thread_disarmed_addr);
-  __ beq(SCR1, SCR2, skip);
+  __ lipc(SCR1, *guard);
+  __ ld_wu(SCR1, SCR1, 0);
+
+  switch (patching_type) {
+    case NMethodPatchingType::conc_data_patch:
+      // Subsequent loads of oops must occur after load of guard value.
+      // BarrierSetNMethod::disarm sets guard with release semantics.
+      __ membar(__ LoadLoad); // fall through to stw_instruction_and_data_patch
+    case NMethodPatchingType::stw_instruction_and_data_patch:
+      {
+        // With STW patching, no data or instructions are updated concurrently,
+        // which means there isn't really any need for any fencing for neither
+        // data nor instruction modification happening concurrently. The
+        // instruction patching is synchronized with global icache_flush() by
+        // the write hart on riscv. So here we can do a plain conditional
+        // branch with no fencing.
+        Address thread_disarmed_addr(TREG, in_bytes(bs_nm->thread_disarmed_offset()));
+        __ ld_wu(SCR2, thread_disarmed_addr);
+        break;
+      }
+    case NMethodPatchingType::conc_instruction_and_data_patch:
+      {
+        // If we patch code we need both a code patching and a loadload
+        // fence. It's not super cheap, so we use a global epoch mechanism
+        // to hide them in a slow path.
+        // The high level idea of the global epoch mechanism is to detect
+        // when any thread has performed the required fencing, after the
+        // last nmethod was disarmed. This implies that the required
+        // fencing has been performed for all preceding nmethod disarms
+        // as well. Therefore, we do not need any further fencing.
+        __ lea(SCR2, ExternalAddress((address)&_patching_epoch));
+        // Embed an artificial data dependency to order the guard load
+        // before the epoch load.
+        __ srli_d(RA, SCR1, 32);
+        __ orr(SCR2, SCR2, RA);
+        // Read the global epoch value.
+        __ ld_wu(SCR2, SCR2);
+        // Combine the guard value (low order) with the epoch value (high order).
+        __ slli_d(SCR2, SCR2, 32);
+        __ orr(SCR1, SCR1, SCR2);
+        // Compare the global values with the thread-local values
+        Address thread_disarmed_and_epoch_addr(TREG, in_bytes(bs_nm->thread_disarmed_offset()));
+        __ ld_d(SCR2, thread_disarmed_and_epoch_addr);
+        break;
+      }
+    default:
+      ShouldNotReachHere();
+  }
 
-  __ call_long(StubRoutines::la::method_entry_barrier());
-  __ b(skip);
+  if (slow_path == NULL) {
+    Label skip_barrier;
+    __ beq(SCR1, SCR2, skip_barrier);
 
-  __ bind(guard);
-  __ emit_int32(0);   // nmethod guard value. Skipped over in common case.
+    __ call_long(StubRoutines::la::method_entry_barrier());
+    __ b(skip_barrier);
 
-  __ bind(skip);
+    __ bind(local_guard);
+    __ emit_int32(0);   // nmethod guard value. Skipped over in common case.
+    __ bind(skip_barrier);
+  } else {
+    __ bne(SCR1, SCR2, *slow_path);
+    __ bind(*continuation);
+  }
 }
 
 void BarrierSetAssembler::c2i_entry_barrier(MacroAssembler* masm) {

src/hotspot/cpu/loongarch/gc/shared/barrierSetAssembler_loongarch.hpp

@@ -34,6 +34,12 @@
 
 class InterpreterMacroAssembler;
 
+enum class NMethodPatchingType {
+  stw_instruction_and_data_patch,
+  conc_instruction_and_data_patch,
+  conc_data_patch
+};
+
 class BarrierSetAssembler: public CHeapObj<mtGC> {
 private:
   void incr_allocated_bytes(MacroAssembler* masm,
@@ -77,9 +83,14 @@ class BarrierSetAssembler: public CHeapObj<mtGC> {
 
   virtual void barrier_stubs_init() {}
 
-  virtual void nmethod_entry_barrier(MacroAssembler* masm);
+  virtual NMethodPatchingType nmethod_patching_type() { return NMethodPatchingType::stw_instruction_and_data_patch; }
+
+  virtual void nmethod_entry_barrier(MacroAssembler* masm, Label* slow_path, Label* continuation, Label* guard);
   virtual void c2i_entry_barrier(MacroAssembler* masm);
 
+  static address patching_epoch_addr();
+  static void clear_patching_epoch();
+  static void increment_patching_epoch();
 };
 
 #endif // CPU_LOONGARCH_GC_SHARED_BARRIERSETASSEMBLER_LOONGARCH_HPP

src/hotspot/cpu/loongarch/gc/shared/barrierSetNMethod_loongarch.cpp

@@ -26,6 +26,7 @@
 #include "precompiled.hpp"
 #include "code/codeCache.hpp"
 #include "code/nativeInst.hpp"
+#include "gc/shared/barrierSetAssembler.hpp"
 #include "gc/shared/barrierSetNMethod.hpp"
 #include "logging/log.hpp"
 #include "memory/resourceArea.hpp"
@@ -36,20 +37,57 @@
 #include "utilities/align.hpp"
 #include "utilities/debug.hpp"
 
+static int slow_path_size(nmethod* nm) {
+  // The slow path code is out of line with C2.
+  // Leave a b to the stub in the fast path.
+  return nm->is_compiled_by_c2() ? 1 : 6;
+}
+
+static int entry_barrier_offset(nmethod* nm) {
+  BarrierSetAssembler* bs_asm = BarrierSet::barrier_set()->barrier_set_assembler();
+  switch (bs_asm->nmethod_patching_type()) {
+    case NMethodPatchingType::stw_instruction_and_data_patch:
+      return -4 * (3 + slow_path_size(nm));
+    case NMethodPatchingType::conc_data_patch:
+      return -4 * (4 + slow_path_size(nm));
+    case NMethodPatchingType::conc_instruction_and_data_patch:
+      return -4 * (9 + slow_path_size(nm));
+  }
+  ShouldNotReachHere();
+  return 0;
+}
+
 class NativeNMethodBarrier: public NativeInstruction {
   address instruction_address() const { return addr_at(0); }
 
-  int *guard_addr() {
-    return reinterpret_cast<int*>(instruction_address() + 9 * 4);
+  int local_guard_offset(nmethod* nm) {
+    // It's the last instruction
+    return (-entry_barrier_offset(nm)) - 4;
+  }
+
+  int *guard_addr(nmethod* nm) {
+    if (nm->is_compiled_by_c2()) {
+      // With c2 compiled code, the guard is out-of-line in a stub
+      // We find it using the RelocIterator.
+      RelocIterator iter(nm);
+      while (iter.next()) {
+        if (iter.type() == relocInfo::entry_guard_type) {
+          entry_guard_Relocation* const reloc = iter.entry_guard_reloc();
+          return reinterpret_cast<int*>(reloc->addr());
+        }
+      }
+      ShouldNotReachHere();
+    }
+    return reinterpret_cast<int*>(instruction_address() + local_guard_offset(nm));
   }
 
 public:
-  int get_value() {
-    return Atomic::load_acquire(guard_addr());
+  int get_value(nmethod* nm) {
+    return Atomic::load_acquire(guard_addr(nm));
   }
 
-  void set_value(int value) {
-    Atomic::release_store(guard_addr(), value);
+  void set_value(nmethod* nm, int value) {
+    Atomic::release_store(guard_addr(nm), value);
   }
 
   void verify() const;
@@ -64,14 +102,7 @@ struct CheckInsn {
 
 static const struct CheckInsn barrierInsn[] = {
   { 0xfe000000, 0x18000000, "pcaddi"},
-  { 0xffc00000, 0x28800000, "ld.w"},
-  { 0xffff8000, 0x38720000, "dbar"},
-  { 0xffc00000, 0x28800000, "ld.w"},
-  { 0xfc000000, 0x58000000, "beq"},
-  { 0xfe000000, 0x14000000, "lu12i.w"},
-  { 0xfe000000, 0x16000000, "lu32i.d"},
-  { 0xfc000000, 0x4c000000, "jirl"},
-  { 0xfc000000, 0x50000000, "b"}
+  { 0xffc00000, 0x2a800000, "ld.wu"},
 };
 
 // The encodings must match the instructions emitted by
@@ -123,17 +154,8 @@ void BarrierSetNMethod::deoptimize(nmethod* nm, address* return_address_ptr) {
   new_frame->pc = SharedRuntime::get_handle_wrong_method_stub();
 }
 
-// This is the offset of the entry barrier from where the frame is completed.
-// If any code changes between the end of the verified entry where the entry
-// barrier resides, and the completion of the frame, then
-// NativeNMethodCmpBarrier::verify() will immediately complain when it does
-// not find the expected native instruction at this offset, which needs updating.
-// Note that this offset is invariant of PreserveFramePointer.
-
-static const int entry_barrier_offset = -4 * 10;
-
 static NativeNMethodBarrier* native_nmethod_barrier(nmethod* nm) {
-  address barrier_address = nm->code_begin() + nm->frame_complete_offset() + entry_barrier_offset;
+  address barrier_address = nm->code_begin() + nm->frame_complete_offset() + entry_barrier_offset(nm);
   NativeNMethodBarrier* barrier = reinterpret_cast<NativeNMethodBarrier*>(barrier_address);
   debug_only(barrier->verify());
   return barrier;
@@ -144,15 +166,40 @@ void BarrierSetNMethod::disarm(nmethod* nm) {
     return;
   }
 
+  // The patching epoch is incremented before the nmethod is disarmed. Disarming
+  // is performed with a release store. In the nmethod entry barrier, the values
+  // are read in the opposite order, such that the load of the nmethod guard
+  // acquires the patching epoch. This way, the guard is guaranteed to block
+  // entries to the nmethod, util it has safely published the requirement for
+  // further fencing by mutators, before they are allowed to enter.
+  BarrierSetAssembler* bs_asm = BarrierSet::barrier_set()->barrier_set_assembler();
+  bs_asm->increment_patching_epoch();
+
   // Disarms the nmethod guard emitted by BarrierSetAssembler::nmethod_entry_barrier.
   // Symmetric "LD.W; DBAR" is in the nmethod barrier.
   NativeNMethodBarrier* barrier = native_nmethod_barrier(nm);
 
-  barrier->set_value(disarmed_value());
+  barrier->set_value(nm, disarmed_value());
 }
 
 void BarrierSetNMethod::arm(nmethod* nm, int arm_value) {
-  Unimplemented();
+  if (!supports_entry_barrier(nm)) {
+    return;
+  }
+
+  if (arm_value == disarmed_value()) {
+    // The patching epoch is incremented before the nmethod is disarmed. Disarming
+    // is performed with a release store. In the nmethod entry barrier, the values
+    // are read in the opposite order, such that the load of the nmethod guard
+    // acquires the patching epoch. This way, the guard is guaranteed to block
+    // entries to the nmethod, until it has safely published the requirement for
+    // further fencing by mutators, before they are allowed to enter.
+    BarrierSetAssembler* bs_asm = BarrierSet::barrier_set()->barrier_set_assembler();
+    bs_asm->increment_patching_epoch();
+  }
+
+  NativeNMethodBarrier* barrier = native_nmethod_barrier(nm);
+  barrier->set_value(nm, arm_value);
 }
 
 bool BarrierSetNMethod::is_armed(nmethod* nm) {
@@ -161,5 +208,5 @@ bool BarrierSetNMethod::is_armed(nmethod* nm) {
   }
 
   NativeNMethodBarrier* barrier = native_nmethod_barrier(nm);
-  return barrier->get_value() != disarmed_value();
+  return barrier->get_value(nm) != disarmed_value();
 }