[5/6] breakpoints_ops for all kinds of breakpoints: new watchpoints instance type

Pedro Alves
2011-07-22T15:45:50Z

Move the watchpoints-only fields in struct breakpoint
to a new struct watchpoint, as a subclass of struct breakpoint,
to go with the move of watchpoints to breakpoint_ops done a
while ago.

--
Pedro Alves

2011-07-22 Pedro Alves <pedro@codesourcery.com>

gdb/
* breakpoint.h (struct breakpoint): Move ops as first field. Move
exp_string, exp_string_reparse, exp, exp_valid_block, cond_exp,
cond_exp_valid_block, val, val_valid, watchpoint_frame,
watchpoint_thread, watchpoint_triggered ...
(struct watchpoint): ... to this new struct.
(is_watchpoint): Declare.
(install_breakpoint): Add new `internal' parameter.
* breakpoint.c (is_watchpoint): Delete declaration.
(set_breakpoint_condition): Handle watchpoints.
(is_watchpoint): Make public.
(watchpoint_in_thread_scope): Change parameter type to struct
watchpoint.
(watchpoint_del_at_next_stop): Change parameter type to struct
watchpoint. Remove assertion. Adjust.
(update_watchpoint): Ditto.
(insert_breakpoints, breakpoint_init_inferior)
(watchpoints_triggered, watchpoint_check)
(bpstat_check_watchpoint, bpstat_check_breakpoint_conditions)
(bpstat_stop_status, print_one_breakpoint_location)
(print_one_breakpoint_location, watchpoint_locations_match): Cast
to struct watchpoint as necessary, and adjust.
(install_breakpoint): Add `internal' argument. If true, don't
mention the new breakpoint. Use set_breakpoint_number.
(create_fork_vfork_event_catchpoint)
(create_syscall_event_catchpoint): Adjust.
(dtor_watchpoint): New.
(re_set_watchpoint, insert_watchpoint, remove_watchpoint)
(breakpoint_hit_watchpoint, resources_needed_watchpoint)
(print_it_watchpoint, print_mention_watchpoint)
(print_recreate_watchpoint, insert_masked_watchpoint)
(remove_masked_watchpoint, resources_needed_masked_watchpoint)
(print_one_detail_masked_watchpoint)
(print_mention_masked_watchpoint)
(print_recreate_masked_watchpoint): Cast to struct watchpoint as
necessary, and adjust.
(watch_command_1): Allocate and initialize a struct watchpoint
instead of a struct breakpoint. Use install_breakpoint.
(catch_exec_command_1): Adjust.
(base_breakpoint_dtor): Delete accesses to watchpoint specific
fields.
(delete_breakpoint, enable_breakpoint_disp)
(invalidate_bp_value_on_memory_change): Cast to struct watchpoint
as necessary, and adjust.
(initialize_breakpoint_ops): Install dtor_watchpoint as
watchpoints' dtor method.
* ada-lang.c (create_ada_exception_catchpoint): Adjust.
* python/py-breakpoint.c (bppy_get_expression): Use is_watchpoint.
to struct watchpoint as necessary, and adjust.

---
gdb/ada-lang.c | 2
gdb/breakpoint.c | 495 ++++++++++++++++++++++++++-------------------
gdb/breakpoint.h | 112 ++++++----
gdb/python/py-breakpoint.c | 10
4 files changed, 366 insertions(+), 253 deletions(-)

Index: src/gdb/breakpoint.h
===================================================================
--- src.orig/gdb/breakpoint.h 2011-07-22 15:37:15.163688209 +0100
+++ src/gdb/breakpoint.h 2011-07-22 15:37:55.003688216 +0100
@@ -519,10 +519,13 @@ extern int target_exact_watchpoints;
useful for a hack I had to put in; I'm going to leave it in because
I can see how there might be times when it would indeed be useful */

-/* This is for a breakpoint or a watchpoint. */
+/* This is for all kinds of breakpoints. */

struct breakpoint
{
+ /* Methods associated with this breakpoint. */
+ struct breakpoint_ops *ops;
+
struct breakpoint *next;
/* Type of breakpoint. */
enum bptype type;
@@ -580,27 +583,6 @@ struct breakpoint
char *cond_string;
/* String form of exp to use for displaying to the user
(malloc'd), or NULL if none. */
- char *exp_string;
- /* String form to use for reparsing of EXP (malloc'd) or NULL. */
- char *exp_string_reparse;
-
- /* The expression we are watching, or NULL if not a watchpoint. */
- struct expression *exp;
- /* The largest block within which it is valid, or NULL if it is
- valid anywhere (e.g. consists just of global symbols). */
- struct block *exp_valid_block;
- /* The conditional expression if any. NULL if not a watchpoint. */
- struct expression *cond_exp;
- /* The largest block within which it is valid, or NULL if it is
- valid anywhere (e.g. consists just of global symbols). */
- struct block *cond_exp_valid_block;
- /* Value of the watchpoint the last time we checked it, or NULL
- when we do not know the value yet or the value was not
- readable. VAL is never lazy. */
- struct value *val;
- /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL,
- then an error occurred reading the value. */
- int val_valid;

/* Holds the address of the related watchpoint_scope breakpoint
when using watchpoints on local variables (might the concept of
@@ -609,20 +591,6 @@ struct breakpoint
FIXME). */
struct breakpoint *related_breakpoint;

- /* Holds the frame address which identifies the frame this
- watchpoint should be evaluated in, or `null' if the watchpoint
- should be evaluated on the outermost frame. */
- struct frame_id watchpoint_frame;
-
- /* Holds the thread which identifies the frame this watchpoint
- should be considered in scope for, or `null_ptid' if the
- watchpoint should be evaluated in all threads. */
- ptid_t watchpoint_thread;
-
- /* For hardware watchpoints, the triggered status according to the
- hardware. */
- enum watchpoint_triggered watchpoint_triggered;
-
/* Thread number for thread-specific breakpoint,
or -1 if don't care. */
int thread;
@@ -637,9 +605,6 @@ struct breakpoint
aborting, so you can back up to just before the abort. */
int hit_count;

- /* Methods associated with this breakpoint. */
- struct breakpoint_ops *ops;
-
/* Is breakpoint's condition not yet parsed because we found
no location initially so had no context to parse
the condition in. */
@@ -674,13 +639,66 @@ struct breakpoint
can sometimes be NULL for enabled GDBs as not all breakpoint
types are tracked by the Python scripting API. */
struct breakpoint_object *py_bp_object;
+ };

- /* Whether this watchpoint is exact (see target_exact_watchpoints). */
- int exact;
+/* An instance of this type is used to represent a watchpoint. It
+ includes a "struct breakpoint" as a kind of base class; users
+ downcast to "struct breakpoint *" when needed. */
+
+struct watchpoint
+{
+ /* The base class. */
+ struct breakpoint base;
+
+ /* String form of exp to use for displaying to the user (malloc'd),
+ or NULL if none. */
+ char *exp_string;
+ /* String form to use for reparsing of EXP (malloc'd) or NULL. */
+ char *exp_string_reparse;
+
+ /* The expression we are watching, or NULL if not a watchpoint. */
+ struct expression *exp;
+ /* The largest block within which it is valid, or NULL if it is
+ valid anywhere (e.g. consists just of global symbols). */
+ struct block *exp_valid_block;
+ /* The conditional expression if any. */
+ struct expression *cond_exp;
+ /* The largest block within which it is valid, or NULL if it is
+ valid anywhere (e.g. consists just of global symbols). */
+ struct block *cond_exp_valid_block;
+ /* Value of the watchpoint the last time we checked it, or NULL when
+ we do not know the value yet or the value was not readable. VAL
+ is never lazy. */
+ struct value *val;
+ /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL,
+ then an error occurred reading the value. */
+ int val_valid;
+
+ /* Holds the frame address which identifies the frame this
+ watchpoint should be evaluated in, or `null' if the watchpoint
+ should be evaluated on the outermost frame. */
+ struct frame_id watchpoint_frame;
+
+ /* Holds the thread which identifies the frame this watchpoint
+ should be considered in scope for, or `null_ptid' if the
+ watchpoint should be evaluated in all threads. */
+ ptid_t watchpoint_thread;
+
+ /* For hardware watchpoints, the triggered status according to the
+ hardware. */
+ enum watchpoint_triggered watchpoint_triggered;
+
+ /* Whether this watchpoint is exact (see
+ target_exact_watchpoints). */
+ int exact;
+
+ /* The mask address for a masked hardware watchpoint. */
+ CORE_ADDR hw_wp_mask;
+};

- /* The mask address for a masked hardware watchpoint. */
- CORE_ADDR hw_wp_mask;
- };
+/* Returns true if BPT is really a watchpoint. */
+
+extern int is_watchpoint (const struct breakpoint *bpt);

typedef struct breakpoint *breakpoint_p;
DEF_VEC_P(breakpoint_p);
@@ -1062,9 +1080,11 @@ extern void
int from_tty);

/* Add breakpoint B on the breakpoint list, and notify the user, the
- target and breakpoint_created observers of its existence. */
+ target and breakpoint_created observers of its existence. If
+ INTERNAL is non-zero, the breakpoint number will be allocated from
+ the internal breakpoint count. */

-extern void install_breakpoint (struct breakpoint *b);
+extern void install_breakpoint (int internal, struct breakpoint *b);

extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
char *cond_string, int thread,
Index: src/gdb/breakpoint.c
===================================================================
--- src.orig/gdb/breakpoint.c 2011-07-22 15:37:15.163688209 +0100
+++ src/gdb/breakpoint.c 2011-07-22 15:37:16.293688209 +0100
@@ -213,8 +213,6 @@ static void update_global_location_list_

static int is_hardware_watchpoint (const struct breakpoint *bpt);

-static int is_watchpoint (const struct breakpoint *bpt);
-
static void insert_breakpoint_locations (void);

static int syscall_catchpoint_p (struct breakpoint *b);
@@ -604,17 +602,26 @@ void
set_breakpoint_condition (struct breakpoint *b, char *exp,
int from_tty)
{
- struct bp_location *loc = b->loc;
+ xfree (b->cond_string);
+ b->cond_string = NULL;

- for (; loc; loc = loc->next)
+ if (is_watchpoint (b))
{
- xfree (loc->cond);
- loc->cond = NULL;
+ struct watchpoint *w = (struct watchpoint *) b;
+
+ xfree (w->cond_exp);
+ w->cond_exp = NULL;
+ }
+ else
+ {
+ struct bp_location *loc;
+
+ for (loc = b->loc; loc; loc = loc->next)
+ {
+ xfree (loc->cond);
+ loc->cond = NULL;
+ }
}
- xfree (b->cond_string);
- b->cond_string = NULL;
- xfree (b->cond_exp);
- b->cond_exp = NULL;

if (*exp == 0)
{
@@ -632,15 +639,19 @@ set_breakpoint_condition (struct breakpo

if (is_watchpoint (b))
{
+ struct watchpoint *w = (struct watchpoint *) b;
+
innermost_block = NULL;
arg = exp;
- b->cond_exp = parse_exp_1 (&arg, 0, 0);
+ w->cond_exp = parse_exp_1 (&arg, 0, 0);
if (*arg)
error (_("Junk at end of expression"));
- b->cond_exp_valid_block = innermost_block;
+ w->cond_exp_valid_block = innermost_block;
}
else
{
+ struct bp_location *loc;
+
for (loc = b->loc; loc; loc = loc->next)
{
arg = exp;
@@ -1164,25 +1175,24 @@ is_hardware_watchpoint (const struct bre
/* Return true if BPT is of any watchpoint kind, hardware or
software. */

-static int
+int
is_watchpoint (const struct breakpoint *bpt)
{
return (is_hardware_watchpoint (bpt)
|| bpt->type == bp_watchpoint);
}

-/* Assuming that B is a watchpoint: returns true if the current thread
- and its running state are safe to evaluate or update watchpoint B.
- Watchpoints on local expressions need to be evaluated in the
- context of the thread that was current when the watchpoint was
- created, and, that thread needs to be stopped to be able to select
- the correct frame context. Watchpoints on global expressions can
- be evaluated on any thread, and in any state. It is presently left
- to the target allowing memory accesses when threads are
- running. */
+/* Returns true if the current thread and its running state are safe
+ to evaluate or update watchpoint B. Watchpoints on local
+ expressions need to be evaluated in the context of the thread that
+ was current when the watchpoint was created, and, that thread needs
+ to be stopped to be able to select the correct frame context.
+ Watchpoints on global expressions can be evaluated on any thread,
+ and in any state. It is presently left to the target allowing
+ memory accesses when threads are running. */

static int
-watchpoint_in_thread_scope (struct breakpoint *b)
+watchpoint_in_thread_scope (struct watchpoint *b)
{
return (ptid_equal (b->watchpoint_thread, null_ptid)
|| (ptid_equal (inferior_ptid, b->watchpoint_thread)
@@ -1193,9 +1203,9 @@ watchpoint_in_thread_scope (struct break
associated bp_watchpoint_scope breakpoint. */

static void
-watchpoint_del_at_next_stop (struct breakpoint *b)
+watchpoint_del_at_next_stop (struct watchpoint *w)
{
- gdb_assert (is_watchpoint (b));
+ struct breakpoint *b = &w->base;

if (b->related_breakpoint != b)
{
@@ -1261,21 +1271,19 @@ watchpoint_del_at_next_stop (struct brea
watchpoint removal from inferior. */

static void
-update_watchpoint (struct breakpoint *b, int reparse)
+update_watchpoint (struct watchpoint *b, int reparse)
{
int within_current_scope;
struct frame_id saved_frame_id;
int frame_saved;

- gdb_assert (is_watchpoint (b));
-
/* If this is a local watchpoint, we only want to check if the
watchpoint frame is in scope if the current thread is the thread
that was used to create the watchpoint. */
if (!watchpoint_in_thread_scope (b))
return;

- if (b->disposition == disp_del_at_next_stop)
+ if (b->base.disposition == disp_del_at_next_stop)
return;

frame_saved = 0;
@@ -1312,7 +1320,7 @@ update_watchpoint (struct breakpoint *b,
/* We don't free locations. They are stored in the bp_location array
and update_global_location_list will eventually delete them and
remove breakpoints if needed. */
- b->loc = NULL;
+ b->base.loc = NULL;

if (within_current_scope && reparse)
{
@@ -1336,7 +1344,7 @@ update_watchpoint (struct breakpoint *b,
/* Note that unlike with breakpoints, the watchpoint's condition
expression is stored in the breakpoint object, not in the
locations (re)created below. */
- if (b->cond_string != NULL)
+ if (b->base.cond_string != NULL)
{
if (b->cond_exp != NULL)
{
@@ -1344,7 +1352,7 @@ update_watchpoint (struct breakpoint *b,
b->cond_exp = NULL;
}

- s = b->cond_string;
+ s = b->base.cond_string;
b->cond_exp = parse_exp_1 (&s, b->cond_exp_valid_block, 0);
}
}
@@ -1374,7 +1382,7 @@ update_watchpoint (struct breakpoint *b,
happens, the code that reports it updates b->val directly.
We don't keep track of the memory value for masked
watchpoints. */
- if (!b->val_valid && !is_masked_watchpoint (b))
+ if (!b->val_valid && !is_masked_watchpoint (&b->base))
{
b->val = v;
b->val_valid = 1;
@@ -1409,13 +1417,13 @@ update_watchpoint (struct breakpoint *b,
addr = value_address (v);
len = TYPE_LENGTH (value_type (v));
type = hw_write;
- if (b->type == bp_read_watchpoint)
+ if (b->base.type == bp_read_watchpoint)
type = hw_read;
- else if (b->type == bp_access_watchpoint)
+ else if (b->base.type == bp_access_watchpoint)
type = hw_access;
-
- loc = allocate_bp_location (b);
- for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
+
+ loc = allocate_bp_location (&b->base);
+ for (tmp = &(b->base.loc); *tmp != NULL; tmp = &((*tmp)->next))
;
*tmp = loc;
loc->gdbarch = get_type_arch (value_type (v));
@@ -1455,15 +1463,15 @@ update_watchpoint (struct breakpoint *b,
hw_watchpoint_used_count call below counts this
watchpoint, make sure that it is marked as a hardware
watchpoint. */
- if (b->type == bp_watchpoint)
- b->type = bp_hardware_watchpoint;
+ if (b->base.type == bp_watchpoint)
+ b->base.type = bp_hardware_watchpoint;

- i = hw_watchpoint_used_count (b->type, &other_type_used);
+ i = hw_watchpoint_used_count (b->base.type, &other_type_used);
target_resources_ok = target_can_use_hardware_watchpoint
- (b->type, i, other_type_used);
+ (b->base.type, i, other_type_used);
if (target_resources_ok <= 0)
{
- int sw_mode = b->ops->works_in_software_mode (b);
+ int sw_mode = b->base.ops->works_in_software_mode (&b->base);

if (target_resources_ok == 0 && !sw_mode)
error (_("Target does not support this type of "
@@ -1472,18 +1480,18 @@ update_watchpoint (struct breakpoint *b,
error (_("There are not enough available hardware "
"resources for this watchpoint."));
else
- b->type = bp_watchpoint;
+ b->base.type = bp_watchpoint;
}
}
- else if (!b->ops->works_in_software_mode (b))
+ else if (!b->base.ops->works_in_software_mode (&b->base))
error (_("Expression cannot be implemented with "
"read/access watchpoint."));
else
- b->type = bp_watchpoint;
+ b->base.type = bp_watchpoint;

- loc_type = (b->type == bp_watchpoint? bp_loc_other
+ loc_type = (b->base.type == bp_watchpoint? bp_loc_other
: bp_loc_hardware_watchpoint);
- for (bl = b->loc; bl; bl = bl->next)
+ for (bl = b->base.loc; bl; bl = bl->next)
bl->loc_type = loc_type;
}

@@ -1498,13 +1506,14 @@ update_watchpoint (struct breakpoint *b,
above left it without any location set up. But,
bpstat_stop_status requires a location to be able to report
stops, so make sure there's at least a dummy one. */
- if (b->type == bp_watchpoint && b->loc == NULL)
+ if (b->base.type == bp_watchpoint && b->base.loc == NULL)
{
- b->loc = allocate_bp_location (b);
- b->loc->pspace = frame_pspace;
- b->loc->address = -1;
- b->loc->length = -1;
- b->loc->watchpoint_type = -1;
+ struct breakpoint *base = &b->base;
+ base->loc = allocate_bp_location (base);
+ base->loc->pspace = frame_pspace;
+ base->loc->address = -1;
+ base->loc->length = -1;
+ base->loc->watchpoint_type = -1;
}
}
else if (!within_current_scope)
@@ -1512,7 +1521,7 @@ update_watchpoint (struct breakpoint *b,
printf_filtered (_("\
Watchpoint %d deleted because the program has left the block\n\
in which its expression is valid.\n"),
- b->number);
+ b->base.number);
watchpoint_del_at_next_stop (b);
}

@@ -1871,7 +1880,11 @@ insert_breakpoints (void)

ALL_BREAKPOINTS (bpt)
if (is_hardware_watchpoint (bpt))
- update_watchpoint (bpt, 0 /* don't reparse. */);
+ {
+ struct watchpoint *w = (struct watchpoint *) bpt;
+
+ update_watchpoint (w, 0 /* don't reparse. */);
+ }

update_global_location_list (1);

@@ -2762,19 +2775,22 @@ breakpoint_init_inferior (enum inf_conte
case bp_hardware_watchpoint:
case bp_read_watchpoint:
case bp_access_watchpoint:
+ {
+ struct watchpoint *w = (struct watchpoint *) b;

- /* Likewise for watchpoints on local expressions. */
- if (b->exp_valid_block != NULL)
- delete_breakpoint (b);
- else if (context == inf_starting)
- {
- /* Reset val field to force reread of starting value in
- insert_breakpoints. */
- if (b->val)
- value_free (b->val);
- b->val = NULL;
- b->val_valid = 0;
+ /* Likewise for watchpoints on local expressions. */
+ if (w->exp_valid_block != NULL)
+ delete_breakpoint (b);
+ else if (context == inf_starting)
+ {
+ /* Reset val field to force reread of starting value in
+ insert_breakpoints. */
+ if (w->val)
+ value_free (w->val);
+ w->val = NULL;
+ w->val_valid = 0;
}
+ }
break;
default:
break;
@@ -3455,7 +3471,11 @@ watchpoints_triggered (struct target_wai
as not triggered. */
ALL_BREAKPOINTS (b)
if (is_hardware_watchpoint (b))
- b->watchpoint_triggered = watch_triggered_no;
+ {
+ struct watchpoint *w = (struct watchpoint *) b;
+
+ w->watchpoint_triggered = watch_triggered_no;
+ }

return 0;
}
@@ -3466,7 +3486,11 @@ watchpoints_triggered (struct target_wai
Mark all watchpoints as unknown. */
ALL_BREAKPOINTS (b)
if (is_hardware_watchpoint (b))
- b->watchpoint_triggered = watch_triggered_unknown;
+ {
+ struct watchpoint *w = (struct watchpoint *) b;
+
+ w->watchpoint_triggered = watch_triggered_unknown;
+ }

return stopped_by_watchpoint;
}
@@ -3478,19 +3502,20 @@ watchpoints_triggered (struct target_wai
ALL_BREAKPOINTS (b)
if (is_hardware_watchpoint (b))
{
+ struct watchpoint *w = (struct watchpoint *) b;
struct bp_location *loc;

- b->watchpoint_triggered = watch_triggered_no;
+ w->watchpoint_triggered = watch_triggered_no;
for (loc = b->loc; loc; loc = loc->next)
{
- if (is_masked_watchpoint (loc->owner))
+ if (is_masked_watchpoint (b))
{
- CORE_ADDR newaddr = addr & loc->owner->hw_wp_mask;
- CORE_ADDR start = loc->address & loc->owner->hw_wp_mask;
+ CORE_ADDR newaddr = addr & w->hw_wp_mask;
+ CORE_ADDR start = loc->address & w->hw_wp_mask;

if (newaddr == start)
{
- b->watchpoint_triggered = watch_triggered_yes;
+ w->watchpoint_triggered = watch_triggered_yes;
break;
}
}
@@ -3499,7 +3524,7 @@ watchpoints_triggered (struct target_wai
addr, loc->address,
loc->length))
{
- b->watchpoint_triggered = watch_triggered_yes;
+ w->watchpoint_triggered = watch_triggered_yes;
break;
}
}
@@ -3532,15 +3557,13 @@ static int
watchpoint_check (void *p)
{
bpstat bs = (bpstat) p;
- struct breakpoint *b;
+ struct watchpoint *b;
struct frame_info *fr;
int within_current_scope;

/* BS is built from an existing struct breakpoint. */
gdb_assert (bs->breakpoint_at != NULL);
- b = bs->breakpoint_at;
-
- gdb_assert (is_watchpoint (b));
+ b = (struct watchpoint *) bs->breakpoint_at;

/* If this is a local watchpoint, we only want to check if the
watchpoint frame is in scope if the current thread is the thread
@@ -3602,7 +3625,7 @@ watchpoint_check (void *p)
struct value *mark;
struct value *new_val;

- if (is_masked_watchpoint (b))
+ if (is_masked_watchpoint (&b->base))
/* Since we don't know the exact trigger address (from
stopped_data_address), just tell the user we've triggered
a mask watchpoint. */
@@ -3654,13 +3677,13 @@ watchpoint_check (void *p)
ui_out_field_string
(uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
ui_out_text (uiout, "\nWatchpoint ");
- ui_out_field_int (uiout, "wpnum", b->number);
+ ui_out_field_int (uiout, "wpnum", b->base.number);
ui_out_text (uiout,
" deleted because the program has left the block in\n\
which its expression is valid.\n");

/* Make sure the watchpoint's commands aren't executed. */
- decref_counted_command_line (&b->commands);
+ decref_counted_command_line (&b->base.commands);
watchpoint_del_at_next_stop (b);

return WP_DELETED;
@@ -3683,26 +3706,25 @@ bpstat_check_location (const struct bp_l
return b->ops->breakpoint_hit (bl, aspace, bp_addr);
}

-/* If BS refers to a watchpoint, determine if the watched values
- has actually changed, and we should stop. If not, set BS->stop
- to 0. */
+/* Determine if the watched values have actually changed, and we
+ should stop. If not, set BS->stop to 0. */
+
static void
bpstat_check_watchpoint (bpstat bs)
{
const struct bp_location *bl;
- struct breakpoint *b;
+ struct watchpoint *b;

/* BS is built for existing struct breakpoint. */
bl = bs->bp_location_at;
gdb_assert (bl != NULL);
- b = bs->breakpoint_at;
+ b = (struct watchpoint *) bs->breakpoint_at;
gdb_assert (b != NULL);

- if (is_watchpoint (b))
{
int must_check_value = 0;

- if (b->type == bp_watchpoint)
+ if (b->base.type == bp_watchpoint)
/* For a software watchpoint, we must always check the
watched value. */
must_check_value = 1;
@@ -3712,18 +3734,18 @@ bpstat_check_watchpoint (bpstat bs)
this watchpoint. */
must_check_value = 1;
else if (b->watchpoint_triggered == watch_triggered_unknown
- && b->type == bp_hardware_watchpoint)
+ && b->base.type == bp_hardware_watchpoint)
/* We were stopped by a hardware watchpoint, but the target could
not report the data address. We must check the watchpoint's
value. Access and read watchpoints are out of luck; without
a data address, we can't figure it out. */
must_check_value = 1;
-
+
if (must_check_value)
{
char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
- b->number);
+ b->base.number);
struct cleanup *cleanups = make_cleanup (xfree, message);
int e = catch_errors (watchpoint_check, bs, message,
RETURN_MASK_ALL);
@@ -3740,7 +3762,7 @@ bpstat_check_watchpoint (bpstat bs)
bs->stop = 0;
break;
case WP_VALUE_CHANGED:
- if (b->type == bp_read_watchpoint)
+ if (b->base.type == bp_read_watchpoint)
{
/* There are two cases to consider here:

@@ -3783,13 +3805,18 @@ bpstat_check_watchpoint (bpstat bs)
struct breakpoint *other_b;

ALL_BREAKPOINTS (other_b)
- if ((other_b->type == bp_hardware_watchpoint
- || other_b->type == bp_access_watchpoint)
- && (other_b->watchpoint_triggered
- == watch_triggered_yes))
+ if (other_b->type == bp_hardware_watchpoint
+ || other_b->type == bp_access_watchpoint)
{
- other_write_watchpoint = 1;
- break;
+ struct watchpoint *other_w =
+ (struct watchpoint *) other_b;
+
+ if (other_w->watchpoint_triggered
+ == watch_triggered_yes)
+ {
+ other_write_watchpoint = 1;
+ break;
+ }
}
}

@@ -3806,8 +3833,8 @@ bpstat_check_watchpoint (bpstat bs)
}
break;
case WP_VALUE_NOT_CHANGED:
- if (b->type == bp_hardware_watchpoint
- || b->type == bp_watchpoint)
+ if (b->base.type == bp_hardware_watchpoint
+ || b->base.type == bp_watchpoint)
{
/* Don't stop: write watchpoints shouldn't fire if
the value hasn't changed. */
@@ -3820,7 +3847,7 @@ bpstat_check_watchpoint (bpstat bs)
/* Can't happen. */
case 0:
/* Error from catch_errors. */
- printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
+ printf_filtered (_("Watchpoint %d deleted.\n"), b->base.number);
watchpoint_del_at_next_stop (b);
/* We've already printed what needs to be printed. */
bs->print_it = print_it_done;
@@ -3871,13 +3898,18 @@ bpstat_check_breakpoint_conditions (bpst
bs->stop = gdbpy_should_stop (b->py_bp_object);

if (is_watchpoint (b))
- cond = b->cond_exp;
+ {
+ struct watchpoint *w = (struct watchpoint *) b;
+
+ cond = w->cond_exp;
+ }
else
cond = bl->cond;

if (cond && b->disposition != disp_del_at_next_stop)
{
int within_current_scope = 1;
+ struct watchpoint * w;

/* We use value_mark and value_free_to_mark because it could
be a long time before we return to the command level and
@@ -3886,13 +3918,18 @@ bpstat_check_breakpoint_conditions (bpst
function call. */
struct value *mark = value_mark ();

+ if (is_watchpoint (b))
+ w = (struct watchpoint *) b;
+ else
+ w = NULL;
+
/* Need to select the frame, with all that implies so that
the conditions will have the right context. Because we
use the frame, we will not see an inlined function's
variables when we arrive at a breakpoint at the start
of the inlined function; the current frame will be the
call site. */
- if (!is_watchpoint (b) || b->cond_exp_valid_block == NULL)
+ if (w == NULL || w->cond_exp_valid_block == NULL)
select_frame (get_current_frame ());
else
{
@@ -3912,7 +3949,7 @@ bpstat_check_breakpoint_conditions (bpst
the innermost frame that's executing where it makes
sense to evaluate the condition. It seems
intuitive. */
- frame = block_innermost_frame (b->cond_exp_valid_block);
+ frame = block_innermost_frame (w->cond_exp_valid_block);
if (frame != NULL)
select_frame (frame);
else
@@ -4034,7 +4071,11 @@ bpstat_stop_status (struct address_space
out-of-scope event. We'll get to the watchpoint next
iteration. */
if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
- b->related_breakpoint->watchpoint_triggered = watch_triggered_yes;
+ {
+ struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
+
+ w->watchpoint_triggered = watch_triggered_yes;
+ }
}
}

@@ -4112,7 +4153,9 @@ bpstat_stop_status (struct address_space
&& bs->breakpoint_at
&& is_hardware_watchpoint (bs->breakpoint_at))
{
- update_watchpoint (bs->breakpoint_at, 0 /* don't reparse. */);
+ struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
+
+ update_watchpoint (w, 0 /* don't reparse. */);
need_remove_insert = 1;
}

@@ -4626,13 +4669,17 @@ print_one_breakpoint_location (struct br
case bp_hardware_watchpoint:
case bp_read_watchpoint:
case bp_access_watchpoint:
- /* Field 4, the address, is omitted (which makes the columns
- not line up too nicely with the headers, but the effect
- is relatively readable). */
- if (opts.addressprint)
- ui_out_field_skip (uiout, "addr");
- annotate_field (5);
- ui_out_field_string (uiout, "what", b->exp_string);
+ {
+ struct watchpoint *w = (struct watchpoint *) b;
+
+ /* Field 4, the address, is omitted (which makes the columns
+ not line up too nicely with the headers, but the effect
+ is relatively readable). */
+ if (opts.addressprint)
+ ui_out_field_skip (uiout, "addr");
+ annotate_field (5);
+ ui_out_field_string (uiout, "what", w->exp_string);
+ }
break;

case bp_breakpoint:
@@ -4812,10 +4859,14 @@ print_one_breakpoint_location (struct br

if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
{
- if (b->addr_string)
+ if (is_watchpoint (b))
+ {
+ struct watchpoint *w = (struct watchpoint *) b;
+
+ ui_out_field_string (uiout, "original-location", w->exp_string);
+ }
+ else if (b->addr_string)
ui_out_field_string (uiout, "original-location", b->addr_string);
- else if (b->exp_string)
- ui_out_field_string (uiout, "original-location", b->exp_string);
}
}

@@ -5247,9 +5298,12 @@ static int
watchpoint_locations_match (struct bp_location *loc1,
struct bp_location *loc2)
{
- /* Both of them must not be in moribund_locations. */
- gdb_assert (loc1->owner != NULL);
- gdb_assert (loc2->owner != NULL);
+ struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
+ struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
+
+ /* Both of them must exist. */
+ gdb_assert (w1 != NULL);
+ gdb_assert (w2 != NULL);

/* If the target can evaluate the condition expression in hardware,
then we we need to insert both watchpoints even if they are at
@@ -5257,16 +5311,16 @@ watchpoint_locations_match (struct bp_lo
the condition of whichever watchpoint was inserted evaluates to
true, not giving a chance for GDB to check the condition of the
other watchpoint. */
- if ((loc1->owner->cond_exp
+ if ((w1->cond_exp
&& target_can_accel_watchpoint_condition (loc1->address,
loc1->length,
loc1->watchpoint_type,
- loc1->owner->cond_exp))
- || (loc2->owner->cond_exp
+ w1->cond_exp))
+ || (w2->cond_exp
&& target_can_accel_watchpoint_condition (loc2->address,
loc2->length,
loc2->watchpoint_type,
- loc2->owner->cond_exp)))
+ w2->cond_exp)))
return 0;

/* Note that this checks the owner's type, not the location's. In
@@ -6562,12 +6616,12 @@ init_catchpoint (struct breakpoint *b,
}

void
-install_breakpoint (struct breakpoint *b)
+install_breakpoint (int internal, struct breakpoint *b)
{
add_to_breakpoint_chain (b);
- set_breakpoint_count (breakpoint_count + 1);
- b->number = breakpoint_count;
- mention (b);
+ set_breakpoint_number (internal, b);
+ if (!internal)
+ mention (b);
observer_notify_breakpoint_created (b);
update_global_location_list (1);
}
@@ -6583,7 +6637,7 @@ create_fork_vfork_event_catchpoint (stru

c->forked_inferior_pid = null_ptid;

- install_breakpoint (&c->base);
+ install_breakpoint (0, &c->base);
}

/* Exec catchpoints. */
@@ -6702,7 +6756,7 @@ create_syscall_event_catchpoint (int tem
init_catchpoint (&c->base, gdbarch, tempflag, NULL, ops);
c->syscalls_to_be_caught = filter;

- install_breakpoint (&c->base);
+ install_breakpoint (0, &c->base);
}

static int
@@ -8420,11 +8474,29 @@ watchpoint_exp_is_const (const struct ex
return 1;
}

+/* Implement the "dtor" breakpoint_ops method for watchpoints. */
+
+static void
+dtor_watchpoint (struct breakpoint *self)
+{
+ struct watchpoint *w = (struct watchpoint *) self;
+
+ xfree (w->cond_exp);
+ xfree (w->exp);
+ xfree (w->exp_string);
+ xfree (w->exp_string_reparse);
+ value_free (w->val);
+
+ base_breakpoint_ops.dtor (self);
+}
+
/* Implement the "re_set" breakpoint_ops method for watchpoints. */

static void
re_set_watchpoint (struct breakpoint *b)
{
+ struct watchpoint *w = (struct watchpoint *) b;
+
/* Watchpoint can be either on expression using entirely global
variables, or it can be on local variables.

@@ -8446,11 +8518,11 @@ re_set_watchpoint (struct breakpoint *b)
I'm not sure we'll ever be called in this case.

If a local watchpoint's frame id is still valid, then
- b->exp_valid_block is likewise valid, and we can safely use it.
+ w->exp_valid_block is likewise valid, and we can safely use it.

- Don't do anything about disabled watchpoints, since they will
- be reevaluated again when enabled. */
- update_watchpoint (b, 1 /* reparse */);
+ Don't do anything about disabled watchpoints, since they will be
+ reevaluated again when enabled. */
+ update_watchpoint (w, 1 /* reparse */);
}

/* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
@@ -8458,10 +8530,11 @@ re_set_watchpoint (struct breakpoint *b)
static int
insert_watchpoint (struct bp_location *bl)
{
- int length = bl->owner->exact? 1 : bl->length;
+ struct watchpoint *w = (struct watchpoint *) bl->owner;
+ int length = w->exact ? 1 : bl->length;

return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
- bl->owner->cond_exp);
+ w->cond_exp);
}

/* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
@@ -8469,10 +8542,11 @@ insert_watchpoint (struct bp_location *b
static int
remove_watchpoint (struct bp_location *bl)
{
- int length = bl->owner->exact? 1 : bl->length;
+ struct watchpoint *w = (struct watchpoint *) bl->owner;
+ int length = w->exact ? 1 : bl->length;

return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
- bl->owner->cond_exp);
+ w->cond_exp);
}

static int
@@ -8480,6 +8554,7 @@ breakpoint_hit_watchpoint (const struct
struct address_space *aspace, CORE_ADDR bp_addr)
{
struct breakpoint *b = bl->owner;
+ struct watchpoint *w = (struct watchpoint *) b;

/* Continuable hardware watchpoints are treated as non-existent if the
reason we stopped wasn't a hardware watchpoint (we didn't stop on
@@ -8488,7 +8563,7 @@ breakpoint_hit_watchpoint (const struct
been defined. Also skip watchpoints which we know did not trigger
(did not match the data address). */
if (is_hardware_watchpoint (b)
- && b->watchpoint_triggered == watch_triggered_no)
+ && w->watchpoint_triggered == watch_triggered_no)
return 0;

return 1;
@@ -8508,7 +8583,8 @@ check_status_watchpoint (bpstat bs)
static int
resources_needed_watchpoint (const struct bp_location *bl)
{
- int length = bl->owner->exact? 1 : bl->length;
+ struct watchpoint *w = (struct watchpoint *) bl->owner;
+ int length = w->exact? 1 : bl->length;

return target_region_ok_for_hw_watchpoint (bl->address, length);
}
@@ -8530,11 +8606,13 @@ print_it_watchpoint (bpstat bs)
const struct bp_location *bl;
struct ui_stream *stb;
enum print_stop_action result;
+ struct watchpoint *w;

gdb_assert (bs->bp_location_at != NULL);

bl = bs->bp_location_at;
b = bs->breakpoint_at;
+ w = (struct watchpoint *) b;

stb = ui_out_stream_new (uiout);
old_chain = make_cleanup_ui_out_stream_delete (stb);
@@ -8554,7 +8632,7 @@ print_it_watchpoint (bpstat bs)
watchpoint_value_print (bs->old_val, stb->stream);
ui_out_field_stream (uiout, "old", stb);
ui_out_text (uiout, "\nNew value = ");
- watchpoint_value_print (b->val, stb->stream);
+ watchpoint_value_print (w->val, stb->stream);
ui_out_field_stream (uiout, "new", stb);
ui_out_text (uiout, "\n");
/* More than one watchpoint may have been triggered. */
@@ -8569,7 +8647,7 @@ print_it_watchpoint (bpstat bs)
mention (b);
make_cleanup_ui_out_tuple_begin_end (uiout, "value");
ui_out_text (uiout, "\nValue = ");
- watchpoint_value_print (b->val, stb->stream);
+ watchpoint_value_print (w->val, stb->stream);
ui_out_field_stream (uiout, "value", stb);
ui_out_text (uiout, "\n");
result = PRINT_UNKNOWN;
@@ -8600,7 +8678,7 @@ print_it_watchpoint (bpstat bs)
make_cleanup_ui_out_tuple_begin_end (uiout, "value");
ui_out_text (uiout, "\nValue = ");
}
- watchpoint_value_print (b->val, stb->stream);
+ watchpoint_value_print (w->val, stb->stream);
ui_out_field_stream (uiout, "new", stb);
ui_out_text (uiout, "\n");
result = PRINT_UNKNOWN;
@@ -8620,6 +8698,7 @@ static void
print_mention_watchpoint (struct breakpoint *b)
{
struct cleanup *ui_out_chain;
+ struct watchpoint *w = (struct watchpoint *) b;

switch (b->type)
{
@@ -8646,7 +8725,7 @@ print_mention_watchpoint (struct breakpo

ui_out_field_int (uiout, "number", b->number);
ui_out_text (uiout, ": ");
- ui_out_field_string (uiout, "exp", b->exp_string);
+ ui_out_field_string (uiout, "exp", w->exp_string);
do_cleanups (ui_out_chain);
}

@@ -8656,6 +8735,8 @@ print_mention_watchpoint (struct breakpo
static void
print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
{
+ struct watchpoint *w = (struct watchpoint *) b;
+
switch (b->type)
{
case bp_watchpoint:
@@ -8673,7 +8754,7 @@ print_recreate_watchpoint (struct breakp
_("Invalid watchpoint type."));
}

- fprintf_unfiltered (fp, " %s", b->exp_string);
+ fprintf_unfiltered (fp, " %s", w->exp_string);
}

/* The breakpoint_ops structure to be used in hardware watchpoints. */
@@ -8686,7 +8767,9 @@ static struct breakpoint_ops watchpoint_
static int
insert_masked_watchpoint (struct bp_location *bl)
{
- return target_insert_mask_watchpoint (bl->address, bl->owner->hw_wp_mask,
+ struct watchpoint *w = (struct watchpoint *) bl->owner;
+
+ return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
bl->watchpoint_type);
}

@@ -8696,7 +8779,9 @@ insert_masked_watchpoint (struct bp_loca
static int
remove_masked_watchpoint (struct bp_location *bl)
{
- return target_remove_mask_watchpoint (bl->address, bl->owner->hw_wp_mask,
+ struct watchpoint *w = (struct watchpoint *) bl->owner;
+
+ return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
bl->watchpoint_type);
}

@@ -8706,8 +8791,9 @@ remove_masked_watchpoint (struct bp_loca
static int
resources_needed_masked_watchpoint (const struct bp_location *bl)
{
- return target_masked_watch_num_registers (bl->address,
- bl->owner->hw_wp_mask);
+ struct watchpoint *w = (struct watchpoint *) bl->owner;
+
+ return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
}

/* Implement the "works_in_software_mode" breakpoint_ops method for
@@ -8775,11 +8861,13 @@ static void
print_one_detail_masked_watchpoint (const struct breakpoint *b,
struct ui_out *uiout)
{
+ struct watchpoint *w = (struct watchpoint *) b;
+
/* Masked watchpoints have only one location. */
gdb_assert (b->loc && b->loc->next == NULL);

ui_out_text (uiout, "\tmask ");
- ui_out_field_core_addr (uiout, "mask", b->loc->gdbarch, b->hw_wp_mask);
+ ui_out_field_core_addr (uiout, "mask", b->loc->gdbarch, w->hw_wp_mask);
ui_out_text (uiout, "\n");
}

@@ -8789,6 +8877,7 @@ print_one_detail_masked_watchpoint (cons
static void
print_mention_masked_watchpoint (struct breakpoint *b)
{
+ struct watchpoint *w = (struct watchpoint *) b;
struct cleanup *ui_out_chain;

switch (b->type)
@@ -8812,7 +8901,7 @@ print_mention_masked_watchpoint (struct

ui_out_field_int (uiout, "number", b->number);
ui_out_text (uiout, ": ");
- ui_out_field_string (uiout, "exp", b->exp_string);
+ ui_out_field_string (uiout, "exp", w->exp_string);
do_cleanups (ui_out_chain);
}

@@ -8822,6 +8911,7 @@ print_mention_masked_watchpoint (struct
static void
print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
{
+ struct watchpoint *w = (struct watchpoint *) b;
char tmp[40];

switch (b->type)
@@ -8840,8 +8930,8 @@ print_recreate_masked_watchpoint (struct
_("Invalid hardware watchpoint type."));
}

- sprintf_vma (tmp, b->hw_wp_mask);
- fprintf_unfiltered (fp, " %s mask 0x%s", b->exp_string, tmp);
+ sprintf_vma (tmp, w->hw_wp_mask);
+ fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
}

/* The breakpoint_ops structure to be used in masked hardware watchpoints. */
@@ -8882,6 +8972,7 @@ watch_command_1 (char *arg, int accessfl
the hardware watchpoint. */
int use_mask = 0;
CORE_ADDR mask = 0;
+ struct watchpoint *w;

/* Make sure that we actually have parameters to parse. */
if (arg != NULL && arg[0] != '\0')
@@ -9078,18 +9169,21 @@ watch_command_1 (char *arg, int accessfl
}

/* Now set up the breakpoint. */
+
+ w = XCNEW (struct watchpoint);
+ b = &w->base;
if (use_mask)
- b = set_raw_breakpoint_without_location (NULL, bp_type,
- &masked_watchpoint_breakpoint_ops);
+ init_raw_breakpoint_without_location (b, NULL, bp_type,
+ &masked_watchpoint_breakpoint_ops);
else
- b = set_raw_breakpoint_without_location (NULL, bp_type,
- &watchpoint_breakpoint_ops);
+ init_raw_breakpoint_without_location (b, NULL, bp_type,
+ &watchpoint_breakpoint_ops);
b->thread = thread;
b->disposition = disp_donttouch;
- b->exp = exp;
- b->exp_valid_block = exp_valid_block;
- b->cond_exp_valid_block = cond_exp_valid_block;
b->pspace = current_program_space;
+ w->exp = exp;
+ w->exp_valid_block = exp_valid_block;
+ w->cond_exp_valid_block = cond_exp_valid_block;
if (just_location)
{
struct type *t = value_type (val);
@@ -9099,27 +9193,27 @@ watch_command_1 (char *arg, int accessfl
t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
name = type_to_string (t);

- b->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
+ w->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
core_addr_to_string (addr));
xfree (name);

- b->exp_string = xstrprintf ("-location %.*s",
+ w->exp_string = xstrprintf ("-location %.*s",
(int) (exp_end - exp_start), exp_start);

/* The above expression is in C. */
b->language = language_c;
}
else
- b->exp_string = savestring (exp_start, exp_end - exp_start);
+ w->exp_string = savestring (exp_start, exp_end - exp_start);

if (use_mask)
{
- b->hw_wp_mask = mask;
+ w->hw_wp_mask = mask;
}
else
{
- b->val = val;
- b->val_valid = 1;
+ w->val = val;
+ w->val_valid = 1;
}

if (cond_start)
@@ -9129,13 +9223,13 @@ watch_command_1 (char *arg, int accessfl

if (frame)
{
- b->watchpoint_frame = get_frame_id (frame);
- b->watchpoint_thread = inferior_ptid;
+ w->watchpoint_frame = get_frame_id (frame);
+ w->watchpoint_thread = inferior_ptid;
}
else
{
- b->watchpoint_frame = null_frame_id;
- b->watchpoint_thread = null_ptid;
+ w->watchpoint_frame = null_frame_id;
+ w->watchpoint_thread = null_ptid;
}

if (scope_breakpoint != NULL)
@@ -9153,7 +9247,7 @@ watch_command_1 (char *arg, int accessfl
{
/* Finally update the new watchpoint. This creates the locations
that should be inserted. */
- update_watchpoint (b, 1);
+ update_watchpoint (w, 1);
}
if (e.reason < 0)
{
@@ -9161,15 +9255,7 @@ watch_command_1 (char *arg, int accessfl
throw_exception (e);
}

- set_breakpoint_number (internal, b);
-
- /* Do not mention breakpoints with a negative number, but do
- notify observers. */
- if (!internal)
- mention (b);
- observer_notify_breakpoint_created (b);
-
- update_global_location_list (1);
+ install_breakpoint (internal, b);
}

/* Return count of debug registers needed to watch the given expression.
@@ -9565,7 +9651,7 @@ catch_exec_command_1 (char *arg, int fro
&catch_exec_breakpoint_ops);
c->exec_pathname = NULL;

- install_breakpoint (&c->base);
+ install_breakpoint (0, &c->base);
}

static enum print_stop_action
@@ -10534,13 +10620,8 @@ base_breakpoint_dtor (struct breakpoint
{
decref_counted_command_line (&self->commands);
xfree (self->cond_string);
- xfree (self->cond_exp);
xfree (self->addr_string);
xfree (self->addr_string_range_end);
- xfree (self->exp);
- xfree (self->exp_string);
- xfree (self->exp_string_reparse);
- value_free (self->val);
xfree (self->source_file);
}

@@ -11044,11 +11125,16 @@ delete_breakpoint (struct breakpoint *bp
if (bpt->related_breakpoint != bpt)
{
struct breakpoint *related;
+ struct watchpoint *w;

if (bpt->type == bp_watchpoint_scope)
- watchpoint_del_at_next_stop (bpt->related_breakpoint);
+ w = (struct watchpoint *) bpt->related_breakpoint;
else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
- watchpoint_del_at_next_stop (bpt);
+ w = (struct watchpoint *) bpt;
+ else
+ w = NULL;
+ if (w != NULL)
+ watchpoint_del_at_next_stop (w);

/* Unlink bpt from the bpt->related_breakpoint ring. */
for (related = bpt; related->related_breakpoint != bpt;
@@ -11995,9 +12081,11 @@ enable_breakpoint_disp (struct breakpoin

TRY_CATCH (e, RETURN_MASK_ALL)
{
+ struct watchpoint *w = (struct watchpoint *) bpt;
+
orig_enable_state = bpt->enable_state;
bpt->enable_state = bp_enabled;
- update_watchpoint (bpt, 1 /* reparse */);
+ update_watchpoint (w, 1 /* reparse */);
}
if (e.reason < 0)
{
@@ -12139,20 +12227,24 @@ invalidate_bp_value_on_memory_change (CO

ALL_BREAKPOINTS (bp)
if (bp->enable_state == bp_enabled
- && bp->type == bp_hardware_watchpoint
- && bp->val_valid && bp->val)
+ && bp->type == bp_hardware_watchpoint)
{
- struct bp_location *loc;
+ struct watchpoint *wp = (struct watchpoint *) bp;

- for (loc = bp->loc; loc != NULL; loc = loc->next)
- if (loc->loc_type == bp_loc_hardware_watchpoint
- && loc->address + loc->length > addr
- && addr + len > loc->address)
- {
- value_free (bp->val);
- bp->val = NULL;
- bp->val_valid = 0;
- }
+ if (wp->val_valid && wp->val)
+ {
+ struct bp_location *loc;
+
+ for (loc = bp->loc; loc != NULL; loc = loc->next)
+ if (loc->loc_type == bp_loc_hardware_watchpoint
+ && loc->address + loc->length > addr
+ && addr + len > loc->address)
+ {
+ value_free (wp->val);
+ wp->val = NULL;
+ wp->val_valid = 0;
+ }
+ }
}
}

@@ -13105,6 +13197,7 @@ initialize_breakpoint_ops (void)
/* Watchpoints. */
ops = &watchpoint_breakpoint_ops;
*ops = base_breakpoint_ops;
+ ops->dtor = dtor_watchpoint;
ops->re_set = re_set_watchpoint;
ops->insert_location = insert_watchpoint;
ops->remove_location = remove_watchpoint;
Index: src/gdb/ada-lang.c
===================================================================
--- src.orig/gdb/ada-lang.c 2011-07-22 15:37:15.163688209 +0100
+++ src/gdb/ada-lang.c 2011-07-22 15:37:16.303688209 +0100
@@ -11701,7 +11701,7 @@ create_ada_exception_catchpoint (struct
ops, tempflag, from_tty);
c->excep_string = excep_string;
create_excep_cond_exprs (c);
- install_breakpoint (&c->base);
+ install_breakpoint (0, &c->base);
}

/* Implement the "catch exception" command. */
Index: src/gdb/python/py-breakpoint.c
===================================================================
--- src.orig/gdb/python/py-breakpoint.c 2011-07-22 15:37:15.163688209 +0100
+++ src/gdb/python/py-breakpoint.c 2011-07-22 15:37:16.303688209 +0100
@@ -399,16 +399,16 @@ bppy_get_expression (PyObject *self, voi
{
char *str;
breakpoint_object *obj = (breakpoint_object *) self;
+ struct watchpoint *wp;

BPPY_REQUIRE_VALID (obj);

- if (obj->bp->type != bp_watchpoint
- && obj->bp->type != bp_hardware_watchpoint
- && obj->bp->type != bp_read_watchpoint
- && obj->bp->type != bp_access_watchpoint)
+ if (!is_watchpoint (obj->bp))
Py_RETURN_NONE;

- str = obj->bp->exp_string;
+ wp = (struct watchpoint *) obj->bp;
+
+ str = wp->exp_string;
if (! str)
str = "";