// 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

};

static void is_decipherable_compiled_frame(frame* fr, RegisterMap* map,

static bool is_decipherable_interpreted_frame(JavaThread* thread,

                                                frame* fr,

                                                methodOop* method_p,

                                                int* bci_p);

vframeStreamForte::vframeStreamForte(JavaThread *jt,

                                     frame fr,

                                     bool stop_at_java_call_stub) : vframeStreamCommon(jt) {

  _frame = fr;

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

  bool filled_in = fill_from_frame();

  assert(filled_in, "invariant");

    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)) {

    _frame = _frame.sender(&_reg_map);

// 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(frame* fr) {

  assert(fr->cb() != NULL && fr->cb()->is_nmethod(), "invariant");

  nmethod* nm = (nmethod*) fr->cb();

  assert(nm->is_java_method(), "invariant");

  // First try and find an exact PcDesc

  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) {

    address probe_pc = fr->pc() + 1;

    pc_desc = nm->pc_desc_near(probe_pc);

    // 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;

static bool is_decipherable_interpreted_frame(JavaThread* thread,

                                                frame* fr,

                                                methodOop* method_p,

                                                int* bci_p) {

  // 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 methodOop 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

    methodOop 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;

    // See if gc may have invalidated method since we validated frame

    if (!Universe::heap()->is_valid_method(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;

// 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,

                                    methodOop* 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 methodOop 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.

  RegisterMap map(thread, false);

    if (candidate.is_first_frame()) {

      // If initial frame is frame from StubGenerator and there is no

      // previous anchor, there are no java frames associated with a method

      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(&candidate)) {

      }

      // is_decipherable_compiled_frame may modify candidate's pc

      *initial_frame_p = candidate;

      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;

                                            ASGCT_CallTrace* trace,

                                            int depth,

                                            frame top_frame) {

  frame initial_Java_frame;

  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;

  // The method is not stored GC safe so see if GC became active

  // after we entered AsyncGetCallTrace() and before we try to

  // use the methodOop.

  // Yes, there is still a window after this check and before

  // we use methodOop below, but we can't lock out GC so that

  // has to be an acceptable risk.

  if (!ch->is_valid_method(method)) {

    trace->num_frames = ticks_GC_active; // -2

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

      trace->num_frames = ticks_GC_active; // -2