Re: [patch 1/2] Convert hardware watchpoints to use breakpoint_ops

Thiago Jung Bauermann
2010-12-23T18:37:00Z

Hi,

On Fri, 2010-11-19 at 18:09 -0200, Thiago Jung Bauermann wrote:
> Here's the new version. I understand you approved it already, but it
> seems more useful to me to wait until patch 2/2 to be approved too so
> that I can commit both together (this one doesn't do anything on its
> own).

This is the same patch, refreshed to apply on top of Jan's bp_location
renaming patch. It also incorporates some additional renaming he did
that touched this patch. I understand that this patch is approved. I'll
commit it when the ranged and/or the masked watchpoints patch get in.
--
[]'s
Thiago Jung Bauermann
IBM Linux Technology Center

2010-12-23 Thiago Jung Bauermann <bauerman@br.ibm.com>

Convert hardware watchpoints to use breakpoint_ops.

gdb/
* breakpoint.h (breakpoint_ops) <insert>: Rename to...
<insert_location>: ... this. Return int instead of void.
Accept pointer to struct bp_location instead of pointer to
struct breakpoint. Adapt all implementations.
(breakpoint_ops) <remove>: Rename to...
<remove_location>: ... this. Accept pointer to struct bp_location
instead of pointer to struct breakpoint. Adapt all implementations.
* breakpoint.c (insert_catchpoint): Delete function.
(insert_bp_location): Call the watchpoint or catchpoint's
breakpoint_ops.insert method.
(remove_breakpoint_1): Call the watchpoint or catchpoint's
breakpoint_ops.remove method.
(insert_watchpoint, remove_watchpoint): New functions.
(watchpoint_breakpoint_ops): New structure.
(watch_command_1): Initialize the OPS field.
* inf-child.c (inf_child_insert_fork_catchpoint)
(inf_child_remove_fork_catchpoint, inf_child_insert_vfork_catchpoint)
(inf_child_remove_vfork_catchpoint, inf_child_insert_exec_catchpoint)
(inf_child_remove_exec_catchpoint, inf_child_set_syscall_catchpoint):
Delete functions.
(inf_child_target): Remove initialization of to_insert_fork_catchpoint,
to_remove_fork_catchpoint, to_insert_vfork_catchpoint,
to_remove_vfork_catchpoint, to_insert_exec_catchpoint,
to_remove_exec_catchpoint and to_set_syscall_catchpoint.
* target.c (update_current_target): Change default implementation of
to_insert_fork_catchpoint, to_remove_fork_catchpoint,
to_insert_vfork_catchpoint, to_remove_vfork_catchpoint,
to_insert_exec_catchpoint, to_remove_exec_catchpoint and
to_set_syscall_catchpoint to return_one.
(debug_to_insert_fork_catchpoint, debug_to_insert_vfork_catchpoint)
(debug_to_insert_exec_catchpoint): Report return value.
* target.h (to_insert_fork_catchpoint, to_insert_vfork_catchpoint)
(to_insert_exec_catchpoint): Change declaration to return int instead
of void.

gdb/testsuite/
* gdb.base/foll-exec.exp: Adapt to new error string when the catchpoint
type is not supported.
* gdb.base/foll-fork.exp: Likewise.
* gdb.base/foll-vfork.exp: Likewise.

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 5736fbc..003899c 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -1194,18 +1194,6 @@ breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len)
}
\f

-/* A wrapper function for inserting catchpoints. */
-static void
-insert_catchpoint (struct ui_out *uo, void *args)
-{
- struct breakpoint *b = (struct breakpoint *) args;
-
- gdb_assert (b->type == bp_catchpoint);
- gdb_assert (b->ops != NULL && b->ops->insert != NULL);
-
- b->ops->insert (b);
-}
-
/* Return true if BPT is of any hardware watchpoint kind. */

static int
@@ -1742,10 +1730,10 @@ Note: automatically using hardware breakpoints for read-only addresses.\n"));
watchpoints. It's not clear that it's necessary... */
&& bl->owner->disposition != disp_del_at_next_stop)
{
- val = target_insert_watchpoint (bl->address,
- bl->length,
- bl->watchpoint_type,
- bl->owner->cond_exp);
+ gdb_assert (bl->owner->ops != NULL
+ && bl->owner->ops->insert_location != NULL);
+
+ val = bl->owner->ops->insert_location (bl);

/* If trying to set a read-watchpoint, and it turns out it's not
supported, try emulating one with an access watchpoint. */
@@ -1771,12 +1759,12 @@ Note: automatically using hardware breakpoints for read-only addresses.\n"));

if (val == 1)
{
- val = target_insert_watchpoint (bl->address,
- bl->length,
- hw_access,
- bl->owner->cond_exp);
- if (val == 0)
- bl->watchpoint_type = hw_access;
+ bl->watchpoint_type = hw_access;
+ val = bl->owner->ops->insert_location (bl);
+
+ if (val)
+ /* Back to the original value. */
+ bl->watchpoint_type = hw_read;
}
}

@@ -1785,14 +1773,23 @@ Note: automatically using hardware breakpoints for read-only addresses.\n"));

else if (bl->owner->type == bp_catchpoint)
{
- struct gdb_exception e = catch_exception (uiout, insert_catchpoint,
- bl->owner, RETURN_MASK_ERROR);
- exception_fprintf (gdb_stderr, e, "warning: inserting catchpoint %d: ",
- bl->owner->number);
- if (e.reason < 0)
- bl->owner->enable_state = bp_disabled;
- else
- bl->inserted = 1;
+ gdb_assert (bl->owner->ops != NULL
+ && bl->owner->ops->insert_location != NULL);
+
+ val = bl->owner->ops->insert_location (bl);
+ if (val)
+ {
+ bl->owner->enable_state = bp_disabled;
+
+ if (val == 1)
+ warning (_("\
+Error inserting catchpoint %d: Your system does not support this type\n\
+of catchpoint."), bl->owner->number);
+ else
+ warning (_("Error inserting catchpoint %d."), bl->owner->number);
+ }
+
+ bl->inserted = (val == 0);

/* We've already printed an error message if there was a problem
inserting this catchpoint, and we've disabled the catchpoint,
@@ -2489,9 +2486,11 @@ remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
}
else if (bl->loc_type == bp_loc_hardware_watchpoint)
{
+ gdb_assert (bl->owner->ops != NULL
+ && bl->owner->ops->remove_location != NULL);
+
bl->inserted = (is == mark_inserted);
- val = target_remove_watchpoint (bl->address, bl->length,
- bl->watchpoint_type, bl->owner->cond_exp);
+ bl->owner->ops->remove_location (bl);

/* Failure to remove any of the hardware watchpoints comes here. */
if ((is == mark_uninserted) && (bl->inserted))
@@ -2502,11 +2501,13 @@ remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
&& breakpoint_enabled (bl->owner)
&& !bl->duplicate)
{
- gdb_assert (bl->owner->ops != NULL && bl->owner->ops->remove != NULL);
+ gdb_assert (bl->owner->ops != NULL
+ && bl->owner->ops->remove_location != NULL);

- val = bl->owner->ops->remove (bl->owner);
+ val = bl->owner->ops->remove_location (bl);
if (val)
return val;
+
bl->inserted = (is == mark_inserted);
}

@@ -5919,16 +5920,16 @@ disable_breakpoints_in_unloaded_shlib (struct so_list *solib)

/* Implement the "insert" breakpoint_ops method for fork catchpoints. */

-static void
-insert_catch_fork (struct breakpoint *b)
+static int
+insert_catch_fork (struct bp_location *bl)
{
- target_insert_fork_catchpoint (PIDGET (inferior_ptid));
+ return target_insert_fork_catchpoint (PIDGET (inferior_ptid));
}

/* Implement the "remove" breakpoint_ops method for fork catchpoints. */

static int
-remove_catch_fork (struct breakpoint *b)
+remove_catch_fork (struct bp_location *bl)
{
return target_remove_fork_catchpoint (PIDGET (inferior_ptid));
}
@@ -6011,16 +6012,16 @@ static struct breakpoint_ops catch_fork_breakpoint_ops =

/* Implement the "insert" breakpoint_ops method for vfork catchpoints. */

-static void
-insert_catch_vfork (struct breakpoint *b)
+static int
+insert_catch_vfork (struct bp_location *bl)
{
- target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
+ return target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
}

/* Implement the "remove" breakpoint_ops method for vfork catchpoints. */

static int
-remove_catch_vfork (struct breakpoint *b)
+remove_catch_vfork (struct bp_location *bl)
{
return target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
}
@@ -6103,20 +6104,20 @@ static struct breakpoint_ops catch_vfork_breakpoint_ops =
/* Implement the "insert" breakpoint_ops method for syscall
catchpoints. */

-static void
-insert_catch_syscall (struct breakpoint *b)
+static int
+insert_catch_syscall (struct bp_location *bl)
{
struct inferior *inf = current_inferior ();

++inf->total_syscalls_count;
- if (!b->syscalls_to_be_caught)
+ if (!bl->owner->syscalls_to_be_caught)
++inf->any_syscall_count;
else
{
int i, iter;

for (i = 0;
- VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
+ VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
i++)
{
int elem;
@@ -6137,30 +6138,30 @@ insert_catch_syscall (struct breakpoint *b)
}
}

- target_set_syscall_catchpoint (PIDGET (inferior_ptid),
- inf->total_syscalls_count != 0,
- inf->any_syscall_count,
- VEC_length (int, inf->syscalls_counts),
- VEC_address (int, inf->syscalls_counts));
+ return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
+ inf->total_syscalls_count != 0,
+ inf->any_syscall_count,
+ VEC_length (int, inf->syscalls_counts),
+ VEC_address (int, inf->syscalls_counts));
}

/* Implement the "remove" breakpoint_ops method for syscall
catchpoints. */

static int
-remove_catch_syscall (struct breakpoint *b)
+remove_catch_syscall (struct bp_location *bl)
{
struct inferior *inf = current_inferior ();

--inf->total_syscalls_count;
- if (!b->syscalls_to_be_caught)
+ if (!bl->owner->syscalls_to_be_caught)
--inf->any_syscall_count;
else
{
int i, iter;

for (i = 0;
- VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
+ VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
i++)
{
int elem;
@@ -6459,14 +6460,14 @@ create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,

/* Exec catchpoints. */

-static void
-insert_catch_exec (struct breakpoint *b)
+static int
+insert_catch_exec (struct bp_location *bl)
{
- target_insert_exec_catchpoint (PIDGET (inferior_ptid));
+ return target_insert_exec_catchpoint (PIDGET (inferior_ptid));
}

static int
-remove_catch_exec (struct breakpoint *b)
+remove_catch_exec (struct bp_location *bl)
{
return target_remove_exec_catchpoint (PIDGET (inferior_ptid));
}
@@ -8113,6 +8114,37 @@ watchpoint_exp_is_const (const struct expression *exp)
return 1;
}

+/* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
+
+static int
+insert_watchpoint (struct bp_location *bl)
+{
+ return target_insert_watchpoint (bl->address, bl->length,
+ bl->watchpoint_type, bl->owner->cond_exp);
+}
+
+/* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
+
+static int
+remove_watchpoint (struct bp_location *bl)
+{
+ return target_remove_watchpoint (bl->address, bl->length,
+ bl->watchpoint_type, bl->owner->cond_exp);
+}
+
+/* The breakpoint_ops structure to be used in hardware watchpoints. */
+
+static struct breakpoint_ops watchpoint_breakpoint_ops =
+{
+ insert_watchpoint,
+ remove_watchpoint,
+ NULL, /* breakpoint_hit */
+ NULL, /* print_it */
+ NULL, /* print_one */
+ NULL, /* print_mention */
+ NULL /* print_recreate */
+};
+
/* accessflag: hw_write: watch write,
hw_read: watch read,
hw_access: watch access (read or write) */
@@ -8355,6 +8387,8 @@ watch_command_1 (char *arg, int accessflag, int from_tty,
b->exp_string = savestring (exp_start, exp_end - exp_start);
b->val = val;
b->val_valid = 1;
+ b->ops = &watchpoint_breakpoint_ops;
+
if (cond_start)
b->cond_string = savestring (cond_start, cond_end - cond_start);
else
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index a044c6b..12c2df2 100644
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -355,16 +355,18 @@ struct bp_location
will be called instead of the performing the default action for this
bptype. */

-struct breakpoint_ops
+struct breakpoint_ops
{
- /* Insert the breakpoint or activate the catchpoint. Should raise
- an exception if the operation failed. */
- void (*insert) (struct breakpoint *);
+ /* Insert the breakpoint or watchpoint or activate the catchpoint.
+ Return 0 for success, 1 if the breakpoint, watchpoint or catchpoint
+ type is not supported, -1 for failure. */
+ int (*insert_location) (struct bp_location *);

/* Remove the breakpoint/catchpoint that was previously inserted
- with the "insert" method above. Return non-zero if the operation
- succeeded. */
- int (*remove) (struct breakpoint *);
+ with the "insert" method above. Return 0 for success, 1 if the
+ breakpoint, watchpoint or catchpoint type is not supported,
+ -1 for failure. */
+ int (*remove_location) (struct bp_location *);

/* Return non-zero if the debugger should tell the user that this
breakpoint was hit. */
diff --git a/gdb/inf-child.c b/gdb/inf-child.c
index 72a18e4..810f688 100644
--- a/gdb/inf-child.c
+++ b/gdb/inf-child.c
@@ -94,36 +94,6 @@ inf_child_acknowledge_created_inferior (int pid)
created inferior" operation by a debugger. */
}

-static void
-inf_child_insert_fork_catchpoint (int pid)
-{
- /* This version of Unix doesn't support notification of fork
- events. */
-}
-
-static int
-inf_child_remove_fork_catchpoint (int pid)
-{
- /* This version of Unix doesn't support notification of fork
- events. */
- return 0;
-}
-
-static void
-inf_child_insert_vfork_catchpoint (int pid)
-{
- /* This version of Unix doesn't support notification of vfork
- events. */
-}
-
-static int
-inf_child_remove_vfork_catchpoint (int pid)
-{
- /* This version of Unix doesn't support notification of vfork
- events. */
- return 0;
-}
-
static int
inf_child_follow_fork (struct target_ops *ops, int follow_child)
{
@@ -132,30 +102,6 @@ inf_child_follow_fork (struct target_ops *ops, int follow_child)
return 0;
}

-static void
-inf_child_insert_exec_catchpoint (int pid)
-{
- /* This version of Unix doesn't support notification of exec
- events. */
-}
-
-static int
-inf_child_remove_exec_catchpoint (int pid)
-{
- /* This version of Unix doesn't support notification of exec
- events. */
- return 0;
-}
-
-static int
-inf_child_set_syscall_catchpoint (int pid, int needed, int any_count,
- int table_size, int *table)
-{
- /* This version of Unix doesn't support notification of syscall
- events. */
- return 0;
-}
-
static int
inf_child_can_run (void)
{
@@ -193,14 +139,7 @@ inf_child_target (void)
t->to_terminal_info = child_terminal_info;
t->to_post_startup_inferior = inf_child_post_startup_inferior;
t->to_acknowledge_created_inferior = inf_child_acknowledge_created_inferior;
- t->to_insert_fork_catchpoint = inf_child_insert_fork_catchpoint;
- t->to_remove_fork_catchpoint = inf_child_remove_fork_catchpoint;
- t->to_insert_vfork_catchpoint = inf_child_insert_vfork_catchpoint;
- t->to_remove_vfork_catchpoint = inf_child_remove_vfork_catchpoint;
t->to_follow_fork = inf_child_follow_fork;
- t->to_insert_exec_catchpoint = inf_child_insert_exec_catchpoint;
- t->to_remove_exec_catchpoint = inf_child_remove_exec_catchpoint;
- t->to_set_syscall_catchpoint = inf_child_set_syscall_catchpoint;
t->to_can_run = inf_child_can_run;
t->to_pid_to_exec_file = inf_child_pid_to_exec_file;
t->to_stratum = process_stratum;
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 56490cc..41dfd24 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -961,36 +961,34 @@ Attaching after process %d fork to child process %d.\n"),
}

\f
-static void
+static int
linux_child_insert_fork_catchpoint (int pid)
{
- if (! linux_supports_tracefork (pid))
- error (_("Your system does not support fork catchpoints."));
+ return !linux_supports_tracefork (pid);
}

-static void
+static int
linux_child_insert_vfork_catchpoint (int pid)
{
- if (!linux_supports_tracefork (pid))
- error (_("Your system does not support vfork catchpoints."));
+ return !linux_supports_tracefork (pid);
}

-static void
+static int
linux_child_insert_exec_catchpoint (int pid)
{
- if (!linux_supports_tracefork (pid))
- error (_("Your system does not support exec catchpoints."));
+ return !linux_supports_tracefork (pid);
}

static int
linux_child_set_syscall_catchpoint (int pid, int needed, int any_count,
int table_size, int *table)
{
- if (! linux_supports_tracesysgood (pid))
- error (_("Your system does not support syscall catchpoints."));
+ if (!linux_supports_tracesysgood (pid))
+ return 1;
+
/* On GNU/Linux, we ignore the arguments. It means that we only
enable the syscall catchpoints, but do not disable them.
-
+
Also, we do not use the `table' information because we do not
filter system calls here. We let GDB do the logic for us. */
return 0;
diff --git a/gdb/target.c b/gdb/target.c
index 5984125..dd976c9 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -782,26 +782,26 @@ update_current_target (void)
(void (*) (int))
target_ignore);
de_fault (to_insert_fork_catchpoint,
- (void (*) (int))
- tcomplain);
+ (int (*) (int))
+ return_one);
de_fault (to_remove_fork_catchpoint,
(int (*) (int))
- tcomplain);
+ return_one);
de_fault (to_insert_vfork_catchpoint,
- (void (*) (int))
- tcomplain);
+ (int (*) (int))
+ return_one);
de_fault (to_remove_vfork_catchpoint,
(int (*) (int))
- tcomplain);
+ return_one);
de_fault (to_insert_exec_catchpoint,
- (void (*) (int))
- tcomplain);
+ (int (*) (int))
+ return_one);
de_fault (to_remove_exec_catchpoint,
(int (*) (int))
- tcomplain);
+ return_one);
de_fault (to_set_syscall_catchpoint,
(int (*) (int, int, int, int, int *))
- tcomplain);
+ return_one);
de_fault (to_has_exited,
(int (*) (int, int, int *))
return_zero);
@@ -3657,13 +3657,17 @@ debug_to_acknowledge_created_inferior (int pid)
pid);
}

-static void
+static int
debug_to_insert_fork_catchpoint (int pid)
{
- debug_target.to_insert_fork_catchpoint (pid);
+ int retval;

- fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
- pid);
+ retval = debug_target.to_insert_fork_catchpoint (pid);
+
+ fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
+ pid, retval);
+
+ return retval;
}

static int
@@ -3679,13 +3683,17 @@ debug_to_remove_fork_catchpoint (int pid)
return retval;
}

-static void
+static int
debug_to_insert_vfork_catchpoint (int pid)
{
- debug_target.to_insert_vfork_catchpoint (pid);
+ int retval;

- fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
- pid);
+ retval = debug_target.to_insert_vfork_catchpoint (pid);
+
+ fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
+ pid, retval);
+
+ return retval;
}

static int
@@ -3701,13 +3709,17 @@ debug_to_remove_vfork_catchpoint (int pid)
return retval;
}

-static void
+static int
debug_to_insert_exec_catchpoint (int pid)
{
- debug_target.to_insert_exec_catchpoint (pid);
+ int retval;

- fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
- pid);
+ retval = debug_target.to_insert_exec_catchpoint (pid);
+
+ fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
+ pid, retval);
+
+ return retval;
}

static int
diff --git a/gdb/target.h b/gdb/target.h
index 7290d90..bc70107 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -468,12 +468,12 @@ struct target_ops
char *, char *, char **, int);
void (*to_post_startup_inferior) (ptid_t);
void (*to_acknowledge_created_inferior) (int);
- void (*to_insert_fork_catchpoint) (int);
+ int (*to_insert_fork_catchpoint) (int);
int (*to_remove_fork_catchpoint) (int);
- void (*to_insert_vfork_catchpoint) (int);
+ int (*to_insert_vfork_catchpoint) (int);
int (*to_remove_vfork_catchpoint) (int);
int (*to_follow_fork) (struct target_ops *, int);
- void (*to_insert_exec_catchpoint) (int);
+ int (*to_insert_exec_catchpoint) (int);
int (*to_remove_exec_catchpoint) (int);
int (*to_set_syscall_catchpoint) (int, int, int, int, int *);
int (*to_has_exited) (int, int, int *);
@@ -1034,7 +1034,8 @@ void target_create_inferior (char *exec_file, char *args,

/* On some targets, we can catch an inferior fork or vfork event when
it occurs. These functions insert/remove an already-created
- catchpoint for such events. */
+ catchpoint for such events. They return 0 for success, 1 if the
+ catchpoint type is not supported and -1 for failure. */

#define target_insert_fork_catchpoint(pid) \
(*current_target.to_insert_fork_catchpoint) (pid)
@@ -1060,7 +1061,8 @@ int target_follow_fork (int follow_child);

/* On some targets, we can catch an inferior exec event when it
occurs. These functions insert/remove an already-created
- catchpoint for such events. */
+ catchpoint for such events. They return 0 for success, 1 if the
+ catchpoint type is not supported and -1 for failure. */

#define target_insert_exec_catchpoint(pid) \
(*current_target.to_insert_exec_catchpoint) (pid)
@@ -1083,7 +1085,10 @@ int target_follow_fork (int follow_child);

TABLE is an array of ints, indexed by syscall number. An element in
this array is nonzero if that syscall should be caught. This argument
- only matters if ANY_COUNT is zero. */
+ only matters if ANY_COUNT is zero.
+
+ Return 0 for success, 1 if syscall catchpoints are not supported or -1
+ for failure. */

#define target_set_syscall_catchpoint(pid, needed, any_count, table_size, table) \
(*current_target.to_set_syscall_catchpoint) (pid, needed, any_count, \
diff --git a/gdb/testsuite/gdb.base/foll-exec.exp b/gdb/testsuite/gdb.base/foll-exec.exp
index 92fd105..e30334d 100644
--- a/gdb/testsuite/gdb.base/foll-exec.exp
+++ b/gdb/testsuite/gdb.base/foll-exec.exp
@@ -89,7 +89,7 @@ proc do_exec_tests {} {
gdb_test "catch exec" "Catchpoint \[0-9\]* \\(exec\\)" "insert first exec catchpoint"
set has_exec_catchpoints 0
gdb_test_multiple "continue" "continue to first exec catchpoint" {
- -re ".*Your system does not support exec catchpoints.*$gdb_prompt $" {
+ -re ".*Your system does not support this type\r\nof catchpoint.*$gdb_prompt $" {
unsupported "continue to first exec catchpoint"
}
-re ".*Catchpoint.*$gdb_prompt $" {
diff --git a/gdb/testsuite/gdb.base/foll-fork.exp b/gdb/testsuite/gdb.base/foll-fork.exp
index 891aa38..6dcfca1 100644
--- a/gdb/testsuite/gdb.base/foll-fork.exp
+++ b/gdb/testsuite/gdb.base/foll-fork.exp
@@ -45,7 +45,7 @@ proc check_fork_catchpoints {} {
gdb_test "catch fork" "Catchpoint \[0-9\]* \\(fork\\)" "insert first fork catchpoint"
set has_fork_catchpoints 0
gdb_test_multiple "continue" "continue to first fork catchpoint" {
- -re ".*Your system does not support fork catchpoints.*$gdb_prompt $" {
+ -re ".*Your system does not support this type\r\nof catchpoint.*$gdb_prompt $" {
unsupported "continue to first fork catchpoint"
}
-re ".*Catchpoint.*$gdb_prompt $" {
diff --git a/gdb/testsuite/gdb.base/foll-vfork.exp b/gdb/testsuite/gdb.base/foll-vfork.exp
index e55d700..1b479f2 100644
--- a/gdb/testsuite/gdb.base/foll-vfork.exp
+++ b/gdb/testsuite/gdb.base/foll-vfork.exp
@@ -74,7 +74,7 @@ proc check_vfork_catchpoints {} {
gdb_test "catch vfork" "Catchpoint \[0-9\]* \\(vfork\\)" "insert first vfork catchpoint"
set has_vfork_catchpoints 0
gdb_test_multiple "continue" "continue to first vfork catchpoint" {
- -re ".*Your system does not support vfork catchpoints.*$gdb_prompt $" {
+ -re ".*Your system does not support this type\r\nof catchpoint.*$gdb_prompt $" {
unsupported "continue to first vfork catchpoint"
}
-re ".*Catchpoint.*$gdb_prompt $" {