gdb/fbsd-tdep.c - third_party/binutils-gdb - Git at Google

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

    Copyright (C) 2002-2016 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 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 cleanup *old_chain;
   struct regcache *regcache;

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

   old_chain = save_inferior_ptid ();
   inferior_ptid = info->ptid;
   target_fetch_registers (regcache, -1);
   do_cleanups (old_chain);

   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_ELF 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);
 }
	/* Target-dependent code for FreeBSD, architecture-independent.

	Copyright (C) 2002-2016 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 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 cleanup *old_chain;
	struct regcache *regcache;

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

	old_chain = save_inferior_ptid ();
	inferior_ptid = info->ptid;
	target_fetch_registers (regcache, -1);
	do_cleanups (old_chain);

	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_ELF 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);
	}