backtrace.h File Reference

Go to the source code of this file.

Data Structures
struct	Symbol
struct	SymbolTable

Macros
#define	SYMBOL_TABLE_PTR_ROM_ADDR   0x18
	ROM address of the pointer to the symbol table.

Functions
int	backtrace (void **buffer, int size)
	Walk the stack and return the current call stack.
int	backtrace_thread (void **buffer, int size, OSThread *thread)
void	debug_backtrace (void)
	Print a backtrace.
void	backtrace_address_to_string (u32 address, char *dest)
	Converts a function address to a string representation using its name, offset, and file.

---

Data Structure Documentation

Symbol

struct Symbol

Data Fields
u32	address	RAM address.
u32	nameOffset	Offset of the symbol name string.
u32	fileOffset	Offset of the file name and line string.

SymbolTable

struct SymbolTable

Data Fields
char	magic[4]
u32	symbolCount
struct Symbol	symbols[0]

Macro Definition Documentation

SYMBOL_TABLE_PTR_ROM_ADDR

#define SYMBOL_TABLE_PTR_ROM_ADDR   0x18

ROM address of the pointer to the symbol table.

This particular location is an unused part of the header lol. Don't modify this without also updating append_symbol_table.py.

Definition at line 12 of file backtrace.h.

Referenced by address2symbol().

Function Documentation

backtrace()

int backtrace	(	void **	buffer,
		int	size )

Walk the stack and return the current call stack.

This function will analyze the current execution context, walking the stack and returning informations on the active call frames.

This function adheres to POSIX specification. It does not allocate memory so it is safe to be called even in the context of low memory conditions or possibly corrupted heap.

If called within an interrupt or exception handler, the function is able to correctly walk backward the interrupt handler and show the context even before the exception was triggered.

Parameters

buffer	Empty array of pointers. This will be populated with pointers to the return addresses for each call frame.
size	Size of the buffer, that is, maximum number of call frames that will be walked by the function.

Returns

Number of call frames walked (at most, size).

Definition at line 291 of file backtrace.c.

                                       {
    struct backtrace_cb_ctx ctx = {
        buffer,
        size,
        -1, // skip backtrace itself
    };
    backtrace_foreach(backtrace_cb, &ctx);
    return ctx.i;
}

Referenced by debug_backtrace().

backtrace_thread()

int backtrace_thread	(	void **	buffer,
		int	size,
		OSThread *	thread )

Definition at line 301 of file backtrace.c.

                                                                {
    struct backtrace_cb_ctx ctx = {
        buffer,
        size,
        0,
    };
    u32 sp = (u32)thread->context.sp;
    u32 pc = (u32)thread->context.pc;
    u32 fp = (u32)thread->context.s8;
    backtrace_cb(&ctx, (void*)pc);
    backtrace_foreach_foreign(backtrace_cb, &ctx, (uint32_t*)sp, (uint32_t*)pc, (uint32_t*)fp);
    return ctx.i;
}

Referenced by crash_screen_draw().

debug_backtrace()

void debug_backtrace

(

void

)

Print a backtrace.

Definition at line 416 of file backtrace.c.

                           {
    s32 bt[32];
    s32 max = backtrace((void**)bt, ARRAY_COUNT(bt));
    s32 i;
    char buf[128];
 
    debugf("Backtrace:\n");
    for (i = 0; i < max; i++) {
        backtrace_address_to_string(bt[i], buf);
        debugf("    %s\n", buf);
    }
}

backtrace_address_to_string()

void backtrace_address_to_string	(	u32	address,
		char *	dest )

Converts a function address to a string representation using its name, offset, and file.

Definition at line 389 of file backtrace.c.

                                                          {
    Symbol sym;
    s32 offset = address2symbol(address, &sym);
 
    if (offset >= 0 && offset < 0x1000) { // 0x1000 = arbitrary func size limit
        char name[0x40];
        char file[0x40];
        char* namep = load_symbol_string(name, sym.nameOffset, ARRAY_COUNT(name));
        char* filep = load_symbol_string(file, sym.fileOffset, ARRAY_COUNT(file));
 
        offset = 0; // Don't show offsets
 
        if (filep == nullptr)
            if (offset == 0)
                sprintf(dest, "%s", namep);
            else
                sprintf(dest, "%s+0x%lX", namep, offset);
        else
            if (offset == 0)
                sprintf(dest, "%s (%s)", namep, filep);
            else
                sprintf(dest, "%s (%s+0x%lX)", namep, filep, offset);
    } else {
        sprintf(dest, "0x%lX", address);
    }
}

Referenced by crash_screen_draw(), debug_backtrace(), and evt_execute_next_command().