• file
• revisions
• annotate
• diff
• comparison
• raw

src/os_cpu/solaris_sparc/vm/thread_solaris_sparc.cpp@f90c822e73f8 (annotated)

src/os_cpu/solaris_sparc/vm/thread_solaris_sparc.cpp

Wed, 27 Apr 2016 01:25:04 +0800

author

aoqi

date

Wed, 27 Apr 2016 01:25:04 +0800

changeset 0

f90c822e73f8

child 6876

710a3c8b516e

permissions

-rw-r--r--

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/
changeset: 6782:28b50d07f6f8
tag: jdk8u25-b17

aoqi@0	1	/*
aoqi@0	2	* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
aoqi@0	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
aoqi@0	4	*
aoqi@0	5	* This code is free software; you can redistribute it and/or modify it
aoqi@0	6	* under the terms of the GNU General Public License version 2 only, as
aoqi@0	7	* published by the Free Software Foundation.
aoqi@0	8	*
aoqi@0	9	* This code is distributed in the hope that it will be useful, but WITHOUT
aoqi@0	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
aoqi@0	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
aoqi@0	12	* version 2 for more details (a copy is included in the LICENSE file that
aoqi@0	13	* accompanied this code).
aoqi@0	14	*
aoqi@0	15	* You should have received a copy of the GNU General Public License version
aoqi@0	16	* 2 along with this work; if not, write to the Free Software Foundation,
aoqi@0	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
aoqi@0	18	*
aoqi@0	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
aoqi@0	20	* or visit www.oracle.com if you need additional information or have any
aoqi@0	21	* questions.
aoqi@0	22	*
aoqi@0	23	*/
aoqi@0	24
aoqi@0	25	#include "precompiled.hpp"
aoqi@0	26	#include "runtime/frame.inline.hpp"
aoqi@0	27	#include "runtime/thread.inline.hpp"
aoqi@0	28
aoqi@0	29	// For Forte Analyzer AsyncGetCallTrace profiling support - thread is
aoqi@0	30	// currently interrupted by SIGPROF
aoqi@0	31	//
aoqi@0	32	// NOTE: On Solaris, register windows are flushed in the signal handler
aoqi@0	33	// except for possibly the top frame.
aoqi@0	34	//
aoqi@0	35	bool JavaThread::pd_get_top_frame_for_signal_handler(frame* fr_addr,
aoqi@0	36	void* ucontext, bool isInJava) {
aoqi@0	37
aoqi@0	38	assert(Thread::current() == this, "caller must be current thread");
aoqi@0	39	return pd_get_top_frame(fr_addr, ucontext, isInJava, true);
aoqi@0	40	}
aoqi@0	41
aoqi@0	42	bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext, bool isInJava) {
aoqi@0	43	// get ucontext somehow
aoqi@0	44	return pd_get_top_frame(fr_addr, ucontext, isInJava, false);
aoqi@0	45	}
aoqi@0	46
aoqi@0	47	bool JavaThread::pd_get_top_frame(frame* fr_addr,
aoqi@0	48	void* ucontext, bool isInJava, bool makeWalkable) {
aoqi@0	49	assert(this->is_Java_thread(), "must be JavaThread");
aoqi@0	50
aoqi@0	51	JavaThread* jt = (JavaThread *)this;
aoqi@0	52
aoqi@0	53	if (!isInJava && makeWalkable) {
aoqi@0	54	// make_walkable flushes register windows and grabs last_Java_pc
aoqi@0	55	// which can not be done if the ucontext sp matches last_Java_sp
aoqi@0	56	// stack walking utilities assume last_Java_pc set if marked flushed
aoqi@0	57	jt->frame_anchor()->make_walkable(jt);
aoqi@0	58	}
aoqi@0	59
aoqi@0	60	// If we have a walkable last_Java_frame, then we should use it
aoqi@0	61	// even if isInJava == true. It should be more reliable than
aoqi@0	62	// ucontext info.
aoqi@0	63	if (jt->has_last_Java_frame() && jt->frame_anchor()->walkable()) {
aoqi@0	64	*fr_addr = jt->pd_last_frame();
aoqi@0	65	return true;
aoqi@0	66	}
aoqi@0	67
aoqi@0	68	ucontext_t* uc = (ucontext_t*) ucontext;
aoqi@0	69
aoqi@0	70	// At this point, we don't have a walkable last_Java_frame, so
aoqi@0	71	// we try to glean some information out of the ucontext.
aoqi@0	72	intptr_t* ret_sp;
aoqi@0	73	ExtendedPC addr = os::Solaris::fetch_frame_from_ucontext(this, uc,
aoqi@0	74	&ret_sp, NULL /* ret_fp only used on Solaris X86 */);
aoqi@0	75	if (addr.pc() == NULL || ret_sp == NULL) {
aoqi@0	76	// ucontext wasn't useful
aoqi@0	77	return false;
aoqi@0	78	}
aoqi@0	79
aoqi@0	80	frame ret_frame(ret_sp, frame::unpatchable, addr.pc());
aoqi@0	81
aoqi@0	82	// we were running Java code when SIGPROF came in
aoqi@0	83	if (isInJava) {
aoqi@0	84
aoqi@0	85
aoqi@0	86	// If the frame we got is safe then it is most certainly valid
aoqi@0	87	if (ret_frame.safe_for_sender(jt)) {
aoqi@0	88	*fr_addr = ret_frame;
aoqi@0	89	return true;
aoqi@0	90	}
aoqi@0	91
aoqi@0	92	// If it isn't safe then we can try several things to try and get
aoqi@0	93	// a good starting point.
aoqi@0	94	//
aoqi@0	95	// On sparc the frames are almost certainly walkable in the sense
aoqi@0	96	// of sp/fp linkages. However because of recycling of windows if
aoqi@0	97	// a piece of code does multiple save's where the initial save creates
aoqi@0	98	// a real frame with a return pc and the succeeding save's are used to
aoqi@0	99	// simply get free registers and have no real pc then the pc linkage on these
aoqi@0	100	// "inner" temporary frames will be bogus.
aoqi@0	101	// Since there is in general only a nesting level like
aoqi@0	102	// this one deep in general we'll try and unwind such an "inner" frame
aoqi@0	103	// here ourselves and see if it makes sense
aoqi@0	104
aoqi@0	105	frame unwind_frame(ret_frame.fp(), frame::unpatchable, addr.pc());
aoqi@0	106
aoqi@0	107	if (unwind_frame.safe_for_sender(jt)) {
aoqi@0	108	*fr_addr = unwind_frame;
aoqi@0	109	return true;
aoqi@0	110	}
aoqi@0	111
aoqi@0	112	// Well that didn't work. Most likely we're toast on this tick
aoqi@0	113	// The previous code would try this. I think it is dubious in light
aoqi@0	114	// of changes to safe_for_sender and the unwind trick above but
aoqi@0	115	// if it gets us a safe frame who wants to argue.
aoqi@0	116
aoqi@0	117	// If we have a last_Java_sp, then the SIGPROF signal caught us
aoqi@0	118	// right when we were transitioning from _thread_in_Java to a new
aoqi@0	119	// JavaThreadState. We use last_Java_sp instead of the sp from
aoqi@0	120	// the ucontext since it should be more reliable.
aoqi@0	121
aoqi@0	122	if (jt->has_last_Java_frame()) {
aoqi@0	123	ret_sp = jt->last_Java_sp();
aoqi@0	124	frame ret_frame2(ret_sp, frame::unpatchable, addr.pc());
aoqi@0	125	if (ret_frame2.safe_for_sender(jt)) {
aoqi@0	126	*fr_addr = ret_frame2;
aoqi@0	127	return true;
aoqi@0	128	}
aoqi@0	129	}
aoqi@0	130
aoqi@0	131	// This is the best we can do. We will only be able to decode the top frame
aoqi@0	132
aoqi@0	133	*fr_addr = ret_frame;
aoqi@0	134	return true;
aoqi@0	135	}
aoqi@0	136
aoqi@0	137	// At this point, we know we weren't running Java code. We might
aoqi@0	138	// have a last_Java_sp, but we don't have a walkable frame.
aoqi@0	139	// However, we might still be able to construct something useful
aoqi@0	140	// if the thread was running native code.
aoqi@0	141	if (jt->has_last_Java_frame()) {
aoqi@0	142	assert(!jt->frame_anchor()->walkable(), "case covered above");
aoqi@0	143
aoqi@0	144	frame ret_frame(jt->last_Java_sp(), frame::unpatchable, addr.pc());
aoqi@0	145	*fr_addr = ret_frame;
aoqi@0	146	return true;
aoqi@0	147	}
aoqi@0	148
aoqi@0	149	// nothing else to try but what we found initially
aoqi@0	150
aoqi@0	151	*fr_addr = ret_frame;
aoqi@0	152	return true;
aoqi@0	153	}
aoqi@0	154
aoqi@0	155	void JavaThread::cache_global_variables() { }
aoqi@0	156