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
  11 #include "backtrace.h"
  12
  13 #include "runtime.h"
  14
  15 /* Get the function name, file name, and line number for a PC value.
  16    We use the backtrace library to get this.  */
  17
  18 /* Data structure to gather file/line information.  */
  19
  20 struct caller
  21 {
  22   String fn;
  23   String file;
  24   intgo line;
  25 };
  26
  27 /* Collect file/line information for a PC value.  If this is called
  28    more than once, due to inlined functions, we use the last call, as
  29    that is usually the most useful one.  */
  30
  31 static int
  32 callback (void *data, uintptr_t pc __attribute__ ((unused)),
  33           const char *filename, int lineno, const char *function)
  34 {
  35   struct caller *c = (struct caller *) data;
  36
  37   if (function == NULL)
  38     {
  39       c->fn.str = NULL;
  40       c->fn.len = 0;
  41     }
  42   else
  43     {
  44       byte *s;
  45
  46       c->fn.len = __builtin_strlen (function);
  47       s = runtime_malloc (c->fn.len);
  48       __builtin_memcpy (s, function, c->fn.len);
  49       c->fn.str = s;
  50     }
  51
  52   if (filename == NULL)
  53     {
  54       c->file.str = NULL;
  55       c->file.len = 0;
  56     }
  57   else
  58     {
  59       byte *s;
  60
  61       c->file.len = __builtin_strlen (filename);
  62       s = runtime_malloc (c->file.len);
  63       __builtin_memcpy (s, filename, c->file.len);
  64       c->file.str = s;
  65     }
  66
  67   c->line = lineno;
  68
  69   return 0;
  70 }
  71
  72 /* The error callback for backtrace_pcinfo and backtrace_syminfo.  */
  73
  74 static void
  75 error_callback (void *data __attribute__ ((unused)),
  76                 const char *msg, int errnum)
  77 {
  78   if (errnum == -1)
  79     return;
  80   if (errnum > 0)
  81     runtime_printf ("%s errno %d\n", msg, errnum);
  82   runtime_throw (msg);
  83 }
  84
  85 /* The backtrace library state.  */
  86
  87 static void *back_state;
  88
  89 /* A lock to control creating back_state.  */
  90
  91 static Lock back_state_lock;
  92
  93 /* Fetch back_state, creating it if necessary.  */
  94
  95 struct backtrace_state *
  96 __go_get_backtrace_state ()
  97 {
  98   runtime_lock (&back_state_lock);
  99   if (back_state == NULL)
 100     {
 101       const char *filename;
 102
 103       filename = (const char *) runtime_progname ();
 104
 105       /* If there is no '/' in FILENAME, it was found on PATH, and
 106          might not be the same as the file with the same name in the
 107          current directory.  */
 108       if (__builtin_strchr (filename, '/') == NULL)
 109         filename = NULL;
 110
 111       back_state = backtrace_create_state (filename, 1, error_callback, NULL);
 112     }
 113   runtime_unlock (&back_state_lock);
 114   return back_state;
 115 }
 116
 117 /* Return function/file/line information for PC.  */
 118
 119 _Bool
 120 __go_file_line (uintptr pc, String *fn, String *file, intgo *line)
 121 {
 122   struct caller c;
 123
 124   runtime_memclr (&c, sizeof c);
 125   backtrace_pcinfo (__go_get_backtrace_state (), pc, callback,
 126                     error_callback, &c);
 127   *fn = c.fn;
 128   *file = c.file;
 129   *line = c.line;
 130   return c.file.len > 0;
 131 }
 132
 133 /* Collect symbol information.  */
 134
 135 static void
 136 syminfo_callback (void *data, uintptr_t pc __attribute__ ((unused)),
 137                   const char *symname __attribute__ ((unused)),
 138                   uintptr_t address, uintptr_t size __attribute__ ((unused)))
 139 {
 140   uintptr_t *pval = (uintptr_t *) data;
 141
 142   *pval = address;
 143 }
 144
 145 /* Set *VAL to the value of the symbol for PC.  */
 146
 147 static _Bool
 148 __go_symbol_value (uintptr_t pc, uintptr_t *val)
 149 {
 150   *val = 0;
 151   backtrace_syminfo (__go_get_backtrace_state (), pc, syminfo_callback,
 152                      error_callback, val);
 153   return *val != 0;
 154 }
 155
 156 /* The values returned by runtime.Caller.  */
 157
 158 struct caller_ret
 159 {
 160   uintptr_t pc;
 161   String file;
 162   intgo line;
 163   _Bool ok;
 164 };
 165
 166 struct caller_ret Caller (int n) __asm__ (GOSYM_PREFIX "runtime.Caller");
 167
 168 Func *FuncForPC (uintptr_t) __asm__ (GOSYM_PREFIX "runtime.FuncForPC");
 169
 170 /* Implement runtime.Caller.  */
 171
 172 struct caller_ret
 173 Caller (int skip)
 174 {
 175   struct caller_ret ret;
 176   Location loc;
 177   int32 n;
 178
 179   runtime_memclr (&ret, sizeof ret);
 180   n = runtime_callers (skip + 1, &loc, 1, false);
 181   if (n < 1)
 182     return ret;
 183   ret.pc = loc.pc;
 184   ret.file = loc.filename;
 185   ret.line = loc.lineno;
 186   ret.ok = 1;
 187   return ret;
 188 }
 189
 190 /* Implement runtime.FuncForPC.  */
 191
 192 Func *
 193 FuncForPC (uintptr_t pc)
 194 {
 195   Func *ret;
 196   String fn;
 197   String file;
 198   intgo line;
 199   uintptr_t val;
 200
 201   if (!__go_file_line (pc, &fn, &file, &line))
 202     return NULL;
 203
 204   ret = (Func *) runtime_malloc (sizeof (*ret));
 205   ret->name = fn;
 206
 207   if (__go_symbol_value (pc, &val))
 208     ret->entry = val;
 209   else
 210     ret->entry = 0;
 211
 212   return ret;
 213 }
 214
 215 /* Look up the file and line information for a PC within a
 216    function.  */
 217
 218 struct funcline_go_return
 219 {
 220   String retfile;
 221   intgo retline;
 222 };
 223
 224 struct funcline_go_return
 225 runtime_funcline_go (Func *f, uintptr targetpc)
 226   __asm__ (GOSYM_PREFIX "runtime.funcline_go");
 227
 228 struct funcline_go_return
 229 runtime_funcline_go (Func *f __attribute__((unused)), uintptr targetpc)
 230 {
 231   struct funcline_go_return ret;
 232   String fn;
 233
 234   if (!__go_file_line (targetpc, &fn, &ret.retfile,  &ret.retline))
 235     runtime_memclr (&ret, sizeof ret);
 236   return ret;
 237 }
 238
 239 /* Return the name of a function.  */
 240 String runtime_funcname_go (Func *f)
 241   __asm__ (GOSYM_PREFIX "runtime.funcname_go");
 242
 243 String
 244 runtime_funcname_go (Func *f)
 245 {
 246   return f->name;
 247 }
 248
 249 /* Return the entry point of a function.  */
 250 uintptr runtime_funcentry_go(Func *f)
 251   __asm__ (GOSYM_PREFIX "runtime.funcentry_go");
 252
 253 uintptr
 254 runtime_funcentry_go (Func *f)
 255 {
 256   return f->entry;
 257 }