/*

** backtrace.c -

**

** See Copyright Notice in mruby.h

*/

#include <mruby.h>

#include <mruby/variable.h>

#include <mruby/proc.h>

#include <mruby/array.h>

#include <mruby/string.h>

#include <mruby/class.h>

#include <mruby/debug.h>

#include <mruby/error.h>

#include <mruby/numeric.h>

#include <mruby/data.h>

#include <mruby/internal.h>

#define MAX_IREP_REFCNT UINT16_MAX

#define UNKNOWN_LINENO -1

#define UNKNOWN_LOCATION "(unknown):0"

static void

copy_backtrace(mrb_state *mrb,

const struct mrb_backtrace_location *loc,

struct mrb_backtrace_location *ptr,

size_t n)

{

ptr[n] = *loc;

if (loc->irep) {

if (loc->irep->refcnt == MAX_IREP_REFCNT) {

ptr[n].irep = NULL;

}

else {

mrb_irep_incref(mrb, (mrb_irep*)loc->irep);

}

}

}

/**

* Creates a packed backtrace from the current call stack

*

* @param mrb The mruby state

* @param ciidx The current callinfo index

* @param ptr Pointer to store the backtrace locations

* @return Number of backtrace entries

* @note This function handles both proc and non-proc cases, managing IREP references

* and building location entries for each stack frame.

*/

static size_t

pack_backtrace(mrb_state *mrb, ptrdiff_t ciidx, struct mrb_backtrace_location *ptr)

{

size_t n = 0;

for (ptrdiff_t i=ciidx; i >= 0; i--) {

struct mrb_backtrace_location loc;

mrb_callinfo *ci;

const mrb_code *pc;

ci = &mrb->c->cibase[i];

loc.method_id = ci->mid;

if (ci->proc && !MRB_PROC_CFUNC_P(ci->proc)) {

mrb_assert(!MRB_PROC_ALIAS_P(ci->proc));

loc.irep = ci->proc->body.irep;

if (!loc.irep) continue;

if (!loc.irep->debug_info) continue;

if (!ci->pc) continue;

pc = &ci->pc[-1];

loc.idx = (uint32_t)(pc - loc.irep->iseq);

}

else {

if (!loc.method_id) continue;

loc.irep = NULL;

for (ptrdiff_t j=i-1; j >= 0; j--) {

ci = &mrb->c->cibase[j];

if (!ci->proc) continue;

if (MRB_PROC_CFUNC_P(ci->proc)) continue;

mrb_assert(!MRB_PROC_ALIAS_P(ci->proc));

const mrb_irep *irep = ci->proc->body.irep;

if (!irep) continue;

if (!irep->debug_info) continue;

if (!ci->pc) continue;

pc = &ci->pc[-1];

loc.irep = irep;

loc.idx = (uint32_t)(pc - irep->iseq);

break;

}

}

copy_backtrace(mrb, &loc, ptr, n);

n++;

}

return n;

}

static struct RBasic*

packed_backtrace(mrb_state *mrb)

{

ptrdiff_t ciidx = mrb->c->ci - mrb->c->cibase;

if (ciidx >= mrb->c->ciend - mrb->c->cibase)

ciidx = mrb->c->ciend - mrb->c->cibase; /* ciidx is broken... */

ptrdiff_t len = ciidx + 1;

struct RBacktrace *backtrace = MRB_OBJ_ALLOC(mrb, MRB_TT_BACKTRACE, NULL);

void *ptr = mrb_malloc(mrb, len * sizeof(struct mrb_backtrace_location));

backtrace->locations = (struct mrb_backtrace_location*)ptr;

backtrace->len = pack_backtrace(mrb, ciidx, backtrace->locations);

return (struct RBasic*)backtrace;

}

static void

store_backtrace(mrb_state *mrb, mrb_value exc, struct RBasic *backtrace)

{

struct RException *e = mrb_exc_ptr(exc);

e->backtrace = backtrace;

mrb_field_write_barrier(mrb, (struct RBasic*)e, backtrace);

}

void

mrb_keep_backtrace(mrb_state *mrb, mrb_value exc)

{

int ai;

if (mrb->c->ci == NULL) return;

if (mrb_exc_ptr(exc)->backtrace) return;

ai = mrb_gc_arena_save(mrb);

struct RBasic *backtrace = packed_backtrace(mrb);

store_backtrace(mrb, exc, backtrace);

mrb_gc_arena_restore(mrb, ai);

}

static mrb_value

decode_location(mrb_state *mrb, const struct mrb_backtrace_location *entry)

{

mrb_value btline;

int32_t lineno;

const char *filename;

// Case 1: No IREP or debug info available

if (!entry->irep) {

return mrb_str_new_lit(mrb, UNKNOWN_LOCATION);

}

// Case 2: Debug info lookup failed

if (!mrb_debug_get_position(mrb, entry->irep, entry->idx, &lineno, &filename)) {

return mrb_str_new_lit(mrb, UNKNOWN_LOCATION);

}

// Case 3: Valid debug info

if (lineno != UNKNOWN_LINENO) {

btline = mrb_format(mrb, "%s:%d", filename, (int)lineno);

}

else { //all that was left was the stack frame

btline = mrb_format(mrb, "%s:0", filename);

}

// Add method name if available

if (entry->method_id != 0) {

mrb_str_cat_lit(mrb, btline, ":in ");

mrb_str_cat_cstr(mrb, btline, mrb_sym_name(mrb, entry->method_id));

}

return btline;

}

static struct RBasic*

mrb_unpack_backtrace(mrb_state *mrb, struct RBasic *backtrace)

{

if (backtrace == NULL) {

return mrb_basic_ptr(mrb_ary_new_capa(mrb, 0));

}

if (backtrace->tt == MRB_TT_ARRAY) return backtrace;

mrb_assert(backtrace->tt == MRB_TT_BACKTRACE);

struct RBacktrace *bt = (struct RBacktrace*)backtrace;

mrb_int n = (mrb_int)bt->len;

const struct mrb_backtrace_location *loc = bt->locations;

backtrace = mrb_basic_ptr(mrb_ary_new_capa(mrb, n));

int ai = mrb_gc_arena_save(mrb);

for (mrb_int i = 0; i < n; i++) {

mrb_value btline = decode_location(mrb, &loc[i]);

mrb_ary_push(mrb, mrb_obj_value(backtrace), btline);

mrb_gc_arena_restore(mrb, ai);

}

return backtrace;

}

mrb_value

mrb_exc_backtrace(mrb_state *mrb, mrb_value exc)

{

struct RBasic *backtrace = mrb_exc_ptr(exc)->backtrace;

if (backtrace == NULL) {

return mrb_nil_value();

}

if (backtrace->tt == MRB_TT_ARRAY) {

return mrb_obj_value(backtrace);

}

/* unpack packed-backtrace */

backtrace = mrb_unpack_backtrace(mrb, backtrace);

store_backtrace(mrb, exc, backtrace);

return mrb_obj_value(backtrace);

}

mrb_value

mrb_get_backtrace(mrb_state *mrb)

{

return mrb_obj_value(mrb_unpack_backtrace(mrb, packed_backtrace(mrb)));

}

#ifndef MRB_NO_STDIO

static void

print_backtrace(mrb_state *mrb, struct RObject *exc, struct RBasic *ptr)

{

struct RArray *ary = NULL;

struct RBacktrace *bt = NULL;

mrb_int n = 0;

if (ptr) {

if (ptr->tt == MRB_TT_ARRAY) {

ary = (struct RArray*)ptr;

n = ARY_LEN(ary);

}

else {

bt = (struct RBacktrace*)ptr;

n = (mrb_int)bt->len;

}

}

if (n != 0) {

mrb_value btline;

fputs("trace (most recent call last):\n", stderr);

for (mrb_int i=n-1; i>0; i--) {

if (ary) btline = ARY_PTR(ary)[i];

else btline = decode_location(mrb, &bt->locations[i]);

if (mrb_string_p(btline)) {

fprintf(stderr, "\t[%d] ", (int)i);

fwrite(RSTRING_PTR(btline), (int)RSTRING_LEN(btline), 1, stderr);

fputc('\n', stderr);

}

}

if (ary) btline = ARY_PTR(ary)[0];

else btline = decode_location(mrb, &bt->locations[0]);

if (mrb_string_p(btline)) {

fwrite(RSTRING_PTR(btline), (int)RSTRING_LEN(btline), 1, stderr);

fputs(": ", stderr);

}

}

else {

fputs(UNKNOWN_LOCATION ": ", stderr);

}

if (exc == mrb->nomem_err) {

static const char nomem[] = "Out of memory (NoMemoryError)\n";

fwrite(nomem, sizeof(nomem)-1, 1, stderr);

}

else {

mrb_value output = mrb_exc_get_output(mrb, exc);

fwrite(RSTRING_PTR(output), RSTRING_LEN(output), 1, stderr);

fputc('\n', stderr);

}

}

/* mrb_print_backtrace

function to retrieve backtrace information from the last exception.

*/

MRB_API void

mrb_print_backtrace(mrb_state *mrb)

{

if (!mrb->exc || mrb->exc->tt != MRB_TT_EXCEPTION) {

return;

}

print_backtrace(mrb, mrb->exc, ((struct RException*)mrb->exc)->backtrace);

}

#else

MRB_API void

mrb_print_backtrace(mrb_state *mrb)

{

}

#endif