libgo/runtime/go-callers.c

   1 /* go-callers.c -- get callers for Go.
   2
   3    Copyright 2012 The Go Authors. All rights reserved.
   4    Use of this source code is governed by a BSD-style
   5    license that can be found in the LICENSE file.  */
   6
   7 #include "config.h"
   8
   9 #include "backtrace.h"
  10
  11 #include "runtime.h"
  12 #include "array.h"
  13
  14 /* This is set to non-zero when calling backtrace_full.  This is used
  15    to avoid getting hanging on a recursive lock in dl_iterate_phdr on
  16    older versions of glibc when a SIGPROF signal arrives while
  17    collecting a backtrace.  */
  18
  19 uint32 runtime_in_callers;
  20
  21 /* Argument passed to callback function.  */
  22
  23 struct callers_data
  24 {
  25   Location *locbuf;
  26   int skip;
  27   int index;
  28   int max;
  29 };
  30
  31 /* Callback function for backtrace_full.  Just collect the locations.
  32    Return zero to continue, non-zero to stop.  */
  33
  34 static int
  35 callback (void *data, uintptr_t pc, const char *filename, int lineno,
  36           const char *function)
  37 {
  38   struct callers_data *arg = (struct callers_data *) data;
  39   Location *loc;
  40
  41   /* Skip split stack functions.  */
  42   if (function != NULL)
  43     {
  44       const char *p;
  45
  46       p = function;
  47       if (__builtin_strncmp (p, "___", 3) == 0)
  48         ++p;
  49       if (__builtin_strncmp (p, "__morestack_", 12) == 0)
  50         return 0;
  51     }
  52   else if (filename != NULL)
  53     {
  54       const char *p;
  55
  56       p = strrchr (filename, '/');
  57       if (p == NULL)
  58         p = filename;
  59       if (__builtin_strncmp (p, "/morestack.S", 12) == 0)
  60         return 0;
  61     }
  62
  63   /* Skip thunks and recover functions.  There is no equivalent to
  64      these functions in the gc toolchain, so returning them here means
  65      significantly different results for runtime.Caller(N).  */
  66   if (function != NULL)
  67     {
  68       const char *p;
  69
  70       p = __builtin_strchr (function, '.');
  71       if (p != NULL && __builtin_strncmp (p + 1, "$thunk", 6) == 0)
  72         return 0;
  73       p = __builtin_strrchr (function, '$');
  74       if (p != NULL && __builtin_strcmp(p, "$recover") == 0)
  75         return 0;
  76     }
  77
  78   if (arg->skip > 0)
  79     {
  80       --arg->skip;
  81       return 0;
  82     }
  83
  84   loc = &arg->locbuf[arg->index];
  85   loc->pc = pc;
  86
  87   /* The libbacktrace library says that these strings might disappear,
  88      but with the current implementation they won't.  We can't easily
  89      allocate memory here, so for now assume that we can save a
  90      pointer to the strings.  */
  91   loc->filename = runtime_gostringnocopy ((const byte *) filename);
  92   loc->function = runtime_gostringnocopy ((const byte *) function);
  93
  94   loc->lineno = lineno;
  95   ++arg->index;
  96   return arg->index >= arg->max;
  97 }
  98
  99 /* Error callback.  */
 100
 101 static void
 102 error_callback (void *data __attribute__ ((unused)),
 103                 const char *msg, int errnum)
 104 {
 105   if (errnum != 0)
 106     runtime_printf ("%s errno %d\n", msg, errnum);
 107   runtime_throw (msg);
 108 }
 109
 110 /* Gather caller PC's.  */
 111
 112 int32
 113 runtime_callers (int32 skip, Location *locbuf, int32 m)
 114 {
 115   struct callers_data data;
 116
 117   data.locbuf = locbuf;
 118   data.skip = skip + 1;
 119   data.index = 0;
 120   data.max = m;
 121   runtime_xadd (&runtime_in_callers, 1);
 122   backtrace_full (__go_get_backtrace_state (), 0, callback, error_callback,
 123                   &data);
 124   runtime_xadd (&runtime_in_callers, -1);
 125   return data.index;
 126 }
 127
 128 int Callers (int, struct __go_open_array)
 129   __asm__ (GOSYM_PREFIX "runtime.Callers");
 130
 131 int
 132 Callers (int skip, struct __go_open_array pc)
 133 {
 134   Location *locbuf;
 135   int ret;
 136   int i;
 137
 138   locbuf = (Location *) runtime_mal (pc.__count * sizeof (Location));
 139
 140   /* In the Go 1 release runtime.Callers has an off-by-one error,
 141      which we can not correct because it would break backward
 142      compatibility.  Normally we would add 1 to SKIP here, but we
 143      don't so that we are compatible.  */
 144   ret = runtime_callers (skip, locbuf, pc.__count);
 145
 146   for (i = 0; i < ret; i++)
 147     ((uintptr *) pc.__values)[i] = locbuf[i].pc;
 148
 149   return ret;
 150 }