libgo/runtime/go-caller.c

   1 /* go-caller.c -- look up function/file/line/entry info
   2
   3    Copyright 2009 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 /* Implement runtime.Caller.  */
   8
   9 #include <stdint.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <unistd.h>
  13
  14 #include "backtrace.h"
  15
  16 #include "runtime.h"
  17
  18 /* Get the function name, file name, and line number for a PC value.
  19    We use the backtrace library to get this.  */
  20
  21 /* Data structure to gather file/line information.  */
  22
  23 struct caller
  24 {
  25   String fn;
  26   String file;
  27   intgo line;
  28   intgo index;
  29 };
  30
  31 /* Collect file/line information for a PC value.  If this is called
  32    more than once, due to inlined functions, we use the last call, as
  33    that is usually the most useful one.  */
  34
  35 static int
  36 callback (void *data, uintptr_t pc __attribute__ ((unused)),
  37           const char *filename, int lineno, const char *function)
  38 {
  39   struct caller *c = (struct caller *) data;
  40
  41   /* The libbacktrace library says that these strings might disappear,
  42      but with the current implementation they won't.  We can't easily
  43      allocate memory here, so for now assume that we can save a
  44      pointer to the strings.  */
  45   c->fn = runtime_gostringnocopy ((const byte *) function);
  46   c->file = runtime_gostringnocopy ((const byte *) filename);
  47   c->line = lineno;
  48
  49   if (c->index == 0)
  50     return 1;
  51
  52   if (c->index > 0)
  53     --c->index;
  54
  55   return 0;
  56 }
  57
  58 /* The error callback for backtrace_pcinfo and backtrace_syminfo.  */
  59
  60 static void
  61 error_callback (void *data __attribute__ ((unused)),
  62                 const char *msg, int errnum)
  63 {
  64   if (errnum == -1)
  65     return;
  66   if (errnum > 0)
  67     runtime_printf ("%s errno %d\n", msg, errnum);
  68   runtime_throw (msg);
  69 }
  70
  71 /* The backtrace library state.  */
  72
  73 static void *back_state;
  74
  75 /* A lock to control creating back_state.  */
  76
  77 static uint32 back_state_lock;
  78
  79 /* The program arguments.  */
  80
  81 extern Slice runtime_get_args(void);
  82
  83 /* Fetch back_state, creating it if necessary.  */
  84
  85 struct backtrace_state *
  86 __go_get_backtrace_state ()
  87 {
  88   uint32 set;
  89
  90   /* We may not have a g here, so we can't use runtime_lock.  */
  91   set = 0;
  92   while (!__atomic_compare_exchange_n (&back_state_lock, &set, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
  93     {
  94       runtime_osyield ();
  95       set = 0;
  96     }
  97   if (back_state == NULL)
  98     {
  99       Slice args;
 100       const char *filename;
 101       struct stat s;
 102
 103       args = runtime_get_args();
 104       filename = NULL;
 105       if (args.__count > 0)
 106         filename = (const char*)((String*)args.__values)[0].str;
 107
 108       /* If there is no '/' in FILENAME, it was found on PATH, and
 109          might not be the same as the file with the same name in the
 110          current directory.  */
 111       if (filename != NULL && __builtin_strchr (filename, '/') == NULL)
 112         filename = NULL;
 113
 114       /* If the file is small, then it's not the real executable.
 115          This is specifically to deal with Docker, which uses a bogus
 116          argv[0] (http://gcc.gnu.org/PR61895).  It would be nice to
 117          have a better check for whether this file is the real
 118          executable.  */
 119       if (stat (filename, &s) < 0 || s.st_size < 1024)
 120         filename = NULL;
 121
 122       back_state = backtrace_create_state (filename, 1, error_callback, NULL);
 123     }
 124   __atomic_store_n (&back_state_lock, 0, __ATOMIC_RELEASE);
 125   return back_state;
 126 }
 127
 128 /* Return function/file/line information for PC.  The index parameter
 129    is the entry on the stack of inlined functions; -1 means the last
 130    one.  */
 131
 132 _Bool
 133 __go_file_line (uintptr pc, int index, String *fn, String *file, intgo *line)
 134 {
 135   struct caller c;
 136
 137   runtime_memclr (&c, sizeof c);
 138   c.index = index;
 139   backtrace_pcinfo (__go_get_backtrace_state (), pc, callback,
 140                     error_callback, &c);
 141   *fn = c.fn;
 142   *file = c.file;
 143   *line = c.line;
 144   return c.file.len > 0;
 145 }
 146
 147 /* Collect symbol information.  */
 148
 149 static void
 150 syminfo_callback (void *data, uintptr_t pc __attribute__ ((unused)),
 151                   const char *symname __attribute__ ((unused)),
 152                   uintptr_t address, uintptr_t size __attribute__ ((unused)))
 153 {
 154   uintptr_t *pval = (uintptr_t *) data;
 155
 156   *pval = address;
 157 }
 158
 159 /* Set *VAL to the value of the symbol for PC.  */
 160
 161 static _Bool
 162 __go_symbol_value (uintptr pc, uintptr *val)
 163 {
 164   *val = 0;
 165   backtrace_syminfo (__go_get_backtrace_state (), pc, syminfo_callback,
 166                      error_callback, val);
 167   return *val != 0;
 168 }
 169
 170 /* The values returned by runtime.Caller.  */
 171
 172 struct caller_ret
 173 {
 174   uintptr_t pc;
 175   String file;
 176   intgo line;
 177   _Bool ok;
 178 };
 179
 180 struct caller_ret Caller (int n) __asm__ (GOSYM_PREFIX "runtime.Caller");
 181
 182 /* Implement runtime.Caller.  */
 183
 184 struct caller_ret
 185 Caller (int skip)
 186 {
 187   struct caller_ret ret;
 188   Location loc;
 189   int32 n;
 190
 191   runtime_memclr (&ret, sizeof ret);
 192   n = runtime_callers (skip + 1, &loc, 1, false);
 193   if (n < 1 || loc.pc == 0)
 194     return ret;
 195   ret.pc = loc.pc;
 196   ret.file = loc.filename;
 197   ret.line = loc.lineno;
 198   ret.ok = 1;
 199   return ret;
 200 }
 201
 202 /* Look up the function name, file name, and line number for a PC.  */
 203
 204 struct funcfileline_return
 205 {
 206   String retfn;
 207   String retfile;
 208   intgo retline;
 209 };
 210
 211 struct funcfileline_return
 212 runtime_funcfileline (uintptr targetpc, int32 index)
 213   __asm__ (GOSYM_PREFIX "runtime.funcfileline");
 214
 215 struct funcfileline_return
 216 runtime_funcfileline (uintptr targetpc, int32 index)
 217 {
 218   struct funcfileline_return ret;
 219
 220   if (!__go_file_line (targetpc, index, &ret.retfn, &ret.retfile,
 221                        &ret.retline))
 222     runtime_memclr (&ret, sizeof ret);
 223   return ret;
 224 }
 225
 226 /* Return the entry point of a function.  */
 227 uintptr runtime_funcentry(uintptr)
 228   __asm__ (GOSYM_PREFIX "runtime.funcentry");
 229
 230 uintptr
 231 runtime_funcentry (uintptr pc)
 232 {
 233   uintptr val;
 234
 235   if (!__go_symbol_value (pc, &val))
 236     return 0;
 237   return val;
 238 }