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 static 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       if (p != NULL && __builtin_strncmp(p, "$stub", 5) == 0)
  78         return 0;
  79     }
  80
  81   if (arg->skip > 0)
  82     {
  83       --arg->skip;
  84       return 0;
  85     }
  86
  87   loc = &arg->locbuf[arg->index];
  88
  89   /* On the call to backtrace_full the pc value was most likely
  90      decremented if there was a normal call, since the pc referred to
  91      the instruction where the call returned and not the call itself.
  92      This was done so that the line number referred to the call
  93      instruction.  To make sure the actual pc from the call stack is
  94      used, it is incremented here.
  95
  96      In the case of a signal, the pc was not decremented by
  97      backtrace_full but still incremented here.  That doesn't really
  98      hurt anything since the line number is right and the pc refers to
  99      the same instruction.  */
 100
 101   loc->pc = pc + 1;
 102
 103   /* The libbacktrace library says that these strings might disappear,
 104      but with the current implementation they won't.  We can't easily
 105      allocate memory here, so for now assume that we can save a
 106      pointer to the strings.  */
 107   loc->filename = runtime_gostringnocopy ((const byte *) filename);
 108   loc->function = runtime_gostringnocopy ((const byte *) function);
 109
 110   loc->lineno = lineno;
 111   ++arg->index;
 112
 113   /* There is no point to tracing past certain runtime functions.
 114      Stopping the backtrace here can avoid problems on systems that
 115      don't provide proper unwind information for makecontext, such as
 116      Solaris (http://gcc.gnu.org/PR52583 comment #21).  */
 117   if (function != NULL)
 118     {
 119       if (__builtin_strcmp (function, "makecontext") == 0)
 120         return 1;
 121       if (filename != NULL)
 122         {
 123           const char *p;
 124
 125           p = strrchr (filename, '/');
 126           if (p == NULL)
 127             p = filename;
 128           if (__builtin_strcmp (p, "/proc.c") == 0)
 129             {
 130               if (__builtin_strcmp (function, "runtime_mstart") == 0)
 131                 return 1;
 132             }
 133           else if (__builtin_strcmp (p, "/proc.go") == 0)
 134             {
 135               if (__builtin_strcmp (function, "runtime.kickoff") == 0
 136                   || __builtin_strcmp (function, "runtime.main") == 0)
 137                 return 1;
 138             }
 139         }
 140     }
 141
 142   return arg->index >= arg->max;
 143 }
 144
 145 /* Error callback.  */
 146
 147 static void
 148 error_callback (void *data __attribute__ ((unused)),
 149                 const char *msg, int errnum)
 150 {
 151   if (errnum == -1)
 152     {
 153       /* No debug info available.  Carry on as best we can.  */
 154       return;
 155     }
 156   if (errnum != 0)
 157     runtime_printf ("%s errno %d\n", msg, errnum);
 158   runtime_throw (msg);
 159 }
 160
 161 /* Return whether we are already collecting a stack trace. This is
 162    called from the signal handler.  */
 163
 164 bool alreadyInCallers(void)
 165   __attribute__ ((no_split_stack));
 166 bool alreadyInCallers(void)
 167   __asm__ (GOSYM_PREFIX "runtime.alreadyInCallers");
 168
 169 bool
 170 alreadyInCallers()
 171 {
 172   return runtime_atomicload(&runtime_in_callers) > 0;
 173 }
 174
 175 /* Gather caller PC's.  */
 176
 177 int32
 178 runtime_callers (int32 skip, Location *locbuf, int32 m, bool keep_thunks)
 179 {
 180   struct callers_data data;
 181
 182   data.locbuf = locbuf;
 183   data.skip = skip + 1;
 184   data.index = 0;
 185   data.max = m;
 186   data.keep_thunks = keep_thunks;
 187   runtime_xadd (&runtime_in_callers, 1);
 188   backtrace_full (__go_get_backtrace_state (), 0, callback, error_callback,
 189                   &data);
 190   runtime_xadd (&runtime_in_callers, -1);
 191
 192   /* For some reason GCC sometimes loses the name of a thunk function
 193      at the top of the stack.  If we are skipping thunks, skip that
 194      one too.  */
 195   if (!keep_thunks
 196       && data.index > 2
 197       && locbuf[data.index - 2].function.len == 0
 198       && locbuf[data.index - 1].function.str != NULL
 199       && __builtin_strcmp ((const char *) locbuf[data.index - 1].function.str,
 200                            "runtime.kickoff") == 0)
 201     {
 202       locbuf[data.index - 2] = locbuf[data.index - 1];
 203       --data.index;
 204     }
 205
 206   return data.index;
 207 }
 208
 209 int Callers (int, struct __go_open_array)
 210   __asm__ (GOSYM_PREFIX "runtime.Callers");
 211
 212 int
 213 Callers (int skip, struct __go_open_array pc)
 214 {
 215   Location *locbuf;
 216   int ret;
 217   int i;
 218
 219   /* Note that calling mallocgc here assumes that we are not going to
 220      store any allocated Go pointers in the slice.  */
 221   locbuf = (Location *) runtime_mallocgc (pc.__count * sizeof (Location),
 222                                           nil, false);
 223
 224   /* In the Go 1 release runtime.Callers has an off-by-one error,
 225      which we can not correct because it would break backward
 226      compatibility.  Normally we would add 1 to SKIP here, but we
 227      don't so that we are compatible.  */
 228   ret = runtime_callers (skip, locbuf, pc.__count, false);
 229
 230   for (i = 0; i < ret; i++)
 231     ((uintptr *) pc.__values)[i] = locbuf[i].pc;
 232
 233   return ret;
 234 }