Create gdb/break-catch-syscall.c

This commits cleans up the gdb/breakpoint.c file and moves everything
that is related to the 'catch syscall' command to the new file
gdb/break-catch-syscall.c.  This is just code movement, and the only
new part is the adjustment needed on 'catching_syscall_number' to use
the new 'breakpoint_find_if' function insted of relying on the
ALL_BREAKPOINTS macro.

Tested by running the 'gdb.base/catch-syscall.exp' testcase.

gdb/ChangeLog:
2015-03-11  Sergio Durigan Junior  <sergiodj@redhat.com>

	* Makefile.in (SFILES): New source break-catch-syscall.c.
	(COMMON_OBS): New object break-catch-syscall.o.
	* break-catch-syscall.c: New file.
	* breakpoint.c: Remove inclusion of "xml-syscall.h".
	(syscall_catchpoint_p): Move declaration to break-catch-syscall.c
	(struct syscall_catchpoint): Likewise.
	(dtor_catch_syscall): Likewise.
	(catch_syscall_inferior_data): Likewise.
	(struct catch_syscall_inferior_data): Likewise.
	(get_catch_syscall_inferior_data): Likewise.
	(catch_syscall_inferior_data_cleanup): Likewise.
	(insert_catch_syscall): Likewise.
	(remove_catch_syscall): Likewise.
	(breakpoint_hit_catch_syscall): Likewise.
	(print_it_catch_syscall): Likewise.
	(print_one_catch_syscall): Likewise.
	(print_mention_catch_syscall): Likewise.
	(print_recreate_catch_syscall): Likewise.
	(catch_syscall_breakpoint_ops): Likewise.
	(syscall_catchpoint_p): Likewise.
	(create_syscall_event_catchpoint): Likewise.
	(catch_syscall_split_args): Likewise.
	(catch_syscall_command_1): Likewise.
	(is_syscall_catchpoint_enabled): Likewise.
	(catch_syscall_enabled): Likewise.
	(catching_syscall_number): Likewise.
	(catch_syscall_completer): Likewise.
	(clear_syscall_counts): Likewise.
	(initialize_breakpoint_ops): Move initialization of syscall
	catchpoints to break-catch-syscall.c.
	(_initialize_breakpoint): Move code related to syscall catchpoints
	to break-catch-syscall.c.

4 files changed, 696 insertions, 600 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ca9fc15..a3ba5dd 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,40 @@
 2015-03-11  Sergio Durigan Junior  <sergiodj@redhat.com>
 
+	* Makefile.in (SFILES): New source break-catch-syscall.c.
+	(COMMON_OBS): New object break-catch-syscall.o.
+	* break-catch-syscall.c: New file.
+	* breakpoint.c: Remove inclusion of "xml-syscall.h".
+	(syscall_catchpoint_p): Move declaration to break-catch-syscall.c
+	(struct syscall_catchpoint): Likewise.
+	(dtor_catch_syscall): Likewise.
+	(catch_syscall_inferior_data): Likewise.
+	(struct catch_syscall_inferior_data): Likewise.
+	(get_catch_syscall_inferior_data): Likewise.
+	(catch_syscall_inferior_data_cleanup): Likewise.
+	(insert_catch_syscall): Likewise.
+	(remove_catch_syscall): Likewise.
+	(breakpoint_hit_catch_syscall): Likewise.
+	(print_it_catch_syscall): Likewise.
+	(print_one_catch_syscall): Likewise.
+	(print_mention_catch_syscall): Likewise.
+	(print_recreate_catch_syscall): Likewise.
+	(catch_syscall_breakpoint_ops): Likewise.
+	(syscall_catchpoint_p): Likewise.
+	(create_syscall_event_catchpoint): Likewise.
+	(catch_syscall_split_args): Likewise.
+	(catch_syscall_command_1): Likewise.
+	(is_syscall_catchpoint_enabled): Likewise.
+	(catch_syscall_enabled): Likewise.
+	(catching_syscall_number): Likewise.
+	(catch_syscall_completer): Likewise.
+	(clear_syscall_counts): Likewise.
+	(initialize_breakpoint_ops): Move initialization of syscall
+	catchpoints to break-catch-syscall.c.
+	(_initialize_breakpoint): Move code related to syscall catchpoints
+	to break-catch-syscall.c.
+
+2015-03-11  Sergio Durigan Junior  <sergiodj@redhat.com>
+
 	* breakpoint.c (breakpoint_find_if): New function.
 	* breakpoint.h (breakpoint_find_if): New prototype.
 
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 0ddcd72..7eefa5b 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -816,6 +816,7 @@ SFILES = ada-exp.y ada-lang.c ada-typeprint.c ada-valprint.c ada-tasks.c \
 	bfd-target.c \
 	block.c blockframe.c \
 	breakpoint.c break-catch-sig.c break-catch-throw.c \
+	break-catch-syscall.c \
 	build-id.c buildsym.c \
 	c-exp.y c-lang.c c-typeprint.c c-valprint.c c-varobj.c \
 	charset.c common/cleanups.c cli-out.c coffread.c coff-pe-read.c \
@@ -1003,6 +1004,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \
 	agent.o \
 	bfd-target.o \
 	blockframe.o breakpoint.o break-catch-sig.o break-catch-throw.o \
+	break-catch-syscall.o \
 	findvar.o regcache.o cleanups.o \
 	charset.o continuations.o corelow.o disasm.o dummy-frame.o dfp.o \
 	source.o value.o eval.o valops.o valarith.o valprint.o printcmd.o \
diff --git a/gdb/break-catch-syscall.c b/gdb/break-catch-syscall.c
new file mode 100644
index 0000000..1718f49
--- /dev/null
+++ b/gdb/break-catch-syscall.c
@@ -0,0 +1,659 @@
+/* Everything about syscall catchpoints, for GDB.
+
+   Copyright (C) 2009-2015 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "defs.h"
+#include <ctype.h>
+#include "breakpoint.h"
+#include "gdbcmd.h"
+#include "inferior.h"
+#include "cli/cli-utils.h"
+#include "annotate.h"
+#include "mi/mi-common.h"
+#include "valprint.h"
+#include "arch-utils.h"
+#include "observer.h"
+#include "xml-syscall.h"
+
+/* An instance of this type is used to represent a syscall catchpoint.
+   It includes a "struct breakpoint" as a kind of base class; users
+   downcast to "struct breakpoint *" when needed.  A breakpoint is
+   really of this type iff its ops pointer points to
+   CATCH_SYSCALL_BREAKPOINT_OPS.  */
+
+struct syscall_catchpoint
+{
+  /* The base class.  */
+  struct breakpoint base;
+
+  /* Syscall numbers used for the 'catch syscall' feature.  If no
+     syscall has been specified for filtering, its value is NULL.
+     Otherwise, it holds a list of all syscalls to be caught.  The
+     list elements are allocated with xmalloc.  */
+  VEC(int) *syscalls_to_be_caught;
+};
+
+/* Implement the "dtor" breakpoint_ops method for syscall
+   catchpoints.  */
+
+static void
+dtor_catch_syscall (struct breakpoint *b)
+{
+  struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
+
+  VEC_free (int, c->syscalls_to_be_caught);
+
+  base_breakpoint_ops.dtor (b);
+}
+
+static const struct inferior_data *catch_syscall_inferior_data = NULL;
+
+struct catch_syscall_inferior_data
+{
+  /* We keep a count of the number of times the user has requested a
+     particular syscall to be tracked, and pass this information to the
+     target.  This lets capable targets implement filtering directly.  */
+
+  /* Number of times that "any" syscall is requested.  */
+  int any_syscall_count;
+
+  /* Count of each system call.  */
+  VEC(int) *syscalls_counts;
+
+  /* This counts all syscall catch requests, so we can readily determine
+     if any catching is necessary.  */
+  int total_syscalls_count;
+};
+
+static struct catch_syscall_inferior_data*
+get_catch_syscall_inferior_data (struct inferior *inf)
+{
+  struct catch_syscall_inferior_data *inf_data;
+
+  inf_data = inferior_data (inf, catch_syscall_inferior_data);
+  if (inf_data == NULL)
+    {
+      inf_data = XCNEW (struct catch_syscall_inferior_data);
+      set_inferior_data (inf, catch_syscall_inferior_data, inf_data);
+    }
+
+  return inf_data;
+}
+
+static void
+catch_syscall_inferior_data_cleanup (struct inferior *inf, void *arg)
+{
+  xfree (arg);
+}
+
+
+/* Implement the "insert" breakpoint_ops method for syscall
+   catchpoints.  */
+
+static int
+insert_catch_syscall (struct bp_location *bl)
+{
+  struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
+  struct inferior *inf = current_inferior ();
+  struct catch_syscall_inferior_data *inf_data
+    = get_catch_syscall_inferior_data (inf);
+
+  ++inf_data->total_syscalls_count;
+  if (!c->syscalls_to_be_caught)
+    ++inf_data->any_syscall_count;
+  else
+    {
+      int i, iter;
+
+      for (i = 0;
+           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
+           i++)
+	{
+          int elem;
+
+	  if (iter >= VEC_length (int, inf_data->syscalls_counts))
+	    {
+              int old_size = VEC_length (int, inf_data->syscalls_counts);
+              uintptr_t vec_addr_offset
+		= old_size * ((uintptr_t) sizeof (int));
+              uintptr_t vec_addr;
+              VEC_safe_grow (int, inf_data->syscalls_counts, iter + 1);
+              vec_addr = ((uintptr_t) VEC_address (int,
+						  inf_data->syscalls_counts)
+			  + vec_addr_offset);
+              memset ((void *) vec_addr, 0,
+                      (iter + 1 - old_size) * sizeof (int));
+	    }
+          elem = VEC_index (int, inf_data->syscalls_counts, iter);
+          VEC_replace (int, inf_data->syscalls_counts, iter, ++elem);
+	}
+    }
+
+  return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
+					inf_data->total_syscalls_count != 0,
+					inf_data->any_syscall_count,
+					VEC_length (int,
+						    inf_data->syscalls_counts),
+					VEC_address (int,
+						     inf_data->syscalls_counts));
+}
+
+/* Implement the "remove" breakpoint_ops method for syscall
+   catchpoints.  */
+
+static int
+remove_catch_syscall (struct bp_location *bl)
+{
+  struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
+  struct inferior *inf = current_inferior ();
+  struct catch_syscall_inferior_data *inf_data
+    = get_catch_syscall_inferior_data (inf);
+
+  --inf_data->total_syscalls_count;
+  if (!c->syscalls_to_be_caught)
+    --inf_data->any_syscall_count;
+  else
+    {
+      int i, iter;
+
+      for (i = 0;
+           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
+           i++)
+	{
+          int elem;
+	  if (iter >= VEC_length (int, inf_data->syscalls_counts))
+	    /* Shouldn't happen.  */
+	    continue;
+          elem = VEC_index (int, inf_data->syscalls_counts, iter);
+          VEC_replace (int, inf_data->syscalls_counts, iter, --elem);
+        }
+    }
+
+  return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
+					inf_data->total_syscalls_count != 0,
+					inf_data->any_syscall_count,
+					VEC_length (int,
+						    inf_data->syscalls_counts),
+					VEC_address (int,
+						     inf_data->syscalls_counts));
+}
+
+/* Implement the "breakpoint_hit" breakpoint_ops method for syscall
+   catchpoints.  */
+
+static int
+breakpoint_hit_catch_syscall (const struct bp_location *bl,
+			      struct address_space *aspace, CORE_ADDR bp_addr,
+			      const struct target_waitstatus *ws)
+{
+  /* We must check if we are catching specific syscalls in this
+     breakpoint.  If we are, then we must guarantee that the called
+     syscall is the same syscall we are catching.  */
+  int syscall_number = 0;
+  const struct syscall_catchpoint *c
+    = (const struct syscall_catchpoint *) bl->owner;
+
+  if (ws->kind != TARGET_WAITKIND_SYSCALL_ENTRY
+      && ws->kind != TARGET_WAITKIND_SYSCALL_RETURN)
+    return 0;
+
+  syscall_number = ws->value.syscall_number;
+
+  /* Now, checking if the syscall is the same.  */
+  if (c->syscalls_to_be_caught)
+    {
+      int i, iter;
+
+      for (i = 0;
+           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
+           i++)
+	if (syscall_number == iter)
+	  return 1;
+
+      return 0;
+    }
+
+  return 1;
+}
+
+/* Implement the "print_it" breakpoint_ops method for syscall
+   catchpoints.  */
+
+static enum print_stop_action
+print_it_catch_syscall (bpstat bs)
+{
+  struct ui_out *uiout = current_uiout;
+  struct breakpoint *b = bs->breakpoint_at;
+  /* These are needed because we want to know in which state a
+     syscall is.  It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
+     or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
+     must print "called syscall" or "returned from syscall".  */
+  ptid_t ptid;
+  struct target_waitstatus last;
+  struct syscall s;
+  struct gdbarch *gdbarch = bs->bp_location_at->gdbarch;
+
+  get_last_target_status (&ptid, &last);
+
+  get_syscall_by_number (gdbarch, last.value.syscall_number, &s);
+
+  annotate_catchpoint (b->number);
+
+  if (b->disposition == disp_del)
+    ui_out_text (uiout, "\nTemporary catchpoint ");
+  else
+    ui_out_text (uiout, "\nCatchpoint ");
+  if (ui_out_is_mi_like_p (uiout))
+    {
+      ui_out_field_string (uiout, "reason",
+			   async_reason_lookup (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY
+						? EXEC_ASYNC_SYSCALL_ENTRY
+						: EXEC_ASYNC_SYSCALL_RETURN));
+      ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
+    }
+  ui_out_field_int (uiout, "bkptno", b->number);
+
+  if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
+    ui_out_text (uiout, " (call to syscall ");
+  else
+    ui_out_text (uiout, " (returned from syscall ");
+
+  if (s.name == NULL || ui_out_is_mi_like_p (uiout))
+    ui_out_field_int (uiout, "syscall-number", last.value.syscall_number);
+  if (s.name != NULL)
+    ui_out_field_string (uiout, "syscall-name", s.name);
+
+  ui_out_text (uiout, "), ");
+
+  return PRINT_SRC_AND_LOC;
+}
+
+/* Implement the "print_one" breakpoint_ops method for syscall
+   catchpoints.  */
+
+static void
+print_one_catch_syscall (struct breakpoint *b,
+			 struct bp_location **last_loc)
+{
+  struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
+  struct value_print_options opts;
+  struct ui_out *uiout = current_uiout;
+  struct gdbarch *gdbarch = b->loc->gdbarch;
+
+  get_user_print_options (&opts);
+  /* 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);
+
+  if (c->syscalls_to_be_caught
+      && VEC_length (int, c->syscalls_to_be_caught) > 1)
+    ui_out_text (uiout, "syscalls \"");
+  else
+    ui_out_text (uiout, "syscall \"");
+
+  if (c->syscalls_to_be_caught)
+    {
+      int i, iter;
+      char *text = xstrprintf ("%s", "");
+
+      for (i = 0;
+           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
+           i++)
+        {
+          char *x = text;
+          struct syscall s;
+          get_syscall_by_number (gdbarch, iter, &s);
+
+          if (s.name != NULL)
+            text = xstrprintf ("%s%s, ", text, s.name);
+          else
+            text = xstrprintf ("%s%d, ", text, iter);
+
+          /* We have to xfree the last 'text' (now stored at 'x')
+             because xstrprintf dynamically allocates new space for it
+             on every call.  */
+	  xfree (x);
+        }
+      /* Remove the last comma.  */
+      text[strlen (text) - 2] = '\0';
+      ui_out_field_string (uiout, "what", text);
+    }
+  else
+    ui_out_field_string (uiout, "what", "<any syscall>");
+  ui_out_text (uiout, "\" ");
+
+  if (ui_out_is_mi_like_p (uiout))
+    ui_out_field_string (uiout, "catch-type", "syscall");
+}
+
+/* Implement the "print_mention" breakpoint_ops method for syscall
+   catchpoints.  */
+
+static void
+print_mention_catch_syscall (struct breakpoint *b)
+{
+  struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
+  struct gdbarch *gdbarch = b->loc->gdbarch;
+
+  if (c->syscalls_to_be_caught)
+    {
+      int i, iter;
+
+      if (VEC_length (int, c->syscalls_to_be_caught) > 1)
+        printf_filtered (_("Catchpoint %d (syscalls"), b->number);
+      else
+        printf_filtered (_("Catchpoint %d (syscall"), b->number);
+
+      for (i = 0;
+           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
+           i++)
+        {
+          struct syscall s;
+          get_syscall_by_number (gdbarch, iter, &s);
+
+          if (s.name)
+            printf_filtered (" '%s' [%d]", s.name, s.number);
+          else
+            printf_filtered (" %d", s.number);
+        }
+      printf_filtered (")");
+    }
+  else
+    printf_filtered (_("Catchpoint %d (any syscall)"),
+                     b->number);
+}
+
+/* Implement the "print_recreate" breakpoint_ops method for syscall
+   catchpoints.  */
+
+static void
+print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
+{
+  struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
+  struct gdbarch *gdbarch = b->loc->gdbarch;
+
+  fprintf_unfiltered (fp, "catch syscall");
+
+  if (c->syscalls_to_be_caught)
+    {
+      int i, iter;
+
+      for (i = 0;
+           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
+           i++)
+        {
+          struct syscall s;
+
+          get_syscall_by_number (gdbarch, iter, &s);
+          if (s.name)
+            fprintf_unfiltered (fp, " %s", s.name);
+          else
+            fprintf_unfiltered (fp, " %d", s.number);
+        }
+    }
+  print_recreate_thread (b, fp);
+}
+
+/* The breakpoint_ops structure to be used in syscall catchpoints.  */
+
+static struct breakpoint_ops catch_syscall_breakpoint_ops;
+
+/* Returns non-zero if 'b' is a syscall catchpoint.  */
+
+static int
+syscall_catchpoint_p (struct breakpoint *b)
+{
+  return (b->ops == &catch_syscall_breakpoint_ops);
+}
+
+static void
+create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
+                                 const struct breakpoint_ops *ops)
+{
+  struct syscall_catchpoint *c;
+  struct gdbarch *gdbarch = get_current_arch ();
+
+  c = XNEW (struct syscall_catchpoint);
+  init_catchpoint (&c->base, gdbarch, tempflag, NULL, ops);
+  c->syscalls_to_be_caught = filter;
+
+  install_breakpoint (0, &c->base, 1);
+}
+
+/* Splits the argument using space as delimiter.  Returns an xmalloc'd
+   filter list, or NULL if no filtering is required.  */
+static VEC(int) *
+catch_syscall_split_args (char *arg)
+{
+  VEC(int) *result = NULL;
+  struct cleanup *cleanup = make_cleanup (VEC_cleanup (int), &result);
+  struct gdbarch *gdbarch = target_gdbarch ();
+
+  while (*arg != '\0')
+    {
+      int i, syscall_number;
+      char *endptr;
+      char cur_name[128];
+      struct syscall s;
+
+      /* Skip whitespace.  */
+      arg = skip_spaces (arg);
+
+      for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
+	cur_name[i] = arg[i];
+      cur_name[i] = '\0';
+      arg += i;
+
+      /* Check if the user provided a syscall name or a number.  */
+      syscall_number = (int) strtol (cur_name, &endptr, 0);
+      if (*endptr == '\0')
+	get_syscall_by_number (gdbarch, syscall_number, &s);
+      else
+	{
+	  /* We have a name.  Let's check if it's valid and convert it
+	     to a number.  */
+	  get_syscall_by_name (gdbarch, cur_name, &s);
+
+	  if (s.number == UNKNOWN_SYSCALL)
+	    /* Here we have to issue an error instead of a warning,
+	       because GDB cannot do anything useful if there's no
+	       syscall number to be caught.  */
+	    error (_("Unknown syscall name '%s'."), cur_name);
+	}
+
+      /* Ok, it's valid.  */
+      VEC_safe_push (int, result, s.number);
+    }
+
+  discard_cleanups (cleanup);
+  return result;
+}
+
+/* Implement the "catch syscall" command.  */
+
+static void
+catch_syscall_command_1 (char *arg, int from_tty, 
+			 struct cmd_list_element *command)
+{
+  int tempflag;
+  VEC(int) *filter;
+  struct syscall s;
+  struct gdbarch *gdbarch = get_current_arch ();
+
+  /* Checking if the feature if supported.  */
+  if (gdbarch_get_syscall_number_p (gdbarch) == 0)
+    error (_("The feature 'catch syscall' is not supported on \
+this architecture yet."));
+
+  tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
+
+  arg = skip_spaces (arg);
+
+  /* We need to do this first "dummy" translation in order
+     to get the syscall XML file loaded or, most important,
+     to display a warning to the user if there's no XML file
+     for his/her architecture.  */
+  get_syscall_by_number (gdbarch, 0, &s);
+
+  /* The allowed syntax is:
+     catch syscall
+     catch syscall <name | number> [<name | number> ... <name | number>]
+
+     Let's check if there's a syscall name.  */
+
+  if (arg != NULL)
+    filter = catch_syscall_split_args (arg);
+  else
+    filter = NULL;
+
+  create_syscall_event_catchpoint (tempflag, filter,
+				   &catch_syscall_breakpoint_ops);
+}
+
+
+/* Returns 0 if 'bp' is NOT a syscall catchpoint,
+   non-zero otherwise.  */
+static int
+is_syscall_catchpoint_enabled (struct breakpoint *bp)
+{
+  if (syscall_catchpoint_p (bp)
+      && bp->enable_state != bp_disabled
+      && bp->enable_state != bp_call_disabled)
+    return 1;
+  else
+    return 0;
+}
+
+int
+catch_syscall_enabled (void)
+{
+  struct catch_syscall_inferior_data *inf_data
+    = get_catch_syscall_inferior_data (current_inferior ());
+
+  return inf_data->total_syscalls_count != 0;
+}
+
+/* Helper function for catching_syscall_number.  If B is a syscall
+   catchpoint for SYSCALL_NUMBER, return 1 (which will make
+   'breakpoint_find_if' return).  Otherwise, return 0.  */
+
+static int
+catching_syscall_number_1 (struct breakpoint *b,
+			   void *data)
+{
+  int syscall_number = (int) (uintptr_t) data;
+
+  if (is_syscall_catchpoint_enabled (b))
+    {
+      struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
+
+      if (c->syscalls_to_be_caught)
+	{
+	  int i, iter;
+	  for (i = 0;
+	       VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
+	       i++)
+	    if (syscall_number == iter)
+	      return 1;
+	}
+      else
+	return 1;
+    }
+
+  return 0;
+}
+
+int
+catching_syscall_number (int syscall_number)
+{
+  struct breakpoint *b = breakpoint_find_if (catching_syscall_number_1,
+					 (void *) (uintptr_t) syscall_number);
+
+  return b != NULL;
+}
+
+/* Complete syscall names.  Used by "catch syscall".  */
+static VEC (char_ptr) *
+catch_syscall_completer (struct cmd_list_element *cmd,
+                         const char *text, const char *word)
+{
+  const char **list = get_syscall_names (get_current_arch ());
+  VEC (char_ptr) *retlist
+    = (list == NULL) ? NULL : complete_on_enum (list, word, word);
+
+  xfree (list);
+  return retlist;
+}
+
+static void
+clear_syscall_counts (struct inferior *inf)
+{
+  struct catch_syscall_inferior_data *inf_data
+    = get_catch_syscall_inferior_data (inf);
+
+  inf_data->total_syscalls_count = 0;
+  inf_data->any_syscall_count = 0;
+  VEC_free (int, inf_data->syscalls_counts);
+}
+
+static void
+initialize_syscall_catchpoint_ops (void)
+{
+  struct breakpoint_ops *ops;
+
+  initialize_breakpoint_ops ();
+
+  /* Syscall catchpoints.  */
+  ops = &catch_syscall_breakpoint_ops;
+  *ops = base_breakpoint_ops;
+  ops->dtor = dtor_catch_syscall;
+  ops->insert_location = insert_catch_syscall;
+  ops->remove_location = remove_catch_syscall;
+  ops->breakpoint_hit = breakpoint_hit_catch_syscall;
+  ops->print_it = print_it_catch_syscall;
+  ops->print_one = print_one_catch_syscall;
+  ops->print_mention = print_mention_catch_syscall;
+  ops->print_recreate = print_recreate_catch_syscall;
+}
+
+initialize_file_ftype _initialize_break_catch_syscall;
+
+void
+_initialize_break_catch_syscall (void)
+{
+  initialize_syscall_catchpoint_ops ();
+
+  observer_attach_inferior_exit (clear_syscall_counts);
+  catch_syscall_inferior_data
+    = register_inferior_data_with_cleanup (NULL,
+					   catch_syscall_inferior_data_cleanup);
+
+  add_catch_command ("syscall", _("\
+Catch system calls by their names and/or numbers.\n\
+Arguments say which system calls to catch.  If no arguments\n\
+are given, every system call will be caught.\n\
+Arguments, if given, should be one or more system call names\n\
+(if your system supports that), or system call numbers."),
+		     catch_syscall_command_1,
+		     catch_syscall_completer,
+		     CATCH_PERMANENT,
+		     CATCH_TEMPORARY);
+}
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index c0ab1d7..0c000f2 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -56,7 +56,6 @@
 #include "top.h"
 #include "valprint.h"
 #include "jit.h"
-#include "xml-syscall.h"
 #include "parser-defs.h"
 #include "gdb_regex.h"
 #include "probe.h"
@@ -274,8 +273,6 @@ static int is_hardware_watchpoint (const struct breakpoint *bpt);
 
 static void insert_breakpoint_locations (void);
 
-static int syscall_catchpoint_p (struct breakpoint *b);
-
 static void tracepoints_info (char *, int);
 
 static void delete_trace_command (char *, int);
@@ -8452,400 +8449,6 @@ catch_unload_command_1 (char *arg, int from_tty,
   catch_load_or_unload (arg, from_tty, 0, command);
 }
 
-/* An instance of this type is used to represent a syscall catchpoint.
-   It includes a "struct breakpoint" as a kind of base class; users
-   downcast to "struct breakpoint *" when needed.  A breakpoint is
-   really of this type iff its ops pointer points to
-   CATCH_SYSCALL_BREAKPOINT_OPS.  */
-
-struct syscall_catchpoint
-{
-  /* The base class.  */
-  struct breakpoint base;
-
-  /* Syscall numbers used for the 'catch syscall' feature.  If no
-     syscall has been specified for filtering, its value is NULL.
-     Otherwise, it holds a list of all syscalls to be caught.  The
-     list elements are allocated with xmalloc.  */
-  VEC(int) *syscalls_to_be_caught;
-};
-
-/* Implement the "dtor" breakpoint_ops method for syscall
-   catchpoints.  */
-
-static void
-dtor_catch_syscall (struct breakpoint *b)
-{
-  struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
-
-  VEC_free (int, c->syscalls_to_be_caught);
-
-  base_breakpoint_ops.dtor (b);
-}
-
-static const struct inferior_data *catch_syscall_inferior_data = NULL;
-
-struct catch_syscall_inferior_data
-{
-  /* We keep a count of the number of times the user has requested a
-     particular syscall to be tracked, and pass this information to the
-     target.  This lets capable targets implement filtering directly.  */
-
-  /* Number of times that "any" syscall is requested.  */
-  int any_syscall_count;
-
-  /* Count of each system call.  */
-  VEC(int) *syscalls_counts;
-
-  /* This counts all syscall catch requests, so we can readily determine
-     if any catching is necessary.  */
-  int total_syscalls_count;
-};
-
-static struct catch_syscall_inferior_data*
-get_catch_syscall_inferior_data (struct inferior *inf)
-{
-  struct catch_syscall_inferior_data *inf_data;
-
-  inf_data = inferior_data (inf, catch_syscall_inferior_data);
-  if (inf_data == NULL)
-    {
-      inf_data = XCNEW (struct catch_syscall_inferior_data);
-      set_inferior_data (inf, catch_syscall_inferior_data, inf_data);
-    }
-
-  return inf_data;
-}
-
-static void
-catch_syscall_inferior_data_cleanup (struct inferior *inf, void *arg)
-{
-  xfree (arg);
-}
-
-
-/* Implement the "insert" breakpoint_ops method for syscall
-   catchpoints.  */
-
-static int
-insert_catch_syscall (struct bp_location *bl)
-{
-  struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
-  struct inferior *inf = current_inferior ();
-  struct catch_syscall_inferior_data *inf_data
-    = get_catch_syscall_inferior_data (inf);
-
-  ++inf_data->total_syscalls_count;
-  if (!c->syscalls_to_be_caught)
-    ++inf_data->any_syscall_count;
-  else
-    {
-      int i, iter;
-
-      for (i = 0;
-           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
-           i++)
-	{
-          int elem;
-
-	  if (iter >= VEC_length (int, inf_data->syscalls_counts))
-	    {
-              int old_size = VEC_length (int, inf_data->syscalls_counts);
-              uintptr_t vec_addr_offset
-		= old_size * ((uintptr_t) sizeof (int));
-              uintptr_t vec_addr;
-              VEC_safe_grow (int, inf_data->syscalls_counts, iter + 1);
-              vec_addr = ((uintptr_t) VEC_address (int,
-						  inf_data->syscalls_counts)
-			  + vec_addr_offset);
-              memset ((void *) vec_addr, 0,
-                      (iter + 1 - old_size) * sizeof (int));
-	    }
-          elem = VEC_index (int, inf_data->syscalls_counts, iter);
-          VEC_replace (int, inf_data->syscalls_counts, iter, ++elem);
-	}
-    }
-
-  return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
-					inf_data->total_syscalls_count != 0,
-					inf_data->any_syscall_count,
-					VEC_length (int,
-						    inf_data->syscalls_counts),
-					VEC_address (int,
-						     inf_data->syscalls_counts));
-}
-
-/* Implement the "remove" breakpoint_ops method for syscall
-   catchpoints.  */
-
-static int
-remove_catch_syscall (struct bp_location *bl)
-{
-  struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
-  struct inferior *inf = current_inferior ();
-  struct catch_syscall_inferior_data *inf_data
-    = get_catch_syscall_inferior_data (inf);
-
-  --inf_data->total_syscalls_count;
-  if (!c->syscalls_to_be_caught)
-    --inf_data->any_syscall_count;
-  else
-    {
-      int i, iter;
-
-      for (i = 0;
-           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
-           i++)
-	{
-          int elem;
-	  if (iter >= VEC_length (int, inf_data->syscalls_counts))
-	    /* Shouldn't happen.  */
-	    continue;
-          elem = VEC_index (int, inf_data->syscalls_counts, iter);
-          VEC_replace (int, inf_data->syscalls_counts, iter, --elem);
-        }
-    }
-
-  return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
-					inf_data->total_syscalls_count != 0,
-					inf_data->any_syscall_count,
-					VEC_length (int,
-						    inf_data->syscalls_counts),
-					VEC_address (int,
-						     inf_data->syscalls_counts));
-}
-
-/* Implement the "breakpoint_hit" breakpoint_ops method for syscall
-   catchpoints.  */
-
-static int
-breakpoint_hit_catch_syscall (const struct bp_location *bl,
-			      struct address_space *aspace, CORE_ADDR bp_addr,
-			      const struct target_waitstatus *ws)
-{
-  /* We must check if we are catching specific syscalls in this
-     breakpoint.  If we are, then we must guarantee that the called
-     syscall is the same syscall we are catching.  */
-  int syscall_number = 0;
-  const struct syscall_catchpoint *c
-    = (const struct syscall_catchpoint *) bl->owner;
-
-  if (ws->kind != TARGET_WAITKIND_SYSCALL_ENTRY
-      && ws->kind != TARGET_WAITKIND_SYSCALL_RETURN)
-    return 0;
-
-  syscall_number = ws->value.syscall_number;
-
-  /* Now, checking if the syscall is the same.  */
-  if (c->syscalls_to_be_caught)
-    {
-      int i, iter;
-
-      for (i = 0;
-           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
-           i++)
-	if (syscall_number == iter)
-	  return 1;
-
-      return 0;
-    }
-
-  return 1;
-}
-
-/* Implement the "print_it" breakpoint_ops method for syscall
-   catchpoints.  */
-
-static enum print_stop_action
-print_it_catch_syscall (bpstat bs)
-{
-  struct ui_out *uiout = current_uiout;
-  struct breakpoint *b = bs->breakpoint_at;
-  /* These are needed because we want to know in which state a
-     syscall is.  It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
-     or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
-     must print "called syscall" or "returned from syscall".  */
-  ptid_t ptid;
-  struct target_waitstatus last;
-  struct syscall s;
-  struct gdbarch *gdbarch = bs->bp_location_at->gdbarch;
-
-  get_last_target_status (&ptid, &last);
-
-  get_syscall_by_number (gdbarch, last.value.syscall_number, &s);
-
-  annotate_catchpoint (b->number);
-
-  if (b->disposition == disp_del)
-    ui_out_text (uiout, "\nTemporary catchpoint ");
-  else
-    ui_out_text (uiout, "\nCatchpoint ");
-  if (ui_out_is_mi_like_p (uiout))
-    {
-      ui_out_field_string (uiout, "reason",
-			   async_reason_lookup (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY
-						? EXEC_ASYNC_SYSCALL_ENTRY
-						: EXEC_ASYNC_SYSCALL_RETURN));
-      ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
-    }
-  ui_out_field_int (uiout, "bkptno", b->number);
-
-  if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
-    ui_out_text (uiout, " (call to syscall ");
-  else
-    ui_out_text (uiout, " (returned from syscall ");
-
-  if (s.name == NULL || ui_out_is_mi_like_p (uiout))
-    ui_out_field_int (uiout, "syscall-number", last.value.syscall_number);
-  if (s.name != NULL)
-    ui_out_field_string (uiout, "syscall-name", s.name);
-
-  ui_out_text (uiout, "), ");
-
-  return PRINT_SRC_AND_LOC;
-}
-
-/* Implement the "print_one" breakpoint_ops method for syscall
-   catchpoints.  */
-
-static void
-print_one_catch_syscall (struct breakpoint *b,
-			 struct bp_location **last_loc)
-{
-  struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
-  struct value_print_options opts;
-  struct ui_out *uiout = current_uiout;
-  struct gdbarch *gdbarch = b->loc->gdbarch;
-
-  get_user_print_options (&opts);
-  /* 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);
-
-  if (c->syscalls_to_be_caught
-      && VEC_length (int, c->syscalls_to_be_caught) > 1)
-    ui_out_text (uiout, "syscalls \"");
-  else
-    ui_out_text (uiout, "syscall \"");
-
-  if (c->syscalls_to_be_caught)
-    {
-      int i, iter;
-      char *text = xstrprintf ("%s", "");
-
-      for (i = 0;
-           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
-           i++)
-        {
-          char *x = text;
-          struct syscall s;
-          get_syscall_by_number (gdbarch, iter, &s);
-
-          if (s.name != NULL)
-            text = xstrprintf ("%s%s, ", text, s.name);
-          else
-            text = xstrprintf ("%s%d, ", text, iter);
-
-          /* We have to xfree the last 'text' (now stored at 'x')
-             because xstrprintf dynamically allocates new space for it
-             on every call.  */
-	  xfree (x);
-        }
-      /* Remove the last comma.  */
-      text[strlen (text) - 2] = '\0';
-      ui_out_field_string (uiout, "what", text);
-    }
-  else
-    ui_out_field_string (uiout, "what", "<any syscall>");
-  ui_out_text (uiout, "\" ");
-
-  if (ui_out_is_mi_like_p (uiout))
-    ui_out_field_string (uiout, "catch-type", "syscall");
-}
-
-/* Implement the "print_mention" breakpoint_ops method for syscall
-   catchpoints.  */
-
-static void
-print_mention_catch_syscall (struct breakpoint *b)
-{
-  struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
-  struct gdbarch *gdbarch = b->loc->gdbarch;
-
-  if (c->syscalls_to_be_caught)
-    {
-      int i, iter;
-
-      if (VEC_length (int, c->syscalls_to_be_caught) > 1)
-        printf_filtered (_("Catchpoint %d (syscalls"), b->number);
-      else
-        printf_filtered (_("Catchpoint %d (syscall"), b->number);
-
-      for (i = 0;
-           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
-           i++)
-        {
-          struct syscall s;
-          get_syscall_by_number (gdbarch, iter, &s);
-
-          if (s.name)
-            printf_filtered (" '%s' [%d]", s.name, s.number);
-          else
-            printf_filtered (" %d", s.number);
-        }
-      printf_filtered (")");
-    }
-  else
-    printf_filtered (_("Catchpoint %d (any syscall)"),
-                     b->number);
-}
-
-/* Implement the "print_recreate" breakpoint_ops method for syscall
-   catchpoints.  */
-
-static void
-print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
-{
-  struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
-  struct gdbarch *gdbarch = b->loc->gdbarch;
-
-  fprintf_unfiltered (fp, "catch syscall");
-
-  if (c->syscalls_to_be_caught)
-    {
-      int i, iter;
-
-      for (i = 0;
-           VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
-           i++)
-        {
-          struct syscall s;
-
-          get_syscall_by_number (gdbarch, iter, &s);
-          if (s.name)
-            fprintf_unfiltered (fp, " %s", s.name);
-          else
-            fprintf_unfiltered (fp, " %d", s.number);
-        }
-    }
-  print_recreate_thread (b, fp);
-}
-
-/* The breakpoint_ops structure to be used in syscall catchpoints.  */
-
-static struct breakpoint_ops catch_syscall_breakpoint_ops;
-
-/* Returns non-zero if 'b' is a syscall catchpoint.  */
-
-static int
-syscall_catchpoint_p (struct breakpoint *b)
-{
-  return (b->ops == &catch_syscall_breakpoint_ops);
-}
-
 /* Initialize a new breakpoint of the bp_catchpoint kind.  If TEMPFLAG
    is non-zero, then make the breakpoint temporary.  If COND_STRING is
    not NULL, then store it in the breakpoint.  OPS, if not NULL, is
@@ -9026,20 +8629,6 @@ print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
 
 static struct breakpoint_ops catch_exec_breakpoint_ops;
 
-static void
-create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
-                                 const struct breakpoint_ops *ops)
-{
-  struct syscall_catchpoint *c;
-  struct gdbarch *gdbarch = get_current_arch ();
-
-  c = XNEW (struct syscall_catchpoint);
-  init_catchpoint (&c->base, gdbarch, tempflag, NULL, ops);
-  c->syscalls_to_be_caught = filter;
-
-  install_breakpoint (0, &c->base, 1);
-}
-
 static int
 hw_breakpoint_used_count (void)
 {
@@ -12116,96 +11705,6 @@ init_ada_exception_breakpoint (struct breakpoint *b,
   b->language = language_ada;
 }
 
-/* Splits the argument using space as delimiter.  Returns an xmalloc'd
-   filter list, or NULL if no filtering is required.  */
-static VEC(int) *
-catch_syscall_split_args (char *arg)
-{
-  VEC(int) *result = NULL;
-  struct cleanup *cleanup = make_cleanup (VEC_cleanup (int), &result);
-  struct gdbarch *gdbarch = target_gdbarch ();
-
-  while (*arg != '\0')
-    {
-      int i, syscall_number;
-      char *endptr;
-      char cur_name[128];
-      struct syscall s;
-
-      /* Skip whitespace.  */
-      arg = skip_spaces (arg);
-
-      for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
-	cur_name[i] = arg[i];
-      cur_name[i] = '\0';
-      arg += i;
-
-      /* Check if the user provided a syscall name or a number.  */
-      syscall_number = (int) strtol (cur_name, &endptr, 0);
-      if (*endptr == '\0')
-	get_syscall_by_number (gdbarch, syscall_number, &s);
-      else
-	{
-	  /* We have a name.  Let's check if it's valid and convert it
-	     to a number.  */
-	  get_syscall_by_name (gdbarch, cur_name, &s);
-
-	  if (s.number == UNKNOWN_SYSCALL)
-	    /* Here we have to issue an error instead of a warning,
-	       because GDB cannot do anything useful if there's no
-	       syscall number to be caught.  */
-	    error (_("Unknown syscall name '%s'."), cur_name);
-	}
-
-      /* Ok, it's valid.  */
-      VEC_safe_push (int, result, s.number);
-    }
-
-  discard_cleanups (cleanup);
-  return result;
-}
-
-/* Implement the "catch syscall" command.  */
-
-static void
-catch_syscall_command_1 (char *arg, int from_tty, 
-			 struct cmd_list_element *command)
-{
-  int tempflag;
-  VEC(int) *filter;
-  struct syscall s;
-  struct gdbarch *gdbarch = get_current_arch ();
-
-  /* Checking if the feature if supported.  */
-  if (gdbarch_get_syscall_number_p (gdbarch) == 0)
-    error (_("The feature 'catch syscall' is not supported on \
-this architecture yet."));
-
-  tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
-
-  arg = skip_spaces (arg);
-
-  /* We need to do this first "dummy" translation in order
-     to get the syscall XML file loaded or, most important,
-     to display a warning to the user if there's no XML file
-     for his/her architecture.  */
-  get_syscall_by_number (gdbarch, 0, &s);
-
-  /* The allowed syntax is:
-     catch syscall
-     catch syscall <name | number> [<name | number> ... <name | number>]
-
-     Let's check if there's a syscall name.  */
-
-  if (arg != NULL)
-    filter = catch_syscall_split_args (arg);
-  else
-    filter = NULL;
-
-  create_syscall_event_catchpoint (tempflag, filter,
-				   &catch_syscall_breakpoint_ops);
-}
-
 static void
 catch_command (char *arg, int from_tty)
 {
@@ -15392,67 +14891,6 @@ single_step_breakpoint_inserted_here_p (struct address_space *aspace,
   return 0;
 }
 
-/* Returns 0 if 'bp' is NOT a syscall catchpoint,
-   non-zero otherwise.  */
-static int
-is_syscall_catchpoint_enabled (struct breakpoint *bp)
-{
-  if (syscall_catchpoint_p (bp)
-      && bp->enable_state != bp_disabled
-      && bp->enable_state != bp_call_disabled)
-    return 1;
-  else
-    return 0;
-}
-
-int
-catch_syscall_enabled (void)
-{
-  struct catch_syscall_inferior_data *inf_data
-    = get_catch_syscall_inferior_data (current_inferior ());
-
-  return inf_data->total_syscalls_count != 0;
-}
-
-int
-catching_syscall_number (int syscall_number)
-{
-  struct breakpoint *bp;
-
-  ALL_BREAKPOINTS (bp)
-    if (is_syscall_catchpoint_enabled (bp))
-      {
-	struct syscall_catchpoint *c = (struct syscall_catchpoint *) bp;
-
-	if (c->syscalls_to_be_caught)
-	  {
-            int i, iter;
-            for (i = 0;
-                 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
-                 i++)
-	      if (syscall_number == iter)
-		return 1;
-	  }
-	else
-	  return 1;
-      }
-
-  return 0;
-}
-
-/* Complete syscall names.  Used by "catch syscall".  */
-static VEC (char_ptr) *
-catch_syscall_completer (struct cmd_list_element *cmd,
-                         const char *text, const char *word)
-{
-  const char **list = get_syscall_names (get_current_arch ());
-  VEC (char_ptr) *retlist
-    = (list == NULL) ? NULL : complete_on_enum (list, word, word);
-
-  xfree (list);
-  return retlist;
-}
-
 /* Tracepoint-specific operations.  */
 
 /* Set tracepoint count to NUM.  */
@@ -16075,17 +15513,6 @@ add_catch_command (char *name, char *docstring,
 }
 
 static void
-clear_syscall_counts (struct inferior *inf)
-{
-  struct catch_syscall_inferior_data *inf_data
-    = get_catch_syscall_inferior_data (inf);
-
-  inf_data->total_syscalls_count = 0;
-  inf_data->any_syscall_count = 0;
-  VEC_free (int, inf_data->syscalls_counts);
-}
-
-static void
 save_command (char *arg, int from_tty)
 {
   printf_unfiltered (_("\"save\" must be followed by "
@@ -16320,18 +15747,6 @@ initialize_breakpoint_ops (void)
   ops->print_mention = print_mention_catch_exec;
   ops->print_recreate = print_recreate_catch_exec;
 
-  /* Syscall catchpoints.  */
-  ops = &catch_syscall_breakpoint_ops;
-  *ops = base_breakpoint_ops;
-  ops->dtor = dtor_catch_syscall;
-  ops->insert_location = insert_catch_syscall;
-  ops->remove_location = remove_catch_syscall;
-  ops->breakpoint_hit = breakpoint_hit_catch_syscall;
-  ops->print_it = print_it_catch_syscall;
-  ops->print_one = print_one_catch_syscall;
-  ops->print_mention = print_mention_catch_syscall;
-  ops->print_recreate = print_recreate_catch_syscall;
-
   /* Solib-related catchpoints.  */
   ops = &catch_solib_breakpoint_ops;
   *ops = base_breakpoint_ops;
@@ -16369,16 +15784,11 @@ _initialize_breakpoint (void)
 
   observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
   observer_attach_free_objfile (disable_breakpoints_in_freed_objfile);
-  observer_attach_inferior_exit (clear_syscall_counts);
   observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
 
   breakpoint_objfile_key
     = register_objfile_data_with_cleanup (NULL, free_breakpoint_probes);
 
-  catch_syscall_inferior_data
-    = register_inferior_data_with_cleanup (NULL,
-					   catch_syscall_inferior_data_cleanup);
-
   breakpoint_chain = 0;
   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
      before a breakpoint is set.  */
@@ -16681,16 +16091,6 @@ If REGEX is given, only stop for libraries matching the regular expression."),
 		     NULL,
 		     CATCH_PERMANENT,
 		     CATCH_TEMPORARY);
-  add_catch_command ("syscall", _("\
-Catch system calls by their names and/or numbers.\n\
-Arguments say which system calls to catch.  If no arguments\n\
-are given, every system call will be caught.\n\
-Arguments, if given, should be one or more system call names\n\
-(if your system supports that), or system call numbers."),
-		     catch_syscall_command_1,
-		     catch_syscall_completer,
-		     CATCH_PERMANENT,
-		     CATCH_TEMPORARY);
 
   c = add_com ("watch", class_breakpoint, watch_command, _("\
 Set a watchpoint for an expression.\n\