Thu, 09 Dec 2010 15:04:26 -0500
7004582: Add GetThisObject() function to JVMTI 1.2
Summary: Add 'GetThisObject' function
Reviewed-by: never, coleenp
1 /*
2 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #include "precompiled.hpp"
26 #include "code/debugInfoRec.hpp"
27 #include "code/pcDesc.hpp"
28 #include "gc_interface/collectedHeap.inline.hpp"
29 #include "memory/space.hpp"
30 #include "memory/universe.inline.hpp"
31 #include "oops/oop.inline.hpp"
32 #include "oops/oop.inline2.hpp"
33 #include "prims/forte.hpp"
34 #include "runtime/thread.hpp"
35 #include "runtime/vframe.hpp"
36 #include "runtime/vframeArray.hpp"
38 // These name match the names reported by the forte quality kit
39 enum {
40 ticks_no_Java_frame = 0,
41 ticks_no_class_load = -1,
42 ticks_GC_active = -2,
43 ticks_unknown_not_Java = -3,
44 ticks_not_walkable_not_Java = -4,
45 ticks_unknown_Java = -5,
46 ticks_not_walkable_Java = -6,
47 ticks_unknown_state = -7,
48 ticks_thread_exit = -8,
49 ticks_deopt = -9,
50 ticks_safepoint = -10
51 };
53 //-------------------------------------------------------
55 // Native interfaces for use by Forte tools.
58 #ifndef IA64
60 class vframeStreamForte : public vframeStreamCommon {
61 public:
62 // constructor that starts with sender of frame fr (top_frame)
63 vframeStreamForte(JavaThread *jt, frame fr, bool stop_at_java_call_stub);
64 void forte_next();
65 };
68 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm);
69 static bool is_decipherable_interpreted_frame(JavaThread* thread,
70 frame* fr,
71 methodOop* method_p,
72 int* bci_p);
77 vframeStreamForte::vframeStreamForte(JavaThread *jt,
78 frame fr,
79 bool stop_at_java_call_stub) : vframeStreamCommon(jt) {
81 _stop_at_java_call_stub = stop_at_java_call_stub;
82 _frame = fr;
84 // We must always have a valid frame to start filling
86 bool filled_in = fill_from_frame();
88 assert(filled_in, "invariant");
90 }
93 // Solaris SPARC Compiler1 needs an additional check on the grandparent
94 // of the top_frame when the parent of the top_frame is interpreted and
95 // the grandparent is compiled. However, in this method we do not know
96 // the relationship of the current _frame relative to the top_frame so
97 // we implement a more broad sanity check. When the previous callee is
98 // interpreted and the current sender is compiled, we verify that the
99 // current sender is also walkable. If it is not walkable, then we mark
100 // the current vframeStream as at the end.
101 void vframeStreamForte::forte_next() {
102 // handle frames with inlining
103 if (_mode == compiled_mode &&
104 vframeStreamCommon::fill_in_compiled_inlined_sender()) {
105 return;
106 }
108 // handle general case
110 int loop_count = 0;
111 int loop_max = MaxJavaStackTraceDepth * 2;
114 do {
116 loop_count++;
118 // By the time we get here we should never see unsafe but better
119 // safe then segv'd
121 if (loop_count > loop_max || !_frame.safe_for_sender(_thread)) {
122 _mode = at_end_mode;
123 return;
124 }
126 _frame = _frame.sender(&_reg_map);
128 } while (!fill_from_frame());
129 }
131 // Determine if 'fr' is a decipherable compiled frame. We are already
132 // assured that fr is for a java nmethod.
134 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm) {
135 assert(nm->is_java_method(), "invariant");
137 if (thread->has_last_Java_frame() && thread->last_Java_pc() == fr->pc()) {
138 // We're stopped at a call into the JVM so look for a PcDesc with
139 // the actual pc reported by the frame.
140 PcDesc* pc_desc = nm->pc_desc_at(fr->pc());
142 // Did we find a useful PcDesc?
143 if (pc_desc != NULL &&
144 pc_desc->scope_decode_offset() != DebugInformationRecorder::serialized_null) {
145 return true;
146 }
147 }
149 // We're at some random pc in the nmethod so search for the PcDesc
150 // whose pc is greater than the current PC. It's done this way
151 // because the extra PcDescs that are recorded for improved debug
152 // info record the end of the region covered by the ScopeDesc
153 // instead of the beginning.
154 PcDesc* pc_desc = nm->pc_desc_near(fr->pc() + 1);
156 // Now do we have a useful PcDesc?
157 if (pc_desc == NULL ||
158 pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
159 // No debug information available for this pc
160 // vframeStream would explode if we try and walk the frames.
161 return false;
162 }
164 // This PcDesc is useful however we must adjust the frame's pc
165 // so that the vframeStream lookups will use this same pc
166 fr->set_pc(pc_desc->real_pc(nm));
167 return true;
168 }
171 // Determine if 'fr' is a walkable interpreted frame. Returns false
172 // if it is not. *method_p, and *bci_p are not set when false is
173 // returned. *method_p is non-NULL if frame was executing a Java
174 // method. *bci_p is != -1 if a valid BCI in the Java method could
175 // be found.
176 // Note: this method returns true when a valid Java method is found
177 // even if a valid BCI cannot be found.
179 static bool is_decipherable_interpreted_frame(JavaThread* thread,
180 frame* fr,
181 methodOop* method_p,
182 int* bci_p) {
183 assert(fr->is_interpreted_frame(), "just checking");
185 // top frame is an interpreted frame
186 // check if it is walkable (i.e. valid methodOop and valid bci)
188 // Because we may be racing a gc thread the method and/or bci
189 // of a valid interpreter frame may look bad causing us to
190 // fail the is_interpreted_frame_valid test. If the thread
191 // is in any of the following states we are assured that the
192 // frame is in fact valid and we must have hit the race.
194 JavaThreadState state = thread->thread_state();
195 bool known_valid = (state == _thread_in_native ||
196 state == _thread_in_vm ||
197 state == _thread_blocked );
199 if (known_valid || fr->is_interpreted_frame_valid(thread)) {
201 // The frame code should completely validate the frame so that
202 // references to methodOop and bci are completely safe to access
203 // If they aren't the frame code should be fixed not this
204 // code. However since gc isn't locked out the values could be
205 // stale. This is a race we can never completely win since we can't
206 // lock out gc so do one last check after retrieving their values
207 // from the frame for additional safety
209 methodOop method = fr->interpreter_frame_method();
211 // We've at least found a method.
212 // NOTE: there is something to be said for the approach that
213 // if we don't find a valid bci then the method is not likely
214 // a valid method. Then again we may have caught an interpreter
215 // frame in the middle of construction and the bci field is
216 // not yet valid.
218 *method_p = method;
220 // See if gc may have invalidated method since we validated frame
222 if (!Universe::heap()->is_valid_method(method)) return false;
224 intptr_t bcx = fr->interpreter_frame_bcx();
226 int bci = method->validate_bci_from_bcx(bcx);
228 // note: bci is set to -1 if not a valid bci
229 *bci_p = bci;
230 return true;
231 }
233 return false;
234 }
237 // Determine if 'fr' can be used to find an initial Java frame.
238 // Return false if it can not find a fully decipherable Java frame
239 // (in other words a frame that isn't safe to use in a vframe stream).
240 // Obviously if it can't even find a Java frame false will also be returned.
241 //
242 // If we find a Java frame decipherable or not then by definition we have
243 // identified a method and that will be returned to the caller via method_p.
244 // If we can determine a bci that is returned also. (Hmm is it possible
245 // to return a method and bci and still return false? )
246 //
247 // The initial Java frame we find (if any) is return via initial_frame_p.
248 //
250 static bool find_initial_Java_frame(JavaThread* thread,
251 frame* fr,
252 frame* initial_frame_p,
253 methodOop* method_p,
254 int* bci_p) {
256 // It is possible that for a frame containing an nmethod
257 // we can capture the method but no bci. If we get no
258 // bci the frame isn't walkable but the method is usable.
259 // Therefore we init the returned methodOop to NULL so the
260 // caller can make the distinction.
262 *method_p = NULL;
264 // On the initial call to this method the frame we get may not be
265 // recognizable to us. This should only happen if we are in a JRT_LEAF
266 // or something called by a JRT_LEAF method.
270 frame candidate = *fr;
272 // If the starting frame we were given has no codeBlob associated with
273 // it see if we can find such a frame because only frames with codeBlobs
274 // are possible Java frames.
276 if (fr->cb() == NULL) {
278 // See if we can find a useful frame
279 int loop_count;
280 int loop_max = MaxJavaStackTraceDepth * 2;
281 RegisterMap map(thread, false);
283 for (loop_count = 0; loop_count < loop_max; loop_count++) {
284 if (!candidate.safe_for_sender(thread)) return false;
285 candidate = candidate.sender(&map);
286 if (candidate.cb() != NULL) break;
287 }
288 if (candidate.cb() == NULL) return false;
289 }
291 // We have a frame known to be in the codeCache
292 // We will hopefully be able to figure out something to do with it.
293 int loop_count;
294 int loop_max = MaxJavaStackTraceDepth * 2;
295 RegisterMap map(thread, false);
297 for (loop_count = 0; loop_count < loop_max; loop_count++) {
299 if (candidate.is_first_frame()) {
300 // If initial frame is frame from StubGenerator and there is no
301 // previous anchor, there are no java frames associated with a method
302 return false;
303 }
305 if (candidate.is_interpreted_frame()) {
306 if (is_decipherable_interpreted_frame(thread, &candidate, method_p, bci_p)) {
307 *initial_frame_p = candidate;
308 return true;
309 }
311 // Hopefully we got some data
312 return false;
313 }
315 if (candidate.cb()->is_nmethod()) {
317 nmethod* nm = (nmethod*) candidate.cb();
318 *method_p = nm->method();
320 // If the frame isn't fully decipherable then the default
321 // value for the bci is a signal that we don't have a bci.
322 // If we have a decipherable frame this bci value will
323 // not be used.
325 *bci_p = -1;
327 *initial_frame_p = candidate;
329 // Native wrapper code is trivial to decode by vframeStream
331 if (nm->is_native_method()) return true;
333 // If it isn't decipherable then we have found a pc that doesn't
334 // have a PCDesc that can get us a bci however we did find
335 // a method
337 if (!is_decipherable_compiled_frame(thread, &candidate, nm)) {
338 return false;
339 }
341 // is_decipherable_compiled_frame may modify candidate's pc
342 *initial_frame_p = candidate;
344 assert(nm->pc_desc_at(candidate.pc()) != NULL, "if it's decipherable then pc must be valid");
346 return true;
347 }
349 // Must be some stub frame that we don't care about
351 if (!candidate.safe_for_sender(thread)) return false;
352 candidate = candidate.sender(&map);
354 // If it isn't in the code cache something is wrong
355 // since once we find a frame in the code cache they
356 // all should be there.
358 if (candidate.cb() == NULL) return false;
360 }
362 return false;
364 }
367 // call frame copied from old .h file and renamed
368 typedef struct {
369 jint lineno; // line number in the source file
370 jmethodID method_id; // method executed in this frame
371 } ASGCT_CallFrame;
373 // call trace copied from old .h file and renamed
374 typedef struct {
375 JNIEnv *env_id; // Env where trace was recorded
376 jint num_frames; // number of frames in this trace
377 ASGCT_CallFrame *frames; // frames
378 } ASGCT_CallTrace;
380 static void forte_fill_call_trace_given_top(JavaThread* thd,
381 ASGCT_CallTrace* trace,
382 int depth,
383 frame top_frame) {
384 NoHandleMark nhm;
386 frame initial_Java_frame;
387 methodOop method;
388 int bci;
389 int count;
391 count = 0;
392 assert(trace->frames != NULL, "trace->frames must be non-NULL");
394 bool fully_decipherable = find_initial_Java_frame(thd, &top_frame, &initial_Java_frame, &method, &bci);
396 // The frame might not be walkable but still recovered a method
397 // (e.g. an nmethod with no scope info for the pc
399 if (method == NULL) return;
401 CollectedHeap* ch = Universe::heap();
403 // The method is not stored GC safe so see if GC became active
404 // after we entered AsyncGetCallTrace() and before we try to
405 // use the methodOop.
406 // Yes, there is still a window after this check and before
407 // we use methodOop below, but we can't lock out GC so that
408 // has to be an acceptable risk.
409 if (!ch->is_valid_method(method)) {
410 trace->num_frames = ticks_GC_active; // -2
411 return;
412 }
414 // We got a Java frame however it isn't fully decipherable
415 // so it won't necessarily be safe to use it for the
416 // initial frame in the vframe stream.
418 if (!fully_decipherable) {
419 // Take whatever method the top-frame decoder managed to scrape up.
420 // We look further at the top frame only if non-safepoint
421 // debugging information is available.
422 count++;
423 trace->num_frames = count;
424 trace->frames[0].method_id = method->find_jmethod_id_or_null();
425 if (!method->is_native()) {
426 trace->frames[0].lineno = bci;
427 } else {
428 trace->frames[0].lineno = -3;
429 }
431 if (!initial_Java_frame.safe_for_sender(thd)) return;
433 RegisterMap map(thd, false);
434 initial_Java_frame = initial_Java_frame.sender(&map);
435 }
437 vframeStreamForte st(thd, initial_Java_frame, false);
439 for (; !st.at_end() && count < depth; st.forte_next(), count++) {
440 bci = st.bci();
441 method = st.method();
443 // The method is not stored GC safe so see if GC became active
444 // after we entered AsyncGetCallTrace() and before we try to
445 // use the methodOop.
446 // Yes, there is still a window after this check and before
447 // we use methodOop below, but we can't lock out GC so that
448 // has to be an acceptable risk.
449 if (!ch->is_valid_method(method)) {
450 // we throw away everything we've gathered in this sample since
451 // none of it is safe
452 trace->num_frames = ticks_GC_active; // -2
453 return;
454 }
456 trace->frames[count].method_id = method->find_jmethod_id_or_null();
457 if (!method->is_native()) {
458 trace->frames[count].lineno = bci;
459 } else {
460 trace->frames[count].lineno = -3;
461 }
462 }
463 trace->num_frames = count;
464 return;
465 }
468 // Forte Analyzer AsyncGetCallTrace() entry point. Currently supported
469 // on Linux X86, Solaris SPARC and Solaris X86.
470 //
471 // Async-safe version of GetCallTrace being called from a signal handler
472 // when a LWP gets interrupted by SIGPROF but the stack traces are filled
473 // with different content (see below).
474 //
475 // This function must only be called when JVM/TI
476 // CLASS_LOAD events have been enabled since agent startup. The enabled
477 // event will cause the jmethodIDs to be allocated at class load time.
478 // The jmethodIDs cannot be allocated in a signal handler because locks
479 // cannot be grabbed in a signal handler safely.
480 //
481 // void (*AsyncGetCallTrace)(ASGCT_CallTrace *trace, jint depth, void* ucontext)
482 //
483 // Called by the profiler to obtain the current method call stack trace for
484 // a given thread. The thread is identified by the env_id field in the
485 // ASGCT_CallTrace structure. The profiler agent should allocate a ASGCT_CallTrace
486 // structure with enough memory for the requested stack depth. The VM fills in
487 // the frames buffer and the num_frames field.
488 //
489 // Arguments:
490 //
491 // trace - trace data structure to be filled by the VM.
492 // depth - depth of the call stack trace.
493 // ucontext - ucontext_t of the LWP
494 //
495 // ASGCT_CallTrace:
496 // typedef struct {
497 // JNIEnv *env_id;
498 // jint num_frames;
499 // ASGCT_CallFrame *frames;
500 // } ASGCT_CallTrace;
501 //
502 // Fields:
503 // env_id - ID of thread which executed this trace.
504 // num_frames - number of frames in the trace.
505 // (< 0 indicates the frame is not walkable).
506 // frames - the ASGCT_CallFrames that make up this trace. Callee followed by callers.
507 //
508 // ASGCT_CallFrame:
509 // typedef struct {
510 // jint lineno;
511 // jmethodID method_id;
512 // } ASGCT_CallFrame;
513 //
514 // Fields:
515 // 1) For Java frame (interpreted and compiled),
516 // lineno - bci of the method being executed or -1 if bci is not available
517 // method_id - jmethodID of the method being executed
518 // 2) For native method
519 // lineno - (-3)
520 // method_id - jmethodID of the method being executed
522 extern "C" {
523 void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {
525 // This is if'd out because we no longer use thread suspension.
526 // However if someone wanted to backport this to a 5.0 jvm then this
527 // code would be important.
528 #if 0
529 if (SafepointSynchronize::is_synchronizing()) {
530 // The safepoint mechanism is trying to synchronize all the threads.
531 // Since this can involve thread suspension, it is not safe for us
532 // to be here. We can reduce the deadlock risk window by quickly
533 // returning to the SIGPROF handler. However, it is still possible
534 // for VMThread to catch us here or in the SIGPROF handler. If we
535 // are suspended while holding a resource and another thread blocks
536 // on that resource in the SIGPROF handler, then we will have a
537 // three-thread deadlock (VMThread, this thread, the other thread).
538 trace->num_frames = ticks_safepoint; // -10
539 return;
540 }
541 #endif
543 JavaThread* thread;
545 if (trace->env_id == NULL ||
546 (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL ||
547 thread->is_exiting()) {
549 // bad env_id, thread has exited or thread is exiting
550 trace->num_frames = ticks_thread_exit; // -8
551 return;
552 }
554 if (thread->in_deopt_handler()) {
555 // thread is in the deoptimization handler so return no frames
556 trace->num_frames = ticks_deopt; // -9
557 return;
558 }
560 assert(JavaThread::current() == thread,
561 "AsyncGetCallTrace must be called by the current interrupted thread");
563 if (!JvmtiExport::should_post_class_load()) {
564 trace->num_frames = ticks_no_class_load; // -1
565 return;
566 }
568 if (Universe::heap()->is_gc_active()) {
569 trace->num_frames = ticks_GC_active; // -2
570 return;
571 }
573 switch (thread->thread_state()) {
574 case _thread_new:
575 case _thread_uninitialized:
576 case _thread_new_trans:
577 // We found the thread on the threads list above, but it is too
578 // young to be useful so return that there are no Java frames.
579 trace->num_frames = 0;
580 break;
581 case _thread_in_native:
582 case _thread_in_native_trans:
583 case _thread_blocked:
584 case _thread_blocked_trans:
585 case _thread_in_vm:
586 case _thread_in_vm_trans:
587 {
588 frame fr;
590 // param isInJava == false - indicate we aren't in Java code
591 if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) {
592 trace->num_frames = ticks_unknown_not_Java; // -3 unknown frame
593 } else {
594 if (!thread->has_last_Java_frame()) {
595 trace->num_frames = 0; // No Java frames
596 } else {
597 trace->num_frames = ticks_not_walkable_not_Java; // -4 non walkable frame by default
598 forte_fill_call_trace_given_top(thread, trace, depth, fr);
600 // This assert would seem to be valid but it is not.
601 // It would be valid if we weren't possibly racing a gc
602 // thread. A gc thread can make a valid interpreted frame
603 // look invalid. It's a small window but it does happen.
604 // The assert is left here commented out as a reminder.
605 // assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable");
607 }
608 }
609 }
610 break;
611 case _thread_in_Java:
612 case _thread_in_Java_trans:
613 {
614 frame fr;
616 // param isInJava == true - indicate we are in Java code
617 if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) {
618 trace->num_frames = ticks_unknown_Java; // -5 unknown frame
619 } else {
620 trace->num_frames = ticks_not_walkable_Java; // -6, non walkable frame by default
621 forte_fill_call_trace_given_top(thread, trace, depth, fr);
622 }
623 }
624 break;
625 default:
626 // Unknown thread state
627 trace->num_frames = ticks_unknown_state; // -7
628 break;
629 }
630 }
633 #ifndef _WINDOWS
634 // Support for the Forte(TM) Peformance Tools collector.
635 //
636 // The method prototype is derived from libcollector.h. For more
637 // information, please see the libcollect man page.
639 // Method to let libcollector know about a dynamically loaded function.
640 // Because it is weakly bound, the calls become NOP's when the library
641 // isn't present.
642 void collector_func_load(char* name,
643 void* null_argument_1,
644 void* null_argument_2,
645 void *vaddr,
646 int size,
647 int zero_argument,
648 void* null_argument_3);
649 #pragma weak collector_func_load
650 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \
651 ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),0 : 0 )
652 #endif // !_WINDOWS
654 } // end extern "C"
655 #endif // !IA64
657 void Forte::register_stub(const char* name, address start, address end) {
658 #if !defined(_WINDOWS) && !defined(IA64)
659 assert(pointer_delta(end, start, sizeof(jbyte)) < INT_MAX,
660 "Code size exceeds maximum range");
662 collector_func_load((char*)name, NULL, NULL, start,
663 pointer_delta(end, start, sizeof(jbyte)), 0, NULL);
664 #endif // !_WINDOWS && !IA64
665 }