Partial fix for PR breakpoints/10737: Make syscall info be per-arch instead of global

This patch intends to partially fix PR breakpoints/10737, which is
about making the syscall information (for the "catch syscall" command)
be per-arch, instead of global.  This is not a full fix because of the
other issues pointed by Pedro here:

  <https://sourceware.org/bugzilla/show_bug.cgi?id=10737#c5>

However, I consider it a good step towards the real fix.  It will also
help me fix <https://sourceware.org/bugzilla/show_bug.cgi?id=17402>.

What this patch does, basically, is move the "syscalls_info"
struct to gdbarch.  Currently, the syscall information is stored in a
global variable inside gdb/xml-syscall.c, which means that there is no
easy way to correlate this info with the current target or
architecture being used, for example.  This causes strange behaviors,
because the syscall info is not re-read when the arch changes.  For
example, if you put a syscall catchpoint in syscall 5 on i386 (syscall
open), and then load a x86_64 program on GDB and put the same syscall
5 there (fstat on x86_64), you will still see that GDB tells you that
it is catching "open", even though it is not.  With this patch, GDB
correctly says that it will be catching fstat syscalls.

  (gdb) set architecture i386
  The target architecture is assumed to be i386
  (gdb) catch syscall 5
  Catchpoint 1 (syscall 'open' [5])
  (gdb) set architecture i386:x86-64
  The target architecture is assumed to be i386:x86-64
  (gdb) catch syscall 5
  Catchpoint 2 (syscall 'open' [5])

But with the patch:

  (gdb) set architecture i386
  The target architecture is assumed to be i386
  (gdb) catch syscall 5
  Catchpoint 1 (syscall 'open' [5])
  (gdb) set architecture i386:x86-64
  The target architecture is assumed to be i386:x86-64
  (gdb) catch syscall 5
  Catchpoint 2 (syscall 'fstat' [5])

As I said, there are still some problems on the "catch syscall"
mechanism, because (for example) the user should be able to "catch
syscall open" on i386, and then expect "open" to be caught also on
x86_64.  Currently, it doesn't work.  I intend to work on this later.

gdb/
2014-11-20  Sergio Durigan Junior  <sergiodj@redhat.com>

	PR breakpoints/10737
	* amd64-linux-tdep.c (amd64_linux_init_abi_common): Adjust call to
	set_xml_syscall_file_name to provide gdbarch.
	* arm-linux-tdep.c (arm_linux_init_abi): Likewise.
	* bfin-linux-tdep.c (bfin_linux_init_abi): Likewise.
	* breakpoint.c (print_it_catch_syscall): Adjust call to
	get_syscall_by_number to provide gdbarch.
	(print_one_catch_syscall): Likewise.
	(print_mention_catch_syscall): Likewise.
	(print_recreate_catch_syscall): Likewise.
	(catch_syscall_split_args): Adjust calls to get_syscall_by_number
	and get_syscall_by_name to provide gdbarch.
	(catch_syscall_completer): Adjust call to get_syscall_names to
	provide gdbarch.
	* gdbarch.c: Regenerate.
	* gdbarch.h: Likewise.
	* gdbarch.sh: Forward declare "struct syscalls_info".
	(xml_syscall_file): New variable.
	(syscalls_info): Likewise.
	* i386-linux-tdep.c (i386_linux_init_abi): Adjust call to
	set_xml_syscall_file_name to provide gdbarch.
	* mips-linux-tdep.c (mips_linux_init_abi): Likewise.
	* ppc-linux-tdep.c (ppc_linux_init_abi): Likewise.
	* s390-linux-tdep.c (s390_gdbarch_init): Likewise.
	* sparc-linux-tdep.c (sparc32_linux_init_abi): Likewise.
	* sparc64-linux-tdep.c (sparc64_linux_init_abi): Likewise.
	* xml-syscall.c: Include gdbarch.h.
	(set_xml_syscall_file_name): Accept gdbarch parameter.
	(get_syscall_by_number): Likewise.
	(get_syscall_by_name): Likewise.
	(get_syscall_names): Likewise.
	(my_gdb_datadir): Delete global variable.
	(struct syscalls_info) <my_gdb_datadir>: New variable.
	(struct syscalls_info) <sysinfo>: Rename variable to
	"syscalls_info".
	(sysinfo): Delete global variable.
	(have_initialized_sysinfo): Likewise.
	(xml_syscall_file): Likewise.
	(sysinfo_free_syscalls_desc): Rename to...
	(syscalls_info_free_syscalls_desc): ... this.
	(free_syscalls_info): Rename "sysinfo" to "syscalls_info".  Adjust
	code to the new layout of "struct syscalls_info".
	(make_cleanup_free_syscalls_info): Rename parameter "sysinfo" to
	"syscalls_info".
	(syscall_create_syscall_desc): Likewise.
	(syscall_start_syscall): Likewise.
	(syscall_parse_xml): Likewise.
	(xml_init_syscalls_info): Likewise.  Drop "const" from return value.
	(init_sysinfo): Rename to...
	(init_syscalls_info): ...this.  Add gdbarch as a parameter.
	Adjust function to deal with gdbarch.
	(xml_get_syscall_number): Delete parameter sysinfo.  Accept
	gdbarch as a parameter.  Adjust code.
	(xml_get_syscall_name): Likewise.
	(xml_list_of_syscalls): Likewise.
	(set_xml_syscall_file_name): Accept gdbarch as parameter.
	(get_syscall_by_number): Likewise.
	(get_syscall_by_name): Likewise.
	(get_syscall_names): Likewise.
	* xml-syscall.h (set_xml_syscall_file_name): Likewise.
	(get_syscall_by_number): Likewise.
	(get_syscall_by_name): Likewise.
	(get_syscall_names): Likewise.

gdb/testsuite/
2014-11-20  Sergio Durigan Junior  <sergiodj@redhat.com>

	PR breakpoints/10737
	* gdb.base/catch-syscall.exp (do_syscall_tests): Call
	test_catch_syscall_multi_arch.
	(test_catch_syscall_multi_arch): New function.

1 files changed, 89 insertions, 79 deletions

diff --git a/gdb/xml-syscall.c b/gdb/xml-syscall.c
index 382446828ed..1da693255aa 100644
--- a/gdb/xml-syscall.c
+++ b/gdb/xml-syscall.c
@@ -22,6 +22,7 @@
 #include "gdbtypes.h"
 #include "xml-support.h"
 #include "xml-syscall.h"
+#include "gdbarch.h"
 
 /* For the struct syscall definition.  */
 #include "target.h"
@@ -46,14 +47,15 @@ syscall_warn_user (void)
 }
 
 void
-set_xml_syscall_file_name (const char *name)
+set_xml_syscall_file_name (const struct gdbarch *gdbarch,
+			   const char *name)
 {
   return;
 }
 
 void
-get_syscall_by_number (int syscall_number,
-                       struct syscall *s)
+get_syscall_by_number (const struct gdbarch *gdbarch,
+		       int syscall_number, struct syscall *s)
 {
   syscall_warn_user ();
   s->number = syscall_number;
@@ -61,8 +63,8 @@ get_syscall_by_number (int syscall_number,
 }
 
 void
-get_syscall_by_name (const char *syscall_name,
-                     struct syscall *s)
+get_syscall_by_name (const struct gdbarch *gdbarch,
+		     const char *syscall_name, struct syscall *s)
 {
   syscall_warn_user ();
   s->number = UNKNOWN_SYSCALL;
@@ -70,7 +72,7 @@ get_syscall_by_name (const char *syscall_name,
 }
 
 const char **
-get_syscall_names (void)
+get_syscall_names (const struct gdbarch *gdbarch)
 {
   syscall_warn_user ();
   return NULL;
@@ -78,10 +80,6 @@ get_syscall_names (void)
 
 #else /* ! HAVE_LIBEXPAT */
 
-/* Variable that will hold the last known data-directory.  This is useful to
-   know whether we should re-read the XML info for the target.  */
-static char *my_gdb_datadir = NULL;
-
 /* Structure which describes a syscall.  */
 typedef struct syscall_desc
 {
@@ -101,6 +99,12 @@ struct syscalls_info
   /* The syscalls.  */
 
   VEC(syscall_desc_p) *syscalls;
+
+  /* Variable that will hold the last known data-directory.  This is
+     useful to know whether we should re-read the XML info for the
+     target.  */
+
+  char *my_gdb_datadir;
 };
 
 /* Callback data for syscall information parsing.  */
@@ -108,19 +112,9 @@ struct syscall_parsing_data
 {
   /* The syscalls_info we are building.  */
 
-  struct syscalls_info *sysinfo;
+  struct syscalls_info *syscalls_info;
 };
 
-/* Structure used to store information about the available syscalls in
-   the system.  */
-static const struct syscalls_info *sysinfo = NULL;
-
-/* A flag to tell if we already initialized the structure above.  */
-static int have_initialized_sysinfo = 0;
-
-/* The filename of the syscall's XML.  */
-static const char *xml_syscall_file = NULL;
-
 static struct syscalls_info *
 allocate_syscalls_info (void)
 {
@@ -128,7 +122,7 @@ allocate_syscalls_info (void)
 }
 
 static void
-sysinfo_free_syscalls_desc (struct syscall_desc *sd)
+syscalls_info_free_syscalls_desc (struct syscall_desc *sd)
 {
   xfree (sd->name);
 }
@@ -136,27 +130,32 @@ sysinfo_free_syscalls_desc (struct syscall_desc *sd)
 static void
 free_syscalls_info (void *arg)
 {
-  struct syscalls_info *sysinfo = arg;
+  struct syscalls_info *syscalls_info = arg;
   struct syscall_desc *sysdesc;
   int i;
 
-  for (i = 0;
-       VEC_iterate (syscall_desc_p, sysinfo->syscalls, i, sysdesc);
-       i++)
-    sysinfo_free_syscalls_desc (sysdesc);
-  VEC_free (syscall_desc_p, sysinfo->syscalls);
+  xfree (syscalls_info->my_gdb_datadir);
+
+  if (syscalls_info->syscalls != NULL)
+    {
+      for (i = 0;
+	   VEC_iterate (syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
+	   i++)
+	syscalls_info_free_syscalls_desc (sysdesc);
+      VEC_free (syscall_desc_p, syscalls_info->syscalls);
+    }
 
-  xfree (sysinfo);
+  xfree (syscalls_info);
 }
 
 static struct cleanup *
-make_cleanup_free_syscalls_info (struct syscalls_info *sysinfo)
+make_cleanup_free_syscalls_info (struct syscalls_info *syscalls_info)
 {
-  return make_cleanup (free_syscalls_info, sysinfo);
+  return make_cleanup (free_syscalls_info, syscalls_info);
 }
 
 static void
-syscall_create_syscall_desc (struct syscalls_info *sysinfo,
+syscall_create_syscall_desc (struct syscalls_info *syscalls_info,
                              const char *name, int number)
 {
   struct syscall_desc *sysdesc = XCNEW (struct syscall_desc);
@@ -164,7 +163,7 @@ syscall_create_syscall_desc (struct syscalls_info *sysinfo,
   sysdesc->name = xstrdup (name);
   sysdesc->number = number;
 
-  VEC_safe_push (syscall_desc_p, sysinfo->syscalls, sysdesc);
+  VEC_safe_push (syscall_desc_p, syscalls_info->syscalls, sysdesc);
 }
 
 /* Handle the start of a <syscall> element.  */
@@ -194,7 +193,7 @@ syscall_start_syscall (struct gdb_xml_parser *parser,
     }
 
   gdb_assert (name);
-  syscall_create_syscall_desc (data->sysinfo, name, number);
+  syscall_create_syscall_desc (data->syscalls_info, name, number);
 }
 
 
@@ -225,15 +224,15 @@ syscall_parse_xml (const char *document, xml_fetch_another fetcher,
   struct cleanup *result_cleanup;
   struct syscall_parsing_data data;
 
-  data.sysinfo = allocate_syscalls_info ();
-  result_cleanup = make_cleanup_free_syscalls_info (data.sysinfo);
+  data.syscalls_info = allocate_syscalls_info ();
+  result_cleanup = make_cleanup_free_syscalls_info (data.syscalls_info);
 
   if (gdb_xml_parse_quick (_("syscalls info"), NULL,
 			   syselements, document, &data) == 0)
     {
       /* Parsed successfully.  */
       discard_cleanups (result_cleanup);
-      return data.sysinfo;
+      return data.syscalls_info;
     }
   else
     {
@@ -248,12 +247,12 @@ syscall_parse_xml (const char *document, xml_fetch_another fetcher,
    struct syscalls_info with the values.
    
    Returns the struct syscalls_info if the file is valid, NULL otherwise.  */
-static const struct syscalls_info *
+static struct syscalls_info *
 xml_init_syscalls_info (const char *filename)
 {
   char *full_file;
   char *dirname;
-  struct syscalls_info *sysinfo;
+  struct syscalls_info *syscalls_info;
   struct cleanup *back_to;
 
   full_file = xml_fetch_content_from_file (filename, gdb_datadir);
@@ -266,41 +265,47 @@ xml_init_syscalls_info (const char *filename)
   if (dirname != NULL)
     make_cleanup (xfree, dirname);
 
-  sysinfo = syscall_parse_xml (full_file,
-			       xml_fetch_content_from_file, dirname);
+  syscalls_info = syscall_parse_xml (full_file,
+				     xml_fetch_content_from_file, dirname);
   do_cleanups (back_to);
 
-  return sysinfo;
+  return syscalls_info;
 }
 
 /* Initializes the syscalls_info structure according to the
    architecture.  */
 static void
-init_sysinfo (void)
+init_syscalls_info (struct gdbarch *gdbarch)
 {
+  struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
+  const char *xml_syscall_file = gdbarch_xml_syscall_file (gdbarch);
+
   /* Should we re-read the XML info for this target?  */
-  if (my_gdb_datadir && filename_cmp (my_gdb_datadir, gdb_datadir) != 0)
+  if (syscalls_info != NULL && syscalls_info->my_gdb_datadir != NULL
+      && filename_cmp (syscalls_info->my_gdb_datadir, gdb_datadir) != 0)
     {
       /* The data-directory changed from the last time we used it.
 	 It means that we have to re-read the XML info.  */
-      have_initialized_sysinfo = 0;
-      xfree (my_gdb_datadir);
-      my_gdb_datadir = NULL;
-      if (sysinfo)
-	free_syscalls_info ((void *) sysinfo);
+      free_syscalls_info (syscalls_info);
+      syscalls_info = NULL;
+      set_gdbarch_syscalls_info (gdbarch, NULL);
     }
 
-  /* Did we already try to initialize the structure?  */
-  if (have_initialized_sysinfo)
+  /* Did we succeed at initializing this?  */
+  if (syscalls_info != NULL)
     return;
 
-  sysinfo = xml_init_syscalls_info (xml_syscall_file);
+  syscalls_info = xml_init_syscalls_info (xml_syscall_file);
 
-  have_initialized_sysinfo = 1;
+  /* If there was some error reading the XML file, we initialize
+     gdbarch->syscalls_info anyway, in order to store information
+     about our attempt.  */
+  if (syscalls_info == NULL)
+    syscalls_info = allocate_syscalls_info ();
 
-  if (sysinfo == NULL)
+  if (syscalls_info->syscalls == NULL)
     {
-      if (xml_syscall_file)
+      if (xml_syscall_file != NULL)
 	warning (_("Could not load the syscall XML file `%s/%s'."),
 		 gdb_datadir, xml_syscall_file);
       else
@@ -312,22 +317,25 @@ init_sysinfo (void)
     }
 
   /* Saving the data-directory used to read this XML info.  */
-  my_gdb_datadir = xstrdup (gdb_datadir);
+  syscalls_info->my_gdb_datadir = xstrdup (gdb_datadir);
+
+  set_gdbarch_syscalls_info (gdbarch, syscalls_info);
 }
 
 static int
-xml_get_syscall_number (const struct syscalls_info *sysinfo,
+xml_get_syscall_number (struct gdbarch *gdbarch,
                         const char *syscall_name)
 {
+  struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
   struct syscall_desc *sysdesc;
   int i;
 
-  if (sysinfo == NULL
+  if (syscalls_info == NULL
       || syscall_name == NULL)
     return UNKNOWN_SYSCALL;
 
   for (i = 0;
-       VEC_iterate(syscall_desc_p, sysinfo->syscalls, i, sysdesc);
+       VEC_iterate(syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
        i++)
     if (strcmp (sysdesc->name, syscall_name) == 0)
       return sysdesc->number;
@@ -336,18 +344,19 @@ xml_get_syscall_number (const struct syscalls_info *sysinfo,
 }
 
 static const char *
-xml_get_syscall_name (const struct syscalls_info *sysinfo,
+xml_get_syscall_name (struct gdbarch *gdbarch,
                       int syscall_number)
 {
+  struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
   struct syscall_desc *sysdesc;
   int i;
 
-  if (sysinfo == NULL
+  if (syscalls_info == NULL
       || syscall_number < 0)
     return NULL;
 
   for (i = 0;
-       VEC_iterate(syscall_desc_p, sysinfo->syscalls, i, sysdesc);
+       VEC_iterate(syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
        i++)
     if (sysdesc->number == syscall_number)
       return sysdesc->name;
@@ -356,21 +365,22 @@ xml_get_syscall_name (const struct syscalls_info *sysinfo,
 }
 
 static const char **
-xml_list_of_syscalls (const struct syscalls_info *sysinfo)
+xml_list_of_syscalls (struct gdbarch *gdbarch)
 {
+  struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
   struct syscall_desc *sysdesc;
   const char **names = NULL;
   int nsyscalls;
   int i;
 
-  if (sysinfo == NULL)
+  if (syscalls_info == NULL)
     return NULL;
 
-  nsyscalls = VEC_length (syscall_desc_p, sysinfo->syscalls);
+  nsyscalls = VEC_length (syscall_desc_p, syscalls_info->syscalls);
   names = xmalloc ((nsyscalls + 1) * sizeof (char *));
 
   for (i = 0;
-       VEC_iterate (syscall_desc_p, sysinfo->syscalls, i, sysdesc);
+       VEC_iterate (syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
        i++)
     names[i] = sysdesc->name;
 
@@ -380,37 +390,37 @@ xml_list_of_syscalls (const struct syscalls_info *sysinfo)
 }
 
 void
-set_xml_syscall_file_name (const char *name)
+set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name)
 {
-  xml_syscall_file = name;
+  set_gdbarch_xml_syscall_file (gdbarch, name);
 }
 
 void
-get_syscall_by_number (int syscall_number,
-                       struct syscall *s)
+get_syscall_by_number (struct gdbarch *gdbarch,
+		       int syscall_number, struct syscall *s)
 {
-  init_sysinfo ();
+  init_syscalls_info (gdbarch);
 
   s->number = syscall_number;
-  s->name = xml_get_syscall_name (sysinfo, syscall_number);
+  s->name = xml_get_syscall_name (gdbarch, syscall_number);
 }
 
 void
-get_syscall_by_name (const char *syscall_name,
-                     struct syscall *s)
+get_syscall_by_name (struct gdbarch *gdbarch,
+		     const char *syscall_name, struct syscall *s)
 {
-  init_sysinfo ();
+  init_syscalls_info (gdbarch);
 
-  s->number = xml_get_syscall_number (sysinfo, syscall_name);
+  s->number = xml_get_syscall_number (gdbarch, syscall_name);
   s->name = syscall_name;
 }
 
 const char **
-get_syscall_names (void)
+get_syscall_names (struct gdbarch *gdbarch)
 {
-  init_sysinfo ();
+  init_syscalls_info (gdbarch);
 
-  return xml_list_of_syscalls (sysinfo);
+  return xml_list_of_syscalls (gdbarch);
 }
 
 #endif /* ! HAVE_LIBEXPAT */