This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: RFA: Breakpoint infrastructure cleanups [8/8] - convert remove_breakpoints
- From: Daniel Jacobowitz <drow at mvista dot com>
- To: gdb-patches at sources dot redhat dot com
- Date: Thu, 6 Nov 2003 13:28:38 -0500
- Subject: Re: RFA: Breakpoint infrastructure cleanups [8/8] - convert remove_breakpoints
- References: <20031008172256.GA9771@nevyn.them.org>
On Wed, Oct 08, 2003 at 01:22:56PM -0400, Daniel Jacobowitz wrote:
> This converts remove_breakpoint similarly to insert_breakpoints. It also
> fixes a typo involving overlays and hardware breakpoints (!= vs ==). Other
> than that it's mechanical.
>
> That's it for now. Most of what's left involves the question of how to
> print breakpoints with multiple addresses.
Last one for now. Next step is a branch, later.
--
Daniel Jacobowitz
MontaVista Software Debian GNU/Linux Developer
2003-11-06 Daniel Jacobowitz <drow@mvista.com>
* breakpoint.c (remove_breakpoint): Take an bp_location
instead of a breakpoint argument. Check the bp_location's type.
Fix a reversed condition for hardware breakpoints.
(insert_bp_location): Update call to remove_breakpoint.
(remove_breakpoints): Likewise. Use ALL_BP_LOCATIONS.
(remove_hw_watchpoints): Likewise.
(reattach_breakpoints): Likewise.
(detach_breakpoints): Likewise.
(delete_breakpoint): Likewise.
%patch
Index: gdb/breakpoint.c
===================================================================
--- gdb.orig/breakpoint.c 2003-11-06 11:00:57.000000000 -0500
+++ gdb/breakpoint.c 2003-11-06 11:08:18.000000000 -0500
@@ -128,7 +128,7 @@ typedef enum
}
insertion_state_t;
-static int remove_breakpoint (struct breakpoint *, insertion_state_t);
+static int remove_breakpoint (struct bp_location *, insertion_state_t);
static enum print_stop_action print_it_typical (bpstat);
@@ -976,7 +976,7 @@ insert_bp_location (struct bp_location *
value chain brings us here. */
if (!bpt->inserted)
{
- remove_breakpoint (bpt->owner, mark_uninserted);
+ remove_breakpoint (bpt, mark_uninserted);
*hw_breakpoint_error = 1;
fprintf_unfiltered (tmp_error_stream,
"Could not insert hardware watchpoint %d.\n",
@@ -1150,12 +1150,12 @@ You may have requested too many hardware
int
remove_breakpoints (void)
{
- struct breakpoint *b;
+ struct bp_location *b;
int val;
- ALL_BREAKPOINTS (b)
+ ALL_BP_LOCATIONS (b)
{
- if (b->loc->inserted)
+ if (b->inserted)
{
val = remove_breakpoint (b, mark_uninserted);
if (val != 0)
@@ -1168,15 +1168,12 @@ remove_breakpoints (void)
int
remove_hw_watchpoints (void)
{
- struct breakpoint *b;
+ struct bp_location *b;
int val;
- ALL_BREAKPOINTS (b)
+ ALL_BP_LOCATIONS (b)
{
- if (b->loc->inserted
- && (b->type == bp_hardware_watchpoint
- || b->type == bp_read_watchpoint
- || b->type == bp_access_watchpoint))
+ if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint)
{
val = remove_breakpoint (b, mark_uninserted);
if (val != 0)
@@ -1189,21 +1186,23 @@ remove_hw_watchpoints (void)
int
reattach_breakpoints (int pid)
{
- struct breakpoint *b;
+ struct bp_location *b;
int val;
struct cleanup *old_chain = save_inferior_ptid ();
/* Set inferior_ptid; remove_breakpoint uses this global. */
inferior_ptid = pid_to_ptid (pid);
- ALL_BREAKPOINTS (b)
+ ALL_BP_LOCATIONS (b)
{
- if (b->loc->inserted)
+ if (b->inserted)
{
remove_breakpoint (b, mark_inserted);
- if (b->type == bp_hardware_breakpoint)
- val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
+ if (b->loc_type == bp_loc_hardware_breakpoint)
+ val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
else
- val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
+ val = target_insert_breakpoint (b->address, b->shadow_contents);
+ /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
+ breakpoints. It's wrong for watchpoints, for example. */
if (val != 0)
{
do_cleanups (old_chain);
@@ -1352,7 +1351,7 @@ update_breakpoints_after_exec (void)
int
detach_breakpoints (int pid)
{
- struct breakpoint *b;
+ struct bp_location *b;
int val;
struct cleanup *old_chain = save_inferior_ptid ();
@@ -1361,9 +1360,9 @@ detach_breakpoints (int pid)
/* Set inferior_ptid; remove_breakpoint uses this global. */
inferior_ptid = pid_to_ptid (pid);
- ALL_BREAKPOINTS (b)
+ ALL_BP_LOCATIONS (b)
{
- if (b->loc->inserted)
+ if (b->inserted)
{
val = remove_breakpoint (b, mark_inserted);
if (val != 0)
@@ -1378,27 +1377,20 @@ detach_breakpoints (int pid)
}
static int
-remove_breakpoint (struct breakpoint *b, insertion_state_t is)
+remove_breakpoint (struct bp_location *b, insertion_state_t is)
{
int val;
- if (b->enable_state == bp_permanent)
+ if (b->owner->enable_state == bp_permanent)
/* Permanent breakpoints cannot be inserted or removed. */
return 0;
- if (b->type == bp_none)
+ if (b->owner->type == bp_none)
warning ("attempted to remove apparently deleted breakpoint #%d?",
- b->number);
+ b->owner->number);
- if (b->type != bp_watchpoint
- && b->type != bp_hardware_watchpoint
- && b->type != bp_read_watchpoint
- && b->type != bp_access_watchpoint
- && b->type != bp_catch_fork
- && b->type != bp_catch_vfork
- && b->type != bp_catch_exec
- && b->type != bp_catch_catch
- && b->type != bp_catch_throw)
+ if (b->loc_type == bp_loc_software_breakpoint
+ || b->loc_type == bp_loc_hardware_breakpoint)
{
/* "Normal" instruction breakpoint: either the standard
trap-instruction bp (bp_breakpoint), or a
@@ -1406,16 +1398,16 @@ remove_breakpoint (struct breakpoint *b,
/* First check to see if we have to handle an overlay. */
if (overlay_debugging == ovly_off
- || b->loc->section == NULL
- || !(section_is_overlay (b->loc->section)))
+ || b->section == NULL
+ || !(section_is_overlay (b->section)))
{
/* No overlay handling: just remove the breakpoint. */
- if (b->type == bp_hardware_breakpoint)
- val = target_remove_hw_breakpoint (b->loc->address,
- b->loc->shadow_contents);
+ if (b->loc_type == bp_loc_hardware_breakpoint)
+ val = target_remove_hw_breakpoint (b->address,
+ b->shadow_contents);
else
- val = target_remove_breakpoint (b->loc->address, b->loc->shadow_contents);
+ val = target_remove_breakpoint (b->address, b->shadow_contents);
}
else
{
@@ -1426,29 +1418,29 @@ remove_breakpoint (struct breakpoint *b,
/* Yes -- overlay event support is not active, so we
should have set a breakpoint at the LMA. Remove it.
*/
- CORE_ADDR addr = overlay_unmapped_address (b->loc->address,
- b->loc->section);
+ CORE_ADDR addr = overlay_unmapped_address (b->address,
+ b->section);
/* Ignore any failures: if the LMA is in ROM, we will
have already warned when we failed to insert it. */
- if (b->type != bp_hardware_breakpoint)
- target_remove_hw_breakpoint (addr, b->loc->shadow_contents);
+ if (b->loc_type == bp_loc_hardware_breakpoint)
+ target_remove_hw_breakpoint (addr, b->shadow_contents);
else
- target_remove_breakpoint (addr, b->loc->shadow_contents);
+ target_remove_breakpoint (addr, b->shadow_contents);
}
/* Did we set a breakpoint at the VMA?
If so, we will have marked the breakpoint 'inserted'. */
- if (b->loc->inserted)
+ if (b->inserted)
{
/* Yes -- remove it. Previously we did not bother to
remove the breakpoint if the section had been
unmapped, but let's not rely on that being safe. We
don't know what the overlay manager might do. */
- if (b->type == bp_hardware_breakpoint)
- val = target_remove_hw_breakpoint (b->loc->address,
- b->loc->shadow_contents);
+ if (b->loc_type == bp_loc_hardware_breakpoint)
+ val = target_remove_hw_breakpoint (b->address,
+ b->shadow_contents);
else
- val = target_remove_breakpoint (b->loc->address,
- b->loc->shadow_contents);
+ val = target_remove_breakpoint (b->address,
+ b->shadow_contents);
}
else
{
@@ -1458,20 +1450,18 @@ remove_breakpoint (struct breakpoint *b,
}
if (val)
return val;
- b->loc->inserted = (is == mark_inserted);
+ b->inserted = (is == mark_inserted);
}
- else if ((b->type == bp_hardware_watchpoint ||
- b->type == bp_read_watchpoint ||
- b->type == bp_access_watchpoint)
- && b->enable_state == bp_enabled
- && !b->loc->duplicate)
+ else if (b->loc_type == bp_loc_hardware_watchpoint
+ && b->owner->enable_state == bp_enabled
+ && !b->duplicate)
{
struct value *v;
struct value *n;
- b->loc->inserted = (is == mark_inserted);
+ b->inserted = (is == mark_inserted);
/* Walk down the saved value chain. */
- for (v = b->val_chain; v; v = v->next)
+ for (v = b->owner->val_chain; v; v = v->next)
{
/* For each memory reference remove the watchpoint
at that address. */
@@ -1480,7 +1470,7 @@ remove_breakpoint (struct breakpoint *b,
{
struct type *vtype = check_typedef (VALUE_TYPE (v));
- if (v == b->val_chain
+ if (v == b->owner->val_chain
|| (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
&& TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
{
@@ -1490,40 +1480,40 @@ remove_breakpoint (struct breakpoint *b,
addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
len = TYPE_LENGTH (VALUE_TYPE (v));
type = hw_write;
- if (b->type == bp_read_watchpoint)
+ if (b->owner->type == bp_read_watchpoint)
type = hw_read;
- else if (b->type == bp_access_watchpoint)
+ else if (b->owner->type == bp_access_watchpoint)
type = hw_access;
val = target_remove_watchpoint (addr, len, type);
if (val == -1)
- b->loc->inserted = 1;
+ b->inserted = 1;
val = 0;
}
}
}
/* Failure to remove any of the hardware watchpoints comes here. */
- if ((is == mark_uninserted) && (b->loc->inserted))
+ if ((is == mark_uninserted) && (b->inserted))
warning ("Could not remove hardware watchpoint %d.",
- b->number);
+ b->owner->number);
/* Free the saved value chain. We will construct a new one
the next time the watchpoint is inserted. */
- for (v = b->val_chain; v; v = n)
+ for (v = b->owner->val_chain; v; v = n)
{
n = v->next;
value_free (v);
}
- b->val_chain = NULL;
+ b->owner->val_chain = NULL;
}
- else if ((b->type == bp_catch_fork ||
- b->type == bp_catch_vfork ||
- b->type == bp_catch_exec)
- && b->enable_state == bp_enabled
- && !b->loc->duplicate)
+ else if ((b->owner->type == bp_catch_fork ||
+ b->owner->type == bp_catch_vfork ||
+ b->owner->type == bp_catch_exec)
+ && b->owner->enable_state == bp_enabled
+ && !b->duplicate)
{
val = -1;
- switch (b->type)
+ switch (b->owner->type)
{
case bp_catch_fork:
val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
@@ -1540,30 +1530,30 @@ remove_breakpoint (struct breakpoint *b,
}
if (val)
return val;
- b->loc->inserted = (is == mark_inserted);
+ b->inserted = (is == mark_inserted);
}
- else if ((b->type == bp_catch_catch ||
- b->type == bp_catch_throw)
- && b->enable_state == bp_enabled
- && !b->loc->duplicate)
+ else if ((b->owner->type == bp_catch_catch ||
+ b->owner->type == bp_catch_throw)
+ && b->owner->enable_state == bp_enabled
+ && !b->duplicate)
{
- val = target_remove_breakpoint (b->loc->address, b->loc->shadow_contents);
+ val = target_remove_breakpoint (b->address, b->shadow_contents);
if (val)
return val;
- b->loc->inserted = (is == mark_inserted);
+ b->inserted = (is == mark_inserted);
}
- else if (ep_is_exception_catchpoint (b)
- && b->loc->inserted /* sometimes previous insert doesn't happen */
- && b->enable_state == bp_enabled
- && !b->loc->duplicate)
+ else if (ep_is_exception_catchpoint (b->owner)
+ && b->inserted /* sometimes previous insert doesn't happen */
+ && b->owner->enable_state == bp_enabled
+ && !b->duplicate)
{
- val = target_remove_breakpoint (b->loc->address, b->loc->shadow_contents);
+ val = target_remove_breakpoint (b->address, b->shadow_contents);
if (val)
return val;
- b->loc->inserted = (is == mark_inserted);
+ b->inserted = (is == mark_inserted);
}
return 0;
@@ -6708,7 +6698,7 @@ delete_breakpoint (struct breakpoint *bp
breakpoint_delete_event (bpt->number);
if (bpt->loc->inserted)
- remove_breakpoint (bpt, mark_inserted);
+ remove_breakpoint (bpt->loc, mark_inserted);
if (breakpoint_chain == bpt)
breakpoint_chain = bpt->next;
%diffstat
breakpoint.c | 162 +++++++++++++++++++++++++++--------------------------------
1 files changed, 76 insertions(+), 86 deletions(-)