Mercurial > hg > truffle

annotate src/os_cpu/solaris_sparc/vm/thread_solaris_sparc.cpp @ 17833:bfdf528be8e8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8038498: Fix includes and C inlining after 8035330 Summary: Change 8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure broke the debug build on AIX. The method do_oop_partial_array() is added in a header, but requires the inline function par_write_ref() through several inlined calls. In some cpp files, like arguments.cpp, par_write_ref() is not defined as the corresponding inline header and is not included. The AIX debug VM does not start because of the missing symbol. This change solves this by cleaning up include dependencies. Reviewed-by: tschatzl, stefank
author tschatzl
date Fri, 04 Apr 2014 10:43:56 +0200
parents f2110083203d
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