212 // ok. adapter blobs never have a frame complete and are never ok.
213
214 if (!_cb->is_frame_complete_at(_pc)) {
215 if (_cb->is_compiled() || _cb->is_adapter_blob() || _cb->is_runtime_stub()) {
216 return false;
217 }
218 }
219
220 // Could just be some random pointer within the codeBlob
221 if (!_cb->code_contains(_pc)) {
222 return false;
223 }
224
225 // Entry frame checks
226 if (is_entry_frame()) {
227 // an entry frame must have a valid fp.
228
229 if (!fp_safe) {
230 return false;
231 }
232
233 // Validate the JavaCallWrapper an entry frame must have
234
235 address jcw = (address)entry_frame_call_wrapper();
236
237 bool jcw_safe = (jcw <= thread->stack_base()) && ( jcw > _FP);
238
239 return jcw_safe;
240
241 }
242
243 intptr_t* younger_sp = sp();
244 intptr_t* _SENDER_SP = sender_sp(); // sender is actually just _FP
245 bool adjusted_stack = is_interpreted_frame();
246
247 address sender_pc = (address)younger_sp[I7->sp_offset_in_saved_window()] + pc_return_offset;
248
249
250 // We must always be able to find a recognizable pc
251 CodeBlob* sender_blob = CodeCache::find_blob_unsafe(sender_pc);
252 if (sender_pc == NULL || sender_blob == NULL) {
253 return false;
254 }
255
256 // Could be a zombie method
257 if (sender_blob->is_zombie() || sender_blob->is_unloaded()) {
258 return false;
259 }
260
273 if (!sender_fp_safe) {
274 return false;
275 }
276
277
278 // If the potential sender is the interpreter then we can do some more checking
279 if (Interpreter::contains(sender_pc)) {
280 return sender.is_interpreted_frame_valid(thread);
281 }
282
283 // Could just be some random pointer within the codeBlob
284 if (!sender.cb()->code_contains(sender_pc)) {
285 return false;
286 }
287
288 // We should never be able to see an adapter if the current frame is something from code cache
289 if (sender_blob->is_adapter_blob()) {
290 return false;
291 }
292
293 if( sender.is_entry_frame()) {
294 // Validate the JavaCallWrapper an entry frame must have
295
296 address jcw = (address)sender.entry_frame_call_wrapper();
297
298 bool jcw_safe = (jcw <= thread->stack_base()) && ( jcw > sender_fp);
299
300 return jcw_safe;
301 }
302
303 // If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size
304 // because you must allocate window space
305
306 if (sender_blob->frame_size() <= 0) {
307 assert(!sender_blob->is_compiled(), "should count return address at least");
308 return false;
309 }
310
311 // The sender should positively be an nmethod or call_stub. On sparc we might in fact see something else.
312 // The cause of this is because at a save instruction the O7 we get is a leftover from an earlier
313 // window use. So if a runtime stub creates two frames (common in fastdebug/debug) then we see the
314 // stale pc. So if the sender blob is not something we'd expect we have little choice but to declare
315 // the stack unwalkable. pd_get_top_frame_for_signal_handler tries to recover from this by unwinding
316 // that initial frame and retrying.
317
318 if (!sender_blob->is_compiled()) {
319 return false;
320 }
|
212 // ok. adapter blobs never have a frame complete and are never ok.
213
214 if (!_cb->is_frame_complete_at(_pc)) {
215 if (_cb->is_compiled() || _cb->is_adapter_blob() || _cb->is_runtime_stub()) {
216 return false;
217 }
218 }
219
220 // Could just be some random pointer within the codeBlob
221 if (!_cb->code_contains(_pc)) {
222 return false;
223 }
224
225 // Entry frame checks
226 if (is_entry_frame()) {
227 // an entry frame must have a valid fp.
228
229 if (!fp_safe) {
230 return false;
231 }
232 return entry_frame_is_safe(thread);
233 }
234
235 intptr_t* younger_sp = sp();
236 intptr_t* _SENDER_SP = sender_sp(); // sender is actually just _FP
237 bool adjusted_stack = is_interpreted_frame();
238
239 address sender_pc = (address)younger_sp[I7->sp_offset_in_saved_window()] + pc_return_offset;
240
241
242 // We must always be able to find a recognizable pc
243 CodeBlob* sender_blob = CodeCache::find_blob_unsafe(sender_pc);
244 if (sender_pc == NULL || sender_blob == NULL) {
245 return false;
246 }
247
248 // Could be a zombie method
249 if (sender_blob->is_zombie() || sender_blob->is_unloaded()) {
250 return false;
251 }
252
265 if (!sender_fp_safe) {
266 return false;
267 }
268
269
270 // If the potential sender is the interpreter then we can do some more checking
271 if (Interpreter::contains(sender_pc)) {
272 return sender.is_interpreted_frame_valid(thread);
273 }
274
275 // Could just be some random pointer within the codeBlob
276 if (!sender.cb()->code_contains(sender_pc)) {
277 return false;
278 }
279
280 // We should never be able to see an adapter if the current frame is something from code cache
281 if (sender_blob->is_adapter_blob()) {
282 return false;
283 }
284
285 if (sender.is_entry_frame()) {
286 return sender.entry_frame_is_safe(thread);
287 }
288
289 // If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size
290 // because you must allocate window space
291
292 if (sender_blob->frame_size() <= 0) {
293 assert(!sender_blob->is_compiled(), "should count return address at least");
294 return false;
295 }
296
297 // The sender should positively be an nmethod or call_stub. On sparc we might in fact see something else.
298 // The cause of this is because at a save instruction the O7 we get is a leftover from an earlier
299 // window use. So if a runtime stub creates two frames (common in fastdebug/debug) then we see the
300 // stale pc. So if the sender blob is not something we'd expect we have little choice but to declare
301 // the stack unwalkable. pd_get_top_frame_for_signal_handler tries to recover from this by unwinding
302 // that initial frame and retrying.
303
304 if (!sender_blob->is_compiled()) {
305 return false;
306 }
|