| /* |
| * Debugger break-points handling |
| * |
| * Copyright 1994 Martin von Loewis |
| * Copyright 1995 Alexandre Julliard |
| * Copyright 1999,2000 Eric Pouech |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include "config.h" |
| #include "debugger.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(winedbg); |
| |
| /*********************************************************************** |
| * break_set_xpoints |
| * |
| * Set or remove all the breakpoints & watchpoints |
| */ |
| void break_set_xpoints(BOOL set) |
| { |
| static BOOL last; /* = 0 = FALSE */ |
| |
| unsigned int i, ret, size; |
| void* addr; |
| struct dbg_breakpoint* bp = dbg_curr_process->bp; |
| |
| if (set == last) return; |
| last = set; |
| |
| for (i = 0; i < dbg_curr_process->next_bp; i++) |
| { |
| if (!bp[i].refcount || !bp[i].enabled) continue; |
| |
| if (bp[i].xpoint_type == be_xpoint_break) |
| size = 0; |
| else |
| size = bp[i].w.len + 1; |
| addr = (void*)memory_to_linear_addr(&bp[i].addr); |
| |
| if (set) |
| ret = be_cpu->insert_Xpoint(dbg_curr_process->handle, &dbg_context, |
| bp[i].xpoint_type, addr, |
| &bp[i].info, size); |
| else |
| ret = be_cpu->remove_Xpoint(dbg_curr_process->handle, &dbg_context, |
| bp[i].xpoint_type, addr, |
| bp[i].info, size); |
| if (!ret) |
| { |
| dbg_printf("Invalid address ("); |
| print_address(&bp[i].addr, FALSE); |
| dbg_printf(") for breakpoint %d, disabling it\n", i); |
| bp[i].enabled = FALSE; |
| } |
| } |
| } |
| |
| /*********************************************************************** |
| * find_xpoint |
| * |
| * Find the breakpoint for a given address. Return the breakpoint |
| * number or -1 if none. |
| */ |
| static int find_xpoint(const ADDRESS* addr, enum be_xpoint_type type) |
| { |
| int i; |
| void* lin = memory_to_linear_addr(addr); |
| struct dbg_breakpoint* bp = dbg_curr_process->bp; |
| |
| for (i = 0; i < dbg_curr_process->next_bp; i++) |
| { |
| if (bp[i].refcount && bp[i].enabled && bp[i].xpoint_type == type && |
| memory_to_linear_addr(&bp[i].addr) == lin) |
| return i; |
| } |
| return -1; |
| } |
| |
| /*********************************************************************** |
| * init_xpoint |
| * |
| * Find an empty slot in BP table to add a new break/watch point |
| */ |
| static int init_xpoint(int type, const ADDRESS* addr) |
| { |
| int num; |
| struct dbg_breakpoint* bp = dbg_curr_process->bp; |
| |
| for (num = (dbg_curr_process->next_bp < MAX_BREAKPOINTS) ? |
| dbg_curr_process->next_bp++ : 1; |
| num < MAX_BREAKPOINTS; num++) |
| { |
| if (bp[num].refcount == 0) |
| { |
| bp[num].refcount = 1; |
| bp[num].enabled = TRUE; |
| bp[num].xpoint_type = type; |
| bp[num].skipcount = 0; |
| bp[num].addr = *addr; |
| return num; |
| } |
| } |
| |
| dbg_printf("Too many bp. Please delete some.\n"); |
| return -1; |
| } |
| |
| /*********************************************************************** |
| * get_watched_value |
| * |
| * Returns the value watched by watch point 'num'. |
| */ |
| static BOOL get_watched_value(int num, LPDWORD val) |
| { |
| BYTE buf[4]; |
| |
| if (!dbg_read_memory(memory_to_linear_addr(&dbg_curr_process->bp[num].addr), |
| buf, dbg_curr_process->bp[num].w.len + 1)) |
| return FALSE; |
| |
| switch (dbg_curr_process->bp[num].w.len + 1) |
| { |
| case 4: *val = *(DWORD*)buf; break; |
| case 2: *val = *(WORD*)buf; break; |
| case 1: *val = *(BYTE*)buf; break; |
| default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); |
| } |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * break_add_break |
| * |
| * Add a breakpoint. |
| */ |
| BOOL break_add_break(const ADDRESS* addr, BOOL verbose) |
| { |
| int num; |
| BYTE ch; |
| struct dbg_breakpoint* bp = dbg_curr_process->bp; |
| |
| if ((num = find_xpoint(addr, be_xpoint_break)) >= 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(be_xpoint_break, addr)) == -1) |
| return FALSE; |
| |
| dbg_printf("Breakpoint %d at ", num); |
| print_address(&bp[num].addr, TRUE); |
| dbg_printf("\n"); |
| |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * break_add_break_from_lvalue |
| * |
| * Add a breakpoint. |
| */ |
| BOOL break_add_break_from_lvalue(const struct dbg_lvalue* lvalue) |
| { |
| ADDRESS addr; |
| |
| addr.Mode = AddrModeFlat; |
| addr.Offset = types_extract_as_integer(lvalue); |
| |
| if (!break_add_break(&addr, TRUE)) |
| { |
| 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].u.addr = addr; |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| /*********************************************************************** |
| * break_add_break_from_id |
| * |
| * Add a breakpoint from a function name (and eventually a line #) |
| */ |
| void break_add_break_from_id(const char *name, int lineno) |
| { |
| struct dbg_lvalue lvalue; |
| int i; |
| |
| switch (symbol_get_lvalue(name, lineno, &lvalue, TRUE)) |
| { |
| case sglv_found: |
| break_add_break(&lvalue.addr, TRUE); |
| return; |
| case sglv_unknown: |
| break; |
| case sglv_aborted: /* user aborted symbol lookup */ |
| return; |
| } |
| |
| dbg_printf("Unable to add breakpoint, will check again when a new DLL is loaded\n"); |
| for (i = 0; i < dbg_curr_process->num_delayed_bp; i++) |
| { |
| if (dbg_curr_process->delayed_bp[i].is_symbol && |
| !strcmp(name, dbg_curr_process->delayed_bp[i].u.symbol.name) && |
| lineno == dbg_curr_process->delayed_bp[i].u.symbol.lineno) |
| return; |
| } |
| 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 = TRUE; |
| dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.symbol.name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(name) + 1), name); |
| dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.symbol.lineno = lineno; |
| } |
| |
| /*********************************************************************** |
| * break_add_break_from_lineno |
| * |
| * Add a breakpoint from a line number in current file |
| */ |
| void break_add_break_from_lineno(int lineno) |
| { |
| ADDRESS addr; |
| |
| memory_get_current_pc(&addr); |
| |
| if (lineno != -1) |
| { |
| IMAGEHLP_LINE il; |
| IMAGEHLP_LINE iil; |
| BOOL found = FALSE; |
| |
| il.SizeOfStruct = sizeof(il); |
| if (!SymGetLineFromAddr(dbg_curr_process->handle, |
| (DWORD)memory_to_linear_addr(&addr), NULL, &il)) |
| { |
| dbg_printf("Unable to add breakpoint (unknown address)\n"); |
| return; |
| } |
| |
| iil = il; |
| while (SymGetLinePrev(dbg_curr_process->handle, &iil)) |
| { |
| if (lineno == iil.LineNumber && !strcmp(il.FileName, iil.FileName)) |
| { |
| addr.Mode = AddrModeFlat; |
| addr.Offset = iil.Address; |
| found = TRUE; |
| break; |
| } |
| } |
| iil = il; |
| if (!found) while (SymGetLineNext(dbg_curr_process->handle, &iil)) |
| { |
| if (lineno == iil.LineNumber && !strcmp(il.FileName, iil.FileName)) |
| { |
| addr.Mode = AddrModeFlat; |
| addr.Offset = iil.Address; |
| found = TRUE; |
| break; |
| } |
| } |
| if (!found) |
| { |
| dbg_printf("Unknown line number\n" |
| "(either out of file, or no code at given line number)\n"); |
| return; |
| } |
| } |
| |
| break_add_break(&addr, TRUE); |
| } |
| |
| /*********************************************************************** |
| * break_check_delayed_bp |
| * |
| * Check is a registered delayed BP is now available. |
| */ |
| void break_check_delayed_bp(void) |
| { |
| struct dbg_lvalue lvalue; |
| int i; |
| struct dbg_delayed_bp* dbp = dbg_curr_process->delayed_bp; |
| |
| for (i = 0; i < dbg_curr_process->num_delayed_bp; i++) |
| { |
| if (dbp[i].is_symbol) |
| { |
| if (symbol_get_lvalue(dbp[i].u.symbol.name, dbp[i].u.symbol.lineno, |
| &lvalue, TRUE) != sglv_found) |
| continue; |
| if (lvalue.cookie != DLV_TARGET) continue; |
| } |
| else |
| lvalue.addr = dbp[i].u.addr; |
| WINE_TRACE("trying to add delayed %s-bp\n", dbp[i].is_symbol ? "S" : "A"); |
| if (!dbp[i].is_symbol) |
| WINE_TRACE("\t%04x:%08lx\n", |
| dbp[i].u.addr.Segment, dbp[i].u.addr.Offset); |
| else |
| WINE_TRACE("\t'%s' @ %d\n", |
| dbp[i].u.symbol.name, dbp[i].u.symbol.lineno); |
| |
| if (break_add_break(&lvalue.addr, FALSE)) |
| memmove(&dbp[i], &dbp[i+1], (--dbg_curr_process->num_delayed_bp - i) * sizeof(*dbp)); |
| } |
| } |
| |
| /*********************************************************************** |
| * break_add_watch |
| * |
| * Add a watchpoint. |
| */ |
| static void break_add_watch(const struct dbg_lvalue* lvalue, BOOL is_write) |
| { |
| int num; |
| DWORD l = 4; |
| |
| num = init_xpoint((is_write) ? be_xpoint_watch_write : be_xpoint_watch_read, |
| &lvalue->addr); |
| if (num == -1) return; |
| |
| if (lvalue->type.id != dbg_itype_none) |
| { |
| if (types_get_info(&lvalue->type, TI_GET_LENGTH, &l)) |
| { |
| switch (l) |
| { |
| case 4: case 2: case 1: break; |
| default: |
| dbg_printf("Unsupported length (%lu) for watch-points, defaulting to 4\n", l); |
| break; |
| } |
| } |
| else dbg_printf("Cannot get watch size, defaulting to 4\n"); |
| } |
| dbg_curr_process->bp[num].w.len = l - 1; |
| |
| if (!get_watched_value(num, &dbg_curr_process->bp[num].w.oldval)) |
| { |
| dbg_printf("Bad address. Watchpoint not set\n"); |
| dbg_curr_process->bp[num].refcount = 0; |
| return; |
| } |
| dbg_printf("Watchpoint %d at ", num); |
| print_address(&dbg_curr_process->bp[num].addr, TRUE); |
| dbg_printf("\n"); |
| } |
| |
| /****************************************************************** |
| * 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) |
| { |
| struct dbg_lvalue lval; |
| |
| lval.addr.Mode = AddrModeFlat; |
| lval.addr.Offset = types_extract_as_integer(lvalue); |
| lval.type.id = dbg_itype_none; |
| |
| break_add_watch(&lval, TRUE); |
| } |
| |
| /*********************************************************************** |
| * break_add_watch_from_id |
| * |
| * Add a watchpoint from a symbol name |
| */ |
| void break_add_watch_from_id(const char *name) |
| { |
| struct dbg_lvalue lvalue; |
| |
| switch (symbol_get_lvalue(name, -1, &lvalue, TRUE)) |
| { |
| case sglv_found: |
| break_add_watch(&lvalue, 1); |
| break; |
| case sglv_unknown: |
| dbg_printf("Unable to add watchpoint\n"); |
| break; |
| case sglv_aborted: /* user aborted symbol lookup */ |
| break; |
| } |
| } |
| |
| /*********************************************************************** |
| * break_delete_xpoint |
| * |
| * Delete a breakpoint. |
| */ |
| void break_delete_xpoint(int num) |
| { |
| struct dbg_breakpoint* bp = dbg_curr_process->bp; |
| |
| if ((num <= 0) || (num >= dbg_curr_process->next_bp) || |
| bp[num].refcount == 0) |
| { |
| dbg_printf("Invalid breakpoint number %d\n", num); |
| return; |
| } |
| |
| if (--bp[num].refcount > 0) |
| return; |
| |
| if (bp[num].condition != NULL) |
| { |
| expr_free(bp[num].condition); |
| bp[num].condition = NULL; |
| } |
| |
| bp[num].enabled = FALSE; |
| bp[num].refcount = 0; |
| bp[num].skipcount = 0; |
| } |
| |
| static inline BOOL module_is_container(const IMAGEHLP_MODULE* wmod_cntnr, |
| const IMAGEHLP_MODULE* wmod_child) |
| { |
| return wmod_cntnr->BaseOfImage <= wmod_child->BaseOfImage && |
| (DWORD)wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >= |
| (DWORD)wmod_child->BaseOfImage + wmod_child->ImageSize; |
| } |
| |
| /****************************************************************** |
| * break_delete_xpoints_from_module |
| * |
| * Remove all Xpoints from module which base is 'base' |
| */ |
| void break_delete_xpoints_from_module(unsigned long base) |
| { |
| IMAGEHLP_MODULE im, im_elf; |
| int i; |
| DWORD linear; |
| struct dbg_breakpoint* bp = dbg_curr_process->bp; |
| |
| /* FIXME: should do it also on the ELF sibbling if any */ |
| im.SizeOfStruct = sizeof(im); |
| im_elf.SizeOfStruct = sizeof(im_elf); |
| if (!SymGetModuleInfo(dbg_curr_process->handle, base, &im)) return; |
| |
| /* try to get in fact the underlying ELF module (if any) */ |
| if (SymGetModuleInfo(dbg_curr_process->handle, im.BaseOfImage - 1, &im_elf) && |
| im_elf.BaseOfImage <= im.BaseOfImage && |
| (DWORD)im_elf.BaseOfImage + im_elf.ImageSize >= (DWORD)im.BaseOfImage + im.ImageSize) |
| im = im_elf; |
| |
| for (i = 0; i < dbg_curr_process->next_bp; i++) |
| { |
| linear = (DWORD)memory_to_linear_addr(&bp[i].addr); |
| if (bp[i].refcount && bp[i].enabled && |
| im.BaseOfImage <= linear && linear < im.BaseOfImage + im.ImageSize) |
| { |
| break_delete_xpoint(i); |
| } |
| } |
| } |
| |
| /*********************************************************************** |
| * break_enable_xpoint |
| * |
| * Enable or disable a break point. |
| */ |
| void break_enable_xpoint(int num, BOOL enable) |
| { |
| if ((num <= 0) || (num >= dbg_curr_process->next_bp) || |
| dbg_curr_process->bp[num].refcount == 0) |
| { |
| dbg_printf("Invalid breakpoint number %d\n", num); |
| return; |
| } |
| dbg_curr_process->bp[num].enabled = (enable) ? TRUE : FALSE; |
| dbg_curr_process->bp[num].skipcount = 0; |
| } |
| |
| |
| /*********************************************************************** |
| * find_triggered_watch |
| * |
| * Lookup the watchpoints to see if one has been triggered |
| * Return >= (watch point index) if one is found and *oldval is set to |
| * the value watched before the TRAP |
| * Return -1 if none found (*oldval is undetermined) |
| * |
| * Unfortunately, Linux does *NOT* (A REAL PITA) report with ptrace |
| * the DR6 register value, so we have to look with our own need the |
| * cause of the TRAP. |
| * -EP |
| */ |
| static int find_triggered_watch(LPDWORD oldval) |
| { |
| int found = -1; |
| int i; |
| struct dbg_breakpoint* bp = dbg_curr_process->bp; |
| |
| /* Method 1 => get triggered watchpoint from context (doesn't work on Linux |
| * 2.2.x). This should be fixed in >= 2.2.16 |
| */ |
| for (i = 0; i < dbg_curr_process->next_bp; i++) |
| { |
| DWORD val = 0; |
| |
| if (bp[i].refcount && bp[i].enabled && bp[i].xpoint_type != be_xpoint_break && |
| (be_cpu->is_watchpoint_set(&dbg_context, bp[i].info))) |
| { |
| be_cpu->clear_watchpoint(&dbg_context, bp[i].info); |
| |
| *oldval = bp[i].w.oldval; |
| if (get_watched_value(i, &val)) |
| { |
| bp[i].w.oldval = val; |
| return i; |
| } |
| } |
| } |
| |
| /* Method 1 failed, trying method 2 */ |
| |
| /* Method 2 => check if value has changed among registered watchpoints |
| * this really sucks, but this is how gdb 4.18 works on my linux box |
| * -EP |
| */ |
| for (i = 0; i < dbg_curr_process->next_bp; i++) |
| { |
| DWORD val = 0; |
| |
| if (bp[i].refcount && bp[i].enabled && bp[i].xpoint_type != be_xpoint_break && |
| get_watched_value(i, &val)) |
| { |
| *oldval = bp[i].w.oldval; |
| if (val != *oldval) |
| { |
| be_cpu->clear_watchpoint(&dbg_context, bp[i].info); |
| bp[i].w.oldval = val; |
| found = i; |
| /* cannot break, because two watch points may have been triggered on |
| * the same access |
| * only one will be reported to the user (FIXME ?) |
| */ |
| } |
| } |
| } |
| return found; |
| } |
| |
| /*********************************************************************** |
| * break_info |
| * |
| * Display break & watch points information. |
| */ |
| void break_info(void) |
| { |
| int i; |
| int nbp = 0, nwp = 0; |
| struct dbg_delayed_bp* dbp = dbg_curr_process->delayed_bp; |
| struct dbg_breakpoint* bp = dbg_curr_process->bp; |
| |
| for (i = 1; i < dbg_curr_process->next_bp; i++) |
| { |
| if (bp[i].refcount) |
| { |
| if (bp[i].xpoint_type == be_xpoint_break) nbp++; else nwp++; |
| } |
| } |
| |
| if (nbp) |
| { |
| dbg_printf("Breakpoints:\n"); |
| for (i = 1; i < dbg_curr_process->next_bp; i++) |
| { |
| if (!bp[i].refcount || bp[i].xpoint_type != be_xpoint_break) |
| continue; |
| dbg_printf("%d: %c ", i, bp[i].enabled ? 'y' : 'n'); |
| print_address(&bp[i].addr, TRUE); |
| dbg_printf(" (%u)\n", bp[i].refcount); |
| if (bp[i].condition != NULL) |
| { |
| dbg_printf("\t\tstop when "); |
| expr_print(bp[i].condition); |
| dbg_printf("\n"); |
| } |
| } |
| } |
| else dbg_printf("No breakpoints\n"); |
| if (nwp) |
| { |
| dbg_printf("Watchpoints:\n"); |
| for (i = 1; i < dbg_curr_process->next_bp; i++) |
| { |
| if (!bp[i].refcount || bp[i].xpoint_type == be_xpoint_break) |
| continue; |
| dbg_printf("%d: %c ", i, bp[i].enabled ? 'y' : 'n'); |
| print_address(&bp[i].addr, TRUE); |
| dbg_printf(" on %d byte%s (%c)\n", |
| bp[i].w.len + 1, bp[i].w.len > 0 ? "s" : "", |
| bp[i].xpoint_type == be_xpoint_watch_write ? 'W' : 'R'); |
| if (bp[i].condition != NULL) |
| { |
| dbg_printf("\t\tstop when "); |
| expr_print(bp[i].condition); |
| dbg_printf("\n"); |
| } |
| } |
| } |
| else dbg_printf("No watchpoints\n"); |
| if (dbg_curr_process->num_delayed_bp) |
| { |
| dbg_printf("Delayed breakpoints:\n"); |
| for (i = 0; i < dbg_curr_process->num_delayed_bp; i++) |
| { |
| if (dbp[i].is_symbol) |
| { |
| dbg_printf("%d: %s", i, dbp[i].u.symbol.name); |
| if (dbp[i].u.symbol.lineno != -1) |
| dbg_printf(" at line %u", dbp[i].u.symbol.lineno); |
| } |
| else |
| { |
| dbg_printf("%d: ", i); |
| print_address(&dbp[i].u.addr, FALSE); |
| } |
| dbg_printf("\n"); |
| } |
| } |
| } |
| |
| /*********************************************************************** |
| * should_stop |
| * |
| * Check whether or not the condition (bp / skipcount) of a break/watch |
| * point are met. |
| */ |
| static BOOL should_stop(int bpnum) |
| { |
| struct dbg_breakpoint* bp = &dbg_curr_process->bp[bpnum]; |
| |
| if (bp->condition != NULL) |
| { |
| struct dbg_lvalue lvalue = expr_eval(bp->condition); |
| |
| if (lvalue.type.id == dbg_itype_none) |
| { |
| /* |
| * Something wrong - unable to evaluate this expression. |
| */ |
| dbg_printf("Unable to evaluate expression "); |
| expr_print(bp->condition); |
| dbg_printf("\nTurning off condition\n"); |
| break_add_condition(bpnum, NULL); |
| } |
| else if (!types_extract_as_integer(&lvalue)) |
| { |
| return FALSE; |
| } |
| } |
| |
| if (bp->skipcount > 0) bp->skipcount--; |
| return bp->skipcount == 0; |
| } |
| |
| /*********************************************************************** |
| * break_should_continue |
| * |
| * Determine if we should continue execution after a SIGTRAP signal when |
| * executing in the given mode. |
| */ |
| BOOL break_should_continue(ADDRESS* addr, DWORD code, int* count, BOOL* is_break) |
| { |
| int bpnum; |
| DWORD oldval; |
| int wpnum; |
| enum dbg_exec_mode mode = dbg_curr_thread->exec_mode; |
| |
| *is_break = FALSE; |
| /* If not single-stepping, back up to the break instruction */ |
| if (code == EXCEPTION_BREAKPOINT) |
| addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, TRUE); |
| |
| bpnum = find_xpoint(addr, be_xpoint_break); |
| dbg_curr_process->bp[0].enabled = FALSE; /* disable the step-over breakpoint */ |
| |
| if (bpnum > 0) |
| { |
| if (!should_stop(bpnum)) return TRUE; |
| |
| dbg_printf("Stopped on breakpoint %d at ", bpnum); |
| print_address(&dbg_curr_process->bp[bpnum].addr, TRUE); |
| dbg_printf("\n"); |
| return FALSE; |
| } |
| |
| wpnum = find_triggered_watch(&oldval); |
| if (wpnum > 0) |
| { |
| /* If not single-stepping, do not back up over the break instruction */ |
| if (code == EXCEPTION_BREAKPOINT) |
| addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE); |
| |
| if (!should_stop(wpnum)) return TRUE; |
| |
| dbg_printf("Stopped on watchpoint %d at ", wpnum); |
| print_address(addr, TRUE); |
| dbg_printf(" values: old=%lu new=%lu\n", |
| oldval, dbg_curr_process->bp[wpnum].w.oldval); |
| return FALSE; |
| } |
| |
| /* |
| * If our mode indicates that we are stepping line numbers, |
| * get the current function, and figure out if we are exactly |
| * on a line number or not. |
| */ |
| if (mode == dbg_exec_step_over_line || mode == dbg_exec_step_into_line) |
| { |
| if (symbol_get_function_line_status(addr) == dbg_on_a_line_number) |
| { |
| (*count)--; |
| } |
| } |
| else if (mode == dbg_exec_step_over_insn || mode == dbg_exec_step_into_insn) |
| { |
| (*count)--; |
| } |
| |
| if (*count > 0 || mode == dbg_exec_finish) |
| { |
| /* |
| * We still need to execute more instructions. |
| */ |
| return TRUE; |
| } |
| |
| /* If there's no breakpoint and we are not single-stepping, then |
| * either we must have encountered a break insn in the Windows program |
| * or someone is trying to stop us |
| */ |
| if (bpnum == -1 && code == EXCEPTION_BREAKPOINT) |
| { |
| *is_break = TRUE; |
| addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE); |
| return FALSE; |
| } |
| |
| /* no breakpoint, continue if in continuous mode */ |
| return mode == dbg_exec_cont || mode == dbg_exec_finish; |
| } |
| |
| /*********************************************************************** |
| * break_suspend_execution |
| * |
| * Remove all bp before entering the debug loop |
| */ |
| void break_suspend_execution(void) |
| { |
| break_set_xpoints(FALSE); |
| dbg_curr_process->bp[0] = dbg_curr_thread->step_over_bp; |
| } |
| |
| /*********************************************************************** |
| * break_restart_execution |
| * |
| * Set the bp to the correct state to restart execution |
| * in the given mode. |
| */ |
| void break_restart_execution(int count) |
| { |
| ADDRESS addr; |
| int bp; |
| enum dbg_line_status status; |
| enum dbg_exec_mode mode, ret_mode; |
| ADDRESS callee; |
| void* linear; |
| |
| memory_get_current_pc(&addr); |
| linear = memory_to_linear_addr(&addr); |
| |
| /* |
| * This is the mode we will be running in after we finish. We would like |
| * to be able to modify this in certain cases. |
| */ |
| ret_mode = mode = dbg_curr_thread->exec_mode; |
| |
| bp = find_xpoint(&addr, be_xpoint_break); |
| if (bp != -1 && bp != 0) |
| { |
| /* |
| * If we have set a new value, then save it in the BP number. |
| */ |
| if (count != 0 && mode == dbg_exec_cont) |
| { |
| dbg_curr_process->bp[bp].skipcount = count; |
| } |
| mode = dbg_exec_step_into_insn; /* If there's a breakpoint, skip it */ |
| } |
| else if (mode == dbg_exec_cont && count > 1) |
| { |
| dbg_printf("Not stopped at any breakpoint; argument ignored.\n"); |
| } |
| |
| if (mode == dbg_exec_finish && be_cpu->is_function_return(linear)) |
| { |
| mode = ret_mode = dbg_exec_step_into_insn; |
| } |
| |
| /* |
| * See if the function we are stepping into has debug info |
| * and line numbers. If not, then we step over it instead. |
| * FIXME - we need to check for things like thunks or trampolines, |
| * as the actual function may in fact have debug info. |
| */ |
| if (be_cpu->is_function_call(linear, &callee)) |
| { |
| status = symbol_get_function_line_status(&callee); |
| #if 0 |
| /* FIXME: we need to get the thunk type */ |
| /* |
| * Anytime we have a trampoline, step over it. |
| */ |
| if ((mode == EXEC_STEP_OVER || mode == EXEC_STEPI_OVER) |
| && status == dbg_in_a_thunk) |
| { |
| WINE_WARN("Not stepping into trampoline at %p (no lines)\n", |
| memory_to_linear_addr(&callee)); |
| mode = EXEC_STEP_OVER_TRAMPOLINE; |
| } |
| #endif |
| if (mode == dbg_exec_step_into_line && status == dbg_no_line_info) |
| { |
| WINE_WARN("Not stepping into function at %p (no lines)\n", |
| memory_to_linear_addr(&callee)); |
| mode = dbg_exec_step_over_line; |
| } |
| } |
| |
| if (mode == dbg_exec_step_into_line && |
| symbol_get_function_line_status(&addr) == dbg_no_line_info) |
| { |
| dbg_printf("Single stepping until exit from function, \n" |
| "which has no line number information.\n"); |
| ret_mode = mode = dbg_exec_finish; |
| } |
| |
| switch (mode) |
| { |
| case dbg_exec_cont: /* Continuous execution */ |
| be_cpu->single_step(&dbg_context, FALSE); |
| break_set_xpoints(TRUE); |
| break; |
| |
| #if 0 |
| case EXEC_STEP_OVER_TRAMPOLINE: |
| /* |
| * This is the means by which we step over our conversion stubs |
| * in callfrom*.s and callto*.s. We dig the appropriate address |
| * off the stack, and we set the breakpoint there instead of the |
| * address just after the call. |
| */ |
| be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, |
| be_cpu_addr_stack, &addr); |
| /* FIXME: we assume stack grows as on a i386 */ |
| addr.Offset += 2 * sizeof(unsigned int); |
| dbg_read_memory(memory_to_linear_addr(&addr), |
| &addr.Offset, sizeof(addr.Offset)); |
| dbg_curr_process->bp[0].addr = addr; |
| dbg_curr_process->bp[0].enabled = TRUE; |
| dbg_curr_process->bp[0].refcount = 1; |
| dbg_curr_process->bp[0].skipcount = 0; |
| dbg_curr_process->bp[0].xpoint_type = be_xpoint_break; |
| dbg_curr_process->bp[0].condition = NULL; |
| be_cpu->single_step(&dbg_context, FALSE); |
| break_set_xpoints(TRUE); |
| break; |
| #endif |
| |
| case dbg_exec_finish: |
| case dbg_exec_step_over_insn: /* Stepping over a call */ |
| case dbg_exec_step_over_line: /* Stepping over a call */ |
| if (be_cpu->is_step_over_insn(linear)) |
| { |
| be_cpu->disasm_one_insn(&addr, FALSE); |
| dbg_curr_process->bp[0].addr = addr; |
| dbg_curr_process->bp[0].enabled = TRUE; |
| dbg_curr_process->bp[0].refcount = 1; |
| dbg_curr_process->bp[0].skipcount = 0; |
| dbg_curr_process->bp[0].xpoint_type = be_xpoint_break; |
| dbg_curr_process->bp[0].condition = NULL; |
| be_cpu->single_step(&dbg_context, FALSE); |
| break_set_xpoints(TRUE); |
| break; |
| } |
| /* else fall through to single-stepping */ |
| |
| case dbg_exec_step_into_line: /* Single-stepping a line */ |
| case dbg_exec_step_into_insn: /* Single-stepping an instruction */ |
| be_cpu->single_step(&dbg_context, TRUE); |
| break; |
| default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); |
| } |
| dbg_curr_thread->step_over_bp = dbg_curr_process->bp[0]; |
| dbg_curr_thread->exec_mode = ret_mode; |
| } |
| |
| int break_add_condition(int num, struct expr* exp) |
| { |
| if (num <= 0 || num >= dbg_curr_process->next_bp || |
| !dbg_curr_process->bp[num].refcount) |
| { |
| dbg_printf("Invalid breakpoint number %d\n", num); |
| return FALSE; |
| } |
| |
| if (dbg_curr_process->bp[num].condition != NULL) |
| { |
| expr_free(dbg_curr_process->bp[num].condition); |
| dbg_curr_process->bp[num].condition = NULL; |
| } |
| |
| if (exp != NULL) dbg_curr_process->bp[num].condition = expr_clone(exp, NULL); |
| |
| return TRUE; |
| } |
