jdk-sandbox: comparison hotspot/src/share/vm/prims/stackwalk.cpp

equal deleted inserted replaced

-:f824aabc7af8
+:873c4aea8d1b
 #include "runtime/javaCalls.hpp"
 #include "runtime/vframe.hpp"
 #include "utilities/globalDefinitions.hpp"
 // setup and cleanup actions
-void StackWalkAnchor::setup_magic_on_entry(objArrayHandle classes_array) {
+void StackWalkAnchor::setup_magic_on_entry(objArrayHandle frames_array) {
-classes_array->obj_at_put(magic_pos, _thread->threadObj());
+frames_array->obj_at_put(magic_pos, _thread->threadObj());
 _anchor = address_value();
-assert(check_magic(classes_array), "invalid magic");
+assert(check_magic(frames_array), "invalid magic");
 }
-bool StackWalkAnchor::check_magic(objArrayHandle classes_array) {
+bool StackWalkAnchor::check_magic(objArrayHandle frames_array) {
-oop   m1 = classes_array->obj_at(magic_pos);
+oop   m1 = frames_array->obj_at(magic_pos);
 jlong m2 = _anchor;
 if (m1 == _thread->threadObj() && m2 == address_value())  return true;
 return false;
 }
-bool StackWalkAnchor::cleanup_magic_on_exit(objArrayHandle classes_array) {
+bool StackWalkAnchor::cleanup_magic_on_exit(objArrayHandle frames_array) {
-bool ok = check_magic(classes_array);
+bool ok = check_magic(frames_array);
-classes_array->obj_at_put(magic_pos, NULL);
+frames_array->obj_at_put(magic_pos, NULL);
 _anchor = 0L;
 return ok;
 }
 // Returns StackWalkAnchor for the current stack being traversed.
 //
 // Parameters:
 //  thread         Current Java thread.
 //  magic          Magic value used for each stack walking
-//  classes_array  User-supplied buffers.  The 0th element is reserved
+//  frames_array   User-supplied buffers.  The 0th element is reserved
 //                 to this StackWalkAnchor to use
 //
 StackWalkAnchor* StackWalkAnchor::from_current(JavaThread* thread, jlong magic,
-objArrayHandle classes_array)
+objArrayHandle frames_array)
 {
 assert(thread != NULL && thread->is_Java_thread(), "");
-oop m1 = classes_array->obj_at(magic_pos);
+oop m1 = frames_array->obj_at(magic_pos);
 if (m1 != thread->threadObj())      return NULL;
 if (magic == 0L)                    return NULL;
 StackWalkAnchor* anchor = (StackWalkAnchor*) (intptr_t) magic;
-if (!anchor->is_valid_in(thread, classes_array))   return NULL;
+if (!anchor->is_valid_in(thread, frames_array))   return NULL;
 return anchor;
 }
 // Unpacks one or more frames into user-supplied buffers.
 // Updates the end index, and returns the number of unpacked frames.
 // Parameters:
 //   mode           Restrict which frames to be decoded.
 //   vfst           vFrameStream.
 //   max_nframes    Maximum number of frames to be filled.
 //   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 Class or StackFrame in, starting at start_index.
-//   frames_array   Buffer to store StackFrame in, starting at start_index.
+//                  frames array is a Class<?>[] array when only getting caller
-//                  NULL if not used.
+//                  reference, and a StackFrameInfo[] array (or derivative)
+//                  otherwise. It should never be null.
 //   end_index      End index to the user-supplied buffers with unpacked frames.
 //
 // Returns the number of frames whose information was transferred into the buffers.
 //
 int StackWalk::fill_in_frames(jlong mode, vframeStream& vfst,
 int max_nframes, int start_index,
-objArrayHandle  classes_array,
 objArrayHandle  frames_array,
 int& end_index, TRAPS) {
 if (TraceStackWalk) {
 tty->print_cr("fill_in_frames limit=%d start=%d frames length=%d",
-max_nframes, start_index, classes_array->length());
+max_nframes, start_index, frames_array->length());
 }
 assert(max_nframes > 0, "invalid max_nframes");
-assert(start_index + max_nframes <= classes_array->length(), "oob");
+assert(start_index + max_nframes <= frames_array->length(), "oob");
 int frames_decoded = 0;
 for (; !vfst.at_end(); vfst.next()) {
 Method* method = vfst.method();
 int bci = vfst.bci();
 if (TraceStackWalk) {
 tty->print("  %d: frame method: ", index); method->print_short_name();
 tty->print_cr(" bci=%d", bci);
 }
-classes_array->obj_at_put(index, method->method_holder()->java_mirror());
 // fill in StackFrameInfo and initialize MemberName
 if (live_frame_info(mode)) {
+assert (use_frames_array(mode), "Bad mode for get live frame");
 Handle stackFrame(frames_array->obj_at(index));
 fill_live_stackframe(stackFrame, method, bci, vfst.java_frame(), CHECK_0);
 } else if (need_method_info(mode)) {
+assert (use_frames_array(mode), "Bad mode for get stack frame");
 Handle stackFrame(frames_array->obj_at(index));
 fill_stackframe(stackFrame, method, bci);
+} else {
+assert (use_frames_array(mode) == false, "Bad mode for get caller class");
+frames_array->obj_at_put(index, method->method_holder()->java_mirror());
 }
 if (++frames_decoded >= max_nframes)  break;
 }
 return frames_decoded;
 }
 //   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.
+//                  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 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()) {
-if (frames_array.is_null()) {
+THROW_MSG_(vmSymbols::java_lang_NullPointerException(), "frames_array is NULL", NULL);
-THROW_MSG_(vmSymbols::java_lang_NullPointerException(), "frames_array is NULL", NULL);
-}
 }
 Klass* stackWalker_klass = SystemDictionary::StackWalker_klass();
 Klass* abstractStackWalker_klass = SystemDictionary::AbstractStackWalker_klass();
 // 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)
+while (!vfst.at_end()) {
-if (!fill_in_stacktrace(mode)) {
+InstanceKlass* ik = vfst.method()->method_holder();
-while (!vfst.at_end()) {
+if (ik != stackWalker_klass &&
-InstanceKlass* ik = vfst.method()->method_holder();
+ik != abstractStackWalker_klass && ik->super() != abstractStackWalker_klass)  {
-if (ik != stackWalker_klass &&
+break;
-ik != abstractStackWalker_klass && ik->super() != abstractStackWalker_klass)  {
-break;
-}
-if (TraceStackWalk) {
-tty->print("  skip "); vfst.method()->print_short_name(); tty->print("\n");
-}
-vfst.next();
 }
-}
+if (TraceStackWalk) {
-// For exceptions, skip Throwable::fillInStackTrace and <init> methods
+tty->print("  skip "); vfst.method()->print_short_name(); tty->print("\n");
-// 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();
 }
+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++) {
 // 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,
+numFrames = fill_in_frames(mode, vfst, frame_count, start_index,
 frames_array, end_index, CHECK_NULL);
 if (numFrames < 1) {
 THROW_MSG_(vmSymbols::java_lang_InternalError(), "stack walk: decode failed", NULL);
 }
 }
 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);
+anchor.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 = anchor.cleanup_magic_on_exit(classes_array);
+bool ok = anchor.cleanup_magic_on_exit(frames_array);
 // Throw pending exception if we must
 (void) (CHECK_NULL);
 if (!ok) {
 //   stackStream    StackStream object
 //   mode           Stack walking mode.
 //   magic          Must be valid value to continue the stack walk
 //   frame_count    Number of frames to be decoded.
 //   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 the end index of frame filled in the buffer.
 //
 jint StackWalk::moreFrames(Handle stackStream, jlong mode, jlong magic,
 int frame_count, int start_index,
-objArrayHandle classes_array,
 objArrayHandle frames_array,
 TRAPS)
 {
 JavaThread* jt = (JavaThread*)THREAD;
-StackWalkAnchor* existing_anchor = StackWalkAnchor::from_current(jt, magic, classes_array);
+StackWalkAnchor* existing_anchor = StackWalkAnchor::from_current(jt, magic, frames_array);
 if (existing_anchor == NULL) {
 THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: corrupted buffers", 0L);
 }
-if ((need_method_info(mode) || live_frame_info(mode)) && frames_array.is_null()) {
+if (frames_array.is_null()) {
 THROW_MSG_(vmSymbols::java_lang_NullPointerException(), "frames_array is NULL", 0L);
 }
 if (TraceStackWalk) {
 tty->print_cr("StackWalk::moreFrames frame_count %d existing_anchor " PTR_FORMAT " start %d frames %d",
-frame_count, p2i(existing_anchor), start_index, classes_array->length());
+frame_count, p2i(existing_anchor), start_index, frames_array->length());
 }
 int end_index = start_index;
 if (frame_count <= 0) {
 return end_index;        // No operation.
 }
 int count = frame_count + start_index;
-assert (classes_array->length() >= count, "not enough space in buffers");
+assert (frames_array->length() >= count, "not enough space in buffers");
 StackWalkAnchor& anchor = (*existing_anchor);
 vframeStream& vfst = anchor.vframe_stream();
 if (!vfst.at_end()) {
 vfst.next();  // this was the last frame decoded in the previous batch
 if (!vfst.at_end()) {
-int n = fill_in_frames(mode, vfst, frame_count, start_index, classes_array,
+int n = fill_in_frames(mode, vfst, frame_count, start_index,
 frames_array, end_index, CHECK_0);
 if (n < 1) {
 THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: later decode failed", 0L);
 }
 return end_index;

changeset 37438	873c4aea8d1b
parent 34253	ba3946143842
child 38213	2f32787e31b1