[thirdparty/binutils-gdb.git] / gdb / nat / amd64-linux-siginfo.c

/* Low-level siginfo manipulation for amd64.

   Copyright (C) 2002-2023 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 "gdbsupport/common-defs.h"
#include <signal.h>
#include "amd64-linux-siginfo.h"

#define GDB_SI_SIZE 128

/* The types below define the most complete kernel siginfo types known
   for the architecture, independent of the system/libc headers.  They
   are named from a 64-bit kernel's perspective:

   | layout | type                 |
   |--------+----------------------|
   | 64-bit | nat_siginfo_t        |
   | 32-bit | compat_siginfo_t     |
   | x32    | compat_x32_siginfo_t |
*/

#ifndef __ILP32__

typedef int nat_int_t;
typedef unsigned long nat_uptr_t;

typedef int nat_time_t;
typedef int nat_timer_t;

/* For native 64-bit, clock_t in _sigchld is 64-bit.  */
typedef long nat_clock_t;

union nat_sigval_t
{
  nat_int_t sival_int;
  nat_uptr_t sival_ptr;
};

struct nat_siginfo_t
{
  int si_signo;
  int si_errno;
  int si_code;

  union
  {
    int _pad[((128 / sizeof (int)) - 4)];
    /* kill() */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
    } _kill;

    /* POSIX.1b timers */
    struct
    {
      nat_timer_t _tid;
      int _overrun;
      nat_sigval_t _sigval;
    } _timer;

    /* POSIX.1b signals */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
      nat_sigval_t _sigval;
    } _rt;

    /* SIGCHLD */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
      int _status;
      nat_clock_t _utime;
      nat_clock_t _stime;
    } _sigchld;

    /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
    struct
    {
      nat_uptr_t _addr;
      short int _addr_lsb;
      struct
      {
	nat_uptr_t _lower;
	nat_uptr_t _upper;
      } si_addr_bnd;
    } _sigfault;

    /* SIGPOLL */
    struct
    {
      int _band;
      int _fd;
    } _sigpoll;
  } _sifields;
};

#endif /* __ILP32__ */

/* These types below (compat_*) define a siginfo type that is layout
   compatible with the siginfo type exported by the 32-bit userspace
   support.  */

typedef int compat_int_t;
typedef unsigned int compat_uptr_t;

typedef int compat_time_t;
typedef int compat_timer_t;
typedef int compat_clock_t;

struct compat_timeval
{
  compat_time_t tv_sec;
  int tv_usec;
};

union compat_sigval_t
{
  compat_int_t sival_int;
  compat_uptr_t sival_ptr;
};

struct compat_siginfo_t
{
  int si_signo;
  int si_errno;
  int si_code;

  union
  {
    int _pad[((128 / sizeof (int)) - 3)];

    /* kill() */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
    } _kill;

    /* POSIX.1b timers */
    struct
    {
      compat_timer_t _tid;
      int _overrun;
      compat_sigval_t _sigval;
    } _timer;

    /* POSIX.1b signals */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
      compat_sigval_t _sigval;
    } _rt;

    /* SIGCHLD */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
      int _status;
      compat_clock_t _utime;
      compat_clock_t _stime;
    } _sigchld;

    /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
    struct
    {
      unsigned int _addr;
      short int _addr_lsb;
      struct
      {
	unsigned int _lower;
	unsigned int _upper;
      } si_addr_bnd;
    } _sigfault;

    /* SIGPOLL */
    struct
    {
      int _band;
      int _fd;
    } _sigpoll;
  } _sifields;
};

/* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes.  */
typedef long __attribute__ ((__aligned__ (4))) compat_x32_clock_t;

struct __attribute__ ((__aligned__ (8))) compat_x32_siginfo_t
{
  int si_signo;
  int si_errno;
  int si_code;

  union
  {
    int _pad[((128 / sizeof (int)) - 3)];

    /* kill() */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
    } _kill;

    /* POSIX.1b timers */
    struct
    {
      compat_timer_t _tid;
      int _overrun;
      compat_sigval_t _sigval;
    } _timer;

    /* POSIX.1b signals */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
      compat_sigval_t _sigval;
    } _rt;

    /* SIGCHLD */
    struct
    {
      unsigned int _pid;
      unsigned int _uid;
      int _status;
      compat_x32_clock_t _utime;
      compat_x32_clock_t _stime;
    } _sigchld;

    /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
    struct
    {
      unsigned int _addr;
      unsigned int _addr_lsb;
    } _sigfault;

    /* SIGPOLL */
    struct
    {
      int _band;
      int _fd;
    } _sigpoll;
  } _sifields;
};

/* To simplify usage of siginfo fields.  */

#define cpt_si_pid _sifields._kill._pid
#define cpt_si_uid _sifields._kill._uid
#define cpt_si_timerid _sifields._timer._tid
#define cpt_si_overrun _sifields._timer._overrun
#define cpt_si_status _sifields._sigchld._status
#define cpt_si_utime _sifields._sigchld._utime
#define cpt_si_stime _sifields._sigchld._stime
#define cpt_si_ptr _sifields._rt._sigval.sival_ptr
#define cpt_si_addr _sifields._sigfault._addr
#define cpt_si_addr_lsb _sifields._sigfault._addr_lsb
#define cpt_si_lower _sifields._sigfault.si_addr_bnd._lower
#define cpt_si_upper _sifields._sigfault.si_addr_bnd._upper
#define cpt_si_band _sifields._sigpoll._band
#define cpt_si_fd _sifields._sigpoll._fd

/* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
   In their place is si_timer1,si_timer2.  */

#ifndef si_timerid
#define si_timerid si_timer1
#endif
#ifndef si_overrun
#define si_overrun si_timer2
#endif

#ifndef SEGV_BNDERR
#define SEGV_BNDERR	3
#endif

/* The type of the siginfo object the kernel returns in
   PTRACE_GETSIGINFO.  If gdb is built as a x32 program, we get a x32
   siginfo.  */
#ifdef __ILP32__
typedef compat_x32_siginfo_t ptrace_siginfo_t;
#else
typedef nat_siginfo_t ptrace_siginfo_t;
#endif

/*  Convert the system provided siginfo into compatible siginfo.  */

static void
compat_siginfo_from_siginfo (compat_siginfo_t *to, const siginfo_t *from)
{
  ptrace_siginfo_t from_ptrace;

  memcpy (&from_ptrace, from, sizeof (from_ptrace));
  memset (to, 0, sizeof (*to));

  to->si_signo = from_ptrace.si_signo;
  to->si_errno = from_ptrace.si_errno;
  to->si_code = from_ptrace.si_code;

  if (to->si_code == SI_TIMER)
    {
      to->cpt_si_timerid = from_ptrace.cpt_si_timerid;
      to->cpt_si_overrun = from_ptrace.cpt_si_overrun;
      to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
    }
  else if (to->si_code == SI_USER)
    {
      to->cpt_si_pid = from_ptrace.cpt_si_pid;
      to->cpt_si_uid = from_ptrace.cpt_si_uid;
    }
#ifndef __ILP32__
  /* The struct compat_x32_siginfo_t doesn't contain
     cpt_si_lower/cpt_si_upper.  */
  else if (to->si_code == SEGV_BNDERR
	   && to->si_signo == SIGSEGV)
    {
      to->cpt_si_addr = from_ptrace.cpt_si_addr;
      to->cpt_si_lower = from_ptrace.cpt_si_lower;
      to->cpt_si_upper = from_ptrace.cpt_si_upper;
    }
#endif
  else if (to->si_code < 0)
    {
      to->cpt_si_pid = from_ptrace.cpt_si_pid;
      to->cpt_si_uid = from_ptrace.cpt_si_uid;
      to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
    }
  else
    {
      switch (to->si_signo)
	{
	case SIGCHLD:
	  to->cpt_si_pid = from_ptrace.cpt_si_pid;
	  to->cpt_si_uid = from_ptrace.cpt_si_uid;
	  to->cpt_si_status = from_ptrace.cpt_si_status;
	  to->cpt_si_utime = from_ptrace.cpt_si_utime;
	  to->cpt_si_stime = from_ptrace.cpt_si_stime;
	  break;
	case SIGILL:
	case SIGFPE:
	case SIGSEGV:
	case SIGBUS:
	  to->cpt_si_addr = from_ptrace.cpt_si_addr;
	  break;
	case SIGPOLL:
	  to->cpt_si_band = from_ptrace.cpt_si_band;
	  to->cpt_si_fd = from_ptrace.cpt_si_fd;
	  break;
	default:
	  to->cpt_si_pid = from_ptrace.cpt_si_pid;
	  to->cpt_si_uid = from_ptrace.cpt_si_uid;
	  to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
	  break;
	}
    }
}

/* Convert the compatible siginfo into system siginfo.  */

static void
siginfo_from_compat_siginfo (siginfo_t *to, const compat_siginfo_t *from)
{
  ptrace_siginfo_t to_ptrace;

  memset (&to_ptrace, 0, sizeof (to_ptrace));

  to_ptrace.si_signo = from->si_signo;
  to_ptrace.si_errno = from->si_errno;
  to_ptrace.si_code = from->si_code;

  if (to_ptrace.si_code == SI_TIMER)
    {
      to_ptrace.cpt_si_timerid = from->cpt_si_timerid;
      to_ptrace.cpt_si_overrun = from->cpt_si_overrun;
      to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
    }
  else if (to_ptrace.si_code == SI_USER)
    {
      to_ptrace.cpt_si_pid = from->cpt_si_pid;
      to_ptrace.cpt_si_uid = from->cpt_si_uid;
    }
  if (to_ptrace.si_code < 0)
    {
      to_ptrace.cpt_si_pid = from->cpt_si_pid;
      to_ptrace.cpt_si_uid = from->cpt_si_uid;
      to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
    }
  else
    {
      switch (to_ptrace.si_signo)
	{
	case SIGCHLD:
	  to_ptrace.cpt_si_pid = from->cpt_si_pid;
	  to_ptrace.cpt_si_uid = from->cpt_si_uid;
	  to_ptrace.cpt_si_status = from->cpt_si_status;
	  to_ptrace.cpt_si_utime = from->cpt_si_utime;
	  to_ptrace.cpt_si_stime = from->cpt_si_stime;
	  break;
	case SIGILL:
	case SIGFPE:
	case SIGSEGV:
	case SIGBUS:
	  to_ptrace.cpt_si_addr = from->cpt_si_addr;
	  to_ptrace.cpt_si_addr_lsb = from->cpt_si_addr_lsb;
	  break;
	case SIGPOLL:
	  to_ptrace.cpt_si_band = from->cpt_si_band;
	  to_ptrace.cpt_si_fd = from->cpt_si_fd;
	  break;
	default:
	  to_ptrace.cpt_si_pid = from->cpt_si_pid;
	  to_ptrace.cpt_si_uid = from->cpt_si_uid;
	  to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
	  break;
	}
    }
  memcpy (to, &to_ptrace, sizeof (to_ptrace));
}

/*  Convert the system provided siginfo into compatible x32 siginfo.  */

static void
compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to,
				 const siginfo_t *from)
{
  ptrace_siginfo_t from_ptrace;

  memcpy (&from_ptrace, from, sizeof (from_ptrace));
  memset (to, 0, sizeof (*to));

  to->si_signo = from_ptrace.si_signo;
  to->si_errno = from_ptrace.si_errno;
  to->si_code = from_ptrace.si_code;

  if (to->si_code == SI_TIMER)
    {
      to->cpt_si_timerid = from_ptrace.cpt_si_timerid;
      to->cpt_si_overrun = from_ptrace.cpt_si_overrun;
      to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
    }
  else if (to->si_code == SI_USER)
    {
      to->cpt_si_pid = from_ptrace.cpt_si_pid;
      to->cpt_si_uid = from_ptrace.cpt_si_uid;
    }
  else if (to->si_code < 0)
    {
      to->cpt_si_pid = from_ptrace.cpt_si_pid;
      to->cpt_si_uid = from_ptrace.cpt_si_uid;
      to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
    }
  else
    {
      switch (to->si_signo)
	{
	case SIGCHLD:
	  to->cpt_si_pid = from_ptrace.cpt_si_pid;
	  to->cpt_si_uid = from_ptrace.cpt_si_uid;
	  to->cpt_si_status = from_ptrace.cpt_si_status;
	  memcpy (&to->cpt_si_utime, &from_ptrace.cpt_si_utime,
		  sizeof (to->cpt_si_utime));
	  memcpy (&to->cpt_si_stime, &from_ptrace.cpt_si_stime,
		  sizeof (to->cpt_si_stime));
	  break;
	case SIGILL:
	case SIGFPE:
	case SIGSEGV:
	case SIGBUS:
	  to->cpt_si_addr = from_ptrace.cpt_si_addr;
	  break;
	case SIGPOLL:
	  to->cpt_si_band = from_ptrace.cpt_si_band;
	  to->cpt_si_fd = from_ptrace.cpt_si_fd;
	  break;
	default:
	  to->cpt_si_pid = from_ptrace.cpt_si_pid;
	  to->cpt_si_uid = from_ptrace.cpt_si_uid;
	  to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
	  break;
	}
    }
}


/* Convert the compatible x32 siginfo into system siginfo.  */
static void
siginfo_from_compat_x32_siginfo (siginfo_t *to,
				 const compat_x32_siginfo_t *from)
{
  ptrace_siginfo_t to_ptrace;

  memset (&to_ptrace, 0, sizeof (to_ptrace));
  to_ptrace.si_signo = from->si_signo;
  to_ptrace.si_errno = from->si_errno;
  to_ptrace.si_code = from->si_code;

  if (to_ptrace.si_code == SI_TIMER)
    {
      to_ptrace.cpt_si_timerid = from->cpt_si_timerid;
      to_ptrace.cpt_si_overrun = from->cpt_si_overrun;
      to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
    }
  else if (to_ptrace.si_code == SI_USER)
    {
      to_ptrace.cpt_si_pid = from->cpt_si_pid;
      to_ptrace.cpt_si_uid = from->cpt_si_uid;
    }
  if (to_ptrace.si_code < 0)
    {
      to_ptrace.cpt_si_pid = from->cpt_si_pid;
      to_ptrace.cpt_si_uid = from->cpt_si_uid;
      to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
    }
  else
    {
      switch (to_ptrace.si_signo)
	{
	case SIGCHLD:
	  to_ptrace.cpt_si_pid = from->cpt_si_pid;
	  to_ptrace.cpt_si_uid = from->cpt_si_uid;
	  to_ptrace.cpt_si_status = from->cpt_si_status;
	  memcpy (&to_ptrace.cpt_si_utime, &from->cpt_si_utime,
		  sizeof (to_ptrace.cpt_si_utime));
	  memcpy (&to_ptrace.cpt_si_stime, &from->cpt_si_stime,
		  sizeof (to_ptrace.cpt_si_stime));
	  break;
	case SIGILL:
	case SIGFPE:
	case SIGSEGV:
	case SIGBUS:
	  to_ptrace.cpt_si_addr = from->cpt_si_addr;
	  break;
	case SIGPOLL:
	  to_ptrace.cpt_si_band = from->cpt_si_band;
	  to_ptrace.cpt_si_fd = from->cpt_si_fd;
	  break;
	default:
	  to_ptrace.cpt_si_pid = from->cpt_si_pid;
	  to_ptrace.cpt_si_uid = from->cpt_si_uid;
	  to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
	  break;
	}
    }
  memcpy (to, &to_ptrace, sizeof (to_ptrace));
}

/* Convert a ptrace siginfo object, into/from the siginfo in the
   layout of the inferiors' architecture.  Returns true if any
   conversion was done; false otherwise.  If DIRECTION is 1, then copy
   from INF to PTRACE.  If DIRECTION is 0, then copy from NATIVE to
   INF.  */

int
amd64_linux_siginfo_fixup_common (siginfo_t *ptrace, gdb_byte *inf,
				  int direction,
				  enum amd64_siginfo_fixup_mode mode)
{
  if (mode == FIXUP_32)
    {
      if (direction == 0)
	compat_siginfo_from_siginfo ((compat_siginfo_t *) inf, ptrace);
      else
	siginfo_from_compat_siginfo (ptrace, (compat_siginfo_t *) inf);

      return 1;
    }
  else if (mode == FIXUP_X32)
    {
      if (direction == 0)
	compat_x32_siginfo_from_siginfo ((compat_x32_siginfo_t *) inf,
					 ptrace);
      else
	siginfo_from_compat_x32_siginfo (ptrace,
					 (compat_x32_siginfo_t *) inf);

      return 1;
    }
  return 0;
}

/* Sanity check for the siginfo structure sizes.  */

gdb_static_assert (sizeof (siginfo_t) == GDB_SI_SIZE);
#ifndef __ILP32__
gdb_static_assert (sizeof (nat_siginfo_t) == GDB_SI_SIZE);
#endif
gdb_static_assert (sizeof (compat_x32_siginfo_t) == GDB_SI_SIZE);
gdb_static_assert (sizeof (compat_siginfo_t) == GDB_SI_SIZE);
gdb_static_assert (sizeof (ptrace_siginfo_t) == GDB_SI_SIZE);
Commit	Line	Data
93813b37 WT	1	/* Low-level siginfo manipulation for amd64.
93813b37 WT	2
213516ef	3	Copyright (C) 2002-2023 Free Software Foundation, Inc.
93813b37 WT	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
268a13a5	20	#include "gdbsupport/common-defs.h"
8488c357	21	#include <signal.h>
93813b37 WT	22	#include "amd64-linux-siginfo.h"
93813b37 WT	23
9cf12d57 PA	24	#define GDB_SI_SIZE 128
	25
	26	/* The types below define the most complete kernel siginfo types known
	27	for the architecture, independent of the system/libc headers. They
	28	are named from a 64-bit kernel's perspective:
	29
	30	\| layout \| type \|
	31	\|--------+----------------------\|
	32	\| 64-bit \| nat_siginfo_t \|
	33	\| 32-bit \| compat_siginfo_t \|
	34	\| x32 \| compat_x32_siginfo_t \|
	35	*/
	36
	37	#ifndef __ILP32__
3f2f6cb5 WT	38
3f2f6cb5 WT	39	typedef int nat_int_t;
9cf12d57	40	typedef unsigned long nat_uptr_t;
3f2f6cb5 WT	41
	42	typedef int nat_time_t;
	43	typedef int nat_timer_t;
	44
9cf12d57 PA	45	/* For native 64-bit, clock_t in _sigchld is 64-bit. */
9cf12d57 PA	46	typedef long nat_clock_t;
3f2f6cb5	47
c57eb1a2	48	union nat_sigval_t
3f2f6cb5 WT	49	{
	50	nat_int_t sival_int;
	51	nat_uptr_t sival_ptr;
c57eb1a2	52	};
3f2f6cb5	53
c57eb1a2	54	struct nat_siginfo_t
3f2f6cb5 WT	55	{
	56	int si_signo;
	57	int si_errno;
	58	int si_code;
	59
	60	union
	61	{
	62	int _pad[((128 / sizeof (int)) - 4)];
	63	/* kill() */
	64	struct
	65	{
	66	unsigned int _pid;
	67	unsigned int _uid;
	68	} _kill;
	69
	70	/* POSIX.1b timers */
	71	struct
	72	{
	73	nat_timer_t _tid;
	74	int _overrun;
	75	nat_sigval_t _sigval;
	76	} _timer;
	77
	78	/* POSIX.1b signals */
	79	struct
	80	{
	81	unsigned int _pid;
	82	unsigned int _uid;
	83	nat_sigval_t _sigval;
	84	} _rt;
	85
	86	/* SIGCHLD */
	87	struct
	88	{
	89	unsigned int _pid;
	90	unsigned int _uid;
	91	int _status;
	92	nat_clock_t _utime;
	93	nat_clock_t _stime;
	94	} _sigchld;
	95
	96	/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
	97	struct
	98	{
	99	nat_uptr_t _addr;
	100	short int _addr_lsb;
	101	struct
	102	{
	103	nat_uptr_t _lower;
	104	nat_uptr_t _upper;
	105	} si_addr_bnd;
	106	} _sigfault;
	107
	108	/* SIGPOLL */
	109	struct
	110	{
	111	int _band;
	112	int _fd;
	113	} _sigpoll;
	114	} _sifields;
c57eb1a2	115	};
3f2f6cb5	116
9cf12d57	117	#endif /* __ILP32__ */
3f2f6cb5	118
93813b37 WT	119	/* These types below (compat_*) define a siginfo type that is layout
	120	compatible with the siginfo type exported by the 32-bit userspace
	121	support. */
	122
	123	typedef int compat_int_t;
	124	typedef unsigned int compat_uptr_t;
	125
	126	typedef int compat_time_t;
	127	typedef int compat_timer_t;
	128	typedef int compat_clock_t;
	129
	130	struct compat_timeval
	131	{
	132	compat_time_t tv_sec;
	133	int tv_usec;
	134	};
	135
c57eb1a2	136	union compat_sigval_t
93813b37 WT	137	{
	138	compat_int_t sival_int;
	139	compat_uptr_t sival_ptr;
c57eb1a2	140	};
93813b37	141
c57eb1a2	142	struct compat_siginfo_t
93813b37 WT	143	{
	144	int si_signo;
	145	int si_errno;
	146	int si_code;
	147
	148	union
	149	{
	150	int _pad[((128 / sizeof (int)) - 3)];
	151
	152	/* kill() */
	153	struct
	154	{
	155	unsigned int _pid;
	156	unsigned int _uid;
	157	} _kill;
	158
	159	/* POSIX.1b timers */
	160	struct
	161	{
	162	compat_timer_t _tid;
	163	int _overrun;
	164	compat_sigval_t _sigval;
	165	} _timer;
	166
	167	/* POSIX.1b signals */
	168	struct
	169	{
	170	unsigned int _pid;
	171	unsigned int _uid;
	172	compat_sigval_t _sigval;
	173	} _rt;
	174
	175	/* SIGCHLD */
	176	struct
	177	{
	178	unsigned int _pid;
	179	unsigned int _uid;
	180	int _status;
	181	compat_clock_t _utime;
	182	compat_clock_t _stime;
	183	} _sigchld;
	184
	185	/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
	186	struct
	187	{
	188	unsigned int _addr;
3f2f6cb5 WT	189	short int _addr_lsb;
	190	struct
	191	{
	192	unsigned int _lower;
	193	unsigned int _upper;
	194	} si_addr_bnd;
93813b37 WT	195	} _sigfault;
	196
	197	/* SIGPOLL */
	198	struct
	199	{
	200	int _band;
	201	int _fd;
	202	} _sigpoll;
	203	} _sifields;
c57eb1a2	204	};
93813b37 WT	205
	206	/* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */
	207	typedef long __attribute__ ((__aligned__ (4))) compat_x32_clock_t;
	208
c57eb1a2	209	struct __attribute__ ((__aligned__ (8))) compat_x32_siginfo_t
93813b37 WT	210	{
	211	int si_signo;
	212	int si_errno;
	213	int si_code;
	214
	215	union
	216	{
	217	int _pad[((128 / sizeof (int)) - 3)];
	218
	219	/* kill() */
	220	struct
	221	{
	222	unsigned int _pid;
	223	unsigned int _uid;
	224	} _kill;
	225
	226	/* POSIX.1b timers */
	227	struct
	228	{
	229	compat_timer_t _tid;
	230	int _overrun;
	231	compat_sigval_t _sigval;
	232	} _timer;
	233
	234	/* POSIX.1b signals */
	235	struct
	236	{
	237	unsigned int _pid;
	238	unsigned int _uid;
	239	compat_sigval_t _sigval;
	240	} _rt;
	241
	242	/* SIGCHLD */
	243	struct
	244	{
	245	unsigned int _pid;
	246	unsigned int _uid;
	247	int _status;
	248	compat_x32_clock_t _utime;
	249	compat_x32_clock_t _stime;
	250	} _sigchld;
	251
	252	/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
	253	struct
	254	{
	255	unsigned int _addr;
3f2f6cb5	256	unsigned int _addr_lsb;
93813b37 WT	257	} _sigfault;
	258
	259	/* SIGPOLL */
	260	struct
	261	{
	262	int _band;
	263	int _fd;
	264	} _sigpoll;
	265	} _sifields;
c57eb1a2	266	};
93813b37 WT	267
	268	/* To simplify usage of siginfo fields. */
	269
	270	#define cpt_si_pid _sifields._kill._pid
	271	#define cpt_si_uid _sifields._kill._uid
	272	#define cpt_si_timerid _sifields._timer._tid
	273	#define cpt_si_overrun _sifields._timer._overrun
	274	#define cpt_si_status _sifields._sigchld._status
	275	#define cpt_si_utime _sifields._sigchld._utime
	276	#define cpt_si_stime _sifields._sigchld._stime
	277	#define cpt_si_ptr _sifields._rt._sigval.sival_ptr
	278	#define cpt_si_addr _sifields._sigfault._addr
3f2f6cb5	279	#define cpt_si_addr_lsb _sifields._sigfault._addr_lsb
d3d7d1ba TV	280	#define cpt_si_lower _sifields._sigfault.si_addr_bnd._lower
d3d7d1ba TV	281	#define cpt_si_upper _sifields._sigfault.si_addr_bnd._upper
93813b37 WT	282	#define cpt_si_band _sifields._sigpoll._band
	283	#define cpt_si_fd _sifields._sigpoll._fd
	284
	285	/* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
	286	In their place is si_timer1,si_timer2. */
	287
	288	#ifndef si_timerid
	289	#define si_timerid si_timer1
	290	#endif
	291	#ifndef si_overrun
	292	#define si_overrun si_timer2
	293	#endif
	294
d3d7d1ba TV	295	#ifndef SEGV_BNDERR
	296	#define SEGV_BNDERR 3
	297	#endif
	298
9cf12d57 PA	299	/* The type of the siginfo object the kernel returns in
	300	PTRACE_GETSIGINFO. If gdb is built as a x32 program, we get a x32
	301	siginfo. */
	302	#ifdef __ILP32__
	303	typedef compat_x32_siginfo_t ptrace_siginfo_t;
	304	#else
	305	typedef nat_siginfo_t ptrace_siginfo_t;
	306	#endif
	307
93813b37 WT	308	/* Convert the system provided siginfo into compatible siginfo. */
	309
	310	static void
9cf12d57	311	compat_siginfo_from_siginfo (compat_siginfo_t to, const siginfo_t from)
93813b37	312	{
9cf12d57	313	ptrace_siginfo_t from_ptrace;
3f2f6cb5	314
9cf12d57	315	memcpy (&from_ptrace, from, sizeof (from_ptrace));
93813b37 WT	316	memset (to, 0, sizeof (*to));
93813b37 WT	317
9cf12d57 PA	318	to->si_signo = from_ptrace.si_signo;
	319	to->si_errno = from_ptrace.si_errno;
	320	to->si_code = from_ptrace.si_code;
93813b37 WT	321
	322	if (to->si_code == SI_TIMER)
	323	{
9cf12d57 PA	324	to->cpt_si_timerid = from_ptrace.cpt_si_timerid;
	325	to->cpt_si_overrun = from_ptrace.cpt_si_overrun;
	326	to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
93813b37 WT	327	}
	328	else if (to->si_code == SI_USER)
	329	{
9cf12d57 PA	330	to->cpt_si_pid = from_ptrace.cpt_si_pid;
9cf12d57 PA	331	to->cpt_si_uid = from_ptrace.cpt_si_uid;
93813b37	332	}
a92d031d TV	333	#ifndef __ILP32__
	334	/* The struct compat_x32_siginfo_t doesn't contain
	335	cpt_si_lower/cpt_si_upper. */
d3d7d1ba TV	336	else if (to->si_code == SEGV_BNDERR
	337	&& to->si_signo == SIGSEGV)
	338	{
	339	to->cpt_si_addr = from_ptrace.cpt_si_addr;
	340	to->cpt_si_lower = from_ptrace.cpt_si_lower;
	341	to->cpt_si_upper = from_ptrace.cpt_si_upper;
	342	}
a92d031d	343	#endif
93813b37 WT	344	else if (to->si_code < 0)
93813b37 WT	345	{
9cf12d57 PA	346	to->cpt_si_pid = from_ptrace.cpt_si_pid;
	347	to->cpt_si_uid = from_ptrace.cpt_si_uid;
	348	to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
93813b37 WT	349	}
	350	else
	351	{
	352	switch (to->si_signo)
	353	{
	354	case SIGCHLD:
9cf12d57 PA	355	to->cpt_si_pid = from_ptrace.cpt_si_pid;
	356	to->cpt_si_uid = from_ptrace.cpt_si_uid;
	357	to->cpt_si_status = from_ptrace.cpt_si_status;
	358	to->cpt_si_utime = from_ptrace.cpt_si_utime;
	359	to->cpt_si_stime = from_ptrace.cpt_si_stime;
93813b37 WT	360	break;
	361	case SIGILL:
	362	case SIGFPE:
	363	case SIGSEGV:
	364	case SIGBUS:
9cf12d57	365	to->cpt_si_addr = from_ptrace.cpt_si_addr;
93813b37 WT	366	break;
93813b37 WT	367	case SIGPOLL:
9cf12d57 PA	368	to->cpt_si_band = from_ptrace.cpt_si_band;
9cf12d57 PA	369	to->cpt_si_fd = from_ptrace.cpt_si_fd;
93813b37 WT	370	break;
93813b37 WT	371	default:
9cf12d57 PA	372	to->cpt_si_pid = from_ptrace.cpt_si_pid;
	373	to->cpt_si_uid = from_ptrace.cpt_si_uid;
	374	to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
93813b37 WT	375	break;
	376	}
	377	}
	378	}
	379
	380	/* Convert the compatible siginfo into system siginfo. */
	381
	382	static void
9cf12d57	383	siginfo_from_compat_siginfo (siginfo_t to, const compat_siginfo_t from)
93813b37	384	{
9cf12d57	385	ptrace_siginfo_t to_ptrace;
93813b37	386
9cf12d57	387	memset (&to_ptrace, 0, sizeof (to_ptrace));
93813b37	388
9cf12d57 PA	389	to_ptrace.si_signo = from->si_signo;
	390	to_ptrace.si_errno = from->si_errno;
	391	to_ptrace.si_code = from->si_code;
3f2f6cb5	392
9cf12d57	393	if (to_ptrace.si_code == SI_TIMER)
93813b37	394	{
9cf12d57 PA	395	to_ptrace.cpt_si_timerid = from->cpt_si_timerid;
	396	to_ptrace.cpt_si_overrun = from->cpt_si_overrun;
	397	to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
93813b37	398	}
9cf12d57	399	else if (to_ptrace.si_code == SI_USER)
93813b37	400	{
9cf12d57 PA	401	to_ptrace.cpt_si_pid = from->cpt_si_pid;
9cf12d57 PA	402	to_ptrace.cpt_si_uid = from->cpt_si_uid;
93813b37	403	}
9cf12d57	404	if (to_ptrace.si_code < 0)
93813b37	405	{
9cf12d57 PA	406	to_ptrace.cpt_si_pid = from->cpt_si_pid;
	407	to_ptrace.cpt_si_uid = from->cpt_si_uid;
	408	to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
93813b37 WT	409	}
	410	else
	411	{
9cf12d57	412	switch (to_ptrace.si_signo)
93813b37 WT	413	{
93813b37 WT	414	case SIGCHLD:
9cf12d57 PA	415	to_ptrace.cpt_si_pid = from->cpt_si_pid;
	416	to_ptrace.cpt_si_uid = from->cpt_si_uid;
	417	to_ptrace.cpt_si_status = from->cpt_si_status;
	418	to_ptrace.cpt_si_utime = from->cpt_si_utime;
	419	to_ptrace.cpt_si_stime = from->cpt_si_stime;
93813b37 WT	420	break;
	421	case SIGILL:
	422	case SIGFPE:
	423	case SIGSEGV:
	424	case SIGBUS:
9cf12d57 PA	425	to_ptrace.cpt_si_addr = from->cpt_si_addr;
9cf12d57 PA	426	to_ptrace.cpt_si_addr_lsb = from->cpt_si_addr_lsb;
93813b37 WT	427	break;
93813b37 WT	428	case SIGPOLL:
9cf12d57 PA	429	to_ptrace.cpt_si_band = from->cpt_si_band;
9cf12d57 PA	430	to_ptrace.cpt_si_fd = from->cpt_si_fd;
93813b37 WT	431	break;
93813b37 WT	432	default:
9cf12d57 PA	433	to_ptrace.cpt_si_pid = from->cpt_si_pid;
	434	to_ptrace.cpt_si_uid = from->cpt_si_uid;
	435	to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
93813b37 WT	436	break;
	437	}
	438	}
9cf12d57	439	memcpy (to, &to_ptrace, sizeof (to_ptrace));
93813b37 WT	440	}
	441
	442	/* Convert the system provided siginfo into compatible x32 siginfo. */
	443
	444	static void
	445	compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to,
9cf12d57	446	const siginfo_t *from)
93813b37	447	{
9cf12d57	448	ptrace_siginfo_t from_ptrace;
3f2f6cb5	449
9cf12d57	450	memcpy (&from_ptrace, from, sizeof (from_ptrace));
93813b37 WT	451	memset (to, 0, sizeof (*to));
93813b37 WT	452
9cf12d57 PA	453	to->si_signo = from_ptrace.si_signo;
	454	to->si_errno = from_ptrace.si_errno;
	455	to->si_code = from_ptrace.si_code;
93813b37 WT	456
	457	if (to->si_code == SI_TIMER)
	458	{
9cf12d57 PA	459	to->cpt_si_timerid = from_ptrace.cpt_si_timerid;
	460	to->cpt_si_overrun = from_ptrace.cpt_si_overrun;
	461	to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
93813b37 WT	462	}
	463	else if (to->si_code == SI_USER)
	464	{
9cf12d57 PA	465	to->cpt_si_pid = from_ptrace.cpt_si_pid;
9cf12d57 PA	466	to->cpt_si_uid = from_ptrace.cpt_si_uid;
93813b37 WT	467	}
	468	else if (to->si_code < 0)
	469	{
9cf12d57 PA	470	to->cpt_si_pid = from_ptrace.cpt_si_pid;
	471	to->cpt_si_uid = from_ptrace.cpt_si_uid;
	472	to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
93813b37 WT	473	}
	474	else
	475	{
	476	switch (to->si_signo)
	477	{
	478	case SIGCHLD:
9cf12d57 PA	479	to->cpt_si_pid = from_ptrace.cpt_si_pid;
	480	to->cpt_si_uid = from_ptrace.cpt_si_uid;
	481	to->cpt_si_status = from_ptrace.cpt_si_status;
	482	memcpy (&to->cpt_si_utime, &from_ptrace.cpt_si_utime,
93813b37	483	sizeof (to->cpt_si_utime));
9cf12d57	484	memcpy (&to->cpt_si_stime, &from_ptrace.cpt_si_stime,
93813b37 WT	485	sizeof (to->cpt_si_stime));
	486	break;
	487	case SIGILL:
	488	case SIGFPE:
	489	case SIGSEGV:
	490	case SIGBUS:
9cf12d57	491	to->cpt_si_addr = from_ptrace.cpt_si_addr;
93813b37 WT	492	break;
93813b37 WT	493	case SIGPOLL:
9cf12d57 PA	494	to->cpt_si_band = from_ptrace.cpt_si_band;
9cf12d57 PA	495	to->cpt_si_fd = from_ptrace.cpt_si_fd;
93813b37 WT	496	break;
93813b37 WT	497	default:
9cf12d57 PA	498	to->cpt_si_pid = from_ptrace.cpt_si_pid;
	499	to->cpt_si_uid = from_ptrace.cpt_si_uid;
	500	to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
93813b37 WT	501	break;
	502	}
	503	}
	504	}
	505
3f2f6cb5 WT	506
	507
	508
93813b37 WT	509	/* Convert the compatible x32 siginfo into system siginfo. */
	510	static void
	511	siginfo_from_compat_x32_siginfo (siginfo_t *to,
9cf12d57	512	const compat_x32_siginfo_t *from)
93813b37	513	{
9cf12d57	514	ptrace_siginfo_t to_ptrace;
93813b37	515
9cf12d57 PA	516	memset (&to_ptrace, 0, sizeof (to_ptrace));
	517	to_ptrace.si_signo = from->si_signo;
	518	to_ptrace.si_errno = from->si_errno;
	519	to_ptrace.si_code = from->si_code;
93813b37	520
9cf12d57	521	if (to_ptrace.si_code == SI_TIMER)
93813b37	522	{
9cf12d57 PA	523	to_ptrace.cpt_si_timerid = from->cpt_si_timerid;
	524	to_ptrace.cpt_si_overrun = from->cpt_si_overrun;
	525	to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
93813b37	526	}
9cf12d57	527	else if (to_ptrace.si_code == SI_USER)
93813b37	528	{
9cf12d57 PA	529	to_ptrace.cpt_si_pid = from->cpt_si_pid;
9cf12d57 PA	530	to_ptrace.cpt_si_uid = from->cpt_si_uid;
93813b37	531	}
9cf12d57	532	if (to_ptrace.si_code < 0)
93813b37	533	{
9cf12d57 PA	534	to_ptrace.cpt_si_pid = from->cpt_si_pid;
	535	to_ptrace.cpt_si_uid = from->cpt_si_uid;
	536	to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
93813b37 WT	537	}
	538	else
	539	{
9cf12d57	540	switch (to_ptrace.si_signo)
93813b37 WT	541	{
93813b37 WT	542	case SIGCHLD:
9cf12d57 PA	543	to_ptrace.cpt_si_pid = from->cpt_si_pid;
	544	to_ptrace.cpt_si_uid = from->cpt_si_uid;
	545	to_ptrace.cpt_si_status = from->cpt_si_status;
	546	memcpy (&to_ptrace.cpt_si_utime, &from->cpt_si_utime,
	547	sizeof (to_ptrace.cpt_si_utime));
	548	memcpy (&to_ptrace.cpt_si_stime, &from->cpt_si_stime,
	549	sizeof (to_ptrace.cpt_si_stime));
93813b37 WT	550	break;
	551	case SIGILL:
	552	case SIGFPE:
	553	case SIGSEGV:
	554	case SIGBUS:
9cf12d57	555	to_ptrace.cpt_si_addr = from->cpt_si_addr;
93813b37 WT	556	break;
93813b37 WT	557	case SIGPOLL:
9cf12d57 PA	558	to_ptrace.cpt_si_band = from->cpt_si_band;
9cf12d57 PA	559	to_ptrace.cpt_si_fd = from->cpt_si_fd;
93813b37 WT	560	break;
93813b37 WT	561	default:
9cf12d57 PA	562	to_ptrace.cpt_si_pid = from->cpt_si_pid;
	563	to_ptrace.cpt_si_uid = from->cpt_si_uid;
	564	to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
93813b37 WT	565	break;
	566	}
	567	}
9cf12d57	568	memcpy (to, &to_ptrace, sizeof (to_ptrace));
93813b37 WT	569	}
93813b37 WT	570
9cf12d57	571	/* Convert a ptrace siginfo object, into/from the siginfo in the
93813b37 WT	572	layout of the inferiors' architecture. Returns true if any
93813b37 WT	573	conversion was done; false otherwise. If DIRECTION is 1, then copy
9cf12d57 PA	574	from INF to PTRACE. If DIRECTION is 0, then copy from NATIVE to
9cf12d57 PA	575	INF. */
93813b37 WT	576
93813b37 WT	577	int
9cf12d57	578	amd64_linux_siginfo_fixup_common (siginfo_t ptrace, gdb_byte inf,
93813b37 WT	579	int direction,
	580	enum amd64_siginfo_fixup_mode mode)
	581	{
	582	if (mode == FIXUP_32)
	583	{
93813b37	584	if (direction == 0)
c57eb1a2	585	compat_siginfo_from_siginfo ((compat_siginfo_t *) inf, ptrace);
93813b37	586	else
c57eb1a2	587	siginfo_from_compat_siginfo (ptrace, (compat_siginfo_t *) inf);
93813b37 WT	588
	589	return 1;
	590	}
	591	else if (mode == FIXUP_X32)
	592	{
93813b37	593	if (direction == 0)
c57eb1a2	594	compat_x32_siginfo_from_siginfo ((compat_x32_siginfo_t *) inf,
9cf12d57	595	ptrace);
93813b37	596	else
9cf12d57	597	siginfo_from_compat_x32_siginfo (ptrace,
c57eb1a2	598	(compat_x32_siginfo_t *) inf);
93813b37 WT	599
	600	return 1;
	601	}
	602	return 0;
	603	}
9cf12d57 PA	604
	605	/* Sanity check for the siginfo structure sizes. */
	606
	607	gdb_static_assert (sizeof (siginfo_t) == GDB_SI_SIZE);
	608	#ifndef __ILP32__
	609	gdb_static_assert (sizeof (nat_siginfo_t) == GDB_SI_SIZE);
	610	#endif
	611	gdb_static_assert (sizeof (compat_x32_siginfo_t) == GDB_SI_SIZE);
	612	gdb_static_assert (sizeof (compat_siginfo_t) == GDB_SI_SIZE);
	613	gdb_static_assert (sizeof (ptrace_siginfo_t) == GDB_SI_SIZE);