templateInterpreterGenerator_s390 finished

Author: offamitkumar

src/hotspot/cpu/s390/interp_masm_s390.cpp

@@ -211,6 +211,7 @@ void InterpreterMacroAssembler::call_VM_preemptable(Register oop_result, address
 }
 
 void InterpreterMacroAssembler::restore_after_resume(Register fp) {
+  // TODO: What's the use of "fp" register coming as an argument ?
   if (!Continuations::enabled()) return;
   load_const_optimized(Z_R1, Interpreter::cont_resume_interpreter_adapter());
   call(Z_R1);

src/hotspot/cpu/s390/interp_masm_s390.hpp

@@ -50,7 +50,6 @@ class InterpreterMacroAssembler: public MacroAssembler {
                             Label *last_java_pc);
 
   void call_VM_preemptable(Register oop_result, address entry_point, Register arg_1, bool check_exceptions = true);
-  void restore_after_resume(Register fp);
 
   // Base routine for all dispatches.
   void dispatch_base(TosState state, address* table, bool generate_poll = false);
@@ -59,6 +58,7 @@ class InterpreterMacroAssembler: public MacroAssembler {
   InterpreterMacroAssembler(CodeBuffer* c)
     : MacroAssembler(c) {}
 
+  void restore_after_resume(Register fp);
   virtual void check_and_handle_popframe(Register java_thread);
   virtual void check_and_handle_earlyret(Register java_thread);
 

src/hotspot/cpu/s390/macroAssembler_s390.hpp

@@ -812,7 +812,7 @@ class MacroAssembler: public Assembler {
   inline void set_last_Java_frame_static(Register last_java_sp, Register last_Java_pc);
   inline void reset_last_Java_frame(void);
   inline void reset_last_Java_frame_static(void);
-  inline void set_top_ijava_frame_at_SP_as_last_Java_frame(Register sp, Register tmp1);
+  inline void set_top_ijava_frame_at_SP_as_last_Java_frame(Register sp, Register tmp1, Label* jpc = nullptr);
   inline void set_top_ijava_frame_at_SP_as_last_Java_frame_static(Register sp, Register tmp1);
 
   void set_thread_state(JavaThreadState new_state);

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

@@ -303,8 +303,8 @@ inline void MacroAssembler::reset_last_Java_frame_static(void) {
   reset_last_Java_frame(false);
 }
 
-inline void MacroAssembler::set_top_ijava_frame_at_SP_as_last_Java_frame(Register sp, Register tmp1) {
-  set_top_ijava_frame_at_SP_as_last_Java_frame(sp, tmp1, true);
+inline void MacroAssembler::set_top_ijava_frame_at_SP_as_last_Java_frame(Register sp, Register tmp1, Label *jpc) {
+  set_top_ijava_frame_at_SP_as_last_Java_frame(sp, tmp1, true, jpc);
 }
 
 inline void MacroAssembler::set_top_ijava_frame_at_SP_as_last_Java_frame_static(Register sp, Register tmp1) {

src/hotspot/cpu/s390/templateInterpreterGenerator_s390.cpp

@@ -1487,8 +1487,13 @@ address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {
 
   __ bind(call_signature_handler);
 
+  bool support_vthread_preemption = Continuations::enabled();
+
   // We have a TOP_IJAVA_FRAME here, which belongs to us.
-  __ set_top_ijava_frame_at_SP_as_last_Java_frame(Z_SP, Z_R1/*tmp*/);
+  Label last_java_pc;
+  Label *resume_pc = support_vthread_preemption ? &last_java_pc : nullptr;
+
+  __ set_top_ijava_frame_at_SP_as_last_Java_frame(Z_SP, Z_R1/*tmp*/, resume_pc);
 
   // Call signature handler and pass locals address in Z_ARG1.
   __ z_lgr(Z_ARG1, Z_locals);
@@ -1545,7 +1550,17 @@ address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {
   // overwritten since "__ call_stub(signature_handler);" (except for
   // ARG1 and ARG2 for static methods).
 
-  // TODO: https://bugs.openjdk.org/browse/JDK-8338383
+  if (support_vthread_preemption) {
+    // Rresult_handler is a nonvolatile register. Its value will be preserved across
+    // the native call but only if the call isn't preempted. To preserve its value even
+    // in the case of preemption we save it in the lresult slot. It is restored at
+    // resume_pc if, and only if the call was preempted. This works because only
+    // j.l.Object::wait calls are preempted which don't return a result.
+
+    // TODO: are we sure this is Z_fp and not Z_SP
+    // TODO: are we sure this will survive till here ?
+    __ z_stg(Rresult_handler, _z_ijava_state_neg(lresult), Z_fp);
+  }
   __ push_cont_fastpath();
   __ call_c(Z_R1/*native_method_entry*/);
   __ pop_cont_fastpath();
@@ -1632,6 +1647,32 @@ address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {
   __ z_lg(Z_bcp, Address(Rmethod, Method::const_offset())); // get constMethod
   __ add2reg(Z_bcp, in_bytes(ConstMethod::codes_offset())); // get codebase
 
+  if (support_vthread_preemption) {
+    // Check preemption for Object.wait()
+    Label not_preempted;
+    __ z_ltg(Z_R1_scratch, Address(Z_thread, JavaThread::preempt_alternate_return_offset()));
+    __ z_brz(not_preempted); // if 0, jump to not_preempted
+    __ z_mvghi(Address(Z_thread, JavaThread::preempt_alternate_return_offset()), 0);
+    __ call(Z_R1);
+
+    // Execution will be resumed here when the vthread becomes runnable again.
+    __ bind(*resume_pc);
+    __ restore_after_resume(Z_fp /* fp */);
+    // We saved the result handler before the call
+    __ z_lg(Rresult_handler, _z_ijava_state_neg(lresult), Z_fp);
+#ifdef ASSERT
+    // Clobber result slots. Only native methods returning void can be preemted currently.
+    __ load_const(Z_RET, UCONST64(0xbad01001));
+    __ z_stg(Z_RET, _z_ijava_state_neg(lresult), Z_fp);
+    __ z_stg(Z_RET, _z_ijava_state_neg(fresult), Z_fp);
+    // reset_last_Java_frame() below asserts that a last java sp is set
+    __ asm_assert_mem8_is_zero(in_bytes(JavaThread::last_Java_sp_offset()),
+         Z_thread, FILE_AND_LINE ": Last java sp should not be set when resuming", 69);
+    __ z_stg(Z_RET, in_bytes(JavaThread::last_Java_sp_offset()), Z_thread);
+#endif
+    __ bind(not_preempted);
+  }
+
   if (CheckJNICalls) {
     // clear_pending_jni_exception_check
     __ clear_mem(Address(Z_thread, JavaThread::pending_jni_exception_check_fn_offset()), sizeof(oop));