8286300: Port JEP 425 to S390X

8338383: Implement JEP 491: Synchronize Virtual Threads without Pinning
8369238: Allow virtual thread preemption on some common class initialization paths

Author: offamitkumar

src/hotspot/cpu/s390/abstractInterpreter_s390.cpp

@@ -197,7 +197,8 @@ void AbstractInterpreter::layout_activation(Method* method,
     assert(is_bottom_frame && (sender_sp == caller->unextended_sp()),
            "must initialize sender_sp of bottom skeleton frame when pushing it");
   } else {
-    assert(caller->is_entry_frame() || caller->is_upcall_stub_frame(), "is there a new frame type??");
+    // FIXME: sender_sp correctly calculated for native frames ?
+    assert(caller->is_entry_frame() || caller->is_upcall_stub_frame() || caller->is_native_frame(), "is there a new frame type??");
     sender_sp = caller->sp(); // Call_stub only uses it's fp.
   }
 

src/hotspot/cpu/s390/assembler_s390.hpp

@@ -3279,6 +3279,9 @@ class Assembler : public AbstractAssembler {
   static bool is_z_nop(address x) {
     return is_z_nop(* (short *) x);
   }
+  static bool is_z_illtrap(address x) {
+    return *(uint16_t*)x == 0u;
+  }
   static bool is_z_br(long x) {
     return is_z_bcr(x) && ((x & 0x00f0) == 0x00f0);
   }

src/hotspot/cpu/s390/c1_LIRAssembler_s390.cpp

@@ -524,6 +524,7 @@ void LIR_Assembler::call(LIR_OpJavaCall* op, relocInfo::relocType rtype) {
   __ z_nop();
   __ z_brasl(Z_R14, op->addr());
   add_call_info(code_offset(), op->info());
+  __ post_call_nop();
 }
 
 void LIR_Assembler::ic_call(LIR_OpJavaCall* op) {
@@ -540,6 +541,7 @@ void LIR_Assembler::ic_call(LIR_OpJavaCall* op) {
   // to determine who we intended to call.
   __ relocate(virtual_call_Relocation::spec(virtual_call_oop_addr));
   call(op, relocInfo::none);
+  __ post_call_nop();
 }
 
 void LIR_Assembler::move_regs(Register from_reg, Register to_reg) {
@@ -2845,6 +2847,7 @@ void LIR_Assembler::rt_call(LIR_Opr result, address dest,
   if (info != nullptr) {
     add_call_info_here(info);
   }
+  __ post_call_nop();
 }
 
 void LIR_Assembler::volatile_move_op(LIR_Opr src, LIR_Opr dest, BasicType type, CodeEmitInfo* info) {

src/hotspot/cpu/s390/c1_Runtime1_s390.cpp

@@ -57,8 +57,8 @@ int StubAssembler::call_RT(Register oop_result1, Register metadata_result, addre
   // z_abi_160.gpr14 (e.g. InterpreterRuntime::_new()).
   // Therefore we load the PC into Z_R1_scratch and let set_last_Java_frame() save
   // it into the frame anchor.
-  address pc = get_PC(Z_R1_scratch);
-  int call_offset = (int)(pc - addr_at(0));
+  Label resume;
+  z_larl(Z_R1_scratch, resume);
   set_last_Java_frame(Z_SP, Z_R1_scratch);
 
   // ARG1 must hold thread address.
@@ -67,9 +67,12 @@ int StubAssembler::call_RT(Register oop_result1, Register metadata_result, addre
   address return_pc = nullptr;
   align_call_far_patchable(this->pc());
   return_pc = call_c_opt(entry_point);
+
+  bind(resume);
+  int call_offset = offset(); // (int)(return_pc - addr_at(0));
   assert(return_pc != nullptr, "const section overflow");
 
-  reset_last_Java_frame();
+  reset_last_Java_frame(/* check_last_java_sp= */ false);
 
   // Check for pending exceptions.
   {
@@ -208,8 +211,37 @@ void Runtime1::initialize_pd() {
 }
 
 uint Runtime1::runtime_blob_current_thread_offset(frame f) {
-  Unimplemented();
-  return 0;
+  CodeBlob* cb = f.cb();
+  assert(cb == Runtime1::blob_for(StubId::c1_monitorenter_id) ||
+         cb == Runtime1::blob_for(StubId::c1_monitorenter_nofpu_id), "must be");
+  assert(cb != nullptr && cb->is_runtime_stub(), "invalid frame");
+
+  // Calculate the offset of Z_thread (Z_R8) in the saved register area.
+  // Both c1_monitorenter_id and c1_monitorenter_nofpu_id have the same frame layout:
+  // - c1_monitorenter_id uses RegisterSaver::all_registers (saves FPU regs)
+  // - c1_monitorenter_nofpu_id uses RegisterSaver::all_integer_registers (excludes FPU regs but reserves space)
+  //
+  // From RegisterSaver_LiveRegs and RegisterSaver_LiveIntRegs:
+  // Both have 15 float register slots (F0, F2-F15, F1 is excluded as scratch)
+  // Then integer registers: R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13
+  // Z_thread is Z_R8, which is the 7th integer register (index 6 from R2)
+  //
+  // Stack layout from SP:
+  //   [0..159]     : z_abi_160
+  //   [160..279]   : 15 float register slots (15 * 8 = 120 bytes)
+  //   [280..327]   : R2-R7 (6 * 8 = 48 bytes)
+  //   [328..335]   : R8 (Z_thread) <- this is what we need
+  //
+  // Offset = 160 + 120 + 48 = 328 bytes from SP
+  // Return value is in 64-bit words: 328 / 8 = 41
+
+  const int float_reg_slots = 15;      // F0, F2-F15 (F1 is scratch, excluded)
+  const int int_regs_before_r8 = 6;    // R2, R3, R4, R5, R6, R7
+  const int z_thread_offset = frame::z_abi_160_size +
+                               (float_reg_slots * 8) +
+                               (int_regs_before_r8 * 8);
+
+  return z_thread_offset / 8;  // Convert to 64-bit words
 }
 
 OopMapSet* Runtime1::generate_exception_throw(StubAssembler* sasm, address target, bool has_argument) {

src/hotspot/cpu/s390/continuationEntry_s390.hpp

@@ -25,8 +25,11 @@
 #ifndef CPU_S390_CONTINUATIONENTRY_S390_HPP
 #define CPU_S390_CONTINUATIONENTRY_S390_HPP
 
+#include "runtime/frame.hpp"
+
 class ContinuationEntryPD {
-  // empty
+  // This is needed to position the ContinuationEntry at the unextended sp of the entry frame
+  frame::z_abi_160_base _abi;
 };
 
 #endif // CPU_S390_CONTINUATIONENTRY_S390_HPP

src/hotspot/cpu/s390/continuationEntry_s390.inline.hpp

@@ -25,22 +25,28 @@
 #ifndef CPU_S390_CONTINUATIONENTRY_S390_INLINE_HPP
 #define CPU_S390_CONTINUATIONENTRY_S390_INLINE_HPP
 
+#include "oops/method.inline.hpp"
+#include "runtime/frame.inline.hpp"
+#include "runtime/registerMap.hpp"
+#include "utilities/macros.hpp"
 #include "runtime/continuationEntry.hpp"
 
-// TODO: Implement
-
 inline frame ContinuationEntry::to_frame() const {
-  Unimplemented();
-  return frame();
+  static CodeBlob* cb = CodeCache::find_blob_fast(entry_pc());
+  assert(cb != nullptr, "");
+  assert(cb->as_nmethod()->method()->is_continuation_enter_intrinsic(), "");
+  return frame(entry_sp(), entry_pc(), entry_sp(), entry_fp(), cb);
 }
 
 inline intptr_t* ContinuationEntry::entry_fp() const {
-  Unimplemented();
-  return nullptr;
+  return (intptr_t*)((address)this + size());
 }
 
 inline void ContinuationEntry::update_register_map(RegisterMap* map) const {
-  Unimplemented();
+  // No register map update needed for s390.
+  // In the Java calling convention on s390, all registers are volatile (caller-saved),
+  // so there are no non-volatile (callee-saved) registers that need to be tracked
+  // in the register map for continuation entry frames.
 }
 
 #endif // CPU_S390_CONTINUATIONENTRY_S390_INLINE_HPP