Mercurial > hg > graal-jvmci-8
annotate src/share/vm/prims/forte.cpp @ 1507:cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
Summary: split MethodHandle.invoke into invokeExact and invokeGeneric; also clean up JVM-to-Java interfaces
Reviewed-by: twisti
author | jrose |
---|---|
date | Sat, 01 May 2010 02:42:18 -0700 |
parents | 547cbe6dacc5 |
children | cff162798819 |
rev | line source |
---|---|
0 | 1 /* |
196 | 2 * Copyright 2003-2008 Sun Microsystems, Inc. All Rights Reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
21 * have any questions. | |
22 * | |
23 */ | |
24 | |
25 # include "incls/_precompiled.incl" | |
26 # include "incls/_forte.cpp.incl" | |
27 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
28 // These name match the names reported by the forte quality kit |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
29 enum { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
30 ticks_no_Java_frame = 0, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
31 ticks_no_class_load = -1, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
32 ticks_GC_active = -2, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
33 ticks_unknown_not_Java = -3, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
34 ticks_not_walkable_not_Java = -4, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
35 ticks_unknown_Java = -5, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
36 ticks_not_walkable_Java = -6, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
37 ticks_unknown_state = -7, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
38 ticks_thread_exit = -8, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
39 ticks_deopt = -9, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
40 ticks_safepoint = -10 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
41 }; |
0 | 42 |
43 //------------------------------------------------------- | |
44 | |
45 // Native interfaces for use by Forte tools. | |
46 | |
47 | |
48 #ifndef IA64 | |
49 | |
50 class vframeStreamForte : public vframeStreamCommon { | |
51 public: | |
52 // constructor that starts with sender of frame fr (top_frame) | |
53 vframeStreamForte(JavaThread *jt, frame fr, bool stop_at_java_call_stub); | |
54 void forte_next(); | |
55 }; | |
56 | |
57 | |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
58 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm); |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
59 static bool is_decipherable_interpreted_frame(JavaThread* thread, |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
60 frame* fr, |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
61 methodOop* method_p, |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
62 int* bci_p); |
0 | 63 |
64 | |
65 | |
66 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
67 vframeStreamForte::vframeStreamForte(JavaThread *jt, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
68 frame fr, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
69 bool stop_at_java_call_stub) : vframeStreamCommon(jt) { |
0 | 70 |
71 _stop_at_java_call_stub = stop_at_java_call_stub; | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
72 _frame = fr; |
0 | 73 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
74 // We must always have a valid frame to start filling |
0 | 75 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
76 bool filled_in = fill_from_frame(); |
0 | 77 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
78 assert(filled_in, "invariant"); |
0 | 79 |
80 } | |
81 | |
82 | |
83 // Solaris SPARC Compiler1 needs an additional check on the grandparent | |
84 // of the top_frame when the parent of the top_frame is interpreted and | |
85 // the grandparent is compiled. However, in this method we do not know | |
86 // the relationship of the current _frame relative to the top_frame so | |
87 // we implement a more broad sanity check. When the previous callee is | |
88 // interpreted and the current sender is compiled, we verify that the | |
89 // current sender is also walkable. If it is not walkable, then we mark | |
90 // the current vframeStream as at the end. | |
91 void vframeStreamForte::forte_next() { | |
92 // handle frames with inlining | |
93 if (_mode == compiled_mode && | |
94 vframeStreamCommon::fill_in_compiled_inlined_sender()) { | |
95 return; | |
96 } | |
97 | |
98 // handle general case | |
99 | |
100 int loop_count = 0; | |
101 int loop_max = MaxJavaStackTraceDepth * 2; | |
102 | |
103 | |
104 do { | |
105 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
106 loop_count++; |
0 | 107 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
108 // By the time we get here we should never see unsafe but better |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
109 // safe then segv'd |
0 | 110 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
111 if (loop_count > loop_max || !_frame.safe_for_sender(_thread)) { |
0 | 112 _mode = at_end_mode; |
113 return; | |
114 } | |
115 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
116 _frame = _frame.sender(&_reg_map); |
0 | 117 |
118 } while (!fill_from_frame()); | |
119 } | |
120 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
121 // Determine if 'fr' is a decipherable compiled frame. We are already |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
122 // assured that fr is for a java nmethod. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
123 |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
124 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm) { |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
125 assert(nm->is_java_method(), "invariant"); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
126 |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
127 if (thread->has_last_Java_frame() && thread->last_Java_pc() == fr->pc()) { |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
128 // We're stopped at a call into the JVM so look for a PcDesc with |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
129 // the actual pc reported by the frame. |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
130 PcDesc* pc_desc = nm->pc_desc_at(fr->pc()); |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
131 |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
132 // Did we find a useful PcDesc? |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
133 if (pc_desc != NULL && |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
134 pc_desc->scope_decode_offset() != DebugInformationRecorder::serialized_null) { |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
135 return true; |
0 | 136 } |
137 } | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
138 |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
139 // We're at some random pc in the nmethod so search for the PcDesc |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
140 // whose pc is greater than the current PC. It's done this way |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
141 // because the extra PcDescs that are recorded for improved debug |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
142 // info record the end of the region covered by the ScopeDesc |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
143 // instead of the beginning. |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
144 PcDesc* pc_desc = nm->pc_desc_near(fr->pc() + 1); |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
145 |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
146 // Now do we have a useful PcDesc? |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
147 if (pc_desc == NULL || |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
148 pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) { |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
149 // No debug information available for this pc |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
150 // vframeStream would explode if we try and walk the frames. |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
151 return false; |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
152 } |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
153 |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
154 // This PcDesc is useful however we must adjust the frame's pc |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
155 // so that the vframeStream lookups will use this same pc |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
156 fr->set_pc(pc_desc->real_pc(nm)); |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
157 return true; |
0 | 158 } |
159 | |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
160 |
0 | 161 // Determine if 'fr' is a walkable interpreted frame. Returns false |
162 // if it is not. *method_p, and *bci_p are not set when false is | |
163 // returned. *method_p is non-NULL if frame was executing a Java | |
164 // method. *bci_p is != -1 if a valid BCI in the Java method could | |
165 // be found. | |
166 // Note: this method returns true when a valid Java method is found | |
167 // even if a valid BCI cannot be found. | |
168 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
169 static bool is_decipherable_interpreted_frame(JavaThread* thread, |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
170 frame* fr, |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
171 methodOop* method_p, |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
172 int* bci_p) { |
0 | 173 assert(fr->is_interpreted_frame(), "just checking"); |
174 | |
175 // top frame is an interpreted frame | |
176 // check if it is walkable (i.e. valid methodOop and valid bci) | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
177 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
178 // Because we may be racing a gc thread the method and/or bci |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
179 // of a valid interpreter frame may look bad causing us to |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
180 // fail the is_interpreted_frame_valid test. If the thread |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
181 // is in any of the following states we are assured that the |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
182 // frame is in fact valid and we must have hit the race. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
183 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
184 JavaThreadState state = thread->thread_state(); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
185 bool known_valid = (state == _thread_in_native || |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
186 state == _thread_in_vm || |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
187 state == _thread_blocked ); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
188 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
189 if (known_valid || fr->is_interpreted_frame_valid(thread)) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
190 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
191 // The frame code should completely validate the frame so that |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
192 // references to methodOop and bci are completely safe to access |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
193 // If they aren't the frame code should be fixed not this |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
194 // code. However since gc isn't locked out the values could be |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
195 // stale. This is a race we can never completely win since we can't |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
196 // lock out gc so do one last check after retrieving their values |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
197 // from the frame for additional safety |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
198 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
199 methodOop method = fr->interpreter_frame_method(); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
200 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
201 // We've at least found a method. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
202 // NOTE: there is something to be said for the approach that |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
203 // if we don't find a valid bci then the method is not likely |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
204 // a valid method. Then again we may have caught an interpreter |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
205 // frame in the middle of construction and the bci field is |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
206 // not yet valid. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
207 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
208 *method_p = method; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
209 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
210 // See if gc may have invalidated method since we validated frame |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
211 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
212 if (!Universe::heap()->is_valid_method(method)) return false; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
213 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
214 intptr_t bcx = fr->interpreter_frame_bcx(); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
215 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
216 int bci = method->validate_bci_from_bcx(bcx); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
217 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
218 // note: bci is set to -1 if not a valid bci |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
219 *bci_p = bci; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
220 return true; |
0 | 221 } |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
222 |
0 | 223 return false; |
224 } | |
225 | |
226 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
227 // Determine if 'fr' can be used to find an initial Java frame. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
228 // Return false if it can not find a fully decipherable Java frame |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
229 // (in other words a frame that isn't safe to use in a vframe stream). |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
230 // Obviously if it can't even find a Java frame false will also be returned. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
231 // |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
232 // If we find a Java frame decipherable or not then by definition we have |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
233 // identified a method and that will be returned to the caller via method_p. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
234 // If we can determine a bci that is returned also. (Hmm is it possible |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
235 // to return a method and bci and still return false? ) |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
236 // |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
237 // The initial Java frame we find (if any) is return via initial_frame_p. |
0 | 238 // |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
239 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
240 static bool find_initial_Java_frame(JavaThread* thread, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
241 frame* fr, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
242 frame* initial_frame_p, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
243 methodOop* method_p, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
244 int* bci_p) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
245 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
246 // It is possible that for a frame containing an nmethod |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
247 // we can capture the method but no bci. If we get no |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
248 // bci the frame isn't walkable but the method is usable. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
249 // Therefore we init the returned methodOop to NULL so the |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
250 // caller can make the distinction. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
251 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
252 *method_p = NULL; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
253 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
254 // On the initial call to this method the frame we get may not be |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
255 // recognizable to us. This should only happen if we are in a JRT_LEAF |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
256 // or something called by a JRT_LEAF method. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
257 |
0 | 258 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
259 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
260 frame candidate = *fr; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
261 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
262 // If the starting frame we were given has no codeBlob associated with |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
263 // it see if we can find such a frame because only frames with codeBlobs |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
264 // are possible Java frames. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
265 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
266 if (fr->cb() == NULL) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
267 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
268 // See if we can find a useful frame |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
269 int loop_count; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
270 int loop_max = MaxJavaStackTraceDepth * 2; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
271 RegisterMap map(thread, false); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
272 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
273 for (loop_count = 0; loop_count < loop_max; loop_count++) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
274 if (!candidate.safe_for_sender(thread)) return false; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
275 candidate = candidate.sender(&map); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
276 if (candidate.cb() != NULL) break; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
277 } |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
278 if (candidate.cb() == NULL) return false; |
0 | 279 } |
280 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
281 // We have a frame known to be in the codeCache |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
282 // We will hopefully be able to figure out something to do with it. |
0 | 283 int loop_count; |
284 int loop_max = MaxJavaStackTraceDepth * 2; | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
285 RegisterMap map(thread, false); |
0 | 286 |
287 for (loop_count = 0; loop_count < loop_max; loop_count++) { | |
288 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
289 if (candidate.is_first_frame()) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
290 // If initial frame is frame from StubGenerator and there is no |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
291 // previous anchor, there are no java frames associated with a method |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
292 return false; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
293 } |
0 | 294 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
295 if (candidate.is_interpreted_frame()) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
296 if (is_decipherable_interpreted_frame(thread, &candidate, method_p, bci_p)) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
297 *initial_frame_p = candidate; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
298 return true; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
299 } |
0 | 300 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
301 // Hopefully we got some data |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
302 return false; |
0 | 303 } |
304 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
305 if (candidate.cb()->is_nmethod()) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
306 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
307 nmethod* nm = (nmethod*) candidate.cb(); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
308 *method_p = nm->method(); |
0 | 309 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
310 // If the frame isn't fully decipherable then the default |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
311 // value for the bci is a signal that we don't have a bci. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
312 // If we have a decipherable frame this bci value will |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
313 // not be used. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
314 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
315 *bci_p = -1; |
0 | 316 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
317 *initial_frame_p = candidate; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
318 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
319 // Native wrapper code is trivial to decode by vframeStream |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
320 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
321 if (nm->is_native_method()) return true; |
0 | 322 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
323 // If it isn't decipherable then we have found a pc that doesn't |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
324 // have a PCDesc that can get us a bci however we did find |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
325 // a method |
0 | 326 |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
327 if (!is_decipherable_compiled_frame(thread, &candidate, nm)) { |
0 | 328 return false; |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
329 } |
0 | 330 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
331 // is_decipherable_compiled_frame may modify candidate's pc |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
332 *initial_frame_p = candidate; |
0 | 333 |
1349
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
334 assert(nm->pc_desc_at(candidate.pc()) != NULL, "if it's decipherable then pc must be valid"); |
547cbe6dacc5
6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly
never
parents:
196
diff
changeset
|
335 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
336 return true; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
337 } |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
338 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
339 // Must be some stub frame that we don't care about |
0 | 340 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
341 if (!candidate.safe_for_sender(thread)) return false; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
342 candidate = candidate.sender(&map); |
0 | 343 |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
344 // If it isn't in the code cache something is wrong |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
345 // since once we find a frame in the code cache they |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
346 // all should be there. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
347 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
348 if (candidate.cb() == NULL) return false; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
349 |
0 | 350 } |
351 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
352 return false; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
353 |
0 | 354 } |
355 | |
356 | |
357 // call frame copied from old .h file and renamed | |
358 typedef struct { | |
359 jint lineno; // line number in the source file | |
360 jmethodID method_id; // method executed in this frame | |
361 } ASGCT_CallFrame; | |
362 | |
363 // call trace copied from old .h file and renamed | |
364 typedef struct { | |
365 JNIEnv *env_id; // Env where trace was recorded | |
366 jint num_frames; // number of frames in this trace | |
367 ASGCT_CallFrame *frames; // frames | |
368 } ASGCT_CallTrace; | |
369 | |
370 static void forte_fill_call_trace_given_top(JavaThread* thd, | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
371 ASGCT_CallTrace* trace, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
372 int depth, |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
373 frame top_frame) { |
0 | 374 NoHandleMark nhm; |
375 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
376 frame initial_Java_frame; |
0 | 377 methodOop method; |
378 int bci; | |
379 int count; | |
380 | |
381 count = 0; | |
382 assert(trace->frames != NULL, "trace->frames must be non-NULL"); | |
383 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
384 bool fully_decipherable = find_initial_Java_frame(thd, &top_frame, &initial_Java_frame, &method, &bci); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
385 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
386 // The frame might not be walkable but still recovered a method |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
387 // (e.g. an nmethod with no scope info for the pc |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
388 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
389 if (method == NULL) return; |
0 | 390 |
391 CollectedHeap* ch = Universe::heap(); | |
392 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
393 // The method is not stored GC safe so see if GC became active |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
394 // after we entered AsyncGetCallTrace() and before we try to |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
395 // use the methodOop. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
396 // Yes, there is still a window after this check and before |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
397 // we use methodOop below, but we can't lock out GC so that |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
398 // has to be an acceptable risk. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
399 if (!ch->is_valid_method(method)) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
400 trace->num_frames = ticks_GC_active; // -2 |
0 | 401 return; |
402 } | |
403 | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
404 // We got a Java frame however it isn't fully decipherable |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
405 // so it won't necessarily be safe to use it for the |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
406 // initial frame in the vframe stream. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
407 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
408 if (!fully_decipherable) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
409 // Take whatever method the top-frame decoder managed to scrape up. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
410 // We look further at the top frame only if non-safepoint |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
411 // debugging information is available. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
412 count++; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
413 trace->num_frames = count; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
414 trace->frames[0].method_id = method->find_jmethod_id_or_null(); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
415 if (!method->is_native()) { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
416 trace->frames[0].lineno = bci; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
417 } else { |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
418 trace->frames[0].lineno = -3; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
419 } |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
420 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
421 if (!initial_Java_frame.safe_for_sender(thd)) return; |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
422 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
423 RegisterMap map(thd, false); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
424 initial_Java_frame = initial_Java_frame.sender(&map); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
425 } |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
426 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
427 vframeStreamForte st(thd, initial_Java_frame, false); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
428 |
0 | 429 for (; !st.at_end() && count < depth; st.forte_next(), count++) { |
430 bci = st.bci(); | |
431 method = st.method(); | |
432 | |
433 // The method is not stored GC safe so see if GC became active | |
434 // after we entered AsyncGetCallTrace() and before we try to | |
435 // use the methodOop. | |
436 // Yes, there is still a window after this check and before | |
437 // we use methodOop below, but we can't lock out GC so that | |
438 // has to be an acceptable risk. | |
439 if (!ch->is_valid_method(method)) { | |
440 // we throw away everything we've gathered in this sample since | |
441 // none of it is safe | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
442 trace->num_frames = ticks_GC_active; // -2 |
0 | 443 return; |
444 } | |
445 | |
446 trace->frames[count].method_id = method->find_jmethod_id_or_null(); | |
447 if (!method->is_native()) { | |
448 trace->frames[count].lineno = bci; | |
449 } else { | |
450 trace->frames[count].lineno = -3; | |
451 } | |
452 } | |
453 trace->num_frames = count; | |
454 return; | |
455 } | |
456 | |
457 | |
458 // Forte Analyzer AsyncGetCallTrace() entry point. Currently supported | |
459 // on Linux X86, Solaris SPARC and Solaris X86. | |
460 // | |
461 // Async-safe version of GetCallTrace being called from a signal handler | |
462 // when a LWP gets interrupted by SIGPROF but the stack traces are filled | |
463 // with different content (see below). | |
464 // | |
465 // This function must only be called when JVM/TI | |
466 // CLASS_LOAD events have been enabled since agent startup. The enabled | |
467 // event will cause the jmethodIDs to be allocated at class load time. | |
468 // The jmethodIDs cannot be allocated in a signal handler because locks | |
469 // cannot be grabbed in a signal handler safely. | |
470 // | |
471 // void (*AsyncGetCallTrace)(ASGCT_CallTrace *trace, jint depth, void* ucontext) | |
472 // | |
473 // Called by the profiler to obtain the current method call stack trace for | |
474 // a given thread. The thread is identified by the env_id field in the | |
475 // ASGCT_CallTrace structure. The profiler agent should allocate a ASGCT_CallTrace | |
476 // structure with enough memory for the requested stack depth. The VM fills in | |
477 // the frames buffer and the num_frames field. | |
478 // | |
479 // Arguments: | |
480 // | |
481 // trace - trace data structure to be filled by the VM. | |
482 // depth - depth of the call stack trace. | |
483 // ucontext - ucontext_t of the LWP | |
484 // | |
485 // ASGCT_CallTrace: | |
486 // typedef struct { | |
487 // JNIEnv *env_id; | |
488 // jint num_frames; | |
489 // ASGCT_CallFrame *frames; | |
490 // } ASGCT_CallTrace; | |
491 // | |
492 // Fields: | |
493 // env_id - ID of thread which executed this trace. | |
494 // num_frames - number of frames in the trace. | |
495 // (< 0 indicates the frame is not walkable). | |
496 // frames - the ASGCT_CallFrames that make up this trace. Callee followed by callers. | |
497 // | |
498 // ASGCT_CallFrame: | |
499 // typedef struct { | |
500 // jint lineno; | |
501 // jmethodID method_id; | |
502 // } ASGCT_CallFrame; | |
503 // | |
504 // Fields: | |
505 // 1) For Java frame (interpreted and compiled), | |
506 // lineno - bci of the method being executed or -1 if bci is not available | |
507 // method_id - jmethodID of the method being executed | |
508 // 2) For native method | |
509 // lineno - (-3) | |
510 // method_id - jmethodID of the method being executed | |
511 | |
512 extern "C" { | |
513 void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) { | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
514 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
515 // This is if'd out because we no longer use thread suspension. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
516 // However if someone wanted to backport this to a 5.0 jvm then this |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
517 // code would be important. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
518 #if 0 |
0 | 519 if (SafepointSynchronize::is_synchronizing()) { |
520 // The safepoint mechanism is trying to synchronize all the threads. | |
521 // Since this can involve thread suspension, it is not safe for us | |
522 // to be here. We can reduce the deadlock risk window by quickly | |
523 // returning to the SIGPROF handler. However, it is still possible | |
524 // for VMThread to catch us here or in the SIGPROF handler. If we | |
525 // are suspended while holding a resource and another thread blocks | |
526 // on that resource in the SIGPROF handler, then we will have a | |
527 // three-thread deadlock (VMThread, this thread, the other thread). | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
528 trace->num_frames = ticks_safepoint; // -10 |
0 | 529 return; |
530 } | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
531 #endif |
0 | 532 |
533 JavaThread* thread; | |
534 | |
535 if (trace->env_id == NULL || | |
536 (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL || | |
537 thread->is_exiting()) { | |
538 | |
539 // bad env_id, thread has exited or thread is exiting | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
540 trace->num_frames = ticks_thread_exit; // -8 |
0 | 541 return; |
542 } | |
543 | |
544 if (thread->in_deopt_handler()) { | |
545 // thread is in the deoptimization handler so return no frames | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
546 trace->num_frames = ticks_deopt; // -9 |
0 | 547 return; |
548 } | |
549 | |
550 assert(JavaThread::current() == thread, | |
551 "AsyncGetCallTrace must be called by the current interrupted thread"); | |
552 | |
553 if (!JvmtiExport::should_post_class_load()) { | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
554 trace->num_frames = ticks_no_class_load; // -1 |
0 | 555 return; |
556 } | |
557 | |
558 if (Universe::heap()->is_gc_active()) { | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
559 trace->num_frames = ticks_GC_active; // -2 |
0 | 560 return; |
561 } | |
562 | |
563 switch (thread->thread_state()) { | |
564 case _thread_new: | |
565 case _thread_uninitialized: | |
566 case _thread_new_trans: | |
567 // We found the thread on the threads list above, but it is too | |
568 // young to be useful so return that there are no Java frames. | |
569 trace->num_frames = 0; | |
570 break; | |
571 case _thread_in_native: | |
572 case _thread_in_native_trans: | |
573 case _thread_blocked: | |
574 case _thread_blocked_trans: | |
575 case _thread_in_vm: | |
576 case _thread_in_vm_trans: | |
577 { | |
578 frame fr; | |
579 | |
580 // param isInJava == false - indicate we aren't in Java code | |
581 if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) { | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
582 trace->num_frames = ticks_unknown_not_Java; // -3 unknown frame |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
583 } else { |
0 | 584 if (!thread->has_last_Java_frame()) { |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
585 trace->num_frames = 0; // No Java frames |
0 | 586 } else { |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
587 trace->num_frames = ticks_not_walkable_not_Java; // -4 non walkable frame by default |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
588 forte_fill_call_trace_given_top(thread, trace, depth, fr); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
589 |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
590 // This assert would seem to be valid but it is not. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
591 // It would be valid if we weren't possibly racing a gc |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
592 // thread. A gc thread can make a valid interpreted frame |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
593 // look invalid. It's a small window but it does happen. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
594 // The assert is left here commented out as a reminder. |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
595 // assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable"); |
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
596 |
0 | 597 } |
598 } | |
599 } | |
600 break; | |
601 case _thread_in_Java: | |
602 case _thread_in_Java_trans: | |
603 { | |
604 frame fr; | |
605 | |
606 // param isInJava == true - indicate we are in Java code | |
607 if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) { | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
608 trace->num_frames = ticks_unknown_Java; // -5 unknown frame |
0 | 609 } else { |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
610 trace->num_frames = ticks_not_walkable_Java; // -6, non walkable frame by default |
0 | 611 forte_fill_call_trace_given_top(thread, trace, depth, fr); |
612 } | |
613 } | |
614 break; | |
615 default: | |
616 // Unknown thread state | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
617 trace->num_frames = ticks_unknown_state; // -7 |
0 | 618 break; |
619 } | |
620 } | |
621 | |
622 | |
623 #ifndef _WINDOWS | |
624 // Support for the Forte(TM) Peformance Tools collector. | |
625 // | |
626 // The method prototype is derived from libcollector.h. For more | |
627 // information, please see the libcollect man page. | |
628 | |
629 // Method to let libcollector know about a dynamically loaded function. | |
630 // Because it is weakly bound, the calls become NOP's when the library | |
631 // isn't present. | |
632 void collector_func_load(char* name, | |
633 void* null_argument_1, | |
634 void* null_argument_2, | |
635 void *vaddr, | |
636 int size, | |
637 int zero_argument, | |
638 void* null_argument_3); | |
639 #pragma weak collector_func_load | |
640 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \ | |
641 ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),0 : 0 ) | |
642 #endif // !_WINDOWS | |
643 | |
644 } // end extern "C" | |
645 #endif // !IA64 | |
646 | |
647 void Forte::register_stub(const char* name, address start, address end) { | |
648 #if !defined(_WINDOWS) && !defined(IA64) | |
649 assert(pointer_delta(end, start, sizeof(jbyte)) < INT_MAX, | |
650 "Code size exceeds maximum range") | |
651 | |
652 collector_func_load((char*)name, NULL, NULL, start, | |
653 pointer_delta(end, start, sizeof(jbyte)), 0, NULL); | |
654 #endif // !_WINDOWS && !IA64 | |
655 } |