/***********************************************************************
* 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);
}
}
