[deliverable/binutils-gdb.git] / gdb / fbsd-tdep.c

/* Target-dependent code for FreeBSD, architecture-independent.

   Copyright (C) 2002-2017 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 "auxv.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
#include "regset.h"
#include "gdbthread.h"
#include "xml-syscall.h"

#include "elf-bfd.h"
#include "fbsd-tdep.h"


/* This is how we want PTIDs from core files to be printed.  */

static const char *
fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
{
  static char buf[80];

  if (ptid_get_lwp (ptid) != 0)
    {
      xsnprintf (buf, sizeof buf, "LWP %ld", ptid_get_lwp (ptid));
      return buf;
    }

  return normal_pid_to_str (ptid);
}

/* Extract the name assigned to a thread from a core.  Returns the
   string in a static buffer.  */

static const char *
fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)
{
  static char buf[80];
  struct bfd_section *section;
  bfd_size_type size;
  char sectionstr[32];

  if (ptid_get_lwp (thr->ptid) != 0)
    {
      /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
	 whose contents are defined by a "struct thrmisc" declared in
	 <sys/procfs.h> on FreeBSD.  The per-thread name is stored as
	 a null-terminated string as the first member of the
	 structure.  Rather than define the full structure here, just
	 extract the null-terminated name from the start of the
	 note.  */
      xsnprintf (sectionstr, sizeof sectionstr, ".thrmisc/%ld",
		ptid_get_lwp (thr->ptid));
      section = bfd_get_section_by_name (core_bfd, sectionstr);
      if (section != NULL && bfd_section_size (core_bfd, section) > 0)
	{
	  /* Truncate the name if it is longer than "buf".  */
	  size = bfd_section_size (core_bfd, section);
	  if (size > sizeof buf - 1)
	    size = sizeof buf - 1;
	  if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,
					size)
	      && buf[0] != '\0')
	    {
	      buf[size] = '\0';

	      /* Note that each thread will report the process command
		 as its thread name instead of an empty name if a name
		 has not been set explicitly.  Return a NULL name in
		 that case.  */
	      if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)
		return buf;
	    }
	}
    }

  return NULL;
}

static int
find_signalled_thread (struct thread_info *info, void *data)
{
  if (info->suspend.stop_signal != GDB_SIGNAL_0
      && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
    return 1;

  return 0;
}

/* Structure for passing information from
   fbsd_collect_thread_registers via an iterator to
   fbsd_collect_regset_section_cb. */

struct fbsd_collect_regset_section_cb_data
{
  const struct regcache *regcache;
  bfd *obfd;
  char *note_data;
  int *note_size;
  unsigned long lwp;
  enum gdb_signal stop_signal;
  int abort_iteration;
};

static void
fbsd_collect_regset_section_cb (const char *sect_name, int size,
				const struct regset *regset,
				const char *human_name, void *cb_data)
{
  char *buf;
  struct fbsd_collect_regset_section_cb_data *data
    = (struct fbsd_collect_regset_section_cb_data *) cb_data;

  if (data->abort_iteration)
    return;

  gdb_assert (regset->collect_regset);

  buf = (char *) xmalloc (size);
  regset->collect_regset (regset, data->regcache, -1, buf, size);

  /* PRSTATUS still needs to be treated specially.  */
  if (strcmp (sect_name, ".reg") == 0)
    data->note_data = (char *) elfcore_write_prstatus
      (data->obfd, data->note_data, data->note_size, data->lwp,
       gdb_signal_to_host (data->stop_signal), buf);
  else
    data->note_data = (char *) elfcore_write_register_note
      (data->obfd, data->note_data, data->note_size,
       sect_name, buf, size);
  xfree (buf);

  if (data->note_data == NULL)
    data->abort_iteration = 1;
}

/* Records the thread's register state for the corefile note
   section.  */

static char *
fbsd_collect_thread_registers (const struct regcache *regcache,
			       ptid_t ptid, bfd *obfd,
			       char *note_data, int *note_size,
			       enum gdb_signal stop_signal)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  struct fbsd_collect_regset_section_cb_data data;

  data.regcache = regcache;
  data.obfd = obfd;
  data.note_data = note_data;
  data.note_size = note_size;
  data.stop_signal = stop_signal;
  data.abort_iteration = 0;
  data.lwp = ptid_get_lwp (ptid);

  gdbarch_iterate_over_regset_sections (gdbarch,
					fbsd_collect_regset_section_cb,
					&data, regcache);
  return data.note_data;
}

struct fbsd_corefile_thread_data
{
  struct gdbarch *gdbarch;
  bfd *obfd;
  char *note_data;
  int *note_size;
  enum gdb_signal stop_signal;
};

/* Records the thread's register state for the corefile note
   section.  */

static void
fbsd_corefile_thread (struct thread_info *info,
		      struct fbsd_corefile_thread_data *args)
{
  struct regcache *regcache;

  regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);

  target_fetch_registers (regcache, -1);

  args->note_data = fbsd_collect_thread_registers
    (regcache, info->ptid, args->obfd, args->note_data,
     args->note_size, args->stop_signal);
}

/* Create appropriate note sections for a corefile, returning them in
   allocated memory.  */

static char *
fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
{
  struct fbsd_corefile_thread_data thread_args;
  char *note_data = NULL;
  Elf_Internal_Ehdr *i_ehdrp;
  struct thread_info *curr_thr, *signalled_thr, *thr;

  /* Put a "FreeBSD" label in the ELF header.  */
  i_ehdrp = elf_elfheader (obfd);
  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;

  gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));

  if (get_exec_file (0))
    {
      const char *fname = lbasename (get_exec_file (0));
      char *psargs = xstrdup (fname);

      if (get_inferior_args ())
	psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
			   (char *) NULL);

      note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
					  fname, psargs);
    }

  /* Thread register information.  */
  TRY
    {
      update_thread_list ();
    }
  CATCH (e, RETURN_MASK_ERROR)
    {
      exception_print (gdb_stderr, e);
    }
  END_CATCH

  /* Like the kernel, prefer dumping the signalled thread first.
     "First thread" is what tools use to infer the signalled thread.
     In case there's more than one signalled thread, prefer the
     current thread, if it is signalled.  */
  curr_thr = inferior_thread ();
  if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
    signalled_thr = curr_thr;
  else
    {
      signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
      if (signalled_thr == NULL)
	signalled_thr = curr_thr;
    }

  thread_args.gdbarch = gdbarch;
  thread_args.obfd = obfd;
  thread_args.note_data = note_data;
  thread_args.note_size = note_size;
  thread_args.stop_signal = signalled_thr->suspend.stop_signal;

  fbsd_corefile_thread (signalled_thr, &thread_args);
  ALL_NON_EXITED_THREADS (thr)
    {
      if (thr == signalled_thr)
	continue;
      if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
	continue;

      fbsd_corefile_thread (thr, &thread_args);
    }

  note_data = thread_args.note_data;

  return note_data;
}

/* Print descriptions of FreeBSD-specific AUXV entries to FILE.  */

static void
fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
		       CORE_ADDR type, CORE_ADDR val)
{
  const char *name;
  const char *description;
  enum auxv_format format;

  switch (type)
    {
#define _TAGNAME(tag) #tag
#define TAGNAME(tag) _TAGNAME(AT_##tag)
#define TAG(tag, text, kind) \
      case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
      TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
      TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
      TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
      TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
      TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
      TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
      TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
      TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
      TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
    default:
      default_print_auxv_entry (gdbarch, file, type, val);
      return;
    }

  fprint_auxv_entry (file, name, description, format, type, val);
}

/* Implement the "get_syscall_number" gdbarch method.  */

static LONGEST
fbsd_get_syscall_number (struct gdbarch *gdbarch,
			 ptid_t ptid)
{

  /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
     native targets fetch the system call number from the
     'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
     However, system call catching requires this function to be
     set.  */

  internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
}

/* To be called from GDB_OSABI_FREEBSD handlers. */

void
fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
  set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
  set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
  set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);

  /* `catch syscall' */
  set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
  set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
}
Commit	Line	Data
a904c024 AA	1	/* Target-dependent code for FreeBSD, architecture-independent.
a904c024 AA	2
61baf725	3	Copyright (C) 2002-2017 Free Software Foundation, Inc.
a904c024 AA	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "defs.h"
82372b2f	21	#include "auxv.h"
a904c024 AA	22	#include "gdbcore.h"
	23	#include "inferior.h"
	24	#include "regcache.h"
	25	#include "regset.h"
	26	#include "gdbthread.h"
e6cdd38e	27	#include "xml-syscall.h"
a904c024	28
a904c024 AA	29	#include "elf-bfd.h"
	30	#include "fbsd-tdep.h"
	31
	32
79117428 JB	33	/* This is how we want PTIDs from core files to be printed. */
79117428 JB	34
7a114964	35	static const char *
79117428 JB	36	fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
	37	{
	38	static char buf[80];
	39
	40	if (ptid_get_lwp (ptid) != 0)
	41	{
	42	xsnprintf (buf, sizeof buf, "LWP %ld", ptid_get_lwp (ptid));
	43	return buf;
	44	}
	45
	46	return normal_pid_to_str (ptid);
	47	}
	48
	49	/* Extract the name assigned to a thread from a core. Returns the
	50	string in a static buffer. */
	51
	52	static const char *
	53	fbsd_core_thread_name (struct gdbarch gdbarch, struct thread_info thr)
	54	{
	55	static char buf[80];
	56	struct bfd_section *section;
	57	bfd_size_type size;
	58	char sectionstr[32];
	59
	60	if (ptid_get_lwp (thr->ptid) != 0)
	61	{
	62	/* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
	63	whose contents are defined by a "struct thrmisc" declared in
	64	<sys/procfs.h> on FreeBSD. The per-thread name is stored as
	65	a null-terminated string as the first member of the
	66	structure. Rather than define the full structure here, just
	67	extract the null-terminated name from the start of the
	68	note. */
	69	xsnprintf (sectionstr, sizeof sectionstr, ".thrmisc/%ld",
	70	ptid_get_lwp (thr->ptid));
	71	section = bfd_get_section_by_name (core_bfd, sectionstr);
	72	if (section != NULL && bfd_section_size (core_bfd, section) > 0)
	73	{
	74	/* Truncate the name if it is longer than "buf". */
	75	size = bfd_section_size (core_bfd, section);
	76	if (size > sizeof buf - 1)
	77	size = sizeof buf - 1;
	78	if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,
	79	size)
	80	&& buf[0] != '\0')
	81	{
	82	buf[size] = '\0';
	83
	84	/* Note that each thread will report the process command
	85	as its thread name instead of an empty name if a name
	86	has not been set explicitly. Return a NULL name in
	87	that case. */
	88	if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)
	89	return buf;
	90	}
	91	}
	92	}
	93
	94	return NULL;
	95	}
	96
a904c024 AA	97	static int
	98	find_signalled_thread (struct thread_info info, void data)
	99	{
	100	if (info->suspend.stop_signal != GDB_SIGNAL_0
	101	&& ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
	102	return 1;
	103
	104	return 0;
	105	}
	106
20a0aab3 JB	107	/* Structure for passing information from
	108	fbsd_collect_thread_registers via an iterator to
	109	fbsd_collect_regset_section_cb. */
a904c024 AA	110
	111	struct fbsd_collect_regset_section_cb_data
	112	{
	113	const struct regcache *regcache;
	114	bfd *obfd;
	115	char *note_data;
	116	int *note_size;
20a0aab3 JB	117	unsigned long lwp;
	118	enum gdb_signal stop_signal;
	119	int abort_iteration;
a904c024 AA	120	};
	121
	122	static void
	123	fbsd_collect_regset_section_cb (const char *sect_name, int size,
	124	const struct regset *regset,
	125	const char human_name, void cb_data)
	126	{
	127	char *buf;
7567e115 SM	128	struct fbsd_collect_regset_section_cb_data *data
7567e115 SM	129	= (struct fbsd_collect_regset_section_cb_data *) cb_data;
a904c024	130
20a0aab3 JB	131	if (data->abort_iteration)
	132	return;
	133
a904c024 AA	134	gdb_assert (regset->collect_regset);
a904c024 AA	135
224c3ddb	136	buf = (char *) xmalloc (size);
a904c024 AA	137	regset->collect_regset (regset, data->regcache, -1, buf, size);
	138
	139	/* PRSTATUS still needs to be treated specially. */
	140	if (strcmp (sect_name, ".reg") == 0)
	141	data->note_data = (char *) elfcore_write_prstatus
20a0aab3 JB	142	(data->obfd, data->note_data, data->note_size, data->lwp,
20a0aab3 JB	143	gdb_signal_to_host (data->stop_signal), buf);
a904c024 AA	144	else
	145	data->note_data = (char *) elfcore_write_register_note
	146	(data->obfd, data->note_data, data->note_size,
	147	sect_name, buf, size);
	148	xfree (buf);
20a0aab3 JB	149
	150	if (data->note_data == NULL)
	151	data->abort_iteration = 1;
	152	}
	153
	154	/* Records the thread's register state for the corefile note
	155	section. */
	156
	157	static char *
	158	fbsd_collect_thread_registers (const struct regcache *regcache,
	159	ptid_t ptid, bfd *obfd,
	160	char note_data, int note_size,
	161	enum gdb_signal stop_signal)
	162	{
	163	struct gdbarch *gdbarch = get_regcache_arch (regcache);
	164	struct fbsd_collect_regset_section_cb_data data;
	165
	166	data.regcache = regcache;
	167	data.obfd = obfd;
	168	data.note_data = note_data;
	169	data.note_size = note_size;
	170	data.stop_signal = stop_signal;
	171	data.abort_iteration = 0;
	172	data.lwp = ptid_get_lwp (ptid);
	173
	174	gdbarch_iterate_over_regset_sections (gdbarch,
	175	fbsd_collect_regset_section_cb,
	176	&data, regcache);
	177	return data.note_data;
	178	}
	179
	180	struct fbsd_corefile_thread_data
	181	{
	182	struct gdbarch *gdbarch;
	183	bfd *obfd;
	184	char *note_data;
	185	int *note_size;
	186	enum gdb_signal stop_signal;
	187	};
	188
	189	/* Records the thread's register state for the corefile note
	190	section. */
	191
	192	static void
	193	fbsd_corefile_thread (struct thread_info *info,
	194	struct fbsd_corefile_thread_data *args)
	195	{
20a0aab3 JB	196	struct regcache *regcache;
	197
	198	regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
	199
20a0aab3	200	target_fetch_registers (regcache, -1);
20a0aab3 JB	201
	202	args->note_data = fbsd_collect_thread_registers
	203	(regcache, info->ptid, args->obfd, args->note_data,
	204	args->note_size, args->stop_signal);
a904c024 AA	205	}
	206
	207	/* Create appropriate note sections for a corefile, returning them in
	208	allocated memory. */
	209
	210	static char *
	211	fbsd_make_corefile_notes (struct gdbarch gdbarch, bfd obfd, int *note_size)
	212	{
20a0aab3 JB	213	struct fbsd_corefile_thread_data thread_args;
20a0aab3 JB	214	char *note_data = NULL;
a904c024	215	Elf_Internal_Ehdr *i_ehdrp;
20a0aab3	216	struct thread_info curr_thr, signalled_thr, *thr;
a904c024 AA	217
	218	/* Put a "FreeBSD" label in the ELF header. */
	219	i_ehdrp = elf_elfheader (obfd);
	220	i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
	221
	222	gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));
	223
a904c024 AA	224	if (get_exec_file (0))
	225	{
	226	const char *fname = lbasename (get_exec_file (0));
	227	char *psargs = xstrdup (fname);
	228
	229	if (get_inferior_args ())
	230	psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
	231	(char *) NULL);
	232
	233	note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
	234	fname, psargs);
	235	}
	236
20a0aab3 JB	237	/* Thread register information. */
	238	TRY
	239	{
	240	update_thread_list ();
	241	}
	242	CATCH (e, RETURN_MASK_ERROR)
	243	{
	244	exception_print (gdb_stderr, e);
	245	}
	246	END_CATCH
	247
	248	/* Like the kernel, prefer dumping the signalled thread first.
	249	"First thread" is what tools use to infer the signalled thread.
	250	In case there's more than one signalled thread, prefer the
	251	current thread, if it is signalled. */
	252	curr_thr = inferior_thread ();
	253	if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
	254	signalled_thr = curr_thr;
	255	else
	256	{
	257	signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
	258	if (signalled_thr == NULL)
	259	signalled_thr = curr_thr;
	260	}
	261
	262	thread_args.gdbarch = gdbarch;
	263	thread_args.obfd = obfd;
	264	thread_args.note_data = note_data;
	265	thread_args.note_size = note_size;
	266	thread_args.stop_signal = signalled_thr->suspend.stop_signal;
	267
	268	fbsd_corefile_thread (signalled_thr, &thread_args);
	269	ALL_NON_EXITED_THREADS (thr)
	270	{
	271	if (thr == signalled_thr)
	272	continue;
	273	if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
	274	continue;
	275
	276	fbsd_corefile_thread (thr, &thread_args);
	277	}
	278
	279	note_data = thread_args.note_data;
	280
a904c024 AA	281	return note_data;
	282	}
	283
82372b2f JB	284	/* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
	285
	286	static void
	287	fbsd_print_auxv_entry (struct gdbarch gdbarch, struct ui_file file,
	288	CORE_ADDR type, CORE_ADDR val)
	289	{
	290	const char *name;
	291	const char *description;
	292	enum auxv_format format;
	293
	294	switch (type)
	295	{
	296	#define _TAGNAME(tag) #tag
	297	#define TAGNAME(tag) _TAGNAME(AT_##tag)
	298	#define TAG(tag, text, kind) \
	299	case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
	300	TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
	301	TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
	302	TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
	303	TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
	304	TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
	305	TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
	306	TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
	307	TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
	308	TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
	309	default:
	310	default_print_auxv_entry (gdbarch, file, type, val);
	311	return;
	312	}
	313
	314	fprint_auxv_entry (file, name, description, format, type, val);
	315	}
	316
e6cdd38e JB	317	/* Implement the "get_syscall_number" gdbarch method. */
	318
	319	static LONGEST
	320	fbsd_get_syscall_number (struct gdbarch *gdbarch,
	321	ptid_t ptid)
	322	{
	323
	324	/* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
	325	native targets fetch the system call number from the
	326	'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
	327	However, system call catching requires this function to be
	328	set. */
	329
	330	internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
	331	}
	332
1736a7bd	333	/* To be called from GDB_OSABI_FREEBSD handlers. */
a904c024 AA	334
	335	void
	336	fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	337	{
79117428 JB	338	set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
79117428 JB	339	set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
a904c024	340	set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
82372b2f	341	set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
e6cdd38e JB	342
	343	/* `catch syscall' */
	344	set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
	345	set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
a904c024	346	}