libjava/stacktrace.cc

   1 // stacktrace.cc - Functions for unwinding & inspecting the call stack.
   2
   3 /* Copyright (C) 2005, 2006  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 #include <config.h>
  12
  13 #include <jvm.h>
  14 #include <gcj/cni.h>
  15 #include <java-interp.h>
  16 #include <java-stack.h>
  17
  18 #ifdef HAVE_DLFCN_H
  19 #include <dlfcn.h>
  20 #endif
  21
  22 #include <stdio.h>
  23
  24 #include <java/lang/Class.h>
  25 #include <java/lang/Long.h>
  26 #include <java/util/ArrayList.h>
  27 #include <java/util/IdentityHashMap.h>
  28 #include <gnu/java/lang/MainThread.h>
  29 #include <gnu/gcj/runtime/NameFinder.h>
  30
  31 #include <sysdep/backtrace.h>
  32 #include <sysdep/descriptor.h>
  33
  34 using namespace java::lang;
  35 using namespace java::lang::reflect;
  36 using namespace java::util;
  37 using namespace gnu::gcj::runtime;
  38
  39 // Maps ncode values to their containing native class.
  40 // NOTE: Currently this Map contradicts class GC for native classes. This map
  41 // (and the "new class stack") will need to use WeakReferences in order to
  42 // enable native class GC.
  43 static java::util::IdentityHashMap *ncodeMap;
  44
  45 // Check the "class stack" for any classes initialized since we were last
  46 // called, and add them to ncodeMap.
  47 void
  48 _Jv_StackTrace::UpdateNCodeMap ()
  49 {
  50   // The Map should be large enough so that a typical Java app doesn't cause
  51   // it to rehash, without using too much memory. ~5000 entries should be
  52   // enough.
  53   if (ncodeMap == NULL)
  54     ncodeMap = new java::util::IdentityHashMap (5087);
  55
  56   jclass klass;
  57   while ((klass = _Jv_PopClass ()))
  58     {
  59       //printf ("got %s\n", klass->name->data);
  60 #ifdef INTERPRETER
  61       JvAssert (! _Jv_IsInterpretedClass (klass));
  62 #endif
  63       for (int i=0; i < klass->method_count; i++)
  64         {
  65           _Jv_Method *method = &klass->methods[i];
  66           void *ncode = method->ncode;
  67           // Add non-abstract methods to ncodeMap.
  68           if (ncode)
  69             {
  70               ncode = UNWRAP_FUNCTION_DESCRIPTOR (ncode);
  71               ncodeMap->put ((java::lang::Object *)ncode, klass);
  72             }
  73         }
  74     }
  75 }
  76
  77 // Given a native frame, return the class which this code belongs
  78 // to. Returns NULL if this IP is not associated with a native Java class.
  79 // If NCODE is supplied, it will be set with the ip for the entry point of the
  80 // enclosing method.
  81 jclass
  82 _Jv_StackTrace::ClassForFrame (_Jv_StackFrame *frame)
  83 {
  84   JvAssert (frame->type == frame_native);
  85   jclass klass = NULL;
  86   // use _Unwind_FindEnclosingFunction to find start of method
  87   //void *entryPoint = _Unwind_FindEnclosingFunction (ip);
  88
  89   // look it up in ncodeMap
  90   if (frame->start_ip)
  91     klass = (jclass) ncodeMap->get ((jobject) frame->start_ip);
  92
  93   return klass;
  94 }
  95
  96 _Unwind_Reason_Code
  97 _Jv_StackTrace::UnwindTraceFn (struct _Unwind_Context *context, void *state_ptr)
  98 {
  99   _Jv_UnwindState *state = (_Jv_UnwindState *) state_ptr;
 100   jint pos = state->pos;
 101
 102   // Check if the trace buffer needs to be extended.
 103   if (pos == state->length)
 104     {
 105       int newLength = state->length * 2;
 106       void *newFrames = _Jv_AllocBytes (newLength * sizeof(_Jv_StackFrame));
 107       memcpy (newFrames, state->frames, state->length * sizeof(_Jv_StackFrame));
 108       state->frames = (_Jv_StackFrame *) newFrames;
 109       state->length = newLength;
 110     }
 111
 112   void *func_addr = (void *) _Unwind_GetRegionStart (context);
 113
 114   // If we see the interpreter's main function, "pop" an entry off the
 115   // interpreter stack and use that instead, so that the trace goes through
 116   // the java code and not the interpreter itself. This assumes a 1:1
 117   // correspondance between call frames in the interpreted stack and occurances
 118   // of _Jv_InterpMethod::run() on the native stack.
 119 #ifdef INTERPRETER
 120   void *interp_run = (void *) &_Jv_InterpMethod::run;
 121   if (func_addr == UNWRAP_FUNCTION_DESCRIPTOR (interp_run))
 122     {
 123       state->frames[pos].type = frame_interpreter;
 124       state->frames[pos].interp.meth = state->interp_frame->self;
 125       state->frames[pos].interp.pc = state->interp_frame->pc;
 126       state->interp_frame = state->interp_frame->next;
 127     }
 128   else
 129 #endif
 130     {
 131       state->frames[pos].type = frame_native;
 132       state->frames[pos].ip = (void *) _Unwind_GetIP (context);
 133       state->frames[pos].start_ip = func_addr;
 134     }
 135
 136   //printf ("unwind ip: %p\n", _Unwind_GetIP (context));
 137
 138   _Unwind_Reason_Code result = _URC_NO_REASON;
 139   if (state->trace_function != NULL)
 140     result = (state->trace_function) (state);
 141   state->pos++;
 142   return result;
 143 }
 144
 145 // Return a raw stack trace from the current point of execution. The raw
 146 // trace will include all functions that have unwind info.
 147 _Jv_StackTrace *
 148 _Jv_StackTrace::GetStackTrace(void)
 149 {
 150   int trace_size = 100;
 151   _Jv_StackFrame frames[trace_size];
 152   _Jv_UnwindState state (trace_size);
 153   state.frames = (_Jv_StackFrame *) &frames;
 154
 155 #ifdef SJLJ_EXCEPTIONS
 156   // The Unwind interface doesn't work with the SJLJ exception model.
 157   // Fall back to a platform-specific unwinder.
 158   fallback_backtrace (&state);
 159 #else /* SJLJ_EXCEPTIONS */
 160   _Unwind_Backtrace (UnwindTraceFn, &state);
 161 #endif /* SJLJ_EXCEPTIONS */
 162
 163   // Copy the trace and return it.
 164   int traceSize = sizeof (_Jv_StackTrace) +
 165     (sizeof (_Jv_StackFrame) * state.pos);
 166   _Jv_StackTrace *trace = (_Jv_StackTrace *) _Jv_AllocBytes (traceSize);
 167   trace->length = state.pos;
 168   memcpy (trace->frames, state.frames, sizeof (_Jv_StackFrame) * state.pos);
 169   return trace;
 170 }
 171
 172 void
 173 _Jv_StackTrace::getLineNumberForFrame(_Jv_StackFrame *frame, NameFinder *finder,
 174                                       jstring *sourceFileName, jint *lineNum,
 175                                       jstring *methodName)
 176 {
 177 #ifdef INTERPRETER
 178   if (frame->type == frame_interpreter)
 179     {
 180       _Jv_InterpMethod *interp_meth = frame->interp.meth;
 181       _Jv_InterpClass *interp_class =
 182          (_Jv_InterpClass *) interp_meth->defining_class->aux_info;
 183       *sourceFileName = interp_class->source_file_name;
 184       *lineNum = interp_meth->get_source_line(frame->interp.pc);
 185       return;
 186     }
 187 #endif
 188   // Use dladdr() to determine in which binary the address IP resides.
 189 #if defined (HAVE_DLFCN_H) && defined (HAVE_DLADDR)
 190   Dl_info info;
 191   jstring binaryName = NULL;
 192   const char *argv0 = _Jv_GetSafeArg(0);
 193
 194   void *ip = frame->ip;
 195   _Unwind_Ptr offset = 0;
 196
 197   if (dladdr (ip, &info))
 198     {
 199       if (info.dli_fname)
 200         binaryName = JvNewStringUTF (info.dli_fname);
 201       else
 202         return;
 203
 204       if (*methodName == NULL && info.dli_sname)
 205         *methodName = JvNewStringUTF (info.dli_sname);
 206
 207       // addr2line expects relative addresses for shared libraries.
 208       if (strcmp (info.dli_fname, argv0) == 0)
 209         offset = (_Unwind_Ptr) ip;
 210       else
 211         offset = (_Unwind_Ptr) ip - (_Unwind_Ptr) info.dli_fbase;
 212
 213       //printf ("linenum ip: %p\n", ip);
 214       //printf ("%s: 0x%x\n", info.dli_fname, offset);
 215       //offset -= sizeof(void *);
 216
 217       // The unwinder gives us the return address. In order to get the right
 218       // line number for the stack trace, roll it back a little.
 219       offset -= 1;
 220
 221       // printf ("%s: 0x%x\n", info.dli_fname, offset);
 222
 223       finder->lookup (binaryName, (jlong) offset);
 224       *sourceFileName = finder->getSourceFile();
 225       *lineNum = finder->getLineNum();
 226     }
 227 #endif
 228 }
 229
 230 // Look up class and method info for the given stack frame, setting
 231 // frame->klass and frame->meth if they are known.
 232 void
 233 _Jv_StackTrace::FillInFrameInfo (_Jv_StackFrame *frame)
 234 {
 235   jclass klass = NULL;
 236   _Jv_Method *meth = NULL;
 237
 238   if (frame->type == frame_native)
 239     {
 240       klass = _Jv_StackTrace::ClassForFrame (frame);
 241
 242       if (klass != NULL)
 243         // Find method in class
 244         for (int j = 0; j < klass->method_count; j++)
 245           {
 246             void *wncode = UNWRAP_FUNCTION_DESCRIPTOR (klass->methods[j].ncode);
 247             if (wncode == frame->start_ip)
 248               {
 249                 meth = &klass->methods[j];
 250                 break;
 251               }
 252           }
 253     }
 254 #ifdef INTERPRETER
 255   else if (frame->type == frame_interpreter)
 256     {
 257       _Jv_InterpMethod *interp_meth = frame->interp.meth;
 258       klass = interp_meth->defining_class;
 259       meth = interp_meth->self;
 260     }
 261 #endif
 262   else
 263     JvFail ("Unknown frame type");
 264
 265   frame->klass = klass;
 266   frame->meth = meth;
 267 }
 268
 269 // Convert raw stack frames to a Java array of StackTraceElement objects.
 270 JArray< ::java::lang::StackTraceElement *>*
 271 _Jv_StackTrace::GetStackTraceElements (_Jv_StackTrace *trace,
 272   Throwable *throwable __attribute__((unused)))
 273 {
 274   ArrayList *list = new ArrayList ();
 275
 276 #ifdef SJLJ_EXCEPTIONS
 277   // We can't use the nCodeMap without unwinder support. Instead,
 278   // fake the method name by giving the IP in hex - better than nothing.
 279   jstring hex = JvNewStringUTF ("0x");
 280
 281   for (int i = 0; i < trace->length; i++)
 282     {
 283       jstring sourceFileName = NULL;
 284       jint lineNum = -1;
 285       _Jv_StackFrame *frame = &trace->frames[i];
 286
 287       jstring className = NULL;
 288       jstring methodName = hex->concat (Long::toHexString ((jlong) frame->ip));
 289
 290       StackTraceElement *element = new StackTraceElement (sourceFileName,
 291         lineNum, className, methodName, 0);
 292       list->add (element);
 293     }
 294
 295 #else /* SJLJ_EXCEPTIONS */
 296
 297   //JvSynchronized (ncodeMap);
 298   UpdateNCodeMap ();
 299
 300   NameFinder *finder = new NameFinder();
 301   int start_idx = 0;
 302   int end_idx = trace->length - 1;
 303
 304   // First pass: strip superfluous frames from beginning and end of the trace.
 305   for (int i = 0; i < trace->length; i++)
 306     {
 307       _Jv_StackFrame *frame = &trace->frames[i];
 308       FillInFrameInfo (frame);
 309
 310       if (!frame->klass || !frame->meth)
 311         // Not a Java frame.
 312         continue;
 313
 314       // Throw away the top of the stack till we see:
 315       //  - the constructor(s) of this Throwable, or
 316       //  - the Throwable.fillInStackTrace call.
 317       if (frame->klass == throwable->getClass()
 318           && strcmp (frame->meth->name->chars(), "<init>") == 0)
 319         start_idx = i + 1;
 320
 321       if (frame->klass == &Throwable::class$
 322           && strcmp (frame->meth->name->chars(), "fillInStackTrace") == 0)
 323         start_idx = i + 1;
 324
 325       // End the trace at the application's main() method if we see call_main.
 326       if (frame->klass == &gnu::java::lang::MainThread::class$
 327           && strcmp (frame->meth->name->chars(), "call_main") == 0)
 328         end_idx = i - 1;
 329     }
 330
 331   const jboolean remove_unknown
 332     = gnu::gcj::runtime::NameFinder::removeUnknown();
 333
 334   // Second pass: Look up line-number info for remaining frames.
 335   for (int i = start_idx; i <= end_idx; i++)
 336     {
 337       _Jv_StackFrame *frame = &trace->frames[i];
 338
 339       if (frame->klass == NULL && remove_unknown)
 340         // Not a Java frame.
 341         continue;
 342
 343       jstring className = NULL;
 344       if (frame->klass != NULL)
 345         className = frame->klass->getName ();
 346
 347       jstring methodName = NULL;
 348       if (frame->meth)
 349         methodName = JvNewStringUTF (frame->meth->name->chars());
 350
 351       jstring sourceFileName = NULL;
 352       jint lineNum = -1;
 353
 354       getLineNumberForFrame(frame, finder, &sourceFileName, &lineNum,
 355                             &methodName);
 356
 357       StackTraceElement *element = new StackTraceElement (sourceFileName, lineNum,
 358         className, methodName, 0);
 359       list->add (element);
 360     }
 361
 362   finder->close();
 363 #endif /* SJLJ_EXCEPTIONS */
 364
 365   JArray<Object *> *array = JvNewObjectArray (list->size (),
 366     &StackTraceElement::class$, NULL);
 367
 368   return (JArray<StackTraceElement *>*) list->toArray (array);
 369 }
 370
 371 struct CallingClassTraceData
 372 {
 373   jclass checkClass;
 374   jclass foundClass;
 375   _Jv_Method *foundMeth;
 376   bool seen_checkClass;
 377 };
 378
 379 _Unwind_Reason_Code
 380 _Jv_StackTrace::calling_class_trace_fn (_Jv_UnwindState *state)
 381 {
 382   CallingClassTraceData *trace_data = (CallingClassTraceData *)
 383     state->trace_data;
 384   _Jv_StackFrame *frame = &state->frames[state->pos];
 385   FillInFrameInfo (frame);
 386
 387   if (trace_data->seen_checkClass
 388       && frame->klass
 389       && frame->klass != trace_data->checkClass)
 390     {
 391       trace_data->foundClass = frame->klass;
 392       trace_data->foundMeth = frame->meth;
 393       return _URC_NORMAL_STOP;
 394     }
 395
 396   if (frame->klass == trace_data->checkClass)
 397     trace_data->seen_checkClass = true;
 398
 399   return _URC_NO_REASON;
 400 }
 401
 402 // Find the class immediately above the given class on the call stack. Any
 403 // intermediate non-Java
 404 // frames are ignored. If the calling class could not be determined (eg because
 405 // the unwinder is not supported on this platform), NULL is returned.
 406 // This function is used to implement calling-classloader checks and reflection
 407 // accessibility checks.
 408 // CHECKCLASS is typically the class calling GetCallingClass. The first class
 409 // above CHECKCLASS on the call stack will be returned.
 410 jclass
 411 _Jv_StackTrace::GetCallingClass (jclass checkClass)
 412 {
 413   jclass result = NULL;
 414   GetCallerInfo (checkClass, &result, NULL);
 415   return result;
 416 }
 417
 418 void
 419 _Jv_StackTrace::GetCallerInfo (jclass checkClass, jclass *caller_class,
 420   _Jv_Method **caller_meth)
 421 {
 422 #ifndef SJLJ_EXCEPTIONS
 423   int trace_size = 20;
 424   _Jv_StackFrame frames[trace_size];
 425   _Jv_UnwindState state (trace_size);
 426   state.frames = (_Jv_StackFrame *) &frames;
 427
 428   CallingClassTraceData trace_data;
 429   trace_data.checkClass = checkClass;
 430   trace_data.seen_checkClass = false;
 431   trace_data.foundClass = NULL;
 432   trace_data.foundMeth = NULL;
 433
 434   state.trace_function = calling_class_trace_fn;
 435   state.trace_data = (void *) &trace_data;
 436
 437   //JvSynchronized (ncodeMap);
 438   UpdateNCodeMap ();
 439
 440   _Unwind_Backtrace (UnwindTraceFn, &state);
 441
 442   if (caller_class)
 443     *caller_class = trace_data.foundClass;
 444   if (caller_meth)
 445     *caller_meth = trace_data.foundMeth;
 446 #else
 447   return;
 448 #endif
 449 }
 450
 451 // Return a java array containing the Java classes on the stack above CHECKCLASS.
 452 JArray<jclass> *
 453 _Jv_StackTrace::GetClassContext (jclass checkClass)
 454 {
 455   JArray<jclass> *result = NULL;
 456
 457   int trace_size = 100;
 458   _Jv_StackFrame frames[trace_size];
 459   _Jv_UnwindState state (trace_size);
 460   state.frames = (_Jv_StackFrame *) &frames;
 461
 462   //JvSynchronized (ncodeMap);
 463   UpdateNCodeMap ();
 464
 465   _Unwind_Backtrace (UnwindTraceFn, &state);
 466
 467   // Count the number of Java frames on the stack.
 468   int jframe_count = 0;
 469   bool seen_checkClass = false;
 470   int start_pos = -1;
 471   for (int i = 0; i < state.pos; i++)
 472     {
 473       _Jv_StackFrame *frame = &state.frames[i];
 474       FillInFrameInfo (frame);
 475
 476       if (seen_checkClass)
 477         {
 478           if (frame->klass)
 479             {
 480               jframe_count++;
 481               if (start_pos == -1)
 482                 start_pos = i;
 483             }
 484         }
 485       else
 486         seen_checkClass = frame->klass == checkClass;
 487     }
 488   result = (JArray<jclass> *) _Jv_NewObjectArray (jframe_count, &Class::class$, NULL);
 489   int pos = 0;
 490
 491   for (int i = start_pos; i < state.pos; i++)
 492     {
 493       _Jv_StackFrame *frame = &state.frames[i];
 494       if (frame->klass)
 495         elements(result)[pos++] = frame->klass;
 496     }
 497   return result;
 498 }
 499
 500 _Unwind_Reason_Code
 501 _Jv_StackTrace::non_system_trace_fn (_Jv_UnwindState *state)
 502 {
 503   _Jv_StackFrame *frame = &state->frames[state->pos];
 504   FillInFrameInfo (frame);
 505
 506   ClassLoader *classLoader = NULL;
 507
 508   if (frame->klass)
 509     {
 510       classLoader = frame->klass->getClassLoaderInternal();
 511 #ifdef INTERPRETER
 512       if (classLoader != NULL)
 513         {
 514           state->trace_data = (void *) classLoader;
 515           return _URC_NORMAL_STOP;
 516         }
 517 #endif
 518     }
 519
 520   return _URC_NO_REASON;
 521 }
 522
 523 ClassLoader *
 524 _Jv_StackTrace::GetFirstNonSystemClassLoader ()
 525 {
 526   int trace_size = 32;
 527   _Jv_StackFrame frames[trace_size];
 528   _Jv_UnwindState state (trace_size);
 529   state.frames = (_Jv_StackFrame *) &frames;
 530   state.trace_function = non_system_trace_fn;
 531   state.trace_data = NULL;
 532
 533   //JvSynchronized (ncodeMap);
 534   UpdateNCodeMap ();
 535
 536   _Unwind_Backtrace (UnwindTraceFn, &state);
 537
 538   if (state.trace_data)
 539     return (ClassLoader *) state.trace_data;
 540
 541   return NULL;
 542 }