/*********************************************************************** * break_add_break_from_lvalue * * Add a breakpoint. */ BOOL break_add_break_from_lvalue(const struct dbg_lvalue* lvalue, BOOL swbp) { ADDRESS64 addr; types_extract_as_address(lvalue, &addr); if (!break_add_break(&addr, TRUE, swbp)) { if (!DBG_IVAR(CanDeferOnBPByAddr)) { dbg_printf("Invalid address, can't set breakpoint\n" "You can turn on deferring bp by address by setting $CanDeferOnBPByAddr to 1\n"); return FALSE; } dbg_printf("Unable to add breakpoint, will check again any time a new DLL is loaded\n"); dbg_curr_process->delayed_bp = dbg_heap_realloc(dbg_curr_process->delayed_bp, sizeof(struct dbg_delayed_bp) * ++dbg_curr_process->num_delayed_bp); dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].is_symbol = FALSE; dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].software_bp = swbp; dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.addr = addr; return TRUE; } return FALSE; }
/****************************************************************** * break_add_watch_from_lvalue * * Adds a watch point from an address (stored in a lvalue) */ void break_add_watch_from_lvalue(const struct dbg_lvalue* lvalue,BOOL is_write) { struct dbg_lvalue lval; types_extract_as_address(lvalue, &lval.addr); lval.type.id = dbg_itype_none; break_add_watch(&lval, is_write); }
void memory_disassemble(const struct dbg_lvalue* xstart, const struct dbg_lvalue* xend, int instruction_count) { static ADDRESS64 last = {0,0,0}; int stop = 0; int i; if (!xstart && !xend) { if (!last.Segment && !last.Offset) memory_get_current_pc(&last); } else { if (xstart) types_extract_as_address(xstart, &last); if (xend) stop = types_extract_as_integer(xend); } for (i = 0; (instruction_count == 0 || i < instruction_count) && (stop == 0 || last.Offset <= stop); i++) memory_disasm_one_insn(&last); }
/*********************************************************************** * memory_examine * * Implementation of the 'x' command. */ void memory_examine(const struct dbg_lvalue *lvalue, int count, char format) { int i; char buffer[256]; ADDRESS64 addr; void *linear; types_extract_as_address(lvalue, &addr); linear = memory_to_linear_addr(&addr); if (format != 'i' && count > 1) { print_address(&addr, FALSE); dbg_printf(": "); } switch (format) { case 'u': if (count == 1) count = 256; memory_get_string(dbg_curr_process, linear, TRUE, TRUE, buffer, min(count, sizeof(buffer))); dbg_printf("%s\n", buffer); return; case 's': if (count == 1) count = 256; memory_get_string(dbg_curr_process, linear, TRUE, FALSE, buffer, min(count, sizeof(buffer))); dbg_printf("%s\n", buffer); return; case 'i': while (count-- && memory_disasm_one_insn(&addr)); return; case 'g': while (count--) { GUID guid; if (!dbg_read_memory(linear, &guid, sizeof(guid))) { memory_report_invalid_addr(linear); break; } dbg_printf("{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n", guid.Data1, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]); linear = (char*)linear + sizeof(guid); addr.Offset += sizeof(guid); if (count) { print_address(&addr, FALSE); dbg_printf(": "); } } return; #define DO_DUMP2(_t,_l,_f,_vv) { \ _t _v; \ for (i = 0; i < count; i++) { \ if (!dbg_read_memory(linear, &_v, sizeof(_t))) \ { memory_report_invalid_addr(linear); break; } \ dbg_printf(_f, (_vv)); \ addr.Offset += sizeof(_t); \ linear = (char*)linear + sizeof(_t); \ if ((i % (_l)) == (_l) - 1 && i != count - 1) \ { \ dbg_printf("\n"); \ print_address(&addr, FALSE); \ dbg_printf(": "); \ } \ } \ dbg_printf("\n"); \ } \ return #define DO_DUMP(_t,_l,_f) DO_DUMP2(_t,_l,_f,_v) case 'x': DO_DUMP(int, 4, " %8.8x"); case 'd': DO_DUMP(unsigned int, 4, " %10d"); case 'w': DO_DUMP(unsigned short, 8, " %04x"); case 'c': DO_DUMP2(char, 32, " %c", (_v < 0x20) ? ' ' : _v); case 'b': DO_DUMP2(char, 16, " %02x", (_v) & 0xff); } }