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   int keep_thunks;
  30 };
  31
  32 /* Callback function for backtrace_full.  Just collect the locations.
  33    Return zero to continue, non-zero to stop.  */
  34
  35 static int
  36 callback (void *data, uintptr_t pc, const char *filename, int lineno,
  37           const char *function)
  38 {
  39   struct callers_data *arg = (struct callers_data *) data;
  40   Location *loc;
  41
  42   /* Skip split stack functions.  */
  43   if (function != NULL)
  44     {
  45       const char *p;
  46
  47       p = function;
  48       if (__builtin_strncmp (p, "___", 3) == 0)
  49         ++p;
  50       if (__builtin_strncmp (p, "__morestack_", 12) == 0)
  51         return 0;
  52     }
  53   else if (filename != NULL)
  54     {
  55       const char *p;
  56
  57       p = strrchr (filename, '/');
  58       if (p == NULL)
  59         p = filename;
  60       if (__builtin_strncmp (p, "/morestack.S", 12) == 0)
  61         return 0;
  62     }
  63
  64   /* Skip thunks and recover functions.  There is no equivalent to
  65      these functions in the gc toolchain, so returning them here means
  66      significantly different results for runtime.Caller(N).  */
  67   if (function != NULL && !arg->keep_thunks)
  68     {
  69       const char *p;
  70
  71       p = __builtin_strchr (function, '.');
  72       if (p != NULL && __builtin_strncmp (p + 1, "$thunk", 6) == 0)
  73         return 0;
  74       p = __builtin_strrchr (function, '$');
  75       if (p != NULL && __builtin_strcmp(p, "$recover") == 0)
  76         return 0;
  77     }
  78
  79   if (arg->skip > 0)
  80     {
  81       --arg->skip;
  82       return 0;
  83     }
  84
  85   loc = &arg->locbuf[arg->index];
  86   loc->pc = pc;
  87
  88   /* The libbacktrace library says that these strings might disappear,
  89      but with the current implementation they won't.  We can't easily
  90      allocate memory here, so for now assume that we can save a
  91      pointer to the strings.  */
  92   loc->filename = runtime_gostringnocopy ((const byte *) filename);
  93   loc->function = runtime_gostringnocopy ((const byte *) function);
  94
  95   loc->lineno = lineno;
  96   ++arg->index;
  97
  98   /* There is no point to tracing past certain runtime functions.
  99      Stopping the backtrace here can avoid problems on systems that
 100      don't provide proper unwind information for makecontext, such as
 101      Solaris (http://gcc.gnu.org/PR52583 comment #21).  */
 102   if (function != NULL)
 103     {
 104       if (__builtin_strcmp (function, "makecontext") == 0)
 105         return 1;
 106       if (filename != NULL)
 107         {
 108           const char *p;
 109
 110           p = strrchr (filename, '/');
 111           if (p == NULL)
 112             p = filename;
 113           if (__builtin_strcmp (p, "/proc.c") == 0)
 114             {
 115               if (__builtin_strcmp (function, "kickoff") == 0
 116                   || __builtin_strcmp (function, "runtime_mstart") == 0
 117                   || __builtin_strcmp (function, "runtime_main") == 0)
 118                 return 1;
 119             }
 120         }
 121     }
 122
 123   return arg->index >= arg->max;
 124 }
 125
 126 /* Error callback.  */
 127
 128 static void
 129 error_callback (void *data __attribute__ ((unused)),
 130                 const char *msg, int errnum)
 131 {
 132   if (errnum != 0)
 133     runtime_printf ("%s errno %d\n", msg, errnum);
 134   runtime_throw (msg);
 135 }
 136
 137 /* Gather caller PC's.  */
 138
 139 int32
 140 runtime_callers (int32 skip, Location *locbuf, int32 m, bool keep_thunks)
 141 {
 142   struct callers_data data;
 143
 144   data.locbuf = locbuf;
 145   data.skip = skip + 1;
 146   data.index = 0;
 147   data.max = m;
 148   data.keep_thunks = keep_thunks;
 149   runtime_xadd (&runtime_in_callers, 1);
 150   backtrace_full (__go_get_backtrace_state (), 0, callback, error_callback,
 151                   &data);
 152   runtime_xadd (&runtime_in_callers, -1);
 153   return data.index;
 154 }
 155
 156 int Callers (int, struct __go_open_array)
 157   __asm__ (GOSYM_PREFIX "runtime.Callers");
 158
 159 int
 160 Callers (int skip, struct __go_open_array pc)
 161 {
 162   Location *locbuf;
 163   int ret;
 164   int i;
 165
 166   locbuf = (Location *) runtime_mal (pc.__count * sizeof (Location));
 167
 168   /* In the Go 1 release runtime.Callers has an off-by-one error,
 169      which we can not correct because it would break backward
 170      compatibility.  Normally we would add 1 to SKIP here, but we
 171      don't so that we are compatible.  */
 172   ret = runtime_callers (skip, locbuf, pc.__count, false);
 173
 174   for (i = 0; i < ret; i++)
 175     ((uintptr *) pc.__values)[i] = locbuf[i].pc;
 176
 177   return ret;
 178 }