[deliverable/binutils-gdb.git] / gdb / xml-syscall.c

/* Functions that provide the mechanism to parse a syscall XML file
   and get its values.

   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 "gdbtypes.h"
#include "xml-support.h"
#include "xml-syscall.h"
#include "gdbarch.h"

/* For the struct syscall definition.  */
#include "target.h"

#include "filenames.h"

#ifndef HAVE_LIBEXPAT

/* Dummy functions to indicate that there's no support for fetching
   syscalls information.  */

static void
syscall_warn_user (void)
{
  static int have_warned = 0;
  if (!have_warned)
    {
      have_warned = 1;
      warning (_("Can not parse XML syscalls information; XML support was "
		 "disabled at compile time."));
    }
}

void
set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name)
{
  return;
}

void
get_syscall_by_number (struct gdbarch *gdbarch,
		       int syscall_number, struct syscall *s)
{
  syscall_warn_user ();
  s->number = syscall_number;
  s->name = NULL;
}

void
get_syscall_by_name (struct gdbarch *gdbarch, const char *syscall_name,
		     struct syscall *s)
{
  syscall_warn_user ();
  s->number = UNKNOWN_SYSCALL;
  s->name = syscall_name;
}

const char **
get_syscall_names (struct gdbarch *gdbarch)
{
  syscall_warn_user ();
  return NULL;
}

#else /* ! HAVE_LIBEXPAT */

/* Structure which describes a syscall.  */
typedef struct syscall_desc
{
  /* The syscall number.  */

  int number;

  /* The syscall name.  */

  char *name;
} *syscall_desc_p;
DEF_VEC_P(syscall_desc_p);

/* Structure that represents syscalls information.  */
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.  */
struct syscall_parsing_data
{
  /* The syscalls_info we are building.  */

  struct syscalls_info *syscalls_info;
};

static struct syscalls_info *
allocate_syscalls_info (void)
{
  return XCNEW (struct syscalls_info);
}

static void
syscalls_info_free_syscalls_desc (struct syscall_desc *sd)
{
  xfree (sd->name);
}

static void
free_syscalls_info (void *arg)
{
  struct syscalls_info *syscalls_info = arg;
  struct syscall_desc *sysdesc;
  int i;

  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 (syscalls_info);
}

static struct cleanup *
make_cleanup_free_syscalls_info (struct syscalls_info *syscalls_info)
{
  return make_cleanup (free_syscalls_info, syscalls_info);
}

static void
syscall_create_syscall_desc (struct syscalls_info *syscalls_info,
                             const char *name, int number)
{
  struct syscall_desc *sysdesc = XCNEW (struct syscall_desc);

  sysdesc->name = xstrdup (name);
  sysdesc->number = number;

  VEC_safe_push (syscall_desc_p, syscalls_info->syscalls, sysdesc);
}

/* Handle the start of a <syscall> element.  */
static void
syscall_start_syscall (struct gdb_xml_parser *parser,
                       const struct gdb_xml_element *element,
                       void *user_data, VEC(gdb_xml_value_s) *attributes)
{
  struct syscall_parsing_data *data = user_data;
  struct gdb_xml_value *attrs = VEC_address (gdb_xml_value_s, attributes);
  int len, i;
  /* syscall info.  */
  char *name = NULL;
  int number = 0;

  len = VEC_length (gdb_xml_value_s, attributes);

  for (i = 0; i < len; i++)
    {
      if (strcmp (attrs[i].name, "name") == 0)
        name = attrs[i].value;
      else if (strcmp (attrs[i].name, "number") == 0)
        number = * (ULONGEST *) attrs[i].value;
      else
        internal_error (__FILE__, __LINE__,
                        _("Unknown attribute name '%s'."), attrs[i].name);
    }

  gdb_assert (name);
  syscall_create_syscall_desc (data->syscalls_info, name, number);
}


/* The elements and attributes of an XML syscall document.  */
static const struct gdb_xml_attribute syscall_attr[] = {
  { "number", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
  { "name", GDB_XML_AF_NONE, NULL, NULL },
  { NULL, GDB_XML_AF_NONE, NULL, NULL }
};

static const struct gdb_xml_element syscalls_info_children[] = {
  { "syscall", syscall_attr, NULL,
    GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
    syscall_start_syscall, NULL },
  { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};

static const struct gdb_xml_element syselements[] = {
  { "syscalls_info", NULL, syscalls_info_children,
    GDB_XML_EF_NONE, NULL, NULL },
  { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};

static struct syscalls_info *
syscall_parse_xml (const char *document, xml_fetch_another fetcher,
                   void *fetcher_baton)
{
  struct cleanup *result_cleanup;
  struct syscall_parsing_data data;

  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.syscalls_info;
    }
  else
    {
      warning (_("Could not load XML syscalls info; ignoring"));
      do_cleanups (result_cleanup);
      return NULL;
    }
}

/* Function responsible for initializing the information
   about the syscalls.  It reads the XML file and fills the
   struct syscalls_info with the values.
   
   Returns the struct syscalls_info if the file is valid, NULL otherwise.  */
static struct syscalls_info *
xml_init_syscalls_info (const char *filename)
{
  char *full_file;
  char *dirname;
  struct syscalls_info *syscalls_info;
  struct cleanup *back_to;

  full_file = xml_fetch_content_from_file (filename, gdb_datadir);
  if (full_file == NULL)
    return NULL;

  back_to = make_cleanup (xfree, full_file);

  dirname = ldirname (filename);
  if (dirname != NULL)
    make_cleanup (xfree, dirname);

  syscalls_info = syscall_parse_xml (full_file,
				     xml_fetch_content_from_file, dirname);
  do_cleanups (back_to);

  return syscalls_info;
}

/* Initializes the syscalls_info structure according to the
   architecture.  */
static 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 (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.  */
      free_syscalls_info (syscalls_info);
      syscalls_info = NULL;
      set_gdbarch_syscalls_info (gdbarch, NULL);
    }

  /* Did we succeed at initializing this?  */
  if (syscalls_info != NULL)
    return;

  syscalls_info = xml_init_syscalls_info (xml_syscall_file);

  /* 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 (syscalls_info->syscalls == NULL)
    {
      if (xml_syscall_file != NULL)
	warning (_("Could not load the syscall XML file `%s/%s'."),
		 gdb_datadir, xml_syscall_file);
      else
	warning (_("There is no XML file to open."));

      warning (_("GDB will not be able to display "
		 "syscall names nor to verify if\n"
		 "any provided syscall numbers are valid."));
    }

  /* Saving the data-directory used to read this XML info.  */
  syscalls_info->my_gdb_datadir = xstrdup (gdb_datadir);

  set_gdbarch_syscalls_info (gdbarch, syscalls_info);
}

static int
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 (syscalls_info == NULL
      || syscall_name == NULL)
    return UNKNOWN_SYSCALL;

  for (i = 0;
       VEC_iterate(syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
       i++)
    if (strcmp (sysdesc->name, syscall_name) == 0)
      return sysdesc->number;

  return UNKNOWN_SYSCALL;
}

static const char *
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 (syscalls_info == NULL
      || syscall_number < 0)
    return NULL;

  for (i = 0;
       VEC_iterate(syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
       i++)
    if (sysdesc->number == syscall_number)
      return sysdesc->name;

  return NULL;
}

static const char **
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 (syscalls_info == NULL)
    return NULL;

  nsyscalls = VEC_length (syscall_desc_p, syscalls_info->syscalls);
  names = xmalloc ((nsyscalls + 1) * sizeof (char *));

  for (i = 0;
       VEC_iterate (syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
       i++)
    names[i] = sysdesc->name;

  names[i] = NULL;

  return names;
}

void
set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name)
{
  set_gdbarch_xml_syscall_file (gdbarch, name);
}

void
get_syscall_by_number (struct gdbarch *gdbarch,
		       int syscall_number, struct syscall *s)
{
  init_syscalls_info (gdbarch);

  s->number = syscall_number;
  s->name = xml_get_syscall_name (gdbarch, syscall_number);
}

void
get_syscall_by_name (struct gdbarch *gdbarch,
		     const char *syscall_name, struct syscall *s)
{
  init_syscalls_info (gdbarch);

  s->number = xml_get_syscall_number (gdbarch, syscall_name);
  s->name = syscall_name;
}

const char **
get_syscall_names (struct gdbarch *gdbarch)
{
  init_syscalls_info (gdbarch);

  return xml_list_of_syscalls (gdbarch);
}

#endif /* ! HAVE_LIBEXPAT */
Commit	Line	Data
	1	/* Functions that provide the mechanism to parse a syscall XML file
	2	and get its values.
	3
	4	Copyright (C) 2009-2015 Free Software Foundation, Inc.
	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 3 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	20
	21	#include "defs.h"
	22	#include "gdbtypes.h"
	23	#include "xml-support.h"
	24	#include "xml-syscall.h"
	25	#include "gdbarch.h"
	26
	27	/* For the struct syscall definition. */
	28	#include "target.h"
	29
	30	#include "filenames.h"
	31
	32	#ifndef HAVE_LIBEXPAT
	33
	34	/* Dummy functions to indicate that there's no support for fetching
	35	syscalls information. */
	36
	37	static void
	38	syscall_warn_user (void)
	39	{
	40	static int have_warned = 0;
	41	if (!have_warned)
	42	{
	43	have_warned = 1;
	44	warning (_("Can not parse XML syscalls information; XML support was "
	45	"disabled at compile time."));
	46	}
	47	}
	48
	49	void
	50	set_xml_syscall_file_name (struct gdbarch gdbarch, const char name)
	51	{
	52	return;
	53	}
	54
	55	void
	56	get_syscall_by_number (struct gdbarch *gdbarch,
	57	int syscall_number, struct syscall *s)
	58	{
	59	syscall_warn_user ();
	60	s->number = syscall_number;
	61	s->name = NULL;
	62	}
	63
	64	void
	65	get_syscall_by_name (struct gdbarch gdbarch, const char syscall_name,
	66	struct syscall *s)
	67	{
	68	syscall_warn_user ();
	69	s->number = UNKNOWN_SYSCALL;
	70	s->name = syscall_name;
	71	}
	72
	73	const char **
	74	get_syscall_names (struct gdbarch *gdbarch)
	75	{
	76	syscall_warn_user ();
	77	return NULL;
	78	}
	79
	80	#else /* ! HAVE_LIBEXPAT */
	81
	82	/* Structure which describes a syscall. */
	83	typedef struct syscall_desc
	84	{
	85	/* The syscall number. */
	86
	87	int number;
	88
	89	/* The syscall name. */
	90
	91	char *name;
	92	} *syscall_desc_p;
	93	DEF_VEC_P(syscall_desc_p);
	94
	95	/* Structure that represents syscalls information. */
	96	struct syscalls_info
	97	{
	98	/* The syscalls. */
	99
	100	VEC(syscall_desc_p) *syscalls;
	101
	102	/* Variable that will hold the last known data-directory. This is
	103	useful to know whether we should re-read the XML info for the
	104	target. */
	105
	106	char *my_gdb_datadir;
	107	};
	108
	109	/* Callback data for syscall information parsing. */
	110	struct syscall_parsing_data
	111	{
	112	/* The syscalls_info we are building. */
	113
	114	struct syscalls_info *syscalls_info;
	115	};
	116
	117	static struct syscalls_info *
	118	allocate_syscalls_info (void)
	119	{
	120	return XCNEW (struct syscalls_info);
	121	}
	122
	123	static void
	124	syscalls_info_free_syscalls_desc (struct syscall_desc *sd)
	125	{
	126	xfree (sd->name);
	127	}
	128
	129	static void
	130	free_syscalls_info (void *arg)
	131	{
	132	struct syscalls_info *syscalls_info = arg;
	133	struct syscall_desc *sysdesc;
	134	int i;
	135
	136	xfree (syscalls_info->my_gdb_datadir);
	137
	138	if (syscalls_info->syscalls != NULL)
	139	{
	140	for (i = 0;
	141	VEC_iterate (syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
	142	i++)
	143	syscalls_info_free_syscalls_desc (sysdesc);
	144	VEC_free (syscall_desc_p, syscalls_info->syscalls);
	145	}
	146
	147	xfree (syscalls_info);
	148	}
	149
	150	static struct cleanup *
	151	make_cleanup_free_syscalls_info (struct syscalls_info *syscalls_info)
	152	{
	153	return make_cleanup (free_syscalls_info, syscalls_info);
	154	}
	155
	156	static void
	157	syscall_create_syscall_desc (struct syscalls_info *syscalls_info,
	158	const char *name, int number)
	159	{
	160	struct syscall_desc *sysdesc = XCNEW (struct syscall_desc);
	161
	162	sysdesc->name = xstrdup (name);
	163	sysdesc->number = number;
	164
	165	VEC_safe_push (syscall_desc_p, syscalls_info->syscalls, sysdesc);
	166	}
	167
	168	/* Handle the start of a <syscall> element. */
	169	static void
	170	syscall_start_syscall (struct gdb_xml_parser *parser,
	171	const struct gdb_xml_element *element,
	172	void user_data, VEC(gdb_xml_value_s) attributes)
	173	{
	174	struct syscall_parsing_data *data = user_data;
	175	struct gdb_xml_value *attrs = VEC_address (gdb_xml_value_s, attributes);
	176	int len, i;
	177	/* syscall info. */
	178	char *name = NULL;
	179	int number = 0;
	180
	181	len = VEC_length (gdb_xml_value_s, attributes);
	182
	183	for (i = 0; i < len; i++)
	184	{
	185	if (strcmp (attrs[i].name, "name") == 0)
	186	name = attrs[i].value;
	187	else if (strcmp (attrs[i].name, "number") == 0)
	188	number = * (ULONGEST *) attrs[i].value;
	189	else
	190	internal_error (__FILE__, __LINE__,
	191	_("Unknown attribute name '%s'."), attrs[i].name);
	192	}
	193
	194	gdb_assert (name);
	195	syscall_create_syscall_desc (data->syscalls_info, name, number);
	196	}
	197
	198
	199	/* The elements and attributes of an XML syscall document. */
	200	static const struct gdb_xml_attribute syscall_attr[] = {
	201	{ "number", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
	202	{ "name", GDB_XML_AF_NONE, NULL, NULL },
	203	{ NULL, GDB_XML_AF_NONE, NULL, NULL }
	204	};
	205
	206	static const struct gdb_xml_element syscalls_info_children[] = {
	207	{ "syscall", syscall_attr, NULL,
	208	GDB_XML_EF_OPTIONAL \| GDB_XML_EF_REPEATABLE,
	209	syscall_start_syscall, NULL },
	210	{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
	211	};
	212
	213	static const struct gdb_xml_element syselements[] = {
	214	{ "syscalls_info", NULL, syscalls_info_children,
	215	GDB_XML_EF_NONE, NULL, NULL },
	216	{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
	217	};
	218
	219	static struct syscalls_info *
	220	syscall_parse_xml (const char *document, xml_fetch_another fetcher,
	221	void *fetcher_baton)
	222	{
	223	struct cleanup *result_cleanup;
	224	struct syscall_parsing_data data;
	225
	226	data.syscalls_info = allocate_syscalls_info ();
	227	result_cleanup = make_cleanup_free_syscalls_info (data.syscalls_info);
	228
	229	if (gdb_xml_parse_quick (_("syscalls info"), NULL,
	230	syselements, document, &data) == 0)
	231	{
	232	/* Parsed successfully. */
	233	discard_cleanups (result_cleanup);
	234	return data.syscalls_info;
	235	}
	236	else
	237	{
	238	warning (_("Could not load XML syscalls info; ignoring"));
	239	do_cleanups (result_cleanup);
	240	return NULL;
	241	}
	242	}
	243
	244	/* Function responsible for initializing the information
	245	about the syscalls. It reads the XML file and fills the
	246	struct syscalls_info with the values.
	247
	248	Returns the struct syscalls_info if the file is valid, NULL otherwise. */
	249	static struct syscalls_info *
	250	xml_init_syscalls_info (const char *filename)
	251	{
	252	char *full_file;
	253	char *dirname;
	254	struct syscalls_info *syscalls_info;
	255	struct cleanup *back_to;
	256
	257	full_file = xml_fetch_content_from_file (filename, gdb_datadir);
	258	if (full_file == NULL)
	259	return NULL;
	260
	261	back_to = make_cleanup (xfree, full_file);
	262
	263	dirname = ldirname (filename);
	264	if (dirname != NULL)
	265	make_cleanup (xfree, dirname);
	266
	267	syscalls_info = syscall_parse_xml (full_file,
	268	xml_fetch_content_from_file, dirname);
	269	do_cleanups (back_to);
	270
	271	return syscalls_info;
	272	}
	273
	274	/* Initializes the syscalls_info structure according to the
	275	architecture. */
	276	static void
	277	init_syscalls_info (struct gdbarch *gdbarch)
	278	{
	279	struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
	280	const char *xml_syscall_file = gdbarch_xml_syscall_file (gdbarch);
	281
	282	/* Should we re-read the XML info for this target? */
	283	if (syscalls_info != NULL && syscalls_info->my_gdb_datadir != NULL
	284	&& filename_cmp (syscalls_info->my_gdb_datadir, gdb_datadir) != 0)
	285	{
	286	/* The data-directory changed from the last time we used it.
	287	It means that we have to re-read the XML info. */
	288	free_syscalls_info (syscalls_info);
	289	syscalls_info = NULL;
	290	set_gdbarch_syscalls_info (gdbarch, NULL);
	291	}
	292
	293	/* Did we succeed at initializing this? */
	294	if (syscalls_info != NULL)
	295	return;
	296
	297	syscalls_info = xml_init_syscalls_info (xml_syscall_file);
	298
	299	/* If there was some error reading the XML file, we initialize
	300	gdbarch->syscalls_info anyway, in order to store information
	301	about our attempt. */
	302	if (syscalls_info == NULL)
	303	syscalls_info = allocate_syscalls_info ();
	304
	305	if (syscalls_info->syscalls == NULL)
	306	{
	307	if (xml_syscall_file != NULL)
	308	warning (_("Could not load the syscall XML file `%s/%s'."),
	309	gdb_datadir, xml_syscall_file);
	310	else
	311	warning (_("There is no XML file to open."));
	312
	313	warning (_("GDB will not be able to display "
	314	"syscall names nor to verify if\n"
	315	"any provided syscall numbers are valid."));
	316	}
	317
	318	/* Saving the data-directory used to read this XML info. */
	319	syscalls_info->my_gdb_datadir = xstrdup (gdb_datadir);
	320
	321	set_gdbarch_syscalls_info (gdbarch, syscalls_info);
	322	}
	323
	324	static int
	325	xml_get_syscall_number (struct gdbarch *gdbarch,
	326	const char *syscall_name)
	327	{
	328	struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
	329	struct syscall_desc *sysdesc;
	330	int i;
	331
	332	if (syscalls_info == NULL
	333	\|\| syscall_name == NULL)
	334	return UNKNOWN_SYSCALL;
	335
	336	for (i = 0;
	337	VEC_iterate(syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
	338	i++)
	339	if (strcmp (sysdesc->name, syscall_name) == 0)
	340	return sysdesc->number;
	341
	342	return UNKNOWN_SYSCALL;
	343	}
	344
	345	static const char *
	346	xml_get_syscall_name (struct gdbarch *gdbarch,
	347	int syscall_number)
	348	{
	349	struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
	350	struct syscall_desc *sysdesc;
	351	int i;
	352
	353	if (syscalls_info == NULL
	354	\|\| syscall_number < 0)
	355	return NULL;
	356
	357	for (i = 0;
	358	VEC_iterate(syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
	359	i++)
	360	if (sysdesc->number == syscall_number)
	361	return sysdesc->name;
	362
	363	return NULL;
	364	}
	365
	366	static const char **
	367	xml_list_of_syscalls (struct gdbarch *gdbarch)
	368	{
	369	struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
	370	struct syscall_desc *sysdesc;
	371	const char **names = NULL;
	372	int nsyscalls;
	373	int i;
	374
	375	if (syscalls_info == NULL)
	376	return NULL;
	377
	378	nsyscalls = VEC_length (syscall_desc_p, syscalls_info->syscalls);
	379	names = xmalloc ((nsyscalls + 1) * sizeof (char *));
	380
	381	for (i = 0;
	382	VEC_iterate (syscall_desc_p, syscalls_info->syscalls, i, sysdesc);
	383	i++)
	384	names[i] = sysdesc->name;
	385
	386	names[i] = NULL;
	387
	388	return names;
	389	}
	390
	391	void
	392	set_xml_syscall_file_name (struct gdbarch gdbarch, const char name)
	393	{
	394	set_gdbarch_xml_syscall_file (gdbarch, name);
	395	}
	396
	397	void
	398	get_syscall_by_number (struct gdbarch *gdbarch,
	399	int syscall_number, struct syscall *s)
	400	{
	401	init_syscalls_info (gdbarch);
	402
	403	s->number = syscall_number;
	404	s->name = xml_get_syscall_name (gdbarch, syscall_number);
	405	}
	406
	407	void
	408	get_syscall_by_name (struct gdbarch *gdbarch,
	409	const char syscall_name, struct syscall s)
	410	{
	411	init_syscalls_info (gdbarch);
	412
	413	s->number = xml_get_syscall_number (gdbarch, syscall_name);
	414	s->name = syscall_name;
	415	}
	416
	417	const char **
	418	get_syscall_names (struct gdbarch *gdbarch)
	419	{
	420	init_syscalls_info (gdbarch);
	421
	422	return xml_list_of_syscalls (gdbarch);
	423	}
	424
	425	#endif /* ! HAVE_LIBEXPAT */