Subversion Repositories eduke32

Compare Revisions

Ignore whitespace Rev 4504 → Rev 4503

/polymer/eduke32/platform/Windows/src/backtrace.c
1,11 → 1,11
/*
Copyright (c) 2010 ,
Cloud Wu . All rights reserved.
Copyright (c) 2010 ,
Cloud Wu . All rights reserved.
 
http://www.codingnow.com
http://www.codingnow.com
 
Use, modification and distribution are subject to the "New BSD License"
as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
Use, modification and distribution are subject to the "New BSD License"
as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
 
filename: backtrace.c
 
75,183 → 75,183
#define BUFFER_MAX (16*1024)
 
struct bfd_ctx {
bfd * handle;
asymbol ** symbol;
bfd * handle;
asymbol ** symbol;
};
 
struct bfd_set {
char * name;
struct bfd_ctx * bc;
struct bfd_set *next;
char * name;
struct bfd_ctx * bc;
struct bfd_set *next;
};
 
struct find_info {
asymbol **symbol;
bfd_vma counter;
const char *file;
const char *func;
unsigned line;
asymbol **symbol;
bfd_vma counter;
const char *file;
const char *func;
unsigned line;
};
 
struct output_buffer {
char * buf;
size_t sz;
size_t ptr;
char * buf;
size_t sz;
size_t ptr;
};
 
static void
output_init(struct output_buffer *ob, char * buf, size_t sz)
{
ob->buf = buf;
ob->sz = sz;
ob->ptr = 0;
ob->buf[0] = '\0';
ob->buf = buf;
ob->sz = sz;
ob->ptr = 0;
ob->buf[0] = '\0';
}
 
static void
output_print(struct output_buffer *ob, const char * format, ...)
{
va_list ap;
va_list ap;
 
if (ob->sz == ob->ptr)
return;
ob->buf[ob->ptr] = '\0';
va_start(ap,format);
vsnprintf(ob->buf + ob->ptr , ob->sz - ob->ptr , format, ap);
va_end(ap);
if (ob->sz == ob->ptr)
return;
ob->buf[ob->ptr] = '\0';
va_start(ap,format);
vsnprintf(ob->buf + ob->ptr , ob->sz - ob->ptr , format, ap);
va_end(ap);
 
ob->ptr = strlen(ob->buf + ob->ptr) + ob->ptr;
ob->ptr = strlen(ob->buf + ob->ptr) + ob->ptr;
}
 
static void
lookup_section(bfd *abfd, asection *sec, void *opaque_data)
{
struct find_info *data = opaque_data;
bfd_vma vma;
struct find_info *data = opaque_data;
bfd_vma vma;
 
if (data->func)
return;
if (data->func)
return;
 
if (!(bfd_get_section_flags(abfd, sec) & SEC_ALLOC))
return;
if (!(bfd_get_section_flags(abfd, sec) & SEC_ALLOC))
return;
 
vma = bfd_get_section_vma(abfd, sec);
if (data->counter < vma || vma + bfd_get_section_size(sec) <= data->counter)
return;
vma = bfd_get_section_vma(abfd, sec);
if (data->counter < vma || vma + bfd_get_section_size(sec) <= data->counter)
return;
 
bfd_find_nearest_line(abfd, sec, data->symbol, data->counter - vma, &(data->file), &(data->func), &(data->line));
bfd_find_nearest_line(abfd, sec, data->symbol, data->counter - vma, &(data->file), &(data->func), &(data->line));
}
 
static void
find(struct bfd_ctx * b, DWORD offset, const char **file, const char **func, unsigned *line)
{
struct find_info data;
data.func = NULL;
data.symbol = b->symbol;
data.counter = offset;
data.file = NULL;
data.func = NULL;
data.line = 0;
struct find_info data;
data.func = NULL;
data.symbol = b->symbol;
data.counter = offset;
data.file = NULL;
data.func = NULL;
data.line = 0;
 
bfd_map_over_sections(b->handle, &lookup_section, &data);
if (file) {
*file = data.file;
}
if (func) {
*func = data.func;
}
if (line) {
*line = data.line;
}
bfd_map_over_sections(b->handle, &lookup_section, &data);
if (file) {
*file = data.file;
}
if (func) {
*func = data.func;
}
if (line) {
*line = data.line;
}
}
 
static int
init_bfd_ctx(struct bfd_ctx *bc, const char * procname, struct output_buffer *ob)
{
int r1, r2, r3;
bfd *b;
void *symbol_table;
unsigned dummy = 0;
bc->handle = NULL;
bc->symbol = NULL;
int r1, r2, r3;
bfd *b;
void *symbol_table;
unsigned dummy = 0;
bc->handle = NULL;
bc->symbol = NULL;
 
b = bfd_openr(procname, 0);
if (!b) {
output_print(ob,"Failed to open bfd from (%s)\n" , procname);
return 1;
}
b = bfd_openr(procname, 0);
if (!b) {
output_print(ob,"Failed to open bfd from (%s)\n" , procname);
return 1;
}
 
r1 = bfd_check_format(b, bfd_object);
r2 = bfd_check_format_matches(b, bfd_object, NULL);
r3 = bfd_get_file_flags(b) & HAS_SYMS;
r1 = bfd_check_format(b, bfd_object);
r2 = bfd_check_format_matches(b, bfd_object, NULL);
r3 = bfd_get_file_flags(b) & HAS_SYMS;
 
if (!(r1 && r2 && r3)) {
bfd_close(b);
if (!(r1 && r2 && r3)) {
bfd_close(b);
if (!(r1 && r2))
output_print(ob,"Failed to init bfd from (%s): %d %d %d\n", procname, r1, r2, r3);
return 1;
}
return 1;
}
 
if (bfd_read_minisymbols(b, FALSE, &symbol_table, &dummy) == 0) {
if (bfd_read_minisymbols(b, TRUE, &symbol_table, &dummy) < 0) {
free(symbol_table);
bfd_close(b);
output_print(ob,"Failed to read symbols from (%s)\n", procname);
return 1;
}
}
if (bfd_read_minisymbols(b, FALSE, &symbol_table, &dummy) == 0) {
if (bfd_read_minisymbols(b, TRUE, &symbol_table, &dummy) < 0) {
free(symbol_table);
bfd_close(b);
output_print(ob,"Failed to read symbols from (%s)\n", procname);
return 1;
}
}
 
bc->handle = b;
bc->symbol = symbol_table;
bc->handle = b;
bc->symbol = symbol_table;
 
return 0;
return 0;
}
 
static void
close_bfd_ctx(struct bfd_ctx *bc)
{
if (bc) {
if (bc->symbol) {
free(bc->symbol);
}
if (bc->handle) {
bfd_close(bc->handle);
}
}
if (bc) {
if (bc->symbol) {
free(bc->symbol);
}
if (bc->handle) {
bfd_close(bc->handle);
}
}
}
 
static struct bfd_ctx *
get_bc(struct output_buffer *ob , struct bfd_set *set , const char *procname)
{
struct bfd_ctx bc;
while(set->name) {
if (strcmp(set->name , procname) == 0) {
return set->bc;
}
set = set->next;
}
if (init_bfd_ctx(&bc, procname , ob)) {
return NULL;
}
set->next = calloc(1, sizeof(*set));
set->bc = malloc(sizeof(struct bfd_ctx));
memcpy(set->bc, &bc, sizeof(bc));
set->name = strdup(procname);
struct bfd_ctx bc;
while(set->name) {
if (strcmp(set->name , procname) == 0) {
return set->bc;
}
set = set->next;
}
if (init_bfd_ctx(&bc, procname , ob)) {
return NULL;
}
set->next = calloc(1, sizeof(*set));
set->bc = malloc(sizeof(struct bfd_ctx));
memcpy(set->bc, &bc, sizeof(bc));
set->name = strdup(procname);
 
return set->bc;
return set->bc;
}
 
static void
release_set(struct bfd_set *set)
{
while(set) {
struct bfd_set * temp = set->next;
while(set) {
struct bfd_set * temp = set->next;
if (set->name)
free(set->name);
close_bfd_ctx(set->bc);
close_bfd_ctx(set->bc);
free(set);
set = temp;
}
set = temp;
}
}
 
static char procname[MAX_PATH];
267,84 → 267,84
static void
_backtrace(struct output_buffer *ob, struct bfd_set *set, int depth , LPCONTEXT context)
{
MAYBE64(STACKFRAME) frame;
MAYBE64(STACKFRAME) frame;
HANDLE process, thread;
char symbol_buffer[sizeof(MAYBE64(IMAGEHLP_SYMBOL)) + 255];
char module_name_raw[MAX_PATH];
struct bfd_ctx *bc = NULL;
char symbol_buffer[sizeof(MAYBE64(IMAGEHLP_SYMBOL)) + 255];
char module_name_raw[MAX_PATH];
struct bfd_ctx *bc = NULL;
 
GetModuleFileNameA(NULL, procname, sizeof procname);
GetModuleFileNameA(NULL, procname, sizeof procname);
 
memset(&frame,0,sizeof(frame));
memset(&frame,0,sizeof(frame));
 
#ifdef EBACKTRACE64
frame.AddrPC.Offset = context->Rip;
frame.AddrStack.Offset = context->Rsp;
frame.AddrFrame.Offset = context->Rbp;
frame.AddrPC.Offset = context->Rip;
frame.AddrStack.Offset = context->Rsp;
frame.AddrFrame.Offset = context->Rbp;
#else
frame.AddrPC.Offset = context->Eip;
frame.AddrStack.Offset = context->Esp;
frame.AddrFrame.Offset = context->Ebp;
frame.AddrPC.Offset = context->Eip;
frame.AddrStack.Offset = context->Esp;
frame.AddrFrame.Offset = context->Ebp;
#endif
 
frame.AddrPC.Mode = AddrModeFlat;
frame.AddrStack.Mode = AddrModeFlat;
frame.AddrFrame.Mode = AddrModeFlat;
frame.AddrPC.Mode = AddrModeFlat;
frame.AddrStack.Mode = AddrModeFlat;
frame.AddrFrame.Mode = AddrModeFlat;
 
process = GetCurrentProcess();
thread = GetCurrentThread();
process = GetCurrentProcess();
thread = GetCurrentThread();
 
while(MAYBE64(StackWalk)(MachineType,
process,
thread,
&frame,
context,
NULL,
MAYBE64(SymFunctionTableAccess),
MAYBE64(SymGetModuleBase), NULL)) {
MAYBE64(IMAGEHLP_SYMBOL) *symbol;
MAYBE64(DWORD) module_base;
const char * module_name = "[unknown module]";
while(MAYBE64(StackWalk)(MachineType,
process,
thread,
&frame,
context,
NULL,
MAYBE64(SymFunctionTableAccess),
MAYBE64(SymGetModuleBase), NULL)) {
MAYBE64(IMAGEHLP_SYMBOL) *symbol;
MAYBE64(DWORD) module_base;
const char * module_name = "[unknown module]";
 
const char * file = NULL;
const char * func = NULL;
unsigned line = 0;
const char * file = NULL;
const char * func = NULL;
unsigned line = 0;
 
--depth;
if (depth < 0)
break;
--depth;
if (depth < 0)
break;
 
symbol = (MAYBE64(IMAGEHLP_SYMBOL) *)symbol_buffer;
symbol->SizeOfStruct = (sizeof *symbol) + 255;
symbol->MaxNameLength = 254;
symbol = (MAYBE64(IMAGEHLP_SYMBOL) *)symbol_buffer;
symbol->SizeOfStruct = (sizeof *symbol) + 255;
symbol->MaxNameLength = 254;
 
module_base = MAYBE64(SymGetModuleBase)(process, frame.AddrPC.Offset);
module_base = MAYBE64(SymGetModuleBase)(process, frame.AddrPC.Offset);
 
if (module_base &&
GetModuleFileNameA((HINSTANCE)(intptr_t)module_base, module_name_raw, MAX_PATH)) {
module_name = module_name_raw;
bc = get_bc(ob, set, module_name);
}
if (module_base &&
GetModuleFileNameA((HINSTANCE)(intptr_t)module_base, module_name_raw, MAX_PATH)) {
module_name = module_name_raw;
bc = get_bc(ob, set, module_name);
}
 
if (bc) {
find(bc,frame.AddrPC.Offset,&file,&func,&line);
}
if (bc) {
find(bc,frame.AddrPC.Offset,&file,&func,&line);
}
 
if (file == NULL) {
MAYBE64(DWORD) dummy = 0;
if (MAYBE64(SymGetSymFromAddr)(process, frame.AddrPC.Offset, &dummy, symbol)) {
file = symbol->Name;
}
else {
file = "[unknown file]";
}
}
if (file == NULL) {
MAYBE64(DWORD) dummy = 0;
if (MAYBE64(SymGetSymFromAddr)(process, frame.AddrPC.Offset, &dummy, symbol)) {
file = symbol->Name;
}
else {
file = "[unknown file]";
}
}
 
output_print(ob,"0x%p : %s : %s", frame.AddrPC.Offset, module_name, file);
if (func != NULL)
output_print(ob, " (%d) : in function (%s)", line, func);
if (func != NULL)
output_print(ob, " (%d) : in function (%s)", line, func);
output_print(ob, "\n");
}
}
}
 
static LPTSTR FormatErrorMessage(DWORD dwMessageId)
373,7 → 373,7
static LONG WINAPI
exception_filter(LPEXCEPTION_POINTERS info)
{
struct output_buffer ob;
struct output_buffer ob;
int logfd, written;
PEXCEPTION_RECORD exception;
BOOL initialized = FALSE;
455,43 → 455,43
 
//fputs(g_output, stderr);
 
exit(0xBAC);
exit(0xBAC);
 
return EXCEPTION_CONTINUE_SEARCH;
return EXCEPTION_CONTINUE_SEARCH;
}
 
static void
backtrace_register(void)
{
if (g_output == NULL) {
g_output = malloc(BUFFER_MAX);
g_prev = AddVectoredExceptionHandler(1, exception_filter);
}
if (g_output == NULL) {
g_output = malloc(BUFFER_MAX);
g_prev = AddVectoredExceptionHandler(1, exception_filter);
}
}
 
static void
backtrace_unregister(void)
{
if (g_output) {
free(g_output);
RemoveVectoredExceptionHandler(g_prev);
g_prev = NULL;
g_output = NULL;
}
if (g_output) {
free(g_output);
RemoveVectoredExceptionHandler(g_prev);
g_prev = NULL;
g_output = NULL;
}
}
 
BOOL WINAPI
DllMain(HINSTANCE hinstDLL ATTRIBUTE((unused)), DWORD dwReason, LPVOID lpvReserved ATTRIBUTE((unused)))
{
switch (dwReason) {
case DLL_PROCESS_ATTACH:
backtrace_register();
break;
case DLL_PROCESS_DETACH:
backtrace_unregister();
break;
}
return TRUE;
switch (dwReason) {
case DLL_PROCESS_ATTACH:
backtrace_register();
break;
case DLL_PROCESS_DETACH:
backtrace_unregister();
break;
}
return TRUE;
}