1 /*

     2  * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "code/debugInfoRec.hpp"

    27 #include "code/pcDesc.hpp"

    28 #include "gc/shared/collectedHeap.inline.hpp"

    29 #include "gc/shared/space.hpp"

    30 #include "memory/universe.inline.hpp"

    31 #include "oops/oop.inline.hpp"

    32 #include "prims/forte.hpp"

    33 #include "runtime/javaCalls.hpp"

    34 #include "runtime/thread.inline.hpp"

    35 #include "runtime/vframe.hpp"

    36 #include "runtime/vframeArray.hpp"

    37 

    38 // call frame copied from old .h file and renamed

    39 typedef struct {

    40     jint lineno;                      // line number in the source file

    41     jmethodID method_id;              // method executed in this frame

    42 } ASGCT_CallFrame;

    43 

    44 // call trace copied from old .h file and renamed

    45 typedef struct {

    46     JNIEnv *env_id;                   // Env where trace was recorded

    47     jint num_frames;                  // number of frames in this trace

    48     ASGCT_CallFrame *frames;          // frames

    49 } ASGCT_CallTrace;

    50 

    51 // These name match the names reported by the forte quality kit

    52 enum {

    53   ticks_no_Java_frame         =  0,

    54   ticks_no_class_load         = -1,

    55   ticks_GC_active             = -2,

    56   ticks_unknown_not_Java      = -3,

    57   ticks_not_walkable_not_Java = -4,

    58   ticks_unknown_Java          = -5,

    59   ticks_not_walkable_Java     = -6,

    60   ticks_unknown_state         = -7,

    61   ticks_thread_exit           = -8,

    62   ticks_deopt                 = -9,

    63   ticks_safepoint             = -10

    64 };

    65 

    66 #if INCLUDE_JVMTI

    67 

    68 //-------------------------------------------------------

    69 

    70 // Native interfaces for use by Forte tools.

    71 

    72 

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

    74 

    75 class vframeStreamForte : public vframeStreamCommon {

    76  public:

    77   // constructor that starts with sender of frame fr (top_frame)

    78   vframeStreamForte(JavaThread *jt, frame fr, bool stop_at_java_call_stub);

    79   void forte_next();

    80 };

    81 

    82 

    83 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, CompiledMethod* nm);

    84 static bool is_decipherable_interpreted_frame(JavaThread* thread,

    85                                               frame* fr,

    86                                               Method** method_p,

    87                                               int* bci_p);

    88 

    89 

    90 

    91 

    92 vframeStreamForte::vframeStreamForte(JavaThread *jt,

    93                                      frame fr,

    94                                      bool stop_at_java_call_stub) : vframeStreamCommon(jt) {

    95 

    96   _stop_at_java_call_stub = stop_at_java_call_stub;

    97   _frame = fr;

    98 

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

   100 

   101   bool filled_in = fill_from_frame();

   102 

   103   assert(filled_in, "invariant");

   104 

   105 }

   106 

   107 

   108 // Solaris SPARC Compiler1 needs an additional check on the grandparent

   109 // of the top_frame when the parent of the top_frame is interpreted and

   110 // the grandparent is compiled. However, in this method we do not know

   111 // the relationship of the current _frame relative to the top_frame so

   112 // we implement a more broad sanity check. When the previous callee is

   113 // interpreted and the current sender is compiled, we verify that the

   114 // current sender is also walkable. If it is not walkable, then we mark

   115 // the current vframeStream as at the end.

   116 void vframeStreamForte::forte_next() {

   117   // handle frames with inlining

   118   if (_mode == compiled_mode &&

   119       vframeStreamCommon::fill_in_compiled_inlined_sender()) {

   120     return;

   121   }

   122 

   123   // handle general case

   124 

   125   int loop_count = 0;

   126   int loop_max = MaxJavaStackTraceDepth * 2;

   127 

   128 

   129   do {

   130 

   131     loop_count++;

   132 

   133     // By the time we get here we should never see unsafe but better

   134     // safe then segv'd

   135 

   136     if (loop_count > loop_max || !_frame.safe_for_sender(_thread)) {

   137       _mode = at_end_mode;

   138       return;

   139     }

   140 

   141     _frame = _frame.sender(&_reg_map);

   142 

   143   } while (!fill_from_frame());

   144 }

   145 

   146 // Determine if 'fr' is a decipherable compiled frame. We are already

   147 // assured that fr is for a java compiled method.

   148 

   149 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, CompiledMethod* nm) {

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

   151 

   152   if (thread->has_last_Java_frame() && thread->last_Java_pc() == fr->pc()) {

   153     // We're stopped at a call into the JVM so look for a PcDesc with

   154     // the actual pc reported by the frame.

   155     PcDesc* pc_desc = nm->pc_desc_at(fr->pc());

   156 

   157     // Did we find a useful PcDesc?

   158     if (pc_desc != NULL &&

   159         pc_desc->scope_decode_offset() != DebugInformationRecorder::serialized_null) {

   160       return true;

   161     }

   162   }

   163 

   164   // We're at some random pc in the compiled method so search for the PcDesc

   165   // whose pc is greater than the current PC.  It's done this way

   166   // because the extra PcDescs that are recorded for improved debug

   167   // info record the end of the region covered by the ScopeDesc

   168   // instead of the beginning.

   169   PcDesc* pc_desc = nm->pc_desc_near(fr->pc() + 1);

   170 

   171   // Now do we have a useful PcDesc?

   172   if (pc_desc == NULL ||

   173       pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {

   174     // No debug information is available for this PC.

   175     //

   176     // vframeStreamCommon::fill_from_frame() will decode the frame depending

   177     // on the state of the thread.

   178     //

   179     // Case #1: If the thread is in Java (state == _thread_in_Java), then

   180     // the vframeStreamCommon object will be filled as if the frame were a native

   181     // compiled frame. Therefore, no debug information is needed.

   182     //

   183     // Case #2: If the thread is in any other state, then two steps will be performed:

   184     // - if asserts are enabled, found_bad_method_frame() will be called and

   185     //   the assert in found_bad_method_frame() will be triggered;

   186     // - if asserts are disabled, the vframeStreamCommon object will be filled

   187     //   as if it were a native compiled frame.

   188     //

   189     // Case (2) is similar to the way interpreter frames are processed in

   190     // vframeStreamCommon::fill_from_interpreter_frame in case no valid BCI

   191     // was found for an interpreted frame. If asserts are enabled, the assert

   192     // in found_bad_method_frame() will be triggered. If asserts are disabled,

   193     // the vframeStreamCommon object will be filled afterwards as if the

   194     // interpreter were at the point of entering into the method.

   195     return false;

   196   }

   197 

   198   // This PcDesc is useful however we must adjust the frame's pc

   199   // so that the vframeStream lookups will use this same pc

   200   fr->set_pc(pc_desc->real_pc(nm));

   201   return true;

   202 }

   203 

   204 

   205 // Determine if 'fr' is a walkable interpreted frame. Returns false

   206 // if it is not. *method_p, and *bci_p are not set when false is

   207 // returned. *method_p is non-NULL if frame was executing a Java

   208 // method. *bci_p is != -1 if a valid BCI in the Java method could

   209 // be found.

   210 // Note: this method returns true when a valid Java method is found

   211 // even if a valid BCI cannot be found.

   212 

   213 static bool is_decipherable_interpreted_frame(JavaThread* thread,

   214                                               frame* fr,

   215                                               Method** method_p,

   216                                               int* bci_p) {

   217   assert(fr->is_interpreted_frame(), "just checking");

   218 

   219   // top frame is an interpreted frame

   220   // check if it is walkable (i.e. valid Method* and valid bci)

   221 

   222   // Because we may be racing a gc thread the method and/or bci

   223   // of a valid interpreter frame may look bad causing us to

   224   // fail the is_interpreted_frame_valid test. If the thread

   225   // is in any of the following states we are assured that the

   226   // frame is in fact valid and we must have hit the race.

   227 

   228   JavaThreadState state = thread->thread_state();

   229   bool known_valid = (state == _thread_in_native ||

   230                       state == _thread_in_vm ||

   231                       state == _thread_blocked );

   232 

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

   234 

   235     // The frame code should completely validate the frame so that

   236     // references to Method* and bci are completely safe to access

   237     // If they aren't the frame code should be fixed not this

   238     // code. However since gc isn't locked out the values could be

   239     // stale. This is a race we can never completely win since we can't

   240     // lock out gc so do one last check after retrieving their values

   241     // from the frame for additional safety

   242 

   243     Method* method = fr->interpreter_frame_method();

   244 

   245     // We've at least found a method.

   246     // NOTE: there is something to be said for the approach that

   247     // if we don't find a valid bci then the method is not likely

   248     // a valid method. Then again we may have caught an interpreter

   249     // frame in the middle of construction and the bci field is

   250     // not yet valid.

   251     if (!method->is_valid_method()) return false;

   252     *method_p = method; // If the Method* found is invalid, it is

   253                         // ignored by forte_fill_call_trace_given_top().

   254                         // So set method_p only if the Method is valid.

   255 

   256     address bcp = fr->interpreter_frame_bcp();

   257     int bci = method->validate_bci_from_bcp(bcp);

   258 

   259     // note: bci is set to -1 if not a valid bci

   260     *bci_p = bci;

   261     return true;

   262   }

   263 

   264   return false;

   265 }

   266 

   267 

   268 // Determine if a Java frame can be found starting with the frame 'fr'.

   269 //

   270 // Check the return value of find_initial_Java_frame and the value of

   271 // 'method_p' to decide on how use the results returned by this method.

   272 //

   273 // If 'method_p' is not NULL, an initial Java frame has been found and

   274 // the stack can be walked starting from that initial frame. In this case,

   275 // 'method_p' points to the Method that the initial frame belongs to and

   276 // the initial Java frame is returned in initial_frame_p.

   277 //

   278 // find_initial_Java_frame() returns true if a Method has been found (i.e.,

   279 // 'method_p' is not NULL) and the initial frame that belongs to that Method

   280 // is decipherable.

   281 //

   282 // A frame is considered to be decipherable:

   283 //

   284 // - if the frame is a compiled frame and a PCDesc is available;

   285 //

   286 // - if the frame is an interpreter frame that is valid or the thread is

   287 //   state (_thread_in_native || state == _thread_in_vm || state == _thread_blocked).

   288 //

   289 // Note that find_initial_Java_frame() can return false even if an initial

   290 // Java method was found (e.g., there is no PCDesc available for the method).

   291 //

   292 // If 'method_p' is NULL, it was not possible to find a Java frame when

   293 // walking the stack starting from 'fr'. In this case find_initial_Java_frame

   294 // returns false.

   295 

   296 static bool find_initial_Java_frame(JavaThread* thread,

   297                                     frame* fr,

   298                                     frame* initial_frame_p,

   299                                     Method** method_p,

   300                                     int* bci_p) {

   301 

   302   // It is possible that for a frame containing a compiled method

   303   // we can capture the method but no bci. If we get no

   304   // bci the frame isn't walkable but the method is usable.

   305   // Therefore we init the returned Method* to NULL so the

   306   // caller can make the distinction.

   307 

   308   *method_p = NULL;

   309 

   310   // On the initial call to this method the frame we get may not be

   311   // recognizable to us. This should only happen if we are in a JRT_LEAF

   312   // or something called by a JRT_LEAF method.

   313 

   314   frame candidate = *fr;

   315 

   316   // If the starting frame we were given has no codeBlob associated with

   317   // it see if we can find such a frame because only frames with codeBlobs

   318   // are possible Java frames.

   319 

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

   321 

   322     // See if we can find a useful frame

   323     int loop_count;

   324     int loop_max = MaxJavaStackTraceDepth * 2;

   325     RegisterMap map(thread, false);

   326 

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

   328       if (!candidate.safe_for_sender(thread)) return false;

   329       candidate = candidate.sender(&map);

   330       if (candidate.cb() != NULL) break;

   331     }

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

   333   }

   334 

   335   // We have a frame known to be in the codeCache

   336   // We will hopefully be able to figure out something to do with it.

   337   int loop_count;

   338   int loop_max = MaxJavaStackTraceDepth * 2;

   339   RegisterMap map(thread, false);

   340 

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

   342 

   343     if (candidate.is_entry_frame()) {

   344       // jcw is NULL if the java call wrapper couldn't be found

   345       JavaCallWrapper *jcw = candidate.entry_frame_call_wrapper_if_safe(thread);

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

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

   348       if (jcw == NULL || jcw->is_first_frame()) {

   349         return false;

   350       }

   351     }

   352 

   353     if (candidate.is_interpreted_frame()) {

   354       if (is_decipherable_interpreted_frame(thread, &candidate, method_p, bci_p)) {

   355         *initial_frame_p = candidate;

   356         return true;

   357       }

   358 

   359       // Hopefully we got some data

   360       return false;

   361     }

   362 

   363     if (candidate.cb()->is_compiled()) {

   364 

   365       CompiledMethod* nm = candidate.cb()->as_compiled_method();

   366       *method_p = nm->method();

   367 

   368       // If the frame is not decipherable, then the value of -1

   369       // for the BCI is used to signal that no BCI is available.

   370       // Furthermore, the method returns false in this case.

   371       //

   372       // If a decipherable frame is available, the BCI value will

   373       // not be used.

   374 

   375       *bci_p = -1;

   376 

   377       *initial_frame_p = candidate;

   378 

   379       // Native wrapper code is trivial to decode by vframeStream

   380 

   381       if (nm->is_native_method()) return true;

   382 

   383       // If the frame is not decipherable, then a PC was found

   384       // that does not have a PCDesc from which a BCI can be obtained.

   385       // Nevertheless, a Method was found.

   386 

   387       if (!is_decipherable_compiled_frame(thread, &candidate, nm)) {

   388         return false;

   389       }

   390 

   391       // is_decipherable_compiled_frame may modify candidate's pc

   392       *initial_frame_p = candidate;

   393 

   394       assert(nm->pc_desc_at(candidate.pc()) != NULL, "debug information must be available if the frame is decipherable");

   395 

   396       return true;

   397     }

   398 

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

   400 

   401     if (!candidate.safe_for_sender(thread)) return false;

   402     candidate = candidate.sender(&map);

   403 

   404     // If it isn't in the code cache something is wrong

   405     // since once we find a frame in the code cache they

   406     // all should be there.

   407 

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

   409 

   410   }

   411 

   412   return false;

   413 

   414 }

   415 

   416 static void forte_fill_call_trace_given_top(JavaThread* thd,

   417                                             ASGCT_CallTrace* trace,

   418                                             int depth,

   419                                             frame top_frame) {

   420   NoHandleMark nhm;

   421 

   422   frame initial_Java_frame;

   423   Method* method;

   424   int bci = -1; // assume BCI is not available for method

   425                 // update with correct information if available

   426   int count;

   427 

   428   count = 0;

   429   assert(trace->frames != NULL, "trace->frames must be non-NULL");

   430 

   431   // Walk the stack starting from 'top_frame' and search for an initial Java frame.

   432   find_initial_Java_frame(thd, &top_frame, &initial_Java_frame, &method, &bci);

   433 

   434   // Check if a Java Method has been found.

   435   if (method == NULL) return;

   436 

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

   438     trace->num_frames = ticks_GC_active; // -2

   439     return;

   440   }

   441 

   442   vframeStreamForte st(thd, initial_Java_frame, false);

   443 

   444   for (; !st.at_end() && count < depth; st.forte_next(), count++) {

   445     bci = st.bci();

   446     method = st.method();

   447 

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

   449       // we throw away everything we've gathered in this sample since

   450       // none of it is safe

   451       trace->num_frames = ticks_GC_active; // -2

   452       return;

   453     }

   454 

   455     trace->frames[count].method_id = method->find_jmethod_id_or_null();

   456     if (!method->is_native()) {

   457       trace->frames[count].lineno = bci;

   458     } else {

   459       trace->frames[count].lineno = -3;

   460     }

   461   }

   462   trace->num_frames = count;

   463   return;

   464 }

   465 

   466 

   467 // Forte Analyzer AsyncGetCallTrace() entry point. Currently supported

   468 // on Linux X86, Solaris SPARC and Solaris X86.

   469 //

   470 // Async-safe version of GetCallTrace being called from a signal handler

   471 // when a LWP gets interrupted by SIGPROF but the stack traces are filled

   472 // with different content (see below).

   473 //

   474 // This function must only be called when JVM/TI

   475 // CLASS_LOAD events have been enabled since agent startup. The enabled

   476 // event will cause the jmethodIDs to be allocated at class load time.

   477 // The jmethodIDs cannot be allocated in a signal handler because locks

   478 // cannot be grabbed in a signal handler safely.

   479 //

   480 // void (*AsyncGetCallTrace)(ASGCT_CallTrace *trace, jint depth, void* ucontext)

   481 //

   482 // Called by the profiler to obtain the current method call stack trace for

   483 // a given thread. The thread is identified by the env_id field in the

   484 // ASGCT_CallTrace structure. The profiler agent should allocate a ASGCT_CallTrace

   485 // structure with enough memory for the requested stack depth. The VM fills in

   486 // the frames buffer and the num_frames field.

   487 //

   488 // Arguments:

   489 //

   490 //   trace    - trace data structure to be filled by the VM.

   491 //   depth    - depth of the call stack trace.

   492 //   ucontext - ucontext_t of the LWP

   493 //

   494 // ASGCT_CallTrace:

   495 //   typedef struct {

   496 //       JNIEnv *env_id;

   497 //       jint num_frames;

   498 //       ASGCT_CallFrame *frames;

   499 //   } ASGCT_CallTrace;

   500 //

   501 // Fields:

   502 //   env_id     - ID of thread which executed this trace.

   503 //   num_frames - number of frames in the trace.

   504 //                (< 0 indicates the frame is not walkable).

   505 //   frames     - the ASGCT_CallFrames that make up this trace. Callee followed by callers.

   506 //

   507 //  ASGCT_CallFrame:

   508 //    typedef struct {

   509 //        jint lineno;

   510 //        jmethodID method_id;

   511 //    } ASGCT_CallFrame;

   512 //

   513 //  Fields:

   514 //    1) For Java frame (interpreted and compiled),

   515 //       lineno    - bci of the method being executed or -1 if bci is not available

   516 //       method_id - jmethodID of the method being executed

   517 //    2) For native method

   518 //       lineno    - (-3)

   519 //       method_id - jmethodID of the method being executed

   520 

   521 extern "C" {

   522 JNIEXPORT

   523 void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {

   524   JavaThread* thread;

   525 

   526   if (trace->env_id == NULL ||

   527     (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL ||

   528     thread->is_exiting()) {

   529 

   530     // bad env_id, thread has exited or thread is exiting

   531     trace->num_frames = ticks_thread_exit; // -8

   532     return;

   533   }

   534 

   535   if (thread->in_deopt_handler()) {

   536     // thread is in the deoptimization handler so return no frames

   537     trace->num_frames = ticks_deopt; // -9

   538     return;

   539   }

   540 

   541   assert(JavaThread::current() == thread,

   542          "AsyncGetCallTrace must be called by the current interrupted thread");

   543 

   544   if (!JvmtiExport::should_post_class_load()) {

   545     trace->num_frames = ticks_no_class_load; // -1

   546     return;

   547   }

   548 

   549   if (Universe::heap()->is_gc_active()) {

   550     trace->num_frames = ticks_GC_active; // -2

   551     return;

   552   }

   553 

   554   switch (thread->thread_state()) {

   555   case _thread_new:

   556   case _thread_uninitialized:

   557   case _thread_new_trans:

   558     // We found the thread on the threads list above, but it is too

   559     // young to be useful so return that there are no Java frames.

   560     trace->num_frames = 0;

   561     break;

   562   case _thread_in_native:

   563   case _thread_in_native_trans:

   564   case _thread_blocked:

   565   case _thread_blocked_trans:

   566   case _thread_in_vm:

   567   case _thread_in_vm_trans:

   568     {

   569       frame fr;

   570 

   571       // param isInJava == false - indicate we aren't in Java code

   572       if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) {

   573         trace->num_frames = ticks_unknown_not_Java;  // -3 unknown frame

   574       } else {

   575         if (!thread->has_last_Java_frame()) {

   576           trace->num_frames = 0; // No Java frames

   577         } else {

   578           trace->num_frames = ticks_not_walkable_not_Java;    // -4 non walkable frame by default

   579           forte_fill_call_trace_given_top(thread, trace, depth, fr);

   580 

   581           // This assert would seem to be valid but it is not.

   582           // It would be valid if we weren't possibly racing a gc

   583           // thread. A gc thread can make a valid interpreted frame

   584           // look invalid. It's a small window but it does happen.

   585           // The assert is left here commented out as a reminder.

   586           // assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable");

   587 

   588         }

   589       }

   590     }

   591     break;

   592   case _thread_in_Java:

   593   case _thread_in_Java_trans:

   594     {

   595       frame fr;

   596 

   597       // param isInJava == true - indicate we are in Java code

   598       if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) {

   599         trace->num_frames = ticks_unknown_Java;  // -5 unknown frame

   600       } else {

   601         trace->num_frames = ticks_not_walkable_Java;  // -6, non walkable frame by default

   602         forte_fill_call_trace_given_top(thread, trace, depth, fr);

   603       }

   604     }

   605     break;

   606   default:

   607     // Unknown thread state

   608     trace->num_frames = ticks_unknown_state; // -7

   609     break;

   610   }

   611 }

   612 

   613 

   614 #ifndef _WINDOWS

   615 // Support for the Forte(TM) Peformance Tools collector.

   616 //

   617 // The method prototype is derived from libcollector.h. For more

   618 // information, please see the libcollect man page.

   619 

   620 // Method to let libcollector know about a dynamically loaded function.

   621 // Because it is weakly bound, the calls become NOP's when the library

   622 // isn't present.

   623 #ifdef __APPLE__

   624 // XXXDARWIN: Link errors occur even when __attribute__((weak_import))

   625 // is added

   626 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) ((void) 0)

   627 #else

   628 void    collector_func_load(char* name,

   629                             void* null_argument_1,

   630                             void* null_argument_2,

   631                             void *vaddr,

   632                             int size,

   633                             int zero_argument,

   634                             void* null_argument_3);

   635 #pragma weak collector_func_load

   636 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \

   637         ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),(void)0 : (void)0 )

   638 #endif // __APPLE__

   639 #endif // !_WINDOWS

   640 

   641 } // end extern "C"

   642 #endif // !IA64 && !PPC64

   643 

   644 void Forte::register_stub(const char* name, address start, address end) {

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

   646   assert(pointer_delta(end, start, sizeof(jbyte)) < INT_MAX,

   647          "Code size exceeds maximum range");

   648 

   649   collector_func_load((char*)name, NULL, NULL, start,

   650     pointer_delta(end, start, sizeof(jbyte)), 0, NULL);

   651 #endif // !_WINDOWS && !IA64 && !PPC64

   652 }

   653 

   654 #else // INCLUDE_JVMTI

   655 extern "C" {

   656   JNIEXPORT

   657   void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {

   658     trace->num_frames = ticks_no_class_load; // -1

   659   }

   660 }

   661 #endif // INCLUDE_JVMTI