Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4134 → Rev 4137

/trunk/kernel/generic/include/symtab.h
44,15 → 44,20
char symbol_name[MAX_SYMBOL_NAME];
};
 
extern char * get_symtab_entry(unative_t addr);
extern uintptr_t get_symbol_addr(const char *name);
extern int symtab_name_lookup(unative_t addr, char **name);
extern char *symtab_fmt_name_lookup(unative_t addr);
extern int symtab_addr_lookup(const char *name, uintptr_t *addr);
extern void symtab_print_search(const char *name);
extern int symtab_compl(char *name);
 
#ifdef CONFIG_SYMTAB
 
/* Symtable linked together by build process */
extern struct symtab_entry symbol_table[];
 
#endif
 
#endif
 
/** @}
*/
/trunk/kernel/generic/src/synch/spinlock.c
42,10 → 42,7
#include <preemption.h>
#include <print.h>
#include <debug.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
#ifdef CONFIG_FB
#include <genarch/fb/fb.h>
80,9 → 77,6
{
count_t i = 0;
bool deadlock_reported = false;
#ifdef CONFIG_SYMTAB
char *symbol;
#endif
 
preemption_disable();
while (test_and_set(&sl->val)) {
111,14 → 105,10
continue;
#endif
if (i++ > DEADLOCK_THRESHOLD) {
printf("cpu%u: looping on spinlock %" PRIp ":%s, caller=%" PRIp,
CPU->id, sl, sl->name, CALLER);
#ifdef CONFIG_SYMTAB
symbol = get_symtab_entry(CALLER);
if (symbol)
printf("(%s)", symbol);
#endif
printf("\n");
printf("cpu%u: looping on spinlock %" PRIp ":%s, "
"caller=%" PRIp "(%s)", CPU->id, sl, sl->name,
CALLER, symtab_fmt_name_lookup(CALLER));
 
i = 0;
deadlock_reported = true;
}
/trunk/kernel/generic/src/debug/symtab.c
41,18 → 41,19
#include <print.h>
#include <arch/types.h>
#include <typedefs.h>
#include <errno.h>
 
/** Return entry that seems most likely to correspond to argument.
/** Get name of symbol that seems most likely to correspond to address.
*
* Return entry that seems most likely to correspond
* to address passed in the argument.
* @param addr Address.
* @param name Place to store pointer to the symbol name.
*
* @param addr Address.
*
* @return Pointer to respective symbol string on success, NULL otherwise.
* @return Zero on success or negative error code, ENOENT if not found,
* ENOTSUP if symbol table not available.
*/
char * get_symtab_entry(unative_t addr)
int symtab_name_lookup(unative_t addr, char **name)
{
#ifdef CONFIG_SYMTAB
count_t i;
 
for (i = 1; symbol_table[i].address_le; ++i) {
59,11 → 60,44
if (addr < uint64_t_le2host(symbol_table[i].address_le))
break;
}
if (addr >= uint64_t_le2host(symbol_table[i - 1].address_le))
return symbol_table[i - 1].symbol_name;
return NULL;
if (addr >= uint64_t_le2host(symbol_table[i - 1].address_le)) {
*name = symbol_table[i - 1].symbol_name;
return EOK;
}
 
*name = NULL;
return ENOENT;
#else
*name = NULL;
return ENOTSUP;
#endif
}
 
/** Lookup symbol by address and format for display.
*
* Returns name of closest corresponding symbol, "Not found" if none exists
* or "N/A" if no symbol information is available.
*
* @param addr Address.
* @param name Place to store pointer to the symbol name.
*
* @return Pointer to a human-readable string.
*/
char *symtab_fmt_name_lookup(unative_t addr)
{
int rc;
char *name;
 
rc = symtab_name_lookup(addr, &name);
switch (rc) {
case EOK: return name;
case ENOENT: return "Not found";
default: return "N/A";
}
}
 
#ifdef CONFIG_SYMTAB
 
/** Find symbols that match the parameter forward and print them.
*
* @param name - search string
102,17 → 136,22
return NULL;
}
 
#endif
 
/** Return address that corresponds to the entry
*
* Search symbol table, and if there is one match, return it
*
* @param name Name of the symbol
* @return 0 - Not found, -1 - Duplicate symbol, other - address of symbol
* @param name Name of the symbol
* @param addr Place to store symbol address
*
* @return Zero on success, ENOENT - not found, EOVERFLOW - duplicate
* symbol, ENOTSUP - no symbol information available.
*/
uintptr_t get_symbol_addr(const char *name)
int symtab_addr_lookup(const char *name, uintptr_t *addr)
{
#ifdef CONFIG_SYMTAB
count_t found = 0;
uintptr_t addr = NULL;
char *hint;
int i;
 
119,19 → 158,25
i = 0;
while ((hint = symtab_search_one(name, &i))) {
if (!strlen(hint)) {
addr = uint64_t_le2host(symbol_table[i].address_le);
*addr = uint64_t_le2host(symbol_table[i].address_le);
found++;
}
i++;
}
if (found > 1)
return ((uintptr_t) -1);
return addr;
return EOVERFLOW;
if (found < 1)
return ENOENT;
return EOK;
#else
return ENOTSUP;
#endif
}
 
/** Find symbols that match parameter and prints them */
void symtab_print_search(const char *name)
{
#ifdef CONFIG_SYMTAB
int i;
uintptr_t addr;
char *realname;
144,6 → 189,9
printf("%p: %s\n", addr, realname);
i++;
}
#else
printf("No symbol information available.\n");
#endif
}
 
/** Symtab completion
153,6 → 201,7
*/
int symtab_compl(char *input)
{
#ifdef CONFIG_SYMTAB
char output[MAX_SYMBOL_NAME + 1];
int startpos = 0;
char *foundtxt;
196,7 → 245,9
}
strncpy(input, output, MAX_SYMBOL_NAME);
return found;
#else
return 0;
#endif
}
 
/** @}
/trunk/kernel/generic/src/interrupt/interrupt.c
45,10 → 45,7
#include <console/cmd.h>
#include <panic.h>
#include <print.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
static struct {
const char *name;
133,13 → 130,7
#endif
for (i = 0; i < IVT_ITEMS; i++) {
#ifdef CONFIG_SYMTAB
symbol = get_symtab_entry((unative_t) exc_table[i].f);
if (!symbol)
symbol = "not found";
#else
symbol = "n/a";
#endif
symbol = symtab_fmt_name_lookup((unative_t) exc_table[i].f);
 
#ifdef __32_BITS__
printf("%-3u %-20s %10p %s\n", i + IVT_FIRST, exc_table[i].name,
/trunk/kernel/generic/src/console/cmd.c
64,10 → 64,8
#include <proc/task.h>
#include <ipc/ipc.h>
#include <ipc/irq.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
#include <errno.h>
 
#ifdef CONFIG_TEST
#include <test.h>
170,7 → 168,6
.argv = &desc_argv
};
 
#ifdef CONFIG_SYMTAB
/* Data and methods for 'symaddr' command. */
static int cmd_symaddr(cmd_arg_t *argv);
static char symaddr_buf[MAX_CMDLINE+1];
186,7 → 183,6
.argc = 1,
.argv = &symaddr_argv
};
#endif
 
static char set_buf[MAX_CMDLINE+1];
static int cmd_set4(cmd_arg_t *argv);
463,9 → 459,7
&ipc_info,
&set4_info,
&slabs_info,
#ifdef CONFIG_SYMTAB
&symaddr_info,
#endif
&sched_info,
&threads_info,
&tasks_info,
612,8 → 606,6
return 1;
}
 
#ifdef CONFIG_SYMTAB
 
/** Search symbol table */
int cmd_symaddr(cmd_arg_t *argv)
{
622,28 → 614,31
return 1;
}
 
#endif
 
/** Call function with zero parameters */
int cmd_call0(cmd_arg_t *argv)
{
#ifdef CONFIG_SYMTAB
uintptr_t symaddr;
char *symbol;
unative_t (*fnc)(void);
fncptr_t fptr;
int rc;
 
symaddr = get_symbol_addr((char *) argv->buffer);
if (!symaddr)
printf("Symbol %s not found.\n", argv->buffer);
else if (symaddr == (uintptr_t) -1) {
symtab_print_search((char *) argv->buffer);
symbol = (char *) argv->buffer;
rc = symtab_addr_lookup(symbol, &symaddr);
 
if (rc == ENOENT)
printf("Symbol %s not found.\n", symbol);
else if (rc == EOVERFLOW) {
symtab_print_search(symbol);
printf("Duplicate symbol, be more specific.\n");
} else if (rc == EOK) {
fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
(void *) symaddr, (void *) cmd_call0);
printf("Calling %s() (%p)\n", symbol, symaddr);
printf("Result: %#" PRIxn "\n", fnc());
} else {
fnc = (unative_t (*)(void)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call0);
printf("Calling %s() (%p)\n", argv->buffer, symaddr);
printf("Result: %#" PRIxn "\n", fnc());
printf("No symbol information available.\n");
}
#endif
return 1;
}
 
679,27 → 674,29
/** Call function with one parameter */
int cmd_call1(cmd_arg_t *argv)
{
#ifdef CONFIG_SYMTAB
uintptr_t symaddr;
char *symbol;
unative_t (*fnc)(unative_t, ...);
unative_t arg1 = argv[1].intval;
fncptr_t fptr;
symaddr = get_symbol_addr((char *) argv->buffer);
int rc;
 
if (!symaddr)
printf("Symbol %s not found.\n", argv->buffer);
else if (symaddr == (uintptr_t) -1) {
symtab_print_search((char *) argv->buffer);
symbol = (char *) argv->buffer;
rc = symtab_addr_lookup(symbol, &symaddr);
 
if (rc == ENOENT) {
printf("Symbol %s not found.\n", symbol);
} else if (rc == EOVERFLOW) {
symtab_print_search(symbol);
printf("Duplicate symbol, be more specific.\n");
} else {
symbol = get_symtab_entry(symaddr);
} else if (rc == EOK) {
fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
printf("Result: %#" PRIxn "\n", fnc(arg1));
} else {
printf("No symbol information available.\n");
}
#endif
 
return 1;
}
 
706,7 → 703,6
/** Call function with two parameters */
int cmd_call2(cmd_arg_t *argv)
{
#ifdef CONFIG_SYMTAB
uintptr_t symaddr;
char *symbol;
unative_t (*fnc)(unative_t, unative_t, ...);
713,21 → 709,24
unative_t arg1 = argv[1].intval;
unative_t arg2 = argv[2].intval;
fncptr_t fptr;
symaddr = get_symbol_addr((char *) argv->buffer);
if (!symaddr)
printf("Symbol %s not found.\n", argv->buffer);
else if (symaddr == (uintptr_t) -1) {
symtab_print_search((char *) argv->buffer);
int rc;
 
symbol = (char *) argv->buffer;
rc = symtab_addr_lookup(symbol, &symaddr);
 
if (rc == ENOENT) {
printf("Symbol %s not found.\n", symbol);
} else if (rc == EOVERFLOW) {
symtab_print_search(symbol);
printf("Duplicate symbol, be more specific.\n");
} else {
symbol = get_symtab_entry(symaddr);
} else if (rc == EOK) {
fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
arg1, arg2, symaddr, symbol);
printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
}
#endif
} else {
printf("No symbol information available.\n");
}
return 1;
}
 
734,7 → 733,6
/** Call function with three parameters */
int cmd_call3(cmd_arg_t *argv)
{
#ifdef CONFIG_SYMTAB
uintptr_t symaddr;
char *symbol;
unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
742,21 → 740,24
unative_t arg2 = argv[2].intval;
unative_t arg3 = argv[3].intval;
fncptr_t fptr;
int rc;
symaddr = get_symbol_addr((char *) argv->buffer);
if (!symaddr)
printf("Symbol %s not found.\n", argv->buffer);
else if (symaddr == (uintptr_t) -1) {
symtab_print_search((char *) argv->buffer);
symbol = (char *) argv->buffer;
rc = symtab_addr_lookup(symbol, &symaddr);
 
if (rc == ENOENT) {
printf("Symbol %s not found.\n", symbol);
} else if (rc == EOVERFLOW) {
symtab_print_search(symbol);
printf("Duplicate symbol, be more specific.\n");
} else {
symbol = get_symtab_entry(symaddr);
} else if (rc == EOK) {
fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
arg1, arg2, arg3, symaddr, symbol);
printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
} else {
printf("No symbol information available.\n");
}
#endif
return 1;
}
 
806,41 → 807,34
/** Write 4 byte value to address */
int cmd_set4(cmd_arg_t *argv)
{
uint32_t *addr;
uintptr_t addr;
uint32_t arg1 = argv[1].intval;
bool pointer = false;
int rc;
 
if (((char *)argv->buffer)[0] == '*') {
#ifdef CONFIG_SYMTAB
addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
#else
addr = 0;
#endif
rc = symtab_addr_lookup((char *) argv->buffer + 1, &addr);
pointer = true;
} else if (((char *) argv->buffer)[0] >= '0' &&
((char *)argv->buffer)[0] <= '9') {
addr = (uint32_t *)atoi((char *)argv->buffer);
rc = EOK;
addr = atoi((char *)argv->buffer);
} else {
#ifdef CONFIG_SYMTAB
addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
#else
addr = 0;
#endif
rc = symtab_addr_lookup((char *) argv->buffer, &addr);
}
 
if (!addr)
if (rc == ENOENT)
printf("Symbol %s not found.\n", argv->buffer);
else if (addr == (uint32_t *) -1) {
#ifdef CONFIG_SYMTAB
else if (rc == EOVERFLOW) {
symtab_print_search((char *) argv->buffer);
#endif
printf("Duplicate symbol, be more specific.\n");
} else {
} else if (rc == EOK) {
if (pointer)
addr = (uint32_t *)(*(unative_t *)addr);
addr = *(uintptr_t *) addr;
printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
*addr = arg1;
*(uint32_t *) addr = arg1;
} else {
printf("No symbol information available.\n");
}
return 1;
/trunk/kernel/generic/src/console/kconsole.c
53,10 → 53,8
#include <macros.h>
#include <sysinfo/sysinfo.h>
#include <ddi/device.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
#include <errno.h>
 
/** Simple kernel console.
*
349,11 → 347,7
if (i == 0) { /* Command completion */
found = cmdtab_compl(tmp);
} else { /* Symtab completion */
#ifdef CONFIG_SYMTAB
found = symtab_compl(tmp);
#else
found = 0;
#endif
}
 
if (found == 0)
524,10 → 518,9
uintptr_t symaddr;
bool isaddr = false;
bool isptr = false;
int rc;
 
#ifdef CONFIG_SYMTAB
static char symname[MAX_SYMBOL_NAME];
#endif
/* If we get a name, try to find it in symbol table */
if (text[0] == '&') {
540,21 → 533,21
len--;
}
if (text[0] < '0' || text[0] > '9') {
#ifdef CONFIG_SYMTAB
strncpy(symname, text, min(len + 1, MAX_SYMBOL_NAME));
symaddr = get_symbol_addr(symname);
if (!symaddr) {
rc = symtab_addr_lookup(symname, &symaddr);
switch (rc) {
case ENOENT:
printf("Symbol %s not found.\n", symname);
return -1;
}
if (symaddr == (uintptr_t) -1) {
case EOVERFLOW:
printf("Duplicate symbol %s.\n", symname);
symtab_print_search(symname);
return -1;
default:
printf("No symbol information available.\n");
return -1;
}
#else
symaddr = 0;
#endif
 
if (isaddr)
*result = (unative_t)symaddr;
else if (isptr)
/trunk/kernel/Makefile
159,6 → 159,7
generic/src/ddi/ddi.c \
generic/src/ddi/irq.c \
generic/src/ddi/device.c \
generic/src/debug/symtab.c \
generic/src/interrupt/interrupt.c \
generic/src/main/main.c \
generic/src/main/kinit.c \
225,14 → 226,6
generic/src/console/cmd.c
endif
 
## Kernel symbol information
#
 
ifeq ($(CONFIG_SYMTAB),y)
GENERIC_SOURCES += \
generic/src/debug/symtab.c
endif
 
## Udebug interface sources
#
 
/trunk/kernel/arch/sparc64/src/trap/exception.c
41,21 → 41,15
#include <arch/register.h>
#include <debug.h>
#include <print.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
void dump_istate(istate_t *istate)
{
char *tpcs, *tnpcs;
 
#ifdef CONFIG_SYMTAB
tpcs = get_symtab_entry(istate->tpc);
tnpcs = get_symtab_entry(istate->tnpc);
#else
tpcs = tnpcs = "n/a";
#endif
tpcs = symtab_fmt_name_lookup(istate->tpc);
tnpcs = symtab_fmt_name_lookup(istate->tnpc);
 
printf("TSTATE=%#" PRIx64 "\n", istate->tstate);
printf("TPC=%#" PRIx64 " (%s)\n", istate->tpc, tpcs);
printf("TNPC=%#" PRIx64 " (%s)\n", istate->tnpc, tnpcs);
/trunk/kernel/arch/ia64/src/interrupt.c
53,10 → 53,7
#include <ipc/ipc.h>
#include <synch/spinlock.h>
#include <mm/tlb.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
#define VECTORS_64_BUNDLE 20
#define VECTORS_16_BUNDLE 48
140,13 → 137,9
{
char *ifa, *iipa, *iip;
 
#ifdef CONFIG_SYMTAB
ifa = get_symtab_entry(istate->cr_ifa);
iipa = get_symtab_entry(istate->cr_iipa);
iip = get_symtab_entry(istate->cr_iip);
#else
ifa = iipa = iip = "n/a";
#endif
ifa = symtab_fmt_name_lookup(istate->cr_ifa);
iipa = symtab_fmt_name_lookup(istate->cr_iipa);
iip = symtab_fmt_name_lookup(istate->cr_iip);
 
putchar('\n');
printf("Interrupted context dump:\n");
/trunk/kernel/arch/ppc32/src/mm/tlb.c
40,10 → 40,7
#include <arch.h>
#include <print.h>
#include <macros.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
static unsigned int seed = 10;
static unsigned int seed_real __attribute__ ((section("K_UNMAPPED_DATA_START"))) = 42;
120,17 → 117,11
 
static void pht_refill_fail(uintptr_t badvaddr, istate_t *istate)
{
char *symbol = "";
char *sym2 = "";
char *symbol;
char *sym2;
 
#ifdef CONFIG_SYMTAB
char *str = get_symtab_entry(istate->pc);
if (str)
symbol = str;
str = get_symtab_entry(istate->lr);
if (str)
sym2 = str;
#endif
symbol = symtab_fmt_name_lookup(istate->pc);
sym2 = symtab_fmt_name_lookup(istate->lr);
 
fault_if_from_uspace(istate,
"PHT Refill Exception on %p.", badvaddr);
/trunk/kernel/arch/amd64/src/debugger.c
43,10 → 43,7
#include <debug.h>
#include <func.h>
#include <smp/ipi.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
typedef struct {
uintptr_t address; /**< Breakpoint address */
233,12 → 230,8
}
}
 
#ifdef CONFIG_SYMTAB
printf("Reached breakpoint %d:%lx(%s)\n", slot, getip(istate),
get_symtab_entry(getip(istate)));
#else
printf("Reached breakpoint %d:%lx\n", slot, getip(istate));
#endif
printf("Reached breakpoint %d:%lx (%s)\n", slot, getip(istate),
symtab_fmt_name_lookup(getip(istate)));
 
#ifdef CONFIG_KCONSOLE
atomic_set(&haltstate, 1);
363,11 → 356,8
for (i = 0; i < BKPOINTS_MAX; i++)
if (breakpoints[i].address) {
#ifdef CONFIG_SYMTAB
symbol = get_symtab_entry(breakpoints[i].address);
#else
symbol = "n/a";
#endif
symbol = symtab_fmt_name_lookup(
breakpoints[i].address);
 
#ifdef __32_BITS__
printf("%-2u %-5d %#10zx %s\n", i,
/trunk/kernel/arch/amd64/src/interrupt.c
51,10 → 51,7
#include <arch/ddi/ddi.h>
#include <interrupt.h>
#include <ddi/irq.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
/*
* Interrupt and exception dispatching.
67,14 → 64,8
void decode_istate(int n, istate_t *istate)
{
char *symbol;
/* uint64_t *x = &istate->stack[0]; */
 
#ifdef CONFIG_SYMTAB
if (!(symbol = get_symtab_entry(istate->rip)))
symbol = "";
#else
symbol = "";
#endif
symbol = symtab_fmt_name_lookup((istate->rip);
 
printf("-----EXCEPTION(%d) OCCURED----- ( %s )\n", n, __func__);
printf("%%rip: %#llx (%s)\n", istate->rip, symbol);
/trunk/kernel/arch/mips32/src/exception.c
46,10 → 46,7
#include <func.h>
#include <ddi/irq.h>
#include <arch/debugger.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
static char * exctable[] = {
"Interrupt",
76,19 → 73,13
 
static void print_regdump(istate_t *istate)
{
char *pcsymbol = "";
char *rasymbol = "";
char *pcsymbol, *rasymbol;
 
#ifdef CONFIG_SYMTAB
char *s = get_symtab_entry(istate->epc);
if (s)
pcsymbol = s;
s = get_symtab_entry(istate->ra);
if (s)
rasymbol = s;
#endif
printf("PC: %#x(%s) RA: %#x(%s), SP(%p)\n", istate->epc, pcsymbol, istate->ra, rasymbol, istate->sp);
pcsymbol = symtab_fmt_name_lookup(istate->epc);
rasymbol = symtab_fmt_name_lookup(istate->ra);
 
printf("PC: %#x(%s) RA: %#x(%s), SP(%p)\n", istate->epc, pcsymbol,
istate->ra, rasymbol, istate->sp);
}
 
static void unhandled_exception(int n, istate_t *istate)
/trunk/kernel/arch/mips32/src/debugger.c
42,10 → 42,7
#include <arch.h>
#include <arch/cp0.h>
#include <func.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
bpinfo_t breakpoints[BKPOINTS_MAX];
SPINLOCK_INITIALIZE(bkpoint_lock);
262,12 → 259,9
for (i = 0; i < BKPOINTS_MAX; i++)
if (breakpoints[i].address) {
#ifdef CONFIG_SYMTAB
symbol = get_symtab_entry(breakpoints[i].address);
#else
symbol = "n/a";
#endif
symbol = symtab_fmt_name_lookup(
breakpoints[i].address);
 
printf("%-2u %-5d %#10zx %-6s %-7s %-8s %s\n", i,
breakpoints[i].counter, breakpoints[i].address,
((breakpoints[i].flags & BKPOINT_INPROG) ? "true" :
356,12 → 350,8
printf("Warning: breakpoint recursion\n");
if (!(cur->flags & BKPOINT_FUNCCALL)) {
#ifdef CONFIG_SYMTAB
printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
get_symtab_entry(istate->epc));
#else
printf("***Breakpoint %d: %p.\n", i, fireaddr);
#endif
symtab_fmt_name_lookup(istate->epc));
}
 
/* Return first instruction back */
375,12 → 365,9
}
cur->flags |= BKPOINT_INPROG;
} else {
#ifdef CONFIG_SYMTAB
printf("***Breakpoint %p in %s.\n", fireaddr,
get_symtab_entry(fireaddr));
#else
printf("***Breakpoint %p.\n", fireaddr);
#endif
printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
symtab_fmt_name_lookup(fireaddr));
 
/* Move on to next instruction */
istate->epc += 4;
}
/trunk/kernel/arch/mips32/src/mm/tlb.c
45,10 → 45,7
#include <debug.h>
#include <align.h>
#include <interrupt.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
static void tlb_refill_fail(istate_t *);
static void tlb_invalid_fail(istate_t *);
323,21 → 320,14
 
void tlb_refill_fail(istate_t *istate)
{
char *symbol = "";
char *sym2 = "";
char *symbol, *sym2;
 
#ifdef CONFIG_SYMTAB
char *s = get_symtab_entry(istate->epc);
if (s)
symbol = s;
s = get_symtab_entry(istate->ra);
if (s)
sym2 = s;
#endif
 
symbol = symtab_fmt_name_lookup(istate->epc);
sym2 = symtab_fmt_name_lookup(istate->ra);
fault_if_from_uspace(istate, "TLB Refill Exception on %p.",
cp0_badvaddr_read());
panic("%x: TLB Refill Exception at %x(%s<-%s).", cp0_badvaddr_read(),
panic("%x: TLB Refill Exception at %x (%s<-%s).", cp0_badvaddr_read(),
istate->epc, symbol, sym2);
}
 
344,33 → 334,25
 
void tlb_invalid_fail(istate_t *istate)
{
char *symbol = "";
char *symbol;
 
#ifdef CONFIG_SYMTAB
char *s = get_symtab_entry(istate->epc);
if (s)
symbol = s;
#endif
symbol = symtab_fmt_name_lookup(istate->epc);
 
fault_if_from_uspace(istate, "TLB Invalid Exception on %p.",
cp0_badvaddr_read());
panic("%x: TLB Invalid Exception at %x(%s).", cp0_badvaddr_read(),
panic("%x: TLB Invalid Exception at %x (%s).", cp0_badvaddr_read(),
istate->epc, symbol);
}
 
void tlb_modified_fail(istate_t *istate)
{
char *symbol = "";
char *symbol;
 
#ifdef CONFIG_SYMTAB
char *s = get_symtab_entry(istate->epc);
if (s)
symbol = s;
#endif
symbol = symtab_fmt_name_lookup(istate->epc);
 
fault_if_from_uspace(istate, "TLB Modified Exception on %p.",
cp0_badvaddr_read());
panic("%x: TLB Modified Exception at %x(%s).", cp0_badvaddr_read(),
panic("%x: TLB Modified Exception at %x (%s).", cp0_badvaddr_read(),
istate->epc, symbol);
}
 
/trunk/kernel/arch/ia32/src/interrupt.c
51,10 → 51,7
#include <ipc/sysipc.h>
#include <interrupt.h>
#include <ddi/irq.h>
 
#ifdef CONFIG_SYMTAB
#include <symtab.h>
#endif
 
/*
* Interrupt and exception dispatching.
68,13 → 65,7
{
char *symbol;
 
#ifdef CONFIG_SYMTAB
symbol = get_symtab_entry(istate->eip);
if (!symbol)
symbol = "";
#else
symbol = "";
#endif
symbol = symtab_fmt_name_lookup(istate->eip);
 
if (CPU)
printf("----------------EXCEPTION OCCURED (cpu%u)----------------\n", CPU->id);