Mercurial > hg > graal-compiler

annotate src/os_cpu/solaris_sparc/vm/thread_solaris_sparc.cpp @ 10405:f2110083203d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8005849: JEP 167: Event-Based JVM Tracing Reviewed-by: acorn, coleenp, sla Contributed-by: Karen Kinnear <karen.kinnear@oracle.com>, Bengt Rutisson <bengt.rutisson@oracle.com>, Calvin Cheung <calvin.cheung@oracle.com>, Erik Gahlin <erik.gahlin@oracle.com>, Erik Helin <erik.helin@oracle.com>, Jesper Wilhelmsson <jesper.wilhelmsson@oracle.com>, Keith McGuigan <keith.mcguigan@oracle.com>, Mattias Tobiasson <mattias.tobiasson@oracle.com>, Markus Gronlund <markus.gronlund@oracle.com>, Mikael Auno <mikael.auno@oracle.com>, Nils Eliasson <nils.eliasson@oracle.com>, Nils Loodin <nils.loodin@oracle.com>, Rickard Backman <rickard.backman@oracle.com>, Staffan Larsen <staffan.larsen@oracle.com>, Stefan Karlsson <stefan.karlsson@oracle.com>, Yekaterina Kantserova <yekaterina.kantserova@oracle.com>
author sla
date Mon, 10 Jun 2013 11:30:51 +0200
parents f34d701e952e
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
2 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 196
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 196
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 196
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
26 #include "runtime/frame.inline.hpp"
7180
f34d701e952e 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 1972
diff changeset
27 #include "runtime/thread.inline.hpp"
0
a61af66fc99e Initial load
duke
parents:
diff changeset
28
a61af66fc99e Initial load
duke
parents:
diff changeset
29 // For Forte Analyzer AsyncGetCallTrace profiling support - thread is
a61af66fc99e Initial load
duke
parents:
diff changeset
30 // currently interrupted by SIGPROF
a61af66fc99e Initial load
duke
parents:
diff changeset
31 //
a61af66fc99e Initial load
duke
parents:
diff changeset
32 // NOTE: On Solaris, register windows are flushed in the signal handler
a61af66fc99e Initial load
duke
parents:
diff changeset
33 // except for possibly the top frame.
a61af66fc99e Initial load
duke
parents:
diff changeset
34 //
a61af66fc99e Initial load
duke
parents:
diff changeset
35 bool JavaThread::pd_get_top_frame_for_signal_handler(frame* fr_addr,
a61af66fc99e Initial load
duke
parents:
diff changeset
36 void* ucontext, bool isInJava) {
a61af66fc99e Initial load
duke
parents:
diff changeset
37
a61af66fc99e Initial load
duke
parents:
diff changeset
38 assert(Thread::current() == this, "caller must be current thread");
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
39 return pd_get_top_frame(fr_addr, ucontext, isInJava, true);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
40 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
41
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
42 bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext, bool isInJava) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
43 // get ucontext somehow
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
44 return pd_get_top_frame(fr_addr, ucontext, isInJava, false);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
45 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
46
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
47 bool JavaThread::pd_get_top_frame(frame* fr_addr,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
48 void* ucontext, bool isInJava, bool makeWalkable) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
49 assert(this->is_Java_thread(), "must be JavaThread");
a61af66fc99e Initial load
duke
parents:
diff changeset
50
a61af66fc99e Initial load
duke
parents:
diff changeset
51 JavaThread* jt = (JavaThread *)this;
a61af66fc99e Initial load
duke
parents:
diff changeset
52
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 7180
diff changeset
53 if (!isInJava && makeWalkable) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
54 // make_walkable flushes register windows and grabs last_Java_pc
a61af66fc99e Initial load
duke
parents:
diff changeset
55 // which can not be done if the ucontext sp matches last_Java_sp
a61af66fc99e Initial load
duke
parents:
diff changeset
56 // stack walking utilities assume last_Java_pc set if marked flushed
a61af66fc99e Initial load
duke
parents:
diff changeset
57 jt->frame_anchor()->make_walkable(jt);
a61af66fc99e Initial load
duke
parents:
diff changeset
58 }
a61af66fc99e Initial load
duke
parents:
diff changeset
59
a61af66fc99e Initial load
duke
parents:
diff changeset
60 // If we have a walkable last_Java_frame, then we should use it
a61af66fc99e Initial load
duke
parents:
diff changeset
61 // even if isInJava == true. It should be more reliable than
a61af66fc99e Initial load
duke
parents:
diff changeset
62 // ucontext info.
a61af66fc99e Initial load
duke
parents:
diff changeset
63 if (jt->has_last_Java_frame() && jt->frame_anchor()->walkable()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
64 *fr_addr = jt->pd_last_frame();
a61af66fc99e Initial load
duke
parents:
diff changeset
65 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
66 }
a61af66fc99e Initial load
duke
parents:
diff changeset
67
a61af66fc99e Initial load
duke
parents:
diff changeset
68 ucontext_t* uc = (ucontext_t*) ucontext;
a61af66fc99e Initial load
duke
parents:
diff changeset
69
a61af66fc99e Initial load
duke
parents:
diff changeset
70 // At this point, we don't have a walkable last_Java_frame, so
a61af66fc99e Initial load
duke
parents:
diff changeset
71 // we try to glean some information out of the ucontext.
a61af66fc99e Initial load
duke
parents:
diff changeset
72 intptr_t* ret_sp;
a61af66fc99e Initial load
duke
parents:
diff changeset
73 ExtendedPC addr = os::Solaris::fetch_frame_from_ucontext(this, uc,
a61af66fc99e Initial load
duke
parents:
diff changeset
74 &ret_sp, NULL /* ret_fp only used on Solaris X86 */);
a61af66fc99e Initial load
duke
parents:
diff changeset
75 if (addr.pc() == NULL || ret_sp == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
76 // ucontext wasn't useful
a61af66fc99e Initial load
duke
parents:
diff changeset
77 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
78 }
a61af66fc99e Initial load
duke
parents:
diff changeset
79
107
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
80 frame ret_frame(ret_sp, frame::unpatchable, addr.pc());
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
81
0
a61af66fc99e Initial load
duke
parents:
diff changeset
82 // we were running Java code when SIGPROF came in
a61af66fc99e Initial load
duke
parents:
diff changeset
83 if (isInJava) {
107
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
84
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
85
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
86 // If the frame we got is safe then it is most certainly valid
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
87 if (ret_frame.safe_for_sender(jt)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
88 *fr_addr = ret_frame;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
89 return true;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
90 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
91
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
92 // If it isn't safe then we can try several things to try and get
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
93 // a good starting point.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
94 //
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
95 // On sparc the frames are almost certainly walkable in the sense
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
96 // of sp/fp linkages. However because of recycling of windows if
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
97 // a piece of code does multiple save's where the initial save creates
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
98 // a real frame with a return pc and the succeeding save's are used to
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
99 // simply get free registers and have no real pc then the pc linkage on these
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
100 // "inner" temporary frames will be bogus.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
101 // Since there is in general only a nesting level like
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
102 // this one deep in general we'll try and unwind such an "inner" frame
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
103 // here ourselves and see if it makes sense
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
104
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
105 frame unwind_frame(ret_frame.fp(), frame::unpatchable, addr.pc());
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
106
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
107 if (unwind_frame.safe_for_sender(jt)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
108 *fr_addr = unwind_frame;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
109 return true;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
110 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
111
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
112 // Well that didn't work. Most likely we're toast on this tick
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
113 // The previous code would try this. I think it is dubious in light
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
114 // of changes to safe_for_sender and the unwind trick above but
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
115 // if it gets us a safe frame who wants to argue.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
116
0
a61af66fc99e Initial load
duke
parents:
diff changeset
117 // If we have a last_Java_sp, then the SIGPROF signal caught us
a61af66fc99e Initial load
duke
parents:
diff changeset
118 // right when we were transitioning from _thread_in_Java to a new
a61af66fc99e Initial load
duke
parents:
diff changeset
119 // JavaThreadState. We use last_Java_sp instead of the sp from
a61af66fc99e Initial load
duke
parents:
diff changeset
120 // the ucontext since it should be more reliable.
107
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
121
0
a61af66fc99e Initial load
duke
parents:
diff changeset
122 if (jt->has_last_Java_frame()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
123 ret_sp = jt->last_Java_sp();
107
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
124 frame ret_frame2(ret_sp, frame::unpatchable, addr.pc());
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
125 if (ret_frame2.safe_for_sender(jt)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
126 *fr_addr = ret_frame2;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
127 return true;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
128 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
129 }
a61af66fc99e Initial load
duke
parents:
diff changeset
130
107
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
131 // This is the best we can do. We will only be able to decode the top frame
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
132
0
a61af66fc99e Initial load
duke
parents:
diff changeset
133 *fr_addr = ret_frame;
a61af66fc99e Initial load
duke
parents:
diff changeset
134 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
135 }
a61af66fc99e Initial load
duke
parents:
diff changeset
136
a61af66fc99e Initial load
duke
parents:
diff changeset
137 // At this point, we know we weren't running Java code. We might
a61af66fc99e Initial load
duke
parents:
diff changeset
138 // have a last_Java_sp, but we don't have a walkable frame.
a61af66fc99e Initial load
duke
parents:
diff changeset
139 // However, we might still be able to construct something useful
a61af66fc99e Initial load
duke
parents:
diff changeset
140 // if the thread was running native code.
a61af66fc99e Initial load
duke
parents:
diff changeset
141 if (jt->has_last_Java_frame()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
142 assert(!jt->frame_anchor()->walkable(), "case covered above");
a61af66fc99e Initial load
duke
parents:
diff changeset
143
107
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
144 frame ret_frame(jt->last_Java_sp(), frame::unpatchable, addr.pc());
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
145 *fr_addr = ret_frame;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
146 return true;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
147 }
a61af66fc99e Initial load
duke
parents:
diff changeset
148
107
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
149 // nothing else to try but what we found initially
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
150
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
151 *fr_addr = ret_frame;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents: 0
diff changeset
152 return true;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
153 }
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
154
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
155 void JavaThread::cache_global_variables() { }
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
156