libgo/runtime/go-caller.c

   1 /* go-caller.c -- runtime.Caller and runtime.FuncForPC for Go.
   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 };
  29
  30 /* Collect file/line information for a PC value.  If this is called
  31    more than once, due to inlined functions, we use the last call, as
  32    that is usually the most useful one.  */
  33
  34 static int
  35 callback (void *data, uintptr_t pc __attribute__ ((unused)),
  36           const char *filename, int lineno, const char *function)
  37 {
  38   struct caller *c = (struct caller *) data;
  39
  40   if (function == NULL)
  41     {
  42       c->fn.str = NULL;
  43       c->fn.len = 0;
  44     }
  45   else
  46     {
  47       byte *s;
  48
  49       c->fn.len = __builtin_strlen (function);
  50       s = runtime_malloc (c->fn.len);
  51       __builtin_memcpy (s, function, c->fn.len);
  52       c->fn.str = s;
  53     }
  54
  55   if (filename == NULL)
  56     {
  57       c->file.str = NULL;
  58       c->file.len = 0;
  59     }
  60   else
  61     {
  62       byte *s;
  63
  64       c->file.len = __builtin_strlen (filename);
  65       s = runtime_malloc (c->file.len);
  66       __builtin_memcpy (s, filename, c->file.len);
  67       c->file.str = s;
  68     }
  69
  70   c->line = lineno;
  71
  72   return 0;
  73 }
  74
  75 /* The error callback for backtrace_pcinfo and backtrace_syminfo.  */
  76
  77 static void
  78 error_callback (void *data __attribute__ ((unused)),
  79                 const char *msg, int errnum)
  80 {
  81   if (errnum == -1)
  82     return;
  83   if (errnum > 0)
  84     runtime_printf ("%s errno %d\n", msg, errnum);
  85   runtime_throw (msg);
  86 }
  87
  88 /* The backtrace library state.  */
  89
  90 static void *back_state;
  91
  92 /* A lock to control creating back_state.  */
  93
  94 static Lock back_state_lock;
  95
  96 /* Fetch back_state, creating it if necessary.  */
  97
  98 struct backtrace_state *
  99 __go_get_backtrace_state ()
 100 {
 101   runtime_lock (&back_state_lock);
 102   if (back_state == NULL)
 103     {
 104       const char *filename;
 105       struct stat s;
 106
 107       filename = (const char *) runtime_progname ();
 108
 109       /* If there is no '/' in FILENAME, it was found on PATH, and
 110          might not be the same as the file with the same name in the
 111          current directory.  */
 112       if (__builtin_strchr (filename, '/') == NULL)
 113         filename = NULL;
 114
 115       /* If the file is small, then it's not the real executable.
 116          This is specifically to deal with Docker, which uses a bogus
 117          argv[0] (http://gcc.gnu.org/PR61895).  It would be nice to
 118          have a better check for whether this file is the real
 119          executable.  */
 120       if (stat (filename, &s) < 0 || s.st_size < 1024)
 121         filename = NULL;
 122
 123       back_state = backtrace_create_state (filename, 1, error_callback, NULL);
 124     }
 125   runtime_unlock (&back_state_lock);
 126   return back_state;
 127 }
 128
 129 /* Return function/file/line information for PC.  */
 130
 131 _Bool
 132 __go_file_line (uintptr pc, String *fn, String *file, intgo *line)
 133 {
 134   struct caller c;
 135
 136   runtime_memclr (&c, sizeof c);
 137   backtrace_pcinfo (__go_get_backtrace_state (), pc, callback,
 138                     error_callback, &c);
 139   *fn = c.fn;
 140   *file = c.file;
 141   *line = c.line;
 142   return c.file.len > 0;
 143 }
 144
 145 /* Collect symbol information.  */
 146
 147 static void
 148 syminfo_callback (void *data, uintptr_t pc __attribute__ ((unused)),
 149                   const char *symname __attribute__ ((unused)),
 150                   uintptr_t address, uintptr_t size __attribute__ ((unused)))
 151 {
 152   uintptr_t *pval = (uintptr_t *) data;
 153
 154   *pval = address;
 155 }
 156
 157 /* Set *VAL to the value of the symbol for PC.  */
 158
 159 static _Bool
 160 __go_symbol_value (uintptr_t pc, uintptr_t *val)
 161 {
 162   *val = 0;
 163   backtrace_syminfo (__go_get_backtrace_state (), pc, syminfo_callback,
 164                      error_callback, val);
 165   return *val != 0;
 166 }
 167
 168 /* The values returned by runtime.Caller.  */
 169
 170 struct caller_ret
 171 {
 172   uintptr_t pc;
 173   String file;
 174   intgo line;
 175   _Bool ok;
 176 };
 177
 178 struct caller_ret Caller (int n) __asm__ (GOSYM_PREFIX "runtime.Caller");
 179
 180 Func *FuncForPC (uintptr_t) __asm__ (GOSYM_PREFIX "runtime.FuncForPC");
 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)
 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 /* Implement runtime.FuncForPC.  */
 203
 204 Func *
 205 FuncForPC (uintptr_t pc)
 206 {
 207   Func *ret;
 208   String fn;
 209   String file;
 210   intgo line;
 211   uintptr_t val;
 212
 213   if (!__go_file_line (pc, &fn, &file, &line))
 214     return NULL;
 215
 216   ret = (Func *) runtime_malloc (sizeof (*ret));
 217   ret->name = fn;
 218
 219   if (__go_symbol_value (pc, &val))
 220     ret->entry = val;
 221   else
 222     ret->entry = 0;
 223
 224   return ret;
 225 }
 226
 227 /* Look up the file and line information for a PC within a
 228    function.  */
 229
 230 struct funcline_go_return
 231 {
 232   String retfile;
 233   intgo retline;
 234 };
 235
 236 struct funcline_go_return
 237 runtime_funcline_go (Func *f, uintptr targetpc)
 238   __asm__ (GOSYM_PREFIX "runtime.funcline_go");
 239
 240 struct funcline_go_return
 241 runtime_funcline_go (Func *f __attribute__((unused)), uintptr targetpc)
 242 {
 243   struct funcline_go_return ret;
 244   String fn;
 245
 246   if (!__go_file_line (targetpc, &fn, &ret.retfile,  &ret.retline))
 247     runtime_memclr (&ret, sizeof ret);
 248   return ret;
 249 }
 250
 251 /* Return the name of a function.  */
 252 String runtime_funcname_go (Func *f)
 253   __asm__ (GOSYM_PREFIX "runtime.funcname_go");
 254
 255 String
 256 runtime_funcname_go (Func *f)
 257 {
 258   return f->name;
 259 }
 260
 261 /* Return the entry point of a function.  */
 262 uintptr runtime_funcentry_go(Func *f)
 263   __asm__ (GOSYM_PREFIX "runtime.funcentry_go");
 264
 265 uintptr
 266 runtime_funcentry_go (Func *f)
 267 {
 268   return f->entry;
 269 }