/*

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

 *

 */

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

};

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

// Native interfaces for use by Forte tools.

#ifndef IA64

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,

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

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

  }

  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,

                                    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.

  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_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(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;

}

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

static void forte_fill_call_trace_given_top(JavaThread* thd,

                                            ASGCT_CallTrace* trace,

                                            int depth,

                                            frame top_frame) {

  NoHandleMark nhm;

  frame initial_Java_frame;

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

  CollectedHeap* ch = Universe::heap();

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

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

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

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