hotspot/src/share/vm/prims/forte.cpp - platform/libcore - Git at Google

 /*
  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */

 #include "precompiled.hpp"
 #include "code/debugInfoRec.hpp"
 #include "code/pcDesc.hpp"
 #include "gc_interface/collectedHeap.inline.hpp"
 #include "memory/space.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.inline2.hpp"
 #include "prims/forte.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/thread.inline.hpp"
 #include "runtime/vframe.hpp"
 #include "runtime/vframeArray.hpp"

 // call frame copied from old .h file and renamed
 typedef struct {
     jint lineno;                      // line number in the source file
     jmethodID method_id;              // method executed in this frame
 } ASGCT_CallFrame;

 // call trace copied from old .h file and renamed
 typedef struct {
     JNIEnv *env_id;                   // Env where trace was recorded
     jint num_frames;                  // number of frames in this trace
     ASGCT_CallFrame *frames;          // frames
 } ASGCT_CallTrace;

 // These name match the names reported by the forte quality kit
 enum {
   ticks_no_Java_frame         =  0,
   ticks_no_class_load         = -1,
   ticks_GC_active             = -2,
   ticks_unknown_not_Java      = -3,
   ticks_not_walkable_not_Java = -4,
   ticks_unknown_Java          = -5,
   ticks_not_walkable_Java     = -6,
   ticks_unknown_state         = -7,
   ticks_thread_exit           = -8,
   ticks_deopt                 = -9,
   ticks_safepoint             = -10
 };

 #if INCLUDE_JVMTI

 //-------------------------------------------------------

 // Native interfaces for use by Forte tools.


 #if !defined(IA64) && !defined(PPC64)

 class vframeStreamForte : public vframeStreamCommon {
  public:
   // constructor that starts with sender of frame fr (top_frame)
   vframeStreamForte(JavaThread *jt, frame fr, bool stop_at_java_call_stub);
   void forte_next();
 };


 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm);
 static bool is_decipherable_interpreted_frame(JavaThread* thread,
                                               frame* fr,
                                               Method** method_p,
                                               int* bci_p);


 vframeStreamForte::vframeStreamForte(JavaThread *jt,
                                      frame fr,
                                      bool stop_at_java_call_stub) : vframeStreamCommon(jt) {

   _stop_at_java_call_stub = stop_at_java_call_stub;
   _frame = fr;

   // We must always have a valid frame to start filling

   bool filled_in = fill_from_frame();

   assert(filled_in, "invariant");

 }


 // Solaris SPARC Compiler1 needs an additional check on the grandparent
 // of the top_frame when the parent of the top_frame is interpreted and
 // the grandparent is compiled. However, in this method we do not know
 // the relationship of the current _frame relative to the top_frame so
 // we implement a more broad sanity check. When the previous callee is
 // interpreted and the current sender is compiled, we verify that the
 // current sender is also walkable. If it is not walkable, then we mark
 // the current vframeStream as at the end.
 void vframeStreamForte::forte_next() {
   // handle frames with inlining
   if (_mode == compiled_mode &&
       vframeStreamCommon::fill_in_compiled_inlined_sender()) {
     return;
   }

   // handle general case

   int loop_count = 0;
   int loop_max = MaxJavaStackTraceDepth * 2;


   do {

     loop_count++;

     // By the time we get here we should never see unsafe but better
     // safe then segv'd

     if (loop_count > loop_max || !_frame.safe_for_sender(_thread)) {
       _mode = at_end_mode;
       return;
     }

     _frame = _frame.sender(&_reg_map);

   } while (!fill_from_frame());
 }

 // Determine if 'fr' is a decipherable compiled frame. We are already
 // assured that fr is for a java nmethod.

 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm) {
   assert(nm->is_java_method(), "invariant");

   if (thread->has_last_Java_frame() && thread->last_Java_pc() == fr->pc()) {
     // We're stopped at a call into the JVM so look for a PcDesc with
     // the actual pc reported by the frame.
     PcDesc* pc_desc = nm->pc_desc_at(fr->pc());

     // Did we find a useful PcDesc?
     if (pc_desc != NULL &&
         pc_desc->scope_decode_offset() != DebugInformationRecorder::serialized_null) {
       return true;
     }
   }

   // We're at some random pc in the nmethod so search for the PcDesc
   // whose pc is greater than the current PC.  It's done this way
   // because the extra PcDescs that are recorded for improved debug
   // info record the end of the region covered by the ScopeDesc
   // instead of the beginning.
   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
     // vframeStream would explode if we try and walk the frames.
     return false;
   }

   // This PcDesc is useful however we must adjust the frame's pc
   // so that the vframeStream lookups will use this same pc
   fr->set_pc(pc_desc->real_pc(nm));
   return true;
 }


 // Determine if 'fr' is a walkable interpreted frame. Returns false
 // if it is not. *method_p, and *bci_p are not set when false is
 // returned. *method_p is non-NULL if frame was executing a Java
 // method. *bci_p is != -1 if a valid BCI in the Java method could
 // be found.
 // Note: this method returns true when a valid Java method is found
 // even if a valid BCI cannot be found.

 static bool is_decipherable_interpreted_frame(JavaThread* thread,
                                               frame* fr,
                                               Method** method_p,
                                               int* bci_p) {
   assert(fr->is_interpreted_frame(), "just checking");

   // top frame is an interpreted frame
   // check if it is walkable (i.e. valid Method* and valid bci)

   // Because we may be racing a gc thread the method and/or bci
   // of a valid interpreter frame may look bad causing us to
   // fail the is_interpreted_frame_valid test. If the thread
   // is in any of the following states we are assured that the
   // frame is in fact valid and we must have hit the race.

   JavaThreadState state = thread->thread_state();
   bool known_valid = (state == _thread_in_native ||
                       state == _thread_in_vm ||
                       state == _thread_blocked );

   if (known_valid || fr->is_interpreted_frame_valid(thread)) {

     // The frame code should completely validate the frame so that
     // references to Method* and bci are completely safe to access
     // If they aren't the frame code should be fixed not this
     // code. However since gc isn't locked out the values could be
     // stale. This is a race we can never completely win since we can't
     // lock out gc so do one last check after retrieving their values
     // from the frame for additional safety

     Method* method = fr->interpreter_frame_method();

     // We've at least found a method.
     // 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;

     intptr_t bcx = fr->interpreter_frame_bcx();

     int      bci = method->validate_bci_from_bcx(bcx);

     // note: bci is set to -1 if not a valid bci
     *bci_p = bci;
     return true;
   }

   return false;
 }


 // Determine if 'fr' can be used to find an initial Java frame.
 // 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).
 // Obviously if it can't even find a Java frame false will also be returned.
 //
 // If we find a Java frame decipherable or not then by definition we have
 // identified a method and that will be returned to the caller via method_p.
 // If we can determine a bci that is returned also. (Hmm is it possible
 // to return a method and bci and still return false? )
 //
 // The initial Java frame we find (if any) is return via initial_frame_p.
 //

 static bool find_initial_Java_frame(JavaThread* thread,
                                     frame* fr,
                                     frame* initial_frame_p,
                                     Method** method_p,
                                     int* bci_p) {

   // It is possible that for a frame containing an nmethod
   // we can capture the method but no bci. If we get no
   // bci the frame isn't walkable but the method is usable.
   // Therefore we init the returned Method* to NULL so the
   // caller can make the distinction.

   *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
   // are possible Java frames.

   if (fr->cb() == NULL) {

     // See if we can find a useful frame
     int loop_count;
     int loop_max = MaxJavaStackTraceDepth * 2;
     RegisterMap map(thread, false);

     for (loop_count = 0; loop_count < loop_max; loop_count++) {
       if (!candidate.safe_for_sender(thread)) return false;
       candidate = candidate.sender(&map);
       if (candidate.cb() != NULL) break;
     }
     if (candidate.cb() == NULL) return false;
   }

   // We have a frame known to be in the codeCache
   // We will hopefully be able to figure out something to do with it.
   int loop_count;
   int loop_max = MaxJavaStackTraceDepth * 2;
   RegisterMap map(thread, false);

   for (loop_count = 0; loop_count < loop_max; loop_count++) {

     if (candidate.is_entry_frame()) {
       // jcw is NULL if the java call wrapper couldn't be found
       JavaCallWrapper *jcw = candidate.entry_frame_call_wrapper_if_safe(thread);
       // If initial frame is frame from StubGenerator and there is no
       // previous anchor, there are no java frames associated with a method
       if (jcw == NULL || jcw->is_first_frame()) {
         return false;
       }
     }

     if (candidate.is_interpreted_frame()) {
       if (is_decipherable_interpreted_frame(thread, &candidate, method_p, bci_p)) {
         *initial_frame_p = candidate;
         return true;
       }

       // Hopefully we got some data
       return false;
     }

     if (candidate.cb()->is_nmethod()) {

       nmethod* nm = (nmethod*) candidate.cb();
       *method_p = nm->method();

       // If the frame isn't fully decipherable then the default
       // value for the bci is a signal that we don't have a bci.
       // If we have a decipherable frame this 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
       // have a PCDesc that can get us a bci however we did find
       // a method

       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");

       return true;
     }

     // Must be some stub frame that we don't care about

     if (!candidate.safe_for_sender(thread)) return false;
     candidate = candidate.sender(&map);

     // If it isn't in the code cache something is wrong
     // since once we find a frame in the code cache they
     // all should be there.

     if (candidate.cb() == NULL) return false;

   }

   return false;

 }

 static void forte_fill_call_trace_given_top(JavaThread* thd,
                                             ASGCT_CallTrace* trace,
                                             int depth,
                                             frame top_frame) {
   NoHandleMark nhm;

   frame initial_Java_frame;
   Method* method;
   int bci;
   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);

   // The frame might not be walkable but still recovered a method
   // (e.g. an nmethod with no scope info for the pc)

   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++) {
     bci = st.bci();
     method = st.method();

     if (!method->is_valid_method()) {
       // we throw away everything we've gathered in this sample since
       // none of it is safe
       trace->num_frames = ticks_GC_active; // -2
       return;
     }

     trace->frames[count].method_id = method->find_jmethod_id_or_null();
     if (!method->is_native()) {
       trace->frames[count].lineno = bci;
     } else {
       trace->frames[count].lineno = -3;
     }
   }
   trace->num_frames = count;
   return;
 }


 // Forte Analyzer AsyncGetCallTrace() entry point. Currently supported
 // on Linux X86, Solaris SPARC and Solaris X86.
 //
 // Async-safe version of GetCallTrace being called from a signal handler
 // when a LWP gets interrupted by SIGPROF but the stack traces are filled
 // with different content (see below).
 //
 // This function must only be called when JVM/TI
 // CLASS_LOAD events have been enabled since agent startup. The enabled
 // event will cause the jmethodIDs to be allocated at class load time.
 // The jmethodIDs cannot be allocated in a signal handler because locks
 // cannot be grabbed in a signal handler safely.
 //
 // void (*AsyncGetCallTrace)(ASGCT_CallTrace *trace, jint depth, void* ucontext)
 //
 // Called by the profiler to obtain the current method call stack trace for
 // a given thread. The thread is identified by the env_id field in the
 // ASGCT_CallTrace structure. The profiler agent should allocate a ASGCT_CallTrace
 // structure with enough memory for the requested stack depth. The VM fills in
 // the frames buffer and the num_frames field.
 //
 // Arguments:
 //
 //   trace    - trace data structure to be filled by the VM.
 //   depth    - depth of the call stack trace.
 //   ucontext - ucontext_t of the LWP
 //
 // ASGCT_CallTrace:
 //   typedef struct {
 //       JNIEnv *env_id;
 //       jint num_frames;
 //       ASGCT_CallFrame *frames;
 //   } ASGCT_CallTrace;
 //
 // Fields:
 //   env_id     - ID of thread which executed this trace.
 //   num_frames - number of frames in the trace.
 //                (< 0 indicates the frame is not walkable).
 //   frames     - the ASGCT_CallFrames that make up this trace. Callee followed by callers.
 //
 //  ASGCT_CallFrame:
 //    typedef struct {
 //        jint lineno;
 //        jmethodID method_id;
 //    } ASGCT_CallFrame;
 //
 //  Fields:
 //    1) For Java frame (interpreted and compiled),
 //       lineno    - bci of the method being executed or -1 if bci is not available
 //       method_id - jmethodID of the method being executed
 //    2) For native method
 //       lineno    - (-3)
 //       method_id - jmethodID of the method being executed

 extern "C" {
 JNIEXPORT
 void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {
   JavaThread* thread;

   if (trace->env_id == NULL ||
     (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL ||
     thread->is_exiting()) {

     // bad env_id, thread has exited or thread is exiting
     trace->num_frames = ticks_thread_exit; // -8
     return;
   }

   if (thread->in_deopt_handler()) {
     // thread is in the deoptimization handler so return no frames
     trace->num_frames = ticks_deopt; // -9
     return;
   }

   assert(JavaThread::current() == thread,
          "AsyncGetCallTrace must be called by the current interrupted thread");

   if (!JvmtiExport::should_post_class_load()) {
     trace->num_frames = ticks_no_class_load; // -1
     return;
   }

   if (Universe::heap()->is_gc_active()) {
     trace->num_frames = ticks_GC_active; // -2
     return;
   }

   switch (thread->thread_state()) {
   case _thread_new:
   case _thread_uninitialized:
   case _thread_new_trans:
     // We found the thread on the threads list above, but it is too
     // young to be useful so return that there are no Java frames.
     trace->num_frames = 0;
     break;
   case _thread_in_native:
   case _thread_in_native_trans:
   case _thread_blocked:
   case _thread_blocked_trans:
   case _thread_in_vm:
   case _thread_in_vm_trans:
     {
       frame fr;

       // param isInJava == false - indicate we aren't in Java code
       if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) {
         trace->num_frames = ticks_unknown_not_Java;  // -3 unknown frame
       } else {
         if (!thread->has_last_Java_frame()) {
           trace->num_frames = 0; // No Java frames
         } else {
           trace->num_frames = ticks_not_walkable_not_Java;    // -4 non walkable frame by default
           forte_fill_call_trace_given_top(thread, trace, depth, fr);

           // This assert would seem to be valid but it is not.
           // It would be valid if we weren't possibly racing a gc
           // thread. A gc thread can make a valid interpreted frame
           // look invalid. It's a small window but it does happen.
           // The assert is left here commented out as a reminder.
           // assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable");

         }
       }
     }
     break;
   case _thread_in_Java:
   case _thread_in_Java_trans:
     {
       frame fr;

       // param isInJava == true - indicate we are in Java code
       if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) {
         trace->num_frames = ticks_unknown_Java;  // -5 unknown frame
       } else {
         trace->num_frames = ticks_not_walkable_Java;  // -6, non walkable frame by default
         forte_fill_call_trace_given_top(thread, trace, depth, fr);
       }
     }
     break;
   default:
     // Unknown thread state
     trace->num_frames = ticks_unknown_state; // -7
     break;
   }
 }


 #ifndef _WINDOWS
 // Support for the Forte(TM) Peformance Tools collector.
 //
 // The method prototype is derived from libcollector.h. For more
 // information, please see the libcollect man page.

 // Method to let libcollector know about a dynamically loaded function.
 // Because it is weakly bound, the calls become NOP's when the library
 // isn't present.
 #ifdef __APPLE__
 // XXXDARWIN: Link errors occur even when __attribute__((weak_import))
 // is added
 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) ((void) 0)
 #else
 void    collector_func_load(char* name,
                             void* null_argument_1,
                             void* null_argument_2,
                             void *vaddr,
                             int size,
                             int zero_argument,
                             void* null_argument_3);
 #pragma weak collector_func_load
 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \
         ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),(void)0 : (void)0 )
 #endif // __APPLE__
 #endif // !_WINDOWS

 } // end extern "C"
 #endif // !IA64 && !PPC64

 void Forte::register_stub(const char* name, address start, address end) {
 #if !defined(_WINDOWS) && !defined(IA64) && !defined(PPC64)
   assert(pointer_delta(end, start, sizeof(jbyte)) < INT_MAX,
          "Code size exceeds maximum range");

   collector_func_load((char*)name, NULL, NULL, start,
     pointer_delta(end, start, sizeof(jbyte)), 0, NULL);
 #endif // !_WINDOWS && !IA64 && !PPC64
 }

 #else // INCLUDE_JVMTI
 extern "C" {
   JNIEXPORT
   void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {
     trace->num_frames = ticks_no_class_load; // -1
   }
 }
 #endif // INCLUDE_JVMTI
	/*
	* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*
	*/

	#include "precompiled.hpp"
	#include "code/debugInfoRec.hpp"
	#include "code/pcDesc.hpp"
	#include "gc_interface/collectedHeap.inline.hpp"
	#include "memory/space.hpp"
	#include "memory/universe.inline.hpp"
	#include "oops/oop.inline.hpp"
	#include "oops/oop.inline2.hpp"
	#include "prims/forte.hpp"
	#include "runtime/javaCalls.hpp"
	#include "runtime/thread.inline.hpp"
	#include "runtime/vframe.hpp"
	#include "runtime/vframeArray.hpp"

	// call frame copied from old .h file and renamed
	typedef struct {
	jint lineno; // line number in the source file
	jmethodID method_id; // method executed in this frame
	} ASGCT_CallFrame;

	// call trace copied from old .h file and renamed
	typedef struct {
	JNIEnv *env_id; // Env where trace was recorded
	jint num_frames; // number of frames in this trace
	ASGCT_CallFrame *frames; // frames
	} ASGCT_CallTrace;

	// These name match the names reported by the forte quality kit
	enum {
	ticks_no_Java_frame = 0,
	ticks_no_class_load = -1,
	ticks_GC_active = -2,
	ticks_unknown_not_Java = -3,
	ticks_not_walkable_not_Java = -4,
	ticks_unknown_Java = -5,
	ticks_not_walkable_Java = -6,
	ticks_unknown_state = -7,
	ticks_thread_exit = -8,
	ticks_deopt = -9,
	ticks_safepoint = -10
	};

	#if INCLUDE_JVMTI

	//-------------------------------------------------------

	// Native interfaces for use by Forte tools.


	#if !defined(IA64) && !defined(PPC64)

	class vframeStreamForte : public vframeStreamCommon {
	public:
	// constructor that starts with sender of frame fr (top_frame)
	vframeStreamForte(JavaThread *jt, frame fr, bool stop_at_java_call_stub);
	void forte_next();
	};


	static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm);
	static bool is_decipherable_interpreted_frame(JavaThread* thread,
	frame* fr,
	Method** method_p,
	int* bci_p);




	vframeStreamForte::vframeStreamForte(JavaThread *jt,
	frame fr,
	bool stop_at_java_call_stub) : vframeStreamCommon(jt) {

	_stop_at_java_call_stub = stop_at_java_call_stub;
	_frame = fr;

	// We must always have a valid frame to start filling

	bool filled_in = fill_from_frame();

	assert(filled_in, "invariant");

	}


	// Solaris SPARC Compiler1 needs an additional check on the grandparent
	// of the top_frame when the parent of the top_frame is interpreted and
	// the grandparent is compiled. However, in this method we do not know
	// the relationship of the current _frame relative to the top_frame so
	// we implement a more broad sanity check. When the previous callee is
	// interpreted and the current sender is compiled, we verify that the
	// current sender is also walkable. If it is not walkable, then we mark
	// the current vframeStream as at the end.
	void vframeStreamForte::forte_next() {
	// handle frames with inlining
	if (_mode == compiled_mode &&
	vframeStreamCommon::fill_in_compiled_inlined_sender()) {
	return;
	}

	// handle general case

	int loop_count = 0;
	int loop_max = MaxJavaStackTraceDepth * 2;


	do {

	loop_count++;

	// By the time we get here we should never see unsafe but better
	// safe then segv'd

	if (loop_count > loop_max \|\| !_frame.safe_for_sender(_thread)) {
	_mode = at_end_mode;
	return;
	}

	_frame = _frame.sender(&_reg_map);

	} while (!fill_from_frame());
	}

	// Determine if 'fr' is a decipherable compiled frame. We are already
	// assured that fr is for a java nmethod.

	static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm) {
	assert(nm->is_java_method(), "invariant");

	if (thread->has_last_Java_frame() && thread->last_Java_pc() == fr->pc()) {
	// We're stopped at a call into the JVM so look for a PcDesc with
	// the actual pc reported by the frame.
	PcDesc* pc_desc = nm->pc_desc_at(fr->pc());

	// Did we find a useful PcDesc?
	if (pc_desc != NULL &&
	pc_desc->scope_decode_offset() != DebugInformationRecorder::serialized_null) {
	return true;
	}
	}

	// We're at some random pc in the nmethod so search for the PcDesc
	// whose pc is greater than the current PC. It's done this way
	// because the extra PcDescs that are recorded for improved debug
	// info record the end of the region covered by the ScopeDesc
	// instead of the beginning.
	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
	// vframeStream would explode if we try and walk the frames.
	return false;
	}

	// This PcDesc is useful however we must adjust the frame's pc
	// so that the vframeStream lookups will use this same pc
	fr->set_pc(pc_desc->real_pc(nm));
	return true;
	}


	// Determine if 'fr' is a walkable interpreted frame. Returns false
	// if it is not. method_p, and bci_p are not set when false is
	// returned. *method_p is non-NULL if frame was executing a Java
	// method. *bci_p is != -1 if a valid BCI in the Java method could
	// be found.
	// Note: this method returns true when a valid Java method is found
	// even if a valid BCI cannot be found.

	static bool is_decipherable_interpreted_frame(JavaThread* thread,
	frame* fr,
	Method** method_p,
	int* bci_p) {
	assert(fr->is_interpreted_frame(), "just checking");

	// top frame is an interpreted frame
	// check if it is walkable (i.e. valid Method* and valid bci)

	// Because we may be racing a gc thread the method and/or bci
	// of a valid interpreter frame may look bad causing us to
	// fail the is_interpreted_frame_valid test. If the thread
	// is in any of the following states we are assured that the
	// frame is in fact valid and we must have hit the race.

	JavaThreadState state = thread->thread_state();
	bool known_valid = (state == _thread_in_native \|\|
	state == _thread_in_vm \|\|
	state == _thread_blocked );

	if (known_valid \|\| fr->is_interpreted_frame_valid(thread)) {

	// The frame code should completely validate the frame so that
	// references to Method* and bci are completely safe to access
	// If they aren't the frame code should be fixed not this
	// code. However since gc isn't locked out the values could be
	// stale. This is a race we can never completely win since we can't
	// lock out gc so do one last check after retrieving their values
	// from the frame for additional safety

	Method* method = fr->interpreter_frame_method();

	// We've at least found a method.
	// 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;

	intptr_t bcx = fr->interpreter_frame_bcx();

	int bci = method->validate_bci_from_bcx(bcx);

	// note: bci is set to -1 if not a valid bci
	*bci_p = bci;
	return true;
	}

	return false;
	}


	// Determine if 'fr' can be used to find an initial Java frame.
	// 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).
	// Obviously if it can't even find a Java frame false will also be returned.
	//
	// If we find a Java frame decipherable or not then by definition we have
	// identified a method and that will be returned to the caller via method_p.
	// If we can determine a bci that is returned also. (Hmm is it possible
	// to return a method and bci and still return false? )
	//
	// The initial Java frame we find (if any) is return via initial_frame_p.
	//

	static bool find_initial_Java_frame(JavaThread* thread,
	frame* fr,
	frame* initial_frame_p,
	Method** method_p,
	int* bci_p) {

	// It is possible that for a frame containing an nmethod
	// we can capture the method but no bci. If we get no
	// bci the frame isn't walkable but the method is usable.
	// Therefore we init the returned Method* to NULL so the
	// caller can make the distinction.

	*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
	// are possible Java frames.

	if (fr->cb() == NULL) {

	// See if we can find a useful frame
	int loop_count;
	int loop_max = MaxJavaStackTraceDepth * 2;
	RegisterMap map(thread, false);

	for (loop_count = 0; loop_count < loop_max; loop_count++) {
	if (!candidate.safe_for_sender(thread)) return false;
	candidate = candidate.sender(&map);
	if (candidate.cb() != NULL) break;
	}
	if (candidate.cb() == NULL) return false;
	}

	// We have a frame known to be in the codeCache
	// We will hopefully be able to figure out something to do with it.
	int loop_count;
	int loop_max = MaxJavaStackTraceDepth * 2;
	RegisterMap map(thread, false);

	for (loop_count = 0; loop_count < loop_max; loop_count++) {

	if (candidate.is_entry_frame()) {
	// jcw is NULL if the java call wrapper couldn't be found
	JavaCallWrapper *jcw = candidate.entry_frame_call_wrapper_if_safe(thread);
	// If initial frame is frame from StubGenerator and there is no
	// previous anchor, there are no java frames associated with a method
	if (jcw == NULL \|\| jcw->is_first_frame()) {
	return false;
	}
	}

	if (candidate.is_interpreted_frame()) {
	if (is_decipherable_interpreted_frame(thread, &candidate, method_p, bci_p)) {
	*initial_frame_p = candidate;
	return true;
	}

	// Hopefully we got some data
	return false;
	}

	if (candidate.cb()->is_nmethod()) {

	nmethod* nm = (nmethod*) candidate.cb();
	*method_p = nm->method();

	// If the frame isn't fully decipherable then the default
	// value for the bci is a signal that we don't have a bci.
	// If we have a decipherable frame this 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
	// have a PCDesc that can get us a bci however we did find
	// a method

	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");

	return true;
	}

	// Must be some stub frame that we don't care about

	if (!candidate.safe_for_sender(thread)) return false;
	candidate = candidate.sender(&map);

	// If it isn't in the code cache something is wrong
	// since once we find a frame in the code cache they
	// all should be there.

	if (candidate.cb() == NULL) return false;

	}

	return false;

	}

	static void forte_fill_call_trace_given_top(JavaThread* thd,
	ASGCT_CallTrace* trace,
	int depth,
	frame top_frame) {
	NoHandleMark nhm;

	frame initial_Java_frame;
	Method* method;
	int bci;
	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);

	// The frame might not be walkable but still recovered a method
	// (e.g. an nmethod with no scope info for the pc)

	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++) {
	bci = st.bci();
	method = st.method();

	if (!method->is_valid_method()) {
	// we throw away everything we've gathered in this sample since
	// none of it is safe
	trace->num_frames = ticks_GC_active; // -2
	return;
	}

	trace->frames[count].method_id = method->find_jmethod_id_or_null();
	if (!method->is_native()) {
	trace->frames[count].lineno = bci;
	} else {
	trace->frames[count].lineno = -3;
	}
	}
	trace->num_frames = count;
	return;
	}


	// Forte Analyzer AsyncGetCallTrace() entry point. Currently supported
	// on Linux X86, Solaris SPARC and Solaris X86.
	//
	// Async-safe version of GetCallTrace being called from a signal handler
	// when a LWP gets interrupted by SIGPROF but the stack traces are filled
	// with different content (see below).
	//
	// This function must only be called when JVM/TI
	// CLASS_LOAD events have been enabled since agent startup. The enabled
	// event will cause the jmethodIDs to be allocated at class load time.
	// The jmethodIDs cannot be allocated in a signal handler because locks
	// cannot be grabbed in a signal handler safely.
	//
	// void (AsyncGetCallTrace)(ASGCT_CallTrace trace, jint depth, void* ucontext)
	//
	// Called by the profiler to obtain the current method call stack trace for
	// a given thread. The thread is identified by the env_id field in the
	// ASGCT_CallTrace structure. The profiler agent should allocate a ASGCT_CallTrace
	// structure with enough memory for the requested stack depth. The VM fills in
	// the frames buffer and the num_frames field.
	//
	// Arguments:
	//
	// trace - trace data structure to be filled by the VM.
	// depth - depth of the call stack trace.
	// ucontext - ucontext_t of the LWP
	//
	// ASGCT_CallTrace:
	// typedef struct {
	// JNIEnv *env_id;
	// jint num_frames;
	// ASGCT_CallFrame *frames;
	// } ASGCT_CallTrace;
	//
	// Fields:
	// env_id - ID of thread which executed this trace.
	// num_frames - number of frames in the trace.
	// (< 0 indicates the frame is not walkable).
	// frames - the ASGCT_CallFrames that make up this trace. Callee followed by callers.
	//
	// ASGCT_CallFrame:
	// typedef struct {
	// jint lineno;
	// jmethodID method_id;
	// } ASGCT_CallFrame;
	//
	// Fields:
	// 1) For Java frame (interpreted and compiled),
	// lineno - bci of the method being executed or -1 if bci is not available
	// method_id - jmethodID of the method being executed
	// 2) For native method
	// lineno - (-3)
	// method_id - jmethodID of the method being executed

	extern "C" {
	JNIEXPORT
	void AsyncGetCallTrace(ASGCT_CallTrace trace, jint depth, void ucontext) {
	JavaThread* thread;

	if (trace->env_id == NULL \|\|
	(thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL \|\|
	thread->is_exiting()) {

	// bad env_id, thread has exited or thread is exiting
	trace->num_frames = ticks_thread_exit; // -8
	return;
	}

	if (thread->in_deopt_handler()) {
	// thread is in the deoptimization handler so return no frames
	trace->num_frames = ticks_deopt; // -9
	return;
	}

	assert(JavaThread::current() == thread,
	"AsyncGetCallTrace must be called by the current interrupted thread");

	if (!JvmtiExport::should_post_class_load()) {
	trace->num_frames = ticks_no_class_load; // -1
	return;
	}

	if (Universe::heap()->is_gc_active()) {
	trace->num_frames = ticks_GC_active; // -2
	return;
	}

	switch (thread->thread_state()) {
	case _thread_new:
	case _thread_uninitialized:
	case _thread_new_trans:
	// We found the thread on the threads list above, but it is too
	// young to be useful so return that there are no Java frames.
	trace->num_frames = 0;
	break;
	case _thread_in_native:
	case _thread_in_native_trans:
	case _thread_blocked:
	case _thread_blocked_trans:
	case _thread_in_vm:
	case _thread_in_vm_trans:
	{
	frame fr;

	// param isInJava == false - indicate we aren't in Java code
	if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) {
	trace->num_frames = ticks_unknown_not_Java; // -3 unknown frame
	} else {
	if (!thread->has_last_Java_frame()) {
	trace->num_frames = 0; // No Java frames
	} else {
	trace->num_frames = ticks_not_walkable_not_Java; // -4 non walkable frame by default
	forte_fill_call_trace_given_top(thread, trace, depth, fr);

	// This assert would seem to be valid but it is not.
	// It would be valid if we weren't possibly racing a gc
	// thread. A gc thread can make a valid interpreted frame
	// look invalid. It's a small window but it does happen.
	// The assert is left here commented out as a reminder.
	// assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable");

	}
	}
	}
	break;
	case _thread_in_Java:
	case _thread_in_Java_trans:
	{
	frame fr;

	// param isInJava == true - indicate we are in Java code
	if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) {
	trace->num_frames = ticks_unknown_Java; // -5 unknown frame
	} else {
	trace->num_frames = ticks_not_walkable_Java; // -6, non walkable frame by default
	forte_fill_call_trace_given_top(thread, trace, depth, fr);
	}
	}
	break;
	default:
	// Unknown thread state
	trace->num_frames = ticks_unknown_state; // -7
	break;
	}
	}


	#ifndef _WINDOWS
	// Support for the Forte(TM) Peformance Tools collector.
	//
	// The method prototype is derived from libcollector.h. For more
	// information, please see the libcollect man page.

	// Method to let libcollector know about a dynamically loaded function.
	// Because it is weakly bound, the calls become NOP's when the library
	// isn't present.
	#ifdef __APPLE__
	// XXXDARWIN: Link errors occur even when __attribute__((weak_import))
	// is added
	#define collector_func_load(x0,x1,x2,x3,x4,x5,x6) ((void) 0)
	#else
	void collector_func_load(char* name,
	void* null_argument_1,
	void* null_argument_2,
	void *vaddr,
	int size,
	int zero_argument,
	void* null_argument_3);
	#pragma weak collector_func_load
	#define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \
	( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),(void)0 : (void)0 )
	#endif // __APPLE__
	#endif // !_WINDOWS

	} // end extern "C"
	#endif // !IA64 && !PPC64

	void Forte::register_stub(const char* name, address start, address end) {
	#if !defined(_WINDOWS) && !defined(IA64) && !defined(PPC64)
	assert(pointer_delta(end, start, sizeof(jbyte)) < INT_MAX,
	"Code size exceeds maximum range");

	collector_func_load((char*)name, NULL, NULL, start,
	pointer_delta(end, start, sizeof(jbyte)), 0, NULL);
	#endif // !_WINDOWS && !IA64 && !PPC64
	}

	#else // INCLUDE_JVMTI
	extern "C" {
	JNIEXPORT
	void AsyncGetCallTrace(ASGCT_CallTrace trace, jint depth, void ucontext) {
	trace->num_frames = ticks_no_class_load; // -1
	}
	}
	#endif // INCLUDE_JVMTI