PPC64 implementation.

Author: TheRealMDoerr

src/hotspot/cpu/ppc/c1_CodeStubs_ppc.cpp

@@ -41,25 +41,8 @@ void C1SafepointPollStub::emit_code(LIR_Assembler* ce) {
   if (UseSIGTRAP) {
     DEBUG_ONLY( __ should_not_reach_here("C1SafepointPollStub::emit_code"); )
   } else {
-    assert(SharedRuntime::polling_page_return_handler_blob() != nullptr,
-           "polling page return stub not created yet");
-    address stub = SharedRuntime::polling_page_return_handler_blob()->entry_point();
-
     __ bind(_entry);
-    // Using pc relative address computation.
-    {
-      Label next_pc;
-      __ bl(next_pc);
-      __ bind(next_pc);
-    }
-    int current_offset = __ offset();
-    __ mflr(R12);
-    __ add_const_optimized(R12, R12, safepoint_offset() - current_offset);
-    __ std(R12, in_bytes(JavaThread::saved_exception_pc_offset()), R16_thread);
-
-    __ add_const_optimized(R0, R29_TOC, MacroAssembler::offset_to_global_toc(stub));
-    __ mtctr(R0);
-    __ bctr();
+    __ jump_to_polling_page_return_handler_blob(safepoint_offset());
   }
 }
 

src/hotspot/cpu/ppc/c2_CodeStubs_ppc.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2021, 2022, SAP SE. All rights reserved.
+ * Copyright (c) 2021, 2025 SAP SE. 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
@@ -34,26 +34,8 @@ int C2SafepointPollStub::max_size() const {
 }
 
 void C2SafepointPollStub::emit(C2_MacroAssembler& masm) {
-  assert(SharedRuntime::polling_page_return_handler_blob() != nullptr,
-         "polling page return stub not created yet");
-  address stub = SharedRuntime::polling_page_return_handler_blob()->entry_point();
-
   __ bind(entry());
-  // Using pc relative address computation.
-  {
-    Label next_pc;
-    __ bl(next_pc);
-    __ bind(next_pc);
-  }
-  int current_offset = __ offset();
   // Code size should not depend on offset: see _stub_size computation in output.cpp
-  __ load_const32(R12, _safepoint_offset - current_offset);
-  __ mflr(R0);
-  __ add(R12, R12, R0);
-  __ std(R12, in_bytes(JavaThread::saved_exception_pc_offset()), R16_thread);
-
-  __ add_const_optimized(R0, R29_TOC, MacroAssembler::offset_to_global_toc(stub));
-  __ mtctr(R0);
-  __ bctr();
+  __ jump_to_polling_page_return_handler_blob(_safepoint_offset, true);
 }
 #undef __

src/hotspot/cpu/ppc/frame_ppc.hpp

@@ -363,7 +363,7 @@
   inline frame(intptr_t* sp, intptr_t* fp, address pc);
   inline frame(intptr_t* sp, address pc, kind knd = kind::nmethod);
   inline frame(intptr_t* sp, address pc, intptr_t* unextended_sp, intptr_t* fp = nullptr, CodeBlob* cb = nullptr);
-  inline frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc, CodeBlob* cb, const ImmutableOopMap* oop_map);
+  inline frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc, CodeBlob* cb, const ImmutableOopMap* oop_map = nullptr);
   inline frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc, CodeBlob* cb, const ImmutableOopMap* oop_map, bool on_heap);
 
  private:

src/hotspot/cpu/ppc/frame_ppc.inline.hpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2012, 2024 SAP SE. All rights reserved.
+ * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2025 SAP SE. 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
@@ -391,4 +391,43 @@ void frame::update_map_with_saved_link(RegisterMapT* map, intptr_t** link_addr)
   // Nothing to do.
 }
 
+#if INCLUDE_JFR
+
+// Static helper routines
+inline intptr_t* frame::sender_sp(intptr_t* fp) { return fp; }
+
+// Extract common_abi parts.
+inline intptr_t* frame::fp(const intptr_t* sp) {
+  assert(sp != nullptr, "invariant");
+  return reinterpret_cast<intptr_t*>(((common_abi*)sp)->callers_sp);
+}
+
+inline intptr_t* frame::link(const intptr_t* fp) { return frame::fp(fp); }
+
+inline address frame::return_address(const intptr_t* sp) {
+  assert(sp != nullptr, "invariant");
+  return reinterpret_cast<address>(((common_abi*)sp)->lr);
+}
+
+inline address frame::interpreter_return_address(const intptr_t* fp) { return frame::return_address(fp); }
+
+// Extract java interpreter state parts.
+inline address frame::interpreter_bcp(const intptr_t* fp) {
+  assert(fp != nullptr, "invariant");
+  return reinterpret_cast<address>(*(fp + ijava_idx(bcp)));
+}
+
+inline intptr_t* frame::interpreter_sender_sp(const intptr_t* fp) {
+  assert(fp != nullptr, "invariant");
+  return reinterpret_cast<intptr_t*>(*(fp + ijava_idx(sender_sp)));
+}
+
+inline bool frame::is_interpreter_frame_setup_at(const intptr_t* fp, const void* sp) {
+  assert(fp != nullptr, "invariant");
+  assert(sp != nullptr, "invariant");
+  return sp <= fp - ((frame::ijava_state_size + frame::top_ijava_frame_abi_size) >> LogBytesPerWord);
+}
+
+#endif // INCLUDE_JFR
+
 #endif // CPU_PPC_FRAME_PPC_INLINE_HPP

src/hotspot/cpu/ppc/interp_masm_ppc.hpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2012, 2023 SAP SE. All rights reserved.
+ * Copyright (c) 2002, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2025 SAP SE. 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
@@ -170,7 +170,11 @@ class InterpreterMacroAssembler: public MacroAssembler {
   void remove_activation(TosState state,
                          bool throw_monitor_exception = true,
                          bool install_monitor_exception = true);
-  void merge_frames(Register Rtop_frame_sp, Register return_pc, Register Rscratch1, Register Rscratch2); // merge top frames
+  JFR_ONLY(void enter_jfr_critical_section();)
+  JFR_ONLY(void leave_jfr_critical_section();)
+  void load_fp(Register fp);
+  void remove_top_frame_given_fp(Register fp, Register sender_sp, Register sender_fp, Register return_pc, Register temp);
+  void merge_frames(Register sender_sp, Register return_pc, Register temp1, Register temp2); // merge top frames
 
   void add_monitor_to_stack(bool stack_is_empty, Register Rtemp1, Register Rtemp2);
 

src/hotspot/cpu/ppc/interp_masm_ppc_64.cpp

@@ -793,19 +793,27 @@ void InterpreterMacroAssembler::unlock_if_synchronized_method(TosState state,
 }
 
 // Support function for remove_activation & Co.
-void InterpreterMacroAssembler::merge_frames(Register Rsender_sp, Register return_pc,
-                                             Register Rscratch1, Register Rscratch2) {
-  // Pop interpreter frame.
-  ld(Rscratch1, 0, R1_SP); // *SP
-  ld(Rsender_sp, _ijava_state_neg(sender_sp), Rscratch1); // top_frame_sp
-  ld(Rscratch2, 0, Rscratch1); // **SP
-  if (return_pc!=noreg) {
-    ld(return_pc, _abi0(lr), Rscratch1); // LR
+void InterpreterMacroAssembler::load_fp(Register fp) {
+  ld(fp, _abi0(callers_sp), R1_SP); // *SP
+}
+
+void InterpreterMacroAssembler::remove_top_frame_given_fp(Register fp, Register sender_sp, Register sender_fp,
+                                                          Register return_pc, Register temp) {
+  assert_different_registers(sender_sp, sender_fp, return_pc, temp);
+  ld(sender_sp, _ijava_state_neg(sender_sp), fp);
+  ld(sender_fp, _abi0(callers_sp), fp); // **SP
+  if (return_pc != noreg) {
+    ld(return_pc, _abi0(lr), fp); // last usage of fp, register can be reused
   }
+  subf(temp, R1_SP, sender_sp);   // sender_sp - SP
+  stdux(sender_fp, R1_SP, temp);  // atomically set *(SP = sender_sp) = sender_fp
+}
 
-  // Merge top frames.
-  subf(Rscratch1, R1_SP, Rsender_sp); // top_frame_sp - SP
-  stdux(Rscratch2, R1_SP, Rscratch1); // atomically set *(SP = top_frame_sp) = **SP
+void InterpreterMacroAssembler::merge_frames(Register sender_sp, Register return_pc,
+                                             Register temp1, Register temp2) {
+  Register fp = temp1, sender_fp = temp2;
+  load_fp(fp);
+  remove_top_frame_given_fp(fp, sender_sp, sender_fp, return_pc, /* temp */ fp);
 }
 
 void InterpreterMacroAssembler::narrow(Register result) {
@@ -864,11 +872,16 @@ void InterpreterMacroAssembler::remove_activation(TosState state,
                                                   bool install_monitor_exception) {
   BLOCK_COMMENT("remove_activation {");
 
+  unlock_if_synchronized_method(state, throw_monitor_exception, install_monitor_exception);
+
   // The below poll is for the stack watermark barrier. It allows fixing up frames lazily,
   // that would normally not be safe to use. Such bad returns into unsafe territory of
   // the stack, will call InterpreterRuntime::at_unwind.
-  Label slow_path;
-  Label fast_path;
+  Label slow_path, fast_path;
+  Register fp = R22_tmp2;
+  load_fp(fp);
+
+  JFR_ONLY(enter_jfr_critical_section();)
   safepoint_poll(slow_path, R11_scratch1, true /* at_return */, false /* in_nmethod */);
   b(fast_path);
   bind(slow_path);
@@ -880,8 +893,6 @@ void InterpreterMacroAssembler::remove_activation(TosState state,
   align(32);
   bind(fast_path);
 
-  unlock_if_synchronized_method(state, throw_monitor_exception, install_monitor_exception);
-
   // Save result (push state before jvmti call and pop it afterwards) and notify jvmti.
   notify_method_exit(false, state, NotifyJVMTI, true);
 
@@ -901,10 +912,11 @@ void InterpreterMacroAssembler::remove_activation(TosState state,
     // call could have a smaller SP, so that this compare succeeds for an
     // inner call of the method annotated with ReservedStack.
     ld_ptr(R0, JavaThread::reserved_stack_activation_offset(), R16_thread);
-    ld_ptr(R11_scratch1, _abi0(callers_sp), R1_SP); // Load frame pointer.
-    cmpld(CR0, R11_scratch1, R0);
+    cmpld(CR0, fp, R0);
     blt_predict_taken(CR0, no_reserved_zone_enabling);
 
+    JFR_ONLY(leave_jfr_critical_section();)
+
     // Enable reserved zone again, throw stack overflow exception.
     call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::enable_stack_reserved_zone), R16_thread);
     call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_delayed_StackOverflowError));
@@ -916,12 +928,26 @@ void InterpreterMacroAssembler::remove_activation(TosState state,
 
   verify_oop(R17_tos, state);
 
-  merge_frames(/*top_frame_sp*/ R21_sender_SP, /*return_pc*/ R0, R11_scratch1, R12_scratch2);
+  remove_top_frame_given_fp(fp, R21_sender_SP, R23_tmp3, /*return_pc*/ R0, R11_scratch1);
   mtlr(R0);
   pop_cont_fastpath();
+  JFR_ONLY(leave_jfr_critical_section();)
+
   BLOCK_COMMENT("} remove_activation");
 }
 
+#if INCLUDE_JFR
+void InterpreterMacroAssembler::enter_jfr_critical_section() {
+  li(R0, 1);
+  stb(R0, in_bytes(SAMPLING_CRITICAL_SECTION_OFFSET_JFR), R16_thread);
+}
+
+void InterpreterMacroAssembler::leave_jfr_critical_section() {
+  li(R0, 0);
+  stb(R0, in_bytes(SAMPLING_CRITICAL_SECTION_OFFSET_JFR), R16_thread);
+}
+#endif // INCLUDE_JFR
+
 // Lock object
 //
 // Registers alive

src/hotspot/cpu/ppc/javaFrameAnchor_ppc.hpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2002, 2023, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2012, 2014 SAP SE. All rights reserved.
+ * Copyright (c) 2002, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2025 SAP SE. 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
@@ -73,6 +73,8 @@
 
   address last_Java_pc(void)          { return _last_Java_pc; }
 
+  intptr_t* last_Java_fp() const      { return *(intptr_t**)_last_Java_sp; }
+
   void set_last_Java_sp(intptr_t* sp) { OrderAccess::release(); _last_Java_sp = sp; }
 
 #endif // CPU_PPC_JAVAFRAMEANCHOR_PPC_HPP

src/hotspot/cpu/ppc/macroAssembler_ppc.cpp

@@ -3342,6 +3342,35 @@ void MacroAssembler::safepoint_poll(Label& slow_path, Register temp, bool at_ret
   }
 }
 
+void MacroAssembler::jump_to_polling_page_return_handler_blob(int safepoint_offset, bool fixed_size) {
+  assert(SharedRuntime::polling_page_return_handler_blob() != nullptr,
+         "polling page return stub not created yet");
+  address stub = SharedRuntime::polling_page_return_handler_blob()->entry_point();
+
+  // Determine saved exception pc using pc relative address computation.
+  {
+    Label next_pc;
+    bl(next_pc);
+    bind(next_pc);
+  }
+  int current_offset = offset();
+
+  if (fixed_size) {
+    // Code size must not depend on offsets.
+    load_const32(R12, safepoint_offset - current_offset);
+    mflr(R0);
+    add(R12, R12, R0);
+  } else {
+    mflr(R12);
+    add_const_optimized(R12, R12, safepoint_offset - current_offset);
+  }
+  std(R12, in_bytes(JavaThread::saved_exception_pc_offset()), R16_thread);
+
+  add_const_optimized(R0, R29_TOC, MacroAssembler::offset_to_global_toc(stub));
+  mtctr(R0);
+  bctr();
+}
+
 void MacroAssembler::resolve_jobject(Register value, Register tmp1, Register tmp2,
                                      MacroAssembler::PreservationLevel preservation_level) {
   BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();

src/hotspot/cpu/ppc/macroAssembler_ppc.hpp

@@ -731,6 +731,7 @@ class MacroAssembler: public Assembler {
 
   // Check if safepoint requested and if so branch
   void safepoint_poll(Label& slow_path, Register temp, bool at_return, bool in_nmethod);
+  void jump_to_polling_page_return_handler_blob(int safepoint_offset, bool fixed_size = false);
 
   void resolve_jobject(Register value, Register tmp1, Register tmp2,
                        MacroAssembler::PreservationLevel preservation_level);

src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp

@@ -2740,30 +2740,45 @@ nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm,
   __ li(r_temp_2, 0);
   __ stw(r_temp_2, in_bytes(JNIHandleBlock::top_offset()), r_temp_1);
 
+  // Prepare for return
+  // --------------------------------------------------------------------------
+  __ pop_frame();
+  __ restore_LR(R11);
+
+#if INCLUDE_JFR
+  // We need to do a poll test after unwind in case the sampler
+  // managed to sample the native frame after returning to Java.
+  Label L_stub;
+  int safepoint_offset = __ offset();
+  if (!UseSIGTRAP) {
+    __ relocate(relocInfo::poll_return_type);
+  }
+  __ safepoint_poll(L_stub, r_temp_2, true /* at_return */, true /* in_nmethod: frame already popped */);
+#endif // INCLUDE_JFR
 
   // Check for pending exceptions.
   // --------------------------------------------------------------------------
   __ ld(r_temp_2, thread_(pending_exception));
   __ cmpdi(CR0, r_temp_2, 0);
   __ bne(CR0, handle_pending_exception);
 
-  // Return
-  // --------------------------------------------------------------------------
-
-  __ pop_frame();
-  __ restore_LR(R11);
+  // Return.
   __ blr();
 
+  // Handler for return safepoint (out-of-line).
+#if INCLUDE_JFR
+  if (!UseSIGTRAP) {
+    __ bind(L_stub);
+    __ jump_to_polling_page_return_handler_blob(safepoint_offset);
+  }
+#endif // INCLUDE_JFR
 
   // Handler for pending exceptions (out-of-line).
   // --------------------------------------------------------------------------
   // Since this is a native call, we know the proper exception handler
   // is the empty function. We just pop this frame and then jump to
   // forward_exception_entry.
   __ bind(handle_pending_exception);
-
-  __ pop_frame();
-  __ restore_LR(R11);
   __ b64_patchable((address)StubRoutines::forward_exception_entry(),
                        relocInfo::runtime_call_type);