third-party/mruby/src/backtrace.c

   1 /*
   2 ** backtrace.c -
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <mruby.h>
   8 #include <mruby/variable.h>
   9 #include <mruby/proc.h>
  10 #include <mruby/array.h>
  11 #include <mruby/string.h>
  12 #include <mruby/class.h>
  13 #include <mruby/debug.h>
  14 #include <mruby/error.h>
  15 #include <mruby/numeric.h>
  16 #include <mruby/data.h>
  17
  18 struct backtrace_location {
  19   int lineno;
  20   mrb_sym method_id;
  21   const char *filename;
  22 };
  23
  24 typedef void (*each_backtrace_func)(mrb_state*, const struct backtrace_location*, void*);
  25
  26 static const mrb_data_type bt_type = { "Backtrace", mrb_free };
  27
  28 static void
  29 each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, mrb_code *pc0, each_backtrace_func func, void *data)
  30 {
  31   ptrdiff_t i;
  32
  33   if (ciidx >= mrb->c->ciend - mrb->c->cibase)
  34     ciidx = 10; /* ciidx is broken... */
  35
  36   for (i=ciidx; i >= 0; i--) {
  37     struct backtrace_location loc;
  38     mrb_callinfo *ci;
  39     mrb_irep *irep;
  40     mrb_code *pc;
  41
  42     ci = &mrb->c->cibase[i];
  43
  44     if (!ci->proc) continue;
  45     if (MRB_PROC_CFUNC_P(ci->proc)) continue;
  46
  47     irep = ci->proc->body.irep;
  48     if (!irep) continue;
  49
  50     if (mrb->c->cibase[i].err) {
  51       pc = mrb->c->cibase[i].err;
  52     }
  53     else if (i+1 <= ciidx) {
  54       if (!mrb->c->cibase[i + 1].pc) continue;
  55       pc = &mrb->c->cibase[i+1].pc[-1];
  56     }
  57     else {
  58       pc = pc0;
  59     }
  60
  61     loc.lineno = mrb_debug_get_line(mrb, irep, pc - irep->iseq);
  62     if (loc.lineno == -1) continue;
  63
  64     loc.filename = mrb_debug_get_filename(mrb, irep, pc - irep->iseq);
  65     if (!loc.filename) {
  66       loc.filename = "(unknown)";
  67     }
  68
  69     loc.method_id = ci->mid;
  70     func(mrb, &loc, data);
  71   }
  72 }
  73
  74 #ifndef MRB_DISABLE_STDIO
  75
  76 static void
  77 print_backtrace(mrb_state *mrb, mrb_value backtrace)
  78 {
  79   int i;
  80   mrb_int n;
  81   FILE *stream = stderr;
  82
  83   n = RARRAY_LEN(backtrace) - 1;
  84   if (n == 0) return;
  85
  86   fprintf(stream, "trace (most recent call last):\n");
  87   for (i=0; i<n; i++) {
  88     mrb_value entry = RARRAY_PTR(backtrace)[n-i-1];
  89
  90     if (mrb_string_p(entry)) {
  91       fprintf(stream, "\t[%d] %.*s\n", i, (int)RSTRING_LEN(entry), RSTRING_PTR(entry));
  92     }
  93   }
  94 }
  95
  96 static int
  97 packed_bt_len(const struct backtrace_location *bt, int n)
  98 {
  99   int len = 0;
 100   int i;
 101
 102   for (i=0; i<n; i++) {
 103     if (!bt[i].filename && !bt[i].lineno && !bt[i].method_id)
 104       continue;
 105     len++;
 106   }
 107   return len;
 108 }
 109
 110 static void
 111 print_packed_backtrace(mrb_state *mrb, mrb_value packed)
 112 {
 113   FILE *stream = stderr;
 114   const struct backtrace_location *bt;
 115   int n, i;
 116   int ai = mrb_gc_arena_save(mrb);
 117
 118   bt = (struct backtrace_location*)mrb_data_check_get_ptr(mrb, packed, &bt_type);
 119   if (bt == NULL) return;
 120   n = (mrb_int)RDATA(packed)->flags;
 121
 122   if (packed_bt_len(bt, n) == 0) return;
 123   fprintf(stream, "trace (most recent call last):\n");
 124   for (i = 0; i<n; i++) {
 125     const struct backtrace_location *entry = &bt[n-i-1];
 126     if (entry->filename == NULL) continue;
 127     fprintf(stream, "\t[%d] %s:%d", i, entry->filename, entry->lineno);
 128     if (entry->method_id != 0) {
 129       const char *method_name;
 130
 131       method_name = mrb_sym2name(mrb, entry->method_id);
 132       fprintf(stream, ":in %s", method_name);
 133       mrb_gc_arena_restore(mrb, ai);
 134     }
 135     fprintf(stream, "\n");
 136   }
 137 }
 138
 139 /* mrb_print_backtrace
 140
 141    function to retrieve backtrace information from the last exception.
 142 */
 143
 144 MRB_API void
 145 mrb_print_backtrace(mrb_state *mrb)
 146 {
 147   mrb_value backtrace;
 148
 149   if (!mrb->exc) {
 150     return;
 151   }
 152
 153   backtrace = mrb_obj_iv_get(mrb, mrb->exc, mrb_intern_lit(mrb, "backtrace"));
 154   if (mrb_nil_p(backtrace)) return;
 155   if (mrb_array_p(backtrace)) {
 156     print_backtrace(mrb, backtrace);
 157   }
 158   else {
 159     print_packed_backtrace(mrb, backtrace);
 160   }
 161 }
 162 #else
 163
 164 MRB_API void
 165 mrb_print_backtrace(mrb_state *mrb)
 166 {
 167 }
 168
 169 #endif
 170
 171 static void
 172 count_backtrace_i(mrb_state *mrb,
 173                  const struct backtrace_location *loc,
 174                  void *data)
 175 {
 176   int *lenp = (int*)data;
 177
 178   if (loc->filename == NULL) return;
 179   (*lenp)++;
 180 }
 181
 182 static void
 183 pack_backtrace_i(mrb_state *mrb,
 184                  const struct backtrace_location *loc,
 185                  void *data)
 186 {
 187   struct backtrace_location **pptr = (struct backtrace_location**)data;
 188   struct backtrace_location *ptr = *pptr;
 189
 190   if (loc->filename == NULL) return;
 191   *ptr = *loc;
 192   *pptr = ptr+1;
 193 }
 194
 195 static mrb_value
 196 packed_backtrace(mrb_state *mrb)
 197 {
 198   struct RData *backtrace;
 199   ptrdiff_t ciidx = mrb->c->ci - mrb->c->cibase;
 200   int len = 0;
 201   int size;
 202   void *ptr;
 203
 204   each_backtrace(mrb, ciidx, mrb->c->ci->pc, count_backtrace_i, &len);
 205   size = len * sizeof(struct backtrace_location);
 206   ptr = mrb_malloc(mrb, size);
 207   backtrace = mrb_data_object_alloc(mrb, NULL, ptr, &bt_type);
 208   backtrace->flags = (unsigned int)len;
 209   each_backtrace(mrb, ciidx, mrb->c->ci->pc, pack_backtrace_i, &ptr);
 210   return mrb_obj_value(backtrace);
 211 }
 212
 213 void
 214 mrb_keep_backtrace(mrb_state *mrb, mrb_value exc)
 215 {
 216   mrb_sym sym = mrb_intern_lit(mrb, "backtrace");
 217   mrb_value backtrace;
 218   int ai;
 219
 220   if (mrb_iv_defined(mrb, exc, sym)) return;
 221   ai = mrb_gc_arena_save(mrb);
 222   backtrace = packed_backtrace(mrb);
 223   mrb_iv_set(mrb, exc, sym, backtrace);
 224   mrb_gc_arena_restore(mrb, ai);
 225 }
 226
 227 mrb_value
 228 mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace)
 229 {
 230   const struct backtrace_location *bt;
 231   mrb_int n, i;
 232   int ai;
 233
 234   if (mrb_nil_p(backtrace)) {
 235   empty_backtrace:
 236     return mrb_ary_new_capa(mrb, 0);
 237   }
 238   if (mrb_array_p(backtrace)) return backtrace;
 239   bt = (struct backtrace_location*)mrb_data_check_get_ptr(mrb, backtrace, &bt_type);
 240   if (bt == NULL) goto empty_backtrace;
 241   n = (mrb_int)RDATA(backtrace)->flags;
 242   backtrace = mrb_ary_new_capa(mrb, n);
 243   ai = mrb_gc_arena_save(mrb);
 244   for (i = 0; i < n; i++) {
 245     const struct backtrace_location *entry = &bt[i];
 246     mrb_value btline;
 247
 248     if (entry->filename == NULL) continue;
 249     btline = mrb_format(mrb, "%S:%S",
 250                               mrb_str_new_cstr(mrb, entry->filename),
 251                               mrb_fixnum_value(entry->lineno));
 252     if (entry->method_id != 0) {
 253       mrb_str_cat_lit(mrb, btline, ":in ");
 254       mrb_str_cat_cstr(mrb, btline, mrb_sym2name(mrb, entry->method_id));
 255     }
 256     mrb_ary_push(mrb, backtrace, btline);
 257     mrb_gc_arena_restore(mrb, ai);
 258   }
 259
 260   return backtrace;
 261 }
 262
 263 MRB_API mrb_value
 264 mrb_exc_backtrace(mrb_state *mrb, mrb_value exc)
 265 {
 266   mrb_sym attr_name;
 267   mrb_value backtrace;
 268
 269   attr_name = mrb_intern_lit(mrb, "backtrace");
 270   backtrace = mrb_iv_get(mrb, exc, attr_name);
 271   if (mrb_nil_p(backtrace) || mrb_array_p(backtrace)) {
 272     return backtrace;
 273   }
 274   backtrace = mrb_unpack_backtrace(mrb, backtrace);
 275   mrb_iv_set(mrb, exc, attr_name, backtrace);
 276   return backtrace;
 277 }
 278
 279 MRB_API mrb_value
 280 mrb_get_backtrace(mrb_state *mrb)
 281 {
 282   return mrb_unpack_backtrace(mrb, packed_backtrace(mrb));
 283 }