mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-27 04:52:05 +08:00
8488c357ce
On Fedora rawhide, after updating to glibc-2.33, I'm seeing the
following build failure:
CXX nat/amd64-linux-siginfo.o
In file included from /usr/include/bits/sigstksz.h:24,
from /usr/include/signal.h:315,
from ../gnulib/import/signal.h:52,
from /ironwood1/sourceware-git/rawhide-gnulib/bld/../../worktree-gnulib/gdbserver/../gdb/nat/amd64-linux-siginfo.c:20:
../gnulib/import/unistd.h:663:3: error: #error "Please include config.h first."
663 | #error "Please include config.h first."
| ^~~~~
glibc-2.33 has changed signal.h to now include <bits/sigstksz.h> which,
in turn, includes <unistd.h>. For a gdb build, this causes the gnulib
version of unistd.h to be pulled in first. The build failure shown
above happens because gnulib's config.h has not been included before
the include of <signal.h>.
The fix is simple - we just rearrange the order of the header file
includes to make sure that gdbsupport/commondefs.h is included before
attempting to include signal.h. Note that gdbsupport/commondefs.h
includes <gnulib/config.h>.
Build and regression tested on Fedora 33. On Fedora rawhide, GDB
builds again.
gdb/ChangeLog:
* nat/amd64-linux-siginfo.c: Include "gdbsupport/common-defs.h"
(which in turn includes <gnulib/config.h>) before include
of <signal.h>.
610 lines
14 KiB
C
610 lines
14 KiB
C
/* Low-level siginfo manipulation for amd64.
|
|
|
|
Copyright (C) 2002-2021 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;
|
|
|
|
typedef union nat_sigval
|
|
{
|
|
nat_int_t sival_int;
|
|
nat_uptr_t sival_ptr;
|
|
} nat_sigval_t;
|
|
|
|
typedef struct nat_siginfo
|
|
{
|
|
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;
|
|
} nat_siginfo_t;
|
|
|
|
#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;
|
|
};
|
|
|
|
typedef union compat_sigval
|
|
{
|
|
compat_int_t sival_int;
|
|
compat_uptr_t sival_ptr;
|
|
} compat_sigval_t;
|
|
|
|
typedef struct compat_siginfo
|
|
{
|
|
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;
|
|
} compat_siginfo_t;
|
|
|
|
/* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */
|
|
typedef long __attribute__ ((__aligned__ (4))) compat_x32_clock_t;
|
|
|
|
typedef struct compat_x32_siginfo
|
|
{
|
|
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;
|
|
} compat_x32_siginfo_t __attribute__ ((__aligned__ (8)));
|
|
|
|
/* 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;
|
|
}
|
|
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;
|
|
}
|
|
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 ((struct compat_siginfo *) inf, ptrace);
|
|
else
|
|
siginfo_from_compat_siginfo (ptrace, (struct compat_siginfo *) inf);
|
|
|
|
return 1;
|
|
}
|
|
else if (mode == FIXUP_X32)
|
|
{
|
|
if (direction == 0)
|
|
compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf,
|
|
ptrace);
|
|
else
|
|
siginfo_from_compat_x32_siginfo (ptrace,
|
|
(struct compat_x32_siginfo *) 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);
|