// Begins stack walking. // // Parameters: // stackStream StackStream object // mode Stack walking mode. // skip_frames Number of frames to be skipped. // frame_count Number of frames to be traversed. // start_index Start index to the user-supplied buffers. // frames_array Buffer to store StackFrame in, starting at start_index. // frames array is a Class<?>[] array when only getting caller // reference, and a StackFrameInfo[] array (or derivative) // otherwise. It should never be null. // // Returns Object returned from AbstractStackWalker::doStackWalk call. // oop StackWalk::walk(Handle stackStream, jlong mode, int skip_frames, int frame_count, int start_index, objArrayHandle frames_array, TRAPS) { ResourceMark rm(THREAD); JavaThread* jt = (JavaThread*)THREAD; log_debug(stackwalk)("Start walking: mode " JLONG_FORMAT " skip %d frames batch size %d", mode, skip_frames, frame_count); if (frames_array.is_null()) { THROW_MSG_(vmSymbols::java_lang_NullPointerException(), "frames_array is NULL", NULL); } // Setup traversal onto my stack. if (live_frame_info(mode)) { assert (use_frames_array(mode), "Bad mode for get live frame"); RegisterMap regMap(jt, true); LiveFrameStream stream(jt, ®Map); return fetchFirstBatch(stream, stackStream, mode, skip_frames, frame_count, start_index, frames_array, THREAD); } else { JavaFrameStream stream(jt, mode); return fetchFirstBatch(stream, stackStream, mode, skip_frames, frame_count, start_index, frames_array, THREAD); } }
// Begins stack walking. // // Parameters: // stackStream StackStream object // mode Stack walking mode. // skip_frames Number of frames to be skipped. // frame_count Number of frames to be traversed. // start_index Start index to the user-supplied buffers. // frames_array Buffer to store StackFrame in, starting at start_index. // frames array is a Class<?>[] array when only getting caller // reference, and a StackFrameInfo[] array (or derivative) // otherwise. It should never be null. // // Returns Object returned from AbstractStackWalker::doStackWalk call. // oop StackWalk::walk(Handle stackStream, jlong mode, int skip_frames, int frame_count, int start_index, objArrayHandle frames_array, TRAPS) { ResourceMark rm(THREAD); JavaThread* jt = (JavaThread*)THREAD; if (TraceStackWalk) { tty->print_cr("Start walking: mode " JLONG_FORMAT " skip %d frames batch size %d", mode, skip_frames, frame_count); } if (frames_array.is_null()) { THROW_MSG_(vmSymbols::java_lang_NullPointerException(), "frames_array is NULL", NULL); } Klass* stackWalker_klass = SystemDictionary::StackWalker_klass(); Klass* abstractStackWalker_klass = SystemDictionary::AbstractStackWalker_klass(); methodHandle m_doStackWalk(THREAD, Universe::do_stack_walk_method()); // Setup traversal onto my stack. RegisterMap regMap(jt, true); JavaFrameStream stream(jt, ®Map); { while (!stream.at_end()) { InstanceKlass* ik = stream.method()->method_holder(); if (ik != stackWalker_klass && ik != abstractStackWalker_klass && ik->super() != abstractStackWalker_klass) { break; } if (TraceStackWalk) { tty->print(" skip "); stream.method()->print_short_name(); tty->print("\n"); } stream.next(); } // stack frame has been traversed individually and resume stack walk // from the stack frame at depth == skip_frames. for (int n=0; n < skip_frames && !stream.at_end(); stream.next(), n++) { if (TraceStackWalk) { tty->print(" skip "); stream.method()->print_short_name(); tty->print_cr(" frame id: " PTR_FORMAT " pc: " PTR_FORMAT, p2i(stream.java_frame()->fr().id()), p2i(stream.java_frame()->fr().pc())); } } } int end_index = start_index; int numFrames = 0; if (!stream.at_end()) { numFrames = fill_in_frames(mode, stream, frame_count, start_index, frames_array, end_index, CHECK_NULL); if (numFrames < 1) { THROW_MSG_(vmSymbols::java_lang_InternalError(), "stack walk: decode failed", NULL); } } // JVM_CallStackWalk walks the stack and fills in stack frames, then calls to // Java method java.lang.StackStreamFactory.AbstractStackWalker::doStackWalk // which calls the implementation to consume the stack frames. // When JVM_CallStackWalk returns, it invalidates the stack stream. JavaValue result(T_OBJECT); JavaCallArguments args(stackStream); args.push_long(stream.address_value()); args.push_int(skip_frames); args.push_int(frame_count); args.push_int(start_index); args.push_int(end_index); // Link the thread and vframe stream into the callee-visible object stream.setup_magic_on_entry(frames_array); JavaCalls::call(&result, m_doStackWalk, &args, THREAD); // Do this before anything else happens, to disable any lingering stream objects bool ok = stream.cleanup_magic_on_exit(frames_array); // Throw pending exception if we must (void) (CHECK_NULL); if (!ok) { THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: corrupted buffers on exit", NULL); } // Return normally return (oop)result.get_jobject(); }