void KlassHierarchy::print_class(outputStream* st, KlassInfoEntry* cie, bool print_interfaces) { ResourceMark rm; InstanceKlass* klass = (InstanceKlass*)cie->klass(); int indent = 0; // Print indentation with proper indicators of superclass. Klass* super = klass->super(); while (super != NULL) { super = super->super(); indent++; } print_indent(st, indent); if (indent != 0) st->print("--"); // Print the class name, its unique ClassLoader identifer, and if it is an interface. print_classname(st, klass); if (klass->is_interface()) { st->print(" (intf)"); } st->print("\n"); // Print any interfaces the class has. if (print_interfaces) { Array<Klass*>* local_intfs = klass->local_interfaces(); Array<Klass*>* trans_intfs = klass->transitive_interfaces(); for (int i = 0; i < local_intfs->length(); i++) { print_interface(st, local_intfs->at(i), "declared", indent); } for (int i = 0; i < trans_intfs->length(); i++) { Klass* trans_interface = trans_intfs->at(i); // Only print transitive interfaces if they are not also declared. if (!local_intfs->contains(trans_interface)) { print_interface(st, trans_interface, "inherited", indent); } } } }
oop StackWalk::fetchFirstBatch(BaseFrameStream& stream, Handle stackStream, jlong mode, int skip_frames, int frame_count, int start_index, objArrayHandle frames_array, TRAPS) { methodHandle m_doStackWalk(THREAD, Universe::do_stack_walk_method()); { Klass* stackWalker_klass = SystemDictionary::StackWalker_klass(); Klass* abstractStackWalker_klass = SystemDictionary::AbstractStackWalker_klass(); while (!stream.at_end()) { InstanceKlass* ik = stream.method()->method_holder(); if (ik != stackWalker_klass && ik != abstractStackWalker_klass && ik->super() != abstractStackWalker_klass) { break; } if (log_is_enabled(Debug, stackwalk)) { ResourceMark rm(THREAD); outputStream* st = Log(stackwalk)::debug_stream(); st->print(" skip "); stream.method()->print_short_name(st); st->cr(); } 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 (log_is_enabled(Debug, stackwalk)) { ResourceMark rm(THREAD); outputStream* st = Log(stackwalk)::debug_stream(); st->print(" skip "); stream.method()->print_short_name(st); st->cr(); } } } 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(); }
// 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. // classes_array Buffer to store classes in, starting at start_index. // frames_array Buffer to store StackFrame in, starting at start_index. // NULL if not used. // // Returns Object returned from AbstractStackWalker::doStackWalk call. // oop StackWalk::walk(Handle stackStream, jlong mode, int skip_frames, int frame_count, int start_index, objArrayHandle classes_array, objArrayHandle frames_array, TRAPS) { 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 (need_method_info(mode)) { 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()); // Open up a traversable stream onto my stack. // This stream will be made available by *reference* to the inner Java call. StackWalkAnchor anchor(jt); vframeStream& vfst = anchor.vframe_stream(); { // Skip all methods from AbstractStackWalker and StackWalk (enclosing method) if (!fill_in_stacktrace(mode)) { while (!vfst.at_end()) { InstanceKlass* ik = vfst.method()->method_holder(); if (ik != stackWalker_klass && ik != abstractStackWalker_klass && ik->super() != abstractStackWalker_klass) { break; } if (TraceStackWalk) { tty->print(" skip "); vfst.method()->print_short_name(); tty->print("\n"); } vfst.next(); } } // For exceptions, skip Throwable::fillInStackTrace and <init> methods // of the exception class and superclasses if (fill_in_stacktrace(mode)) { bool skip_to_fillInStackTrace = false; bool skip_throwableInit_check = false; while (!vfst.at_end() && !skip_throwableInit_check) { InstanceKlass* ik = vfst.method()->method_holder(); Method* method = vfst.method(); if (!skip_to_fillInStackTrace) { if (ik == SystemDictionary::Throwable_klass() && method->name() == vmSymbols::fillInStackTrace_name()) { // this frame will be skipped skip_to_fillInStackTrace = true; } } else if (!(ik->is_subclass_of(SystemDictionary::Throwable_klass()) && method->name() == vmSymbols::object_initializer_name())) { // there are none or we've seen them all - either way stop checking skip_throwableInit_check = true; break; } if (TraceStackWalk) { tty->print("stack walk: skip "); vfst.method()->print_short_name(); tty->print("\n"); } vfst.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 && !vfst.at_end(); vfst.next(), n++) { if (TraceStackWalk) { tty->print(" skip "); vfst.method()->print_short_name(); tty->print_cr(" frame id: " PTR_FORMAT " pc: " PTR_FORMAT, p2i(vfst.frame_id()), p2i(vfst.frame_pc())); } } } // The Method* pointer in the vfst has a very short shelf life. Grab it now. int end_index = start_index; int numFrames = 0; if (!vfst.at_end()) { numFrames = fill_in_frames(mode, vfst, frame_count, start_index, classes_array, 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(anchor.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 anchor.setup_magic_on_entry(classes_array); JavaCalls::call(&result, m_doStackWalk, &args, THREAD); // Do this before anything else happens, to disable any lingering stream objects bool ok = anchor.cleanup_magic_on_exit(classes_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(); }
// 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(); }