2010-01-11 Thiago Jung Bauermann <bauerman@br.ibm.com>
authorThiago Jung Bauermann <bauerman@br.ibm.com>
Tue, 11 Jan 2011 19:16:23 +0000 (19:16 +0000)
committerThiago Jung Bauermann <bauerman@br.ibm.com>
Tue, 11 Jan 2011 19:16:23 +0000 (19:16 +0000)
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.

gdb/ChangeLog
gdb/breakpoint.c
gdb/breakpoint.h
gdb/inf-child.c
gdb/linux-nat.c
gdb/target.c
gdb/target.h
gdb/testsuite/ChangeLog
gdb/testsuite/gdb.base/foll-exec.exp
gdb/testsuite/gdb.base/foll-fork.exp
gdb/testsuite/gdb.base/foll-vfork.exp

index 4e92633f377f3ee63ba5e6321598774e61d12ae1..8d74a1f8e1135bc0251509ffbd9b0de2d0f534d8 100644 (file)
@@ -1,3 +1,41 @@
+2010-01-11  Thiago Jung Bauermann  <bauerman@br.ibm.com>
+
+       Convert hardware watchpoints to use breakpoint_ops.
+       * 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.
+
 2011-01-11  Michael Snyder  <msnyder@vmware.com>
 
        * arm-tdep.c: Internationalization.
index a909aa378f3257766d3b0095071858f3f53eb6e1..fc66e9b73d21687a816568b994278ed92911f784 100644 (file)
@@ -1228,18 +1228,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
@@ -1790,10 +1778,10 @@ insert_bp_location (struct bp_location *bl,
              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.  */
@@ -1819,12 +1807,12 @@ insert_bp_location (struct bp_location *bl,
 
          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;
            }
        }
 
@@ -1833,14 +1821,23 @@ insert_bp_location (struct bp_location *bl,
 
   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,
@@ -2537,10 +2534,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))
@@ -2551,11 +2549,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);
     }
 
@@ -5997,17 +5997,17 @@ 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));
 }
@@ -6093,17 +6093,17 @@ 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));
 }
@@ -6188,20 +6188,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;
@@ -6223,30 +6223,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;
@@ -6546,14 +6546,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));
 }
@@ -8211,6 +8211,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) */
@@ -8454,6 +8485,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
index 2d815c24947a85730889e2ed959157e4c10bf9f6..cd9b6b8cf3f59cda906a859f8893287fad380783 100644 (file)
@@ -368,16 +368,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.  */
index 6802343c778638bb132abbae182e2332dd90c4de..1c45483d1ebf384e5ed7ee11db26d6b585bc2b00 100644 (file)
@@ -87,36 +87,6 @@ inf_child_post_startup_inferior (ptid_t ptid)
      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)
 {
@@ -125,30 +95,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)
 {
@@ -185,14 +131,7 @@ inf_child_target (void)
   t->to_terminal_ours = terminal_ours;
   t->to_terminal_info = child_terminal_info;
   t->to_post_startup_inferior = inf_child_post_startup_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;
index c769010f99e250aaf9fa7e667307719d02601ae3..62a453879bbb63bfc4b3ff8bd1e7c058fc514610 100644 (file)
@@ -974,36 +974,34 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
 }
 
 \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;
index bfb2bbd90dc815f72b6de513f46596e9235950ab..4854834d9e557c0440c3fe555be5eccb2aac3d48 100644 (file)
@@ -779,26 +779,26 @@ update_current_target (void)
            (void (*) (ptid_t))
            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);
@@ -3661,13 +3661,17 @@ debug_to_post_startup_inferior (ptid_t ptid)
                      PIDGET (ptid));
 }
 
-static void
+static int
 debug_to_insert_fork_catchpoint (int pid)
 {
-  debug_target.to_insert_fork_catchpoint (pid);
+  int retval;
+
+  retval = debug_target.to_insert_fork_catchpoint (pid);
+
+  fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
+                     pid, retval);
 
-  fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
-                     pid);
+  return retval;
 }
 
 static int
@@ -3683,13 +3687,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;
+
+  retval = debug_target.to_insert_vfork_catchpoint (pid);
 
-  fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
-                     pid);
+  fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
+                     pid, retval);
+
+  return retval;
 }
 
 static int
@@ -3705,13 +3713,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;
+
+  retval = debug_target.to_insert_exec_catchpoint (pid);
 
-  fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
-                     pid);
+  fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
+                     pid, retval);
+
+  return retval;
 }
 
 static int
index c34625cc41a14ac86ce68e5b83d34c176be0baea..72fd211024b807e838e3fa709a2ce49358d729f1 100644 (file)
@@ -468,12 +468,12 @@ struct target_ops
     void (*to_create_inferior) (struct target_ops *, 
                                char *, char *, char **, int);
     void (*to_post_startup_inferior) (ptid_t);
-    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 *);
@@ -1029,7 +1029,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)
@@ -1055,7 +1056,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)
@@ -1078,7 +1080,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, \
index 437a229010111948e907b4cce46335d20874b121..8c16e5344e2c7ff3a0cc6ef107c94a95eb47dee3 100644 (file)
@@ -1,3 +1,11 @@
+2010-01-11  Thiago Jung Bauermann  <bauerman@br.ibm.com>
+
+       Convert hardware watchpoints to use breakpoint_ops.
+       * 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.
+
 2011-01-10  Phil Muldoon  <pmuldoon@redhat.com>
 
        * gdb.python/py-cmd.exp: Remove gdb_py_test_multiple function.
index 88194fba77485ce4b813c4ed17b928d73c1fda76..64c1bfdb0a448b03c3d573b88dcbbb6075afcbba 100644 (file)
@@ -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 $" {
index 36a56b5fa37355464e12176a209203bd8fe0d6e1..40d0702e28fe39315f4593d492242a32394620ac 100644 (file)
@@ -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 $" {
index 1bad95718c5ce30c37c89edee8883aac3128ab0e..f8a3eeb1f505913ede1f2a4095c11291447c652b 100644 (file)
@@ -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 $" {