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 Lock 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   runtime_lock (&back_state_lock);
  89   if (back_state == NULL)
  90     {
  91       Slice args;
  92       const char *filename;
  93       struct stat s;
  94
  95       args = runtime_get_args();
  96       filename = NULL;
  97       if (args.__count > 0)
  98         filename = (const char*)((String*)args.__values)[0].str;
  99
 100       /* If there is no '/' in FILENAME, it was found on PATH, and
 101          might not be the same as the file with the same name in the
 102          current directory.  */
 103       if (filename != NULL && __builtin_strchr (filename, '/') == NULL)
 104         filename = NULL;
 105
 106       /* If the file is small, then it's not the real executable.
 107          This is specifically to deal with Docker, which uses a bogus
 108          argv[0] (http://gcc.gnu.org/PR61895).  It would be nice to
 109          have a better check for whether this file is the real
 110          executable.  */
 111       if (stat (filename, &s) < 0 || s.st_size < 1024)
 112         filename = NULL;
 113
 114       back_state = backtrace_create_state (filename, 1, error_callback, NULL);
 115     }
 116   runtime_unlock (&back_state_lock);
 117   return back_state;
 118 }
 119
 120 /* Return function/file/line information for PC.  The index parameter
 121    is the entry on the stack of inlined functions; -1 means the last
 122    one.  */
 123
 124 _Bool
 125 __go_file_line (uintptr pc, int index, String *fn, String *file, intgo *line)
 126 {
 127   struct caller c;
 128
 129   runtime_memclr (&c, sizeof c);
 130   c.index = index;
 131   backtrace_pcinfo (__go_get_backtrace_state (), pc, callback,
 132                     error_callback, &c);
 133   *fn = c.fn;
 134   *file = c.file;
 135   *line = c.line;
 136   return c.file.len > 0;
 137 }
 138
 139 /* Collect symbol information.  */
 140
 141 static void
 142 syminfo_callback (void *data, uintptr_t pc __attribute__ ((unused)),
 143                   const char *symname __attribute__ ((unused)),
 144                   uintptr_t address, uintptr_t size __attribute__ ((unused)))
 145 {
 146   uintptr_t *pval = (uintptr_t *) data;
 147
 148   *pval = address;
 149 }
 150
 151 /* Set *VAL to the value of the symbol for PC.  */
 152
 153 static _Bool
 154 __go_symbol_value (uintptr_t pc, uintptr_t *val)
 155 {
 156   *val = 0;
 157   backtrace_syminfo (__go_get_backtrace_state (), pc, syminfo_callback,
 158                      error_callback, val);
 159   return *val != 0;
 160 }
 161
 162 /* The values returned by runtime.Caller.  */
 163
 164 struct caller_ret
 165 {
 166   uintptr_t pc;
 167   String file;
 168   intgo line;
 169   _Bool ok;
 170 };
 171
 172 struct caller_ret Caller (int n) __asm__ (GOSYM_PREFIX "runtime.Caller");
 173
 174 /* Implement runtime.Caller.  */
 175
 176 struct caller_ret
 177 Caller (int skip)
 178 {
 179   struct caller_ret ret;
 180   Location loc;
 181   int32 n;
 182
 183   runtime_memclr (&ret, sizeof ret);
 184   n = runtime_callers (skip + 1, &loc, 1, false);
 185   if (n < 1 || loc.pc == 0)
 186     return ret;
 187   ret.pc = loc.pc;
 188   ret.file = loc.filename;
 189   ret.line = loc.lineno;
 190   ret.ok = 1;
 191   return ret;
 192 }
 193
 194 /* Look up the function name, file name, and line number for a PC.  */
 195
 196 struct funcfileline_return
 197 {
 198   String retfn;
 199   String retfile;
 200   intgo retline;
 201 };
 202
 203 struct funcfileline_return
 204 runtime_funcfileline (uintptr targetpc, int32 index)
 205   __asm__ (GOSYM_PREFIX "runtime.funcfileline");
 206
 207 struct funcfileline_return
 208 runtime_funcfileline (uintptr targetpc, int32 index)
 209 {
 210   struct funcfileline_return ret;
 211
 212   if (!__go_file_line (targetpc, index, &ret.retfn, &ret.retfile,
 213                        &ret.retline))
 214     runtime_memclr (&ret, sizeof ret);
 215   return ret;
 216 }
 217
 218 /* Return the entry point of a function.  */
 219 uintptr runtime_funcentry(uintptr)
 220   __asm__ (GOSYM_PREFIX "runtime.funcentry");
 221
 222 uintptr
 223 runtime_funcentry (uintptr pc)
 224 {
 225   uintptr val;
 226
 227   if (!__go_symbol_value (pc, &val))
 228     return 0;
 229   return val;
 230 }