/*********************************************************************** * print_address * * Print an 16- or 32-bit address, with the nearest symbol if any. */ void print_address(const ADDRESS64* addr, BOOLEAN with_line) { char buffer[sizeof(SYMBOL_INFO) + 256]; SYMBOL_INFO* si = (SYMBOL_INFO*)buffer; void* lin = memory_to_linear_addr(addr); DWORD64 disp64; DWORD disp; print_bare_address(addr); si->SizeOfStruct = sizeof(*si); si->MaxNameLen = 256; if (!SymFromAddr(dbg_curr_process->handle, (DWORD_PTR)lin, &disp64, si)) return; dbg_printf(" %s", si->Name); if (disp64) dbg_printf("+0x%lx", (DWORD_PTR)disp64); if (with_line) { IMAGEHLP_LINE il; IMAGEHLP_MODULE im; il.SizeOfStruct = sizeof(il); if (SymGetLineFromAddr(dbg_curr_process->handle, (DWORD_PTR)lin, &disp, &il)) dbg_printf(" [%s:%lu]", il.FileName, il.LineNumber); im.SizeOfStruct = sizeof(im); if (SymGetModuleInfo(dbg_curr_process->handle, (DWORD_PTR)lin, &im)) dbg_printf(" in %s", im.ModuleName); } }
static void stack_print_addr_and_args(int nf) { char buffer[sizeof(SYMBOL_INFO) + 256]; SYMBOL_INFO* si = (SYMBOL_INFO*)buffer; IMAGEHLP_STACK_FRAME ihsf; IMAGEHLP_LINE64 il; IMAGEHLP_MODULE im; DWORD64 disp64; print_bare_address(&dbg_curr_thread->frames[nf].addr_pc); stack_get_frame(nf, &ihsf); /* grab module where symbol is. If we don't have a module, we cannot print more */ im.SizeOfStruct = sizeof(im); if (!SymGetModuleInfo(dbg_curr_process->handle, ihsf.InstructionOffset, &im)) return; si->SizeOfStruct = sizeof(*si); si->MaxNameLen = 256; if (SymFromAddr(dbg_curr_process->handle, ihsf.InstructionOffset, &disp64, si)) { struct sym_enum se; DWORD disp; dbg_printf(" %s", si->Name); if (disp64) dbg_printf("+0x%lx", (DWORD_PTR)disp64); SymSetContext(dbg_curr_process->handle, &ihsf, NULL); se.first = TRUE; se.frame = ihsf.FrameOffset; dbg_printf("("); SymEnumSymbols(dbg_curr_process->handle, 0, NULL, sym_enum_cb, &se); dbg_printf(")"); il.SizeOfStruct = sizeof(il); if (SymGetLineFromAddr64(dbg_curr_process->handle, ihsf.InstructionOffset, &disp, &il)) dbg_printf(" [%s:%u]", il.FileName, il.LineNumber); dbg_printf(" in %s", im.ModuleName); } else dbg_printf(" in %s (+0x%lx)", im.ModuleName, (DWORD_PTR)(ihsf.InstructionOffset - im.BaseOfImage)); }
/*********************************************************************** * break_add_break * * Add a breakpoint. */ BOOL break_add_break(const ADDRESS64* addr, BOOL verbose, BOOL swbp) { int num; BYTE ch; struct dbg_breakpoint* bp = dbg_curr_process->bp; int type = swbp ? be_xpoint_break : be_xpoint_watch_exec; if ((num = find_xpoint(addr, type)) >= 1) { bp[num].refcount++; dbg_printf("Breakpoint %d at ", num); print_address(&bp[num].addr, TRUE); dbg_printf(" (refcount=%d)\n", bp[num].refcount); return TRUE; } if (!dbg_read_memory(memory_to_linear_addr(addr), &ch, sizeof(ch))) { if (verbose) { dbg_printf("Invalid address "); print_bare_address(addr); dbg_printf(", can't set breakpoint\n"); } return FALSE; } if ((num = init_xpoint(type, addr)) == -1) return FALSE; dbg_printf("Breakpoint %d at ", num); print_address(&bp[num].addr, TRUE); dbg_printf("\n"); return TRUE; }
/****************************************************************** * backtrace * * Do a backtrace on the current thread */ static void backtrace(void) { unsigned cf = dbg_curr_thread->curr_frame; IMAGEHLP_STACK_FRAME ihsf; dbg_printf("Backtrace:\n"); for (dbg_curr_thread->curr_frame = 0; dbg_curr_thread->curr_frame < dbg_curr_thread->num_frames; dbg_curr_thread->curr_frame++) { dbg_printf("%s%d ", (cf == dbg_curr_thread->curr_frame ? "=>" : " "), dbg_curr_thread->curr_frame); stack_print_addr_and_args(dbg_curr_thread->curr_frame); dbg_printf(" ("); print_bare_address(&dbg_curr_thread->frames[dbg_curr_thread->curr_frame].addr_frame); dbg_printf(")\n"); } /* reset context to current stack frame */ dbg_curr_thread->curr_frame = cf; if (!dbg_curr_thread->frames) return; stack_get_frame(dbg_curr_thread->curr_frame, &ihsf); SymSetContext(dbg_curr_process->handle, &ihsf, NULL); }