jdk-sandbox: comparison hotspot/src/cpu/sparc/vm/methodHandles

equal deleted inserted replaced

-:25f3e9348905
+:23f825a42a85
 (*bounce_offset) = __ pc() - start;
 BLOCK_COMMENT("ricochet_blob.bounce");
 if (VerifyMethodHandles)  RicochetFrame::verify_clean(_masm);
-trace_method_handle(_masm, "ricochet_blob.bounce");
+trace_method_handle(_masm, "return/ricochet_blob.bounce");
 __ JMP(L1_continuation, 0);
 __ delayed()->nop();
 __ illtrap(0);
 __ mov(L2_saved_target, recv_reg);
 BLOCK_COMMENT("} end_ricochet_frame");
 }
 // Emit code to verify that FP is pointing at a valid ricochet frame.
-#ifdef ASSERT
+#ifndef PRODUCT
 enum {
 ARG_LIMIT = 255, SLOP = 45,
 // use this parameter for checking for garbage stack movements:
 UNREASONABLE_STACK_MOVE = (ARG_LIMIT + SLOP)
 // the slop defends against false alarms due to fencepost errors
 };
+#endif
+#ifdef ASSERT
 void MethodHandles::RicochetFrame::verify_clean(MacroAssembler* _masm) {
 // The stack should look like this:
 //    ... keep1 | dest=42 | keep2 | magic | handler | magic | recursive args | [RF]
 // Check various invariants.
 ShouldNotReachHere();
 }
 BLOCK_COMMENT("} move_return_value");
 }
-#ifdef ASSERT
+#ifndef PRODUCT
 void MethodHandles::RicochetFrame::describe(const frame* fr, FrameValues& values, int frame_no)  {
 RicochetFrame* rf = new RicochetFrame(*fr);
 // ricochet slots (kept in registers for sparc)
 values.describe(frame_no, rf->register_addr(I5_savedSP), err_msg("exact_sender_sp reg for #%d", frame_no));
 #ifndef PRODUCT
 extern "C" void print_method_handle(oop mh);
 void trace_method_handle_stub(const char* adaptername,
 oopDesc* mh,
-intptr_t* saved_sp) {
+intptr_t* saved_sp,
+intptr_t* args,
+intptr_t* tracing_fp) {
 bool has_mh = (strstr(adaptername, "return/") == NULL);  // return adapters don't have mh
-tty->print_cr("MH %s mh="INTPTR_FORMAT " saved_sp=" INTPTR_FORMAT, adaptername, (intptr_t) mh, saved_sp);
-if (has_mh)
+tty->print_cr("MH %s mh="INTPTR_FORMAT " saved_sp=" INTPTR_FORMAT " args=" INTPTR_FORMAT, adaptername, (intptr_t) mh, saved_sp, args);
+if (Verbose) {
+// dumping last frame with frame::describe
+JavaThread* p = JavaThread::active();
+ResourceMark rm;
+PRESERVE_EXCEPTION_MARK; // may not be needed by safer and unexpensive here
+FrameValues values;
+// Note: We want to allow trace_method_handle from any call site.
+// While trace_method_handle creates a frame, it may be entered
+// without a valid return PC in O7 (e.g. not just after a call).
+// Walking that frame could lead to failures due to that invalid PC.
+// => carefully detect that frame when doing the stack walking
+// walk up to the right frame using the "tracing_fp" argument
+intptr_t* cur_sp = StubRoutines::Sparc::flush_callers_register_windows_func()();
+frame cur_frame(cur_sp, frame::unpatchable, NULL);
+while (cur_frame.fp() != (intptr_t *)(STACK_BIAS+(uintptr_t)tracing_fp)) {
+cur_frame = os::get_sender_for_C_frame(&cur_frame);
+}
+// safely create a frame and call frame::describe
+intptr_t *dump_sp = cur_frame.sender_sp();
+intptr_t *dump_fp = cur_frame.link();
+bool walkable = has_mh; // whether the traced frame shoud be walkable
+// the sender for cur_frame is the caller of trace_method_handle
+if (walkable) {
+// The previous definition of walkable may have to be refined
+// if new call sites cause the next frame constructor to start
+// failing. Alternatively, frame constructors could be
+// modified to support the current or future non walkable
+// frames (but this is more intrusive and is not considered as
+// part of this RFE, which will instead use a simpler output).
+frame dump_frame = frame(dump_sp,
+cur_frame.sp(), // younger_sp
+false); // no adaptation
+dump_frame.describe(values, 1);
+} else {
+// Robust dump for frames which cannot be constructed from sp/younger_sp
+// Add descriptions without building a Java frame to avoid issues
+values.describe(-1, dump_fp, "fp for #1 <not parsed, cannot trust pc>");
+values.describe(-1, dump_sp, "sp");
+}
+bool has_args = has_mh; // whether Gargs is meaningful
+// mark args, if seems valid (may not be valid for some adapters)
+if (has_args) {
+if ((args >= dump_sp) && (args < dump_fp)) {
+values.describe(-1, args, "*G4_args");
+}
+}
+// mark saved_sp, if seems valid (may not be valid for some adapters)
+intptr_t *unbiased_sp = (intptr_t *)(STACK_BIAS+(uintptr_t)saved_sp);
+if ((unbiased_sp >= dump_sp - UNREASONABLE_STACK_MOVE) && (unbiased_sp < dump_fp)) {
+values.describe(-1, unbiased_sp, "*saved_sp+STACK_BIAS");
+}
+// Note: the unextended_sp may not be correct
+tty->print_cr("  stack layout:");
+values.print(p);
+}
+if (has_mh) {
 print_method_handle(mh);
 }
+}
 void MethodHandles::trace_method_handle(MacroAssembler* _masm, const char* adaptername) {
 if (!TraceMethodHandles)  return;
 BLOCK_COMMENT("trace_method_handle {");
 // save: Gargs, O5_savedSP
-__ save_frame(16);
+__ save_frame(16); // need space for saving required FPU state
 __ set((intptr_t) adaptername, O0);
 __ mov(G3_method_handle, O1);
 __ mov(I5_savedSP, O2);
+__ mov(Gargs, O3);
+__ mov(I6, O4); // frame identifier for safe stack walking
+// Save scratched registers that might be needed. Robustness is more
+// important than optimizing the saves for this debug only code.
+// save FP result, valid at some call sites (adapter_opt_return_float, ...)
+Address d_save(FP, -sizeof(jdouble) + STACK_BIAS);
+__ stf(FloatRegisterImpl::D, Ftos_d, d_save);
+// Safely save all globals but G2 (handled by call_VM_leaf) and G7
+// (OS reserved).
 __ mov(G3_method_handle, L3);
 __ mov(Gargs, L4);
 __ mov(G5_method_type, L5);
-__ call_VM_leaf(L7, CAST_FROM_FN_PTR(address, trace_method_handle_stub));
+__ mov(G6, L6);
+__ mov(G1, L1);
+__ call_VM_leaf(L2 /* for G2 */, CAST_FROM_FN_PTR(address, trace_method_handle_stub));
 __ mov(L3, G3_method_handle);
 __ mov(L4, Gargs);
 __ mov(L5, G5_method_type);
+__ mov(L6, G6);
+__ mov(L1, G1);
+__ ldf(FloatRegisterImpl::D, d_save, Ftos_d);
 __ restore();
 BLOCK_COMMENT("} trace_method_handle");
 }
 #endif // PRODUCT
 } else {
 Address prim_value_addr(O1_scratch, java_lang_boxing_object::value_offset_in_bytes(arg_type));
 move_typed_arg(_masm, arg_type, false,
 prim_value_addr,
 Address(O0_argslot, 0),
 O2_scratch);  // must be an even register for !_LP64 long moves (uses O2/O3)
 }
 if (direct_to_method) {
 __ load_heap_oop(G3_mh_vmtarget, G5_method);  // target is a methodOop
 jump_from_method_handle(_masm, G5_method, O1_scratch, O2_scratch);

changeset 11571	23f825a42a85
parent 11565	713a0398ca58
child 13391	30245956af37