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

equal deleted inserted replaced

-:ecca632210ef
+:b92a97e1e9cb
 PcDesc* pc_desc = nm->pc_desc_near(fr->pc() + 1);
 // Now do we have a useful PcDesc?
 if (pc_desc == NULL ||
 pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
-// No debug information available for this pc
+// No debug information is available for this PC.
-// vframeStream would explode if we try and walk the frames.
+//
+// vframeStreamCommon::fill_from_frame() will decode the frame depending
+// on the state of the thread.
+//
+// Case #1: If the thread is in Java (state == _thread_in_Java), then
+// the vframeStreamCommon object will be filled as if the frame were a native
+// compiled frame. Therefore, no debug information is needed.
+//
+// Case #2: If the thread is in any other state, then two steps will be performed:
+// - if asserts are enabled, found_bad_method_frame() will be called and
+//   the assert in found_bad_method_frame() will be triggered;
+// - if asserts are disabled, the vframeStreamCommon object will be filled
+//   as if it were a native compiled frame.
+//
+// Case (2) is similar to the way interpreter frames are processed in
+// vframeStreamCommon::fill_from_interpreter_frame in case no valid BCI
+// was found for an interpreted frame. If asserts are enabled, the assert
+// in found_bad_method_frame() will be triggered. If asserts are disabled,
+// the vframeStreamCommon object will be filled afterwards as if the
+// interpreter were at the point of entering into the method.
 return false;
 }
 // This PcDesc is useful however we must adjust the frame's pc
 // so that the vframeStream lookups will use this same pc
 // NOTE: there is something to be said for the approach that
 // if we don't find a valid bci then the method is not likely
 // a valid method. Then again we may have caught an interpreter
 // frame in the middle of construction and the bci field is
 // not yet valid.
-*method_p = method;
 if (!method->is_valid_method()) return false;
+*method_p = method; // If the Method* found is invalid, it is
+// ignored by forte_fill_call_trace_given_top().
+// So set method_p only if the Method is valid.
 address bcp = fr->interpreter_frame_bcp();
 int bci = method->validate_bci_from_bcp(bcp);
 // note: bci is set to -1 if not a valid bci
 return false;
 }
-// Determine if 'fr' can be used to find an initial Java frame.
+// Determine if a Java frame can be found starting with the frame 'fr'.
-// Return false if it can not find a fully decipherable Java frame
+//
-// (in other words a frame that isn't safe to use in a vframe stream).
+// Check the return value of find_initial_Java_frame and the value of
-// Obviously if it can't even find a Java frame false will also be returned.
+// 'method_p' to decide on how use the results returned by this method.
 //
-// If we find a Java frame decipherable or not then by definition we have
+// If 'method_p' is not NULL, an initial Java frame has been found and
-// identified a method and that will be returned to the caller via method_p.
+// the stack can be walked starting from that initial frame. In this case,
-// If we can determine a bci that is returned also. (Hmm is it possible
+// 'method_p' points to the Method that the initial frame belongs to and
-// to return a method and bci and still return false? )
+// the initial Java frame is returned in initial_frame_p.
 //
-// The initial Java frame we find (if any) is return via initial_frame_p.
+// find_initial_Java_frame() returns true if a Method has been found (i.e.,
-//
+// 'method_p' is not NULL) and the initial frame that belongs to that Method
+// is decipherable.
+//
+// A frame is considered to be decipherable:
+//
+// - if the frame is a compiled frame and a PCDesc is available;
+//
+// - if the frame is an interpreter frame that is valid or the thread is
+//   state (_thread_in_native || state == _thread_in_vm || state == _thread_blocked).
+//
+// Note that find_initial_Java_frame() can return false even if an initial
+// Java method was found (e.g., there is no PCDesc available for the method).
+//
+// If 'method_p' is NULL, it was not possible to find a Java frame when
+// walking the stack starting from 'fr'. In this case find_initial_Java_frame
+// returns false.
 static bool find_initial_Java_frame(JavaThread* thread,
 frame* fr,
 frame* initial_frame_p,
 Method** method_p,
 *method_p = NULL;
 // On the initial call to this method the frame we get may not be
 // recognizable to us. This should only happen if we are in a JRT_LEAF
 // or something called by a JRT_LEAF method.
 frame candidate = *fr;
 // If the starting frame we were given has no codeBlob associated with
 // it see if we can find such a frame because only frames with codeBlobs
 if (candidate.cb()->is_nmethod()) {
 nmethod* nm = (nmethod*) candidate.cb();
 *method_p = nm->method();
-// If the frame isn't fully decipherable then the default
+// If the frame is not decipherable, then the value of -1
-// value for the bci is a signal that we don't have a bci.
+// for the BCI is used to signal that no BCI is available.
-// If we have a decipherable frame this bci value will
+// Furthermore, the method returns false in this case.
+//
+// If a decipherable frame is available, the BCI value will
 // not be used.
 *bci_p = -1;
 *initial_frame_p = candidate;
 // Native wrapper code is trivial to decode by vframeStream
 if (nm->is_native_method()) return true;
-// If it isn't decipherable then we have found a pc that doesn't
+// If the frame is not decipherable, then a PC was found
-// have a PCDesc that can get us a bci however we did find
+// that does not have a PCDesc from which a BCI can be obtained.
-// a method
+// Nevertheless, a Method was found.
 if (!is_decipherable_compiled_frame(thread, &candidate, nm)) {
 return false;
 }
 // is_decipherable_compiled_frame may modify candidate's pc
 *initial_frame_p = candidate;
-assert(nm->pc_desc_at(candidate.pc()) != NULL, "if it's decipherable then pc must be valid");
+assert(nm->pc_desc_at(candidate.pc()) != NULL, "debug information must be available if the frame is decipherable");
 return true;
 }
 // Must be some stub frame that we don't care about
 frame top_frame) {
 NoHandleMark nhm;
 frame initial_Java_frame;
 Method* method;
-int bci;
+int bci = -1; // assume BCI is not available for method
+// update with correct information if available
 int count;
 count = 0;
 assert(trace->frames != NULL, "trace->frames must be non-NULL");
-bool fully_decipherable = find_initial_Java_frame(thd, &top_frame, &initial_Java_frame, &method, &bci);
+// Walk the stack starting from 'top_frame' and search for an initial Java frame.
+find_initial_Java_frame(thd, &top_frame, &initial_Java_frame, &method, &bci);
-// The frame might not be walkable but still recovered a method
-// (e.g. an nmethod with no scope info for the pc)
+// Check if a Java Method has been found.
 if (method == NULL) return;
 if (!method->is_valid_method()) {
 trace->num_frames = ticks_GC_active; // -2
 return;
-}
-// We got a Java frame however it isn't fully decipherable
-// so it won't necessarily be safe to use it for the
-// initial frame in the vframe stream.
-if (!fully_decipherable) {
-// Take whatever method the top-frame decoder managed to scrape up.
-// We look further at the top frame only if non-safepoint
-// debugging information is available.
-count++;
-trace->num_frames = count;
-trace->frames[0].method_id = method->find_jmethod_id_or_null();
-if (!method->is_native()) {
-trace->frames[0].lineno = bci;
-} else {
-trace->frames[0].lineno = -3;
-}
-if (!initial_Java_frame.safe_for_sender(thd)) return;
-RegisterMap map(thd, false);
-initial_Java_frame = initial_Java_frame.sender(&map);
 }
 vframeStreamForte st(thd, initial_Java_frame, false);
 for (; !st.at_end() && count < depth; st.forte_next(), count++) {

changeset 30305	b92a97e1e9cb
parent 29081	c61eb4914428
child 30764	fec48bf5a827