gdb/amd64-linux-nat.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Native-dependent code for GNU/Linux x86-64.

  3.    Copyright (C) 2001-2015 Free Software Foundation, Inc.
  4.    Contributed by Jiri Smid, SuSE Labs.

  6.    This file is part of GDB.

  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.

  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.

  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/>.  */

  21. #include "defs.h"
  22. #include "inferior.h"
  23. #include "regcache.h"
  24. #include "elf/common.h"
  25. #include <sys/uio.h>
  26. #include <sys/ptrace.h>
  27. #include <asm/prctl.h>
  28. #include <sys/reg.h>
  29. #include "gregset.h"
  30. #include "gdb_proc_service.h"

  32. #include "amd64-nat.h"
  33. #include "linux-nat.h"
  34. #include "amd64-tdep.h"
  35. #include "amd64-linux-tdep.h"
  36. #include "i386-linux-tdep.h"
  37. #include "x86-xstate.h"

  39. #include "x86-linux-nat.h"

  41. /* Mapping between the general-purpose registers in GNU/Linux x86-64
  42.    `struct user' format and GDB's register cache layout for GNU/Linux
  43.    i386.

  45.    Note that most GNU/Linux x86-64 registers are 64-bit, while the
  46.    GNU/Linux i386 registers are all 32-bit, but since we're
  47.    little-endian we get away with that.  */

  49. /* From <sys/reg.h> on GNU/Linux i386.  */
  50. ‌static int amd64_linux_gregset32_reg_offset[] =
  51. {
  52.   RAX * 8, RCX * 8,                /* %eax, %ecx */
  53.   RDX * 8, RBX * 8,                /* %edx, %ebx */
  54.   RSP * 8, RBP * 8,                /* %esp, %ebp */
  55.   RSI * 8, RDI * 8,                /* %esi, %edi */
  56.   RIP * 8, EFLAGS * 8,                /* %eip, %eflags */
  57.   CS * 8, SS * 8,                /* %cs, %ss */
  58.   DS * 8, ES * 8,                /* %ds, %es */
  59.   FS * 8, GS * 8,                /* %fs, %gs */
  60.   -1, -1, -1, -1, -1, -1, -1, -1,
  61.   -1, -1, -1, -1, -1, -1, -1, -1,
  62.   -1, -1, -1, -1, -1, -1, -1, -1, -1,
  63.   -1, -1, -1, -1, -1, -1, -1, -1,
  64.   -1, -1, -1, -1,                  /* MPX registers BND0 ... BND3.  */
  65.   -1, -1,                          /* MPX registers BNDCFGU, BNDSTATUS.  */
  66.   -1, -1, -1, -1, -1, -1, -1, -1, /* k0 ... k7 (AVX512)  */
  67.   -1, -1, -1, -1, -1, -1, -1, -1, /* zmm0 ... zmm7 (AVX512)  */
  68.   ORIG_RAX * 8                          /* "orig_eax"  */
  69. };


  72. /* Transfering the general-purpose registers between GDB, inferiors
  73.    and core files.  */

  75. /* Fill GDB's register cache with the general-purpose register values
  76.    in *GREGSETP.  */

  78. void
  79. ‌supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
  80. {
  81.   amd64_supply_native_gregset (regcache, gregsetp, -1);
  82. }

  84. /* Fill register REGNUM (if it is a general-purpose register) in
  85.    *GREGSETP with the value in GDB's register cache.  If REGNUM is -1,
  86.    do this for all registers.  */

  88. void
  89. ‌fill_gregset (const struct regcache *regcache,
  90.               elf_gregset_t *gregsetp, int regnum)
  91. {
  92.   amd64_collect_native_gregset (regcache, gregsetp, regnum);
  93. }

  95. /* Transfering floating-point registers between GDB, inferiors and cores.  */

  97. /* Fill GDB's register cache with the floating-point and SSE register
  98.    values in *FPREGSETP.  */

  100. void
  101. ‌supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
  102. {
  103.   amd64_supply_fxsave (regcache, -1, fpregsetp);
  104. }

  106. /* Fill register REGNUM (if it is a floating-point or SSE register) in
  107.    *FPREGSETP with the value in GDB's register cache.  If REGNUM is
  108.    -1, do this for all registers.  */

  110. void
  111. ‌fill_fpregset (const struct regcache *regcache,
  112.                elf_fpregset_t *fpregsetp, int regnum)
  113. {
  114.   amd64_collect_fxsave (regcache, regnum, fpregsetp);
  115. }


  118. /* Transferring arbitrary registers between GDB and inferior.  */

  120. /* Fetch register REGNUM from the child process.  If REGNUM is -1, do
  121.    this for all registers (including the floating point and SSE
  122.    registers).  */

  124. static void
  125. ‌amd64_linux_fetch_inferior_registers (struct target_ops *ops,
  126.                                       struct regcache *regcache, int regnum)
  127. {
  128.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  129.   int tid;

  131.   /* GNU/Linux LWP ID's are process ID's.  */
  132.   tid = ptid_get_lwp (inferior_ptid);
  133.   if (tid == 0)
  134.     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */

  136.   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
  137.     {
  138.       elf_gregset_t regs;

  140.       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
  141.         perror_with_name (_("Couldn't get registers"));

  143.       amd64_supply_native_gregset (regcache, &regs, -1);
  144.       if (regnum != -1)
  145.         return;
  146.     }

  148.   if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
  149.     {
  150.       elf_fpregset_t fpregs;

  152.       if (have_ptrace_getregset)
  153.         {
  154.           char xstateregs[X86_XSTATE_MAX_SIZE];
  155.           struct iovec iov;

  157.           iov.iov_base = xstateregs;
  158.           iov.iov_len = sizeof (xstateregs);
  159.           if (ptrace (PTRACE_GETREGSET, tid,
  160.                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
  161.             perror_with_name (_("Couldn't get extended state status"));

  163.           amd64_supply_xsave (regcache, -1, xstateregs);
  164.         }
  165.       else
  166.         {
  167.           if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
  168.             perror_with_name (_("Couldn't get floating point status"));

  170.           amd64_supply_fxsave (regcache, -1, &fpregs);
  171.         }
  172.     }
  173. }

  175. /* Store register REGNUM back into the child process.  If REGNUM is
  176.    -1, do this for all registers (including the floating-point and SSE
  177.    registers).  */

  179. static void
  180. ‌amd64_linux_store_inferior_registers (struct target_ops *ops,
  181.                                       struct regcache *regcache, int regnum)
  182. {
  183.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  184.   int tid;

  186.   /* GNU/Linux LWP ID's are process ID's.  */
  187.   tid = ptid_get_lwp (inferior_ptid);
  188.   if (tid == 0)
  189.     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */

  191.   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
  192.     {
  193.       elf_gregset_t regs;

  195.       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
  196.         perror_with_name (_("Couldn't get registers"));

  198.       amd64_collect_native_gregset (regcache, &regs, regnum);

  200.       if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
  201.         perror_with_name (_("Couldn't write registers"));

  203.       if (regnum != -1)
  204.         return;
  205.     }

  207.   if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
  208.     {
  209.       elf_fpregset_t fpregs;

  211.       if (have_ptrace_getregset)
  212.         {
  213.           char xstateregs[X86_XSTATE_MAX_SIZE];
  214.           struct iovec iov;

  216.           iov.iov_base = xstateregs;
  217.           iov.iov_len = sizeof (xstateregs);
  218.           if (ptrace (PTRACE_GETREGSET, tid,
  219.                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
  220.             perror_with_name (_("Couldn't get extended state status"));

  222.           amd64_collect_xsave (regcache, regnum, xstateregs, 0);

  224.           if (ptrace (PTRACE_SETREGSET, tid,
  225.                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
  226.             perror_with_name (_("Couldn't write extended state status"));
  227.         }
  228.       else
  229.         {
  230.           if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
  231.             perror_with_name (_("Couldn't get floating point status"));

  233.           amd64_collect_fxsave (regcache, regnum, &fpregs);

  235.           if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
  236.             perror_with_name (_("Couldn't write floating point status"));
  237.         }
  238.     }
  239. }


  242. /* This function is called by libthread_db as part of its handling of
  243.    a request for a thread's local storage address.  */

  245. ps_err_e
  246. ‌ps_get_thread_area (const struct ps_prochandle *ph,
  247.                     lwpid_t lwpid, int idx, void **base)
  248. {
  249.   if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32)
  250.     {
  251.       unsigned int base_addr;
  252.       ps_err_e result;

  254.       result = x86_linux_get_thread_area (lwpid, (void *) (long) idx,
  255.                                           &base_addr);
  256.       if (result == PS_OK)
  257.         {
  258.           /* Extend the value to 64 bits.  Here it's assumed that
  259.              a "long" and a "void *" are the same.  */
  260.           (*base) = (void *) (long) base_addr;
  261.         }
  262.       return result;
  263.     }
  264.   else
  265.     {
  266.       /* This definition comes from prctl.h, but some kernels may not
  267.          have it.  */
  268. #ifndef PTRACE_ARCH_PRCTL
  269. ‌#define PTRACE_ARCH_PRCTL      30
  270. #endif
  271.       /* FIXME: ezannoni-2003-07-09 see comment above about include
  272.          file order.  We could be getting bogus values for these two.  */
  273.       gdb_assert (FS < ELF_NGREG);
  274.       gdb_assert (GS < ELF_NGREG);
  275.       switch (idx)
  276.         {
  277.         case FS:
  278. #ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE
  279.             {
  280.               /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the
  281.                  fs_base and gs_base fields of user_regs_struct can be
  282.                  used directly.  */
  283.               unsigned long fs;
  284.               errno = 0;
  285.               fs = ptrace (PTRACE_PEEKUSER, lwpid,
  286.                            offsetof (struct user_regs_struct, fs_base), 0);
  287.               if (errno == 0)
  288.                 {
  289.                   *base = (void *) fs;
  290.                   return PS_OK;
  291.                 }
  292.             }
  293. #endif
  294.           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
  295.             return PS_OK;
  296.           break;
  297.         case GS:
  298. #ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE
  299.             {
  300.               unsigned long gs;
  301.               errno = 0;
  302.               gs = ptrace (PTRACE_PEEKUSER, lwpid,
  303.                            offsetof (struct user_regs_struct, gs_base), 0);
  304.               if (errno == 0)
  305.                 {
  306.                   *base = (void *) gs;
  307.                   return PS_OK;
  308.                 }
  309.             }
  310. #endif
  311.           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
  312.             return PS_OK;
  313.           break;
  314.         default:                   /* Should not happen.  */
  315.           return PS_BADADDR;
  316.         }
  317.     }
  318.   return PS_ERR;               /* ptrace failed.  */
  319. }


  322. /* When GDB is built as a 64-bit application on linux, the
  323.    PTRACE_GETSIGINFO data is always presented in 64-bit layout.  Since
  324.    debugging a 32-bit inferior with a 64-bit GDB should look the same
  325.    as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
  326.    conversion in-place ourselves.  */

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

  332. ‌typedef int compat_int_t;
  333. ‌typedef unsigned int compat_uptr_t;

  335. ‌typedef int compat_time_t;
  336. ‌typedef int compat_timer_t;
  337. ‌typedef int compat_clock_t;

  339. ‌struct compat_timeval
  340. {
  341.   compat_time_t tv_sec;
  342.   int tv_usec;
  343. };

  345. ‌typedef union compat_sigval
  346. {
  347.   compat_int_t sival_int;
  348.   compat_uptr_t sival_ptr;
  349. ‌} compat_sigval_t;

  351. ‌typedef struct compat_siginfo
  352. {
  353.   int si_signo;
  354.   int si_errno;
  355.   int si_code;

  357.   union
  358.   {
  359.     int _pad[((128 / sizeof (int)) - 3)];

  361.     /* kill() */
  362.     struct
  363.     {
  364.       unsigned int _pid;
  365.       unsigned int _uid;
  366.     } _kill;

  368.     /* POSIX.1b timers */
  369.     struct
  370.     {
  371.       compat_timer_t _tid;
  372.       int _overrun;
  373.       compat_sigval_t _sigval;
  374.     } _timer;

  376.     /* POSIX.1b signals */
  377.     struct
  378.     {
  379.       unsigned int _pid;
  380.       unsigned int _uid;
  381.       compat_sigval_t _sigval;
  382.     } _rt;

  384.     /* SIGCHLD */
  385.     struct
  386.     {
  387.       unsigned int _pid;
  388.       unsigned int _uid;
  389.       int _status;
  390.       compat_clock_t _utime;
  391.       compat_clock_t _stime;
  392.     } _sigchld;

  394.     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
  395.     struct
  396.     {
  397.       unsigned int _addr;
  398.     } _sigfault;

  400.     /* SIGPOLL */
  401.     struct
  402.     {
  403.       int _band;
  404.       int _fd;
  405.     } _sigpoll;
  406.   } _sifields;
  407. ‌} compat_siginfo_t;

  409. /* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes.  */
  410. ‌typedef struct compat_x32_clock
  411. {
  412.   int lower;
  413.   int upper;
  414. ‌} compat_x32_clock_t;

  416. ‌typedef struct compat_x32_siginfo
  417. {
  418.   int si_signo;
  419.   int si_errno;
  420.   int si_code;

  422.   union
  423.   {
  424.     int _pad[((128 / sizeof (int)) - 3)];

  426.     /* kill() */
  427.     struct
  428.     {
  429.       unsigned int _pid;
  430.       unsigned int _uid;
  431.     } _kill;

  433.     /* POSIX.1b timers */
  434.     struct
  435.     {
  436.       compat_timer_t _tid;
  437.       int _overrun;
  438.       compat_sigval_t _sigval;
  439.     } _timer;

  441.     /* POSIX.1b signals */
  442.     struct
  443.     {
  444.       unsigned int _pid;
  445.       unsigned int _uid;
  446.       compat_sigval_t _sigval;
  447.     } _rt;

  449.     /* SIGCHLD */
  450.     struct
  451.     {
  452.       unsigned int _pid;
  453.       unsigned int _uid;
  454.       int _status;
  455.       compat_x32_clock_t _utime;
  456.       compat_x32_clock_t _stime;
  457.     } _sigchld;

  459.     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
  460.     struct
  461.     {
  462.       unsigned int _addr;
  463.     } _sigfault;

  465.     /* SIGPOLL */
  466.     struct
  467.     {
  468.       int _band;
  469.       int _fd;
  470.     } _sigpoll;
  471.   } _sifields;
  472. ‌} compat_x32_siginfo_t;

  474. ‌#define cpt_si_pid _sifields._kill._pid
  475. ‌#define cpt_si_uid _sifields._kill._uid
  476. ‌#define cpt_si_timerid _sifields._timer._tid
  477. ‌#define cpt_si_overrun _sifields._timer._overrun
  478. ‌#define cpt_si_status _sifields._sigchld._status
  479. ‌#define cpt_si_utime _sifields._sigchld._utime
  480. ‌#define cpt_si_stime _sifields._sigchld._stime
  481. ‌#define cpt_si_ptr _sifields._rt._sigval.sival_ptr
  482. ‌#define cpt_si_addr _sifields._sigfault._addr
  483. ‌#define cpt_si_band _sifields._sigpoll._band
  484. ‌#define cpt_si_fd _sifields._sigpoll._fd

  486. /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
  487.    In their place is si_timer1,si_timer2.  */
  488. #ifndef si_timerid
  489. ‌#define si_timerid si_timer1
  490. #endif
  491. #ifndef si_overrun
  492. ‌#define si_overrun si_timer2
  493. #endif

  495. static void
  496. ‌compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
  497. {
  498.   memset (to, 0, sizeof (*to));

  500.   to->si_signo = from->si_signo;
  501.   to->si_errno = from->si_errno;
  502.   to->si_code = from->si_code;

  504.   if (to->si_code == SI_TIMER)
  505.     {
  506.       to->cpt_si_timerid = from->si_timerid;
  507.       to->cpt_si_overrun = from->si_overrun;
  508.       to->cpt_si_ptr = (intptr_t) from->si_ptr;
  509.     }
  510.   else if (to->si_code == SI_USER)
  511.     {
  512.       to->cpt_si_pid = from->si_pid;
  513.       to->cpt_si_uid = from->si_uid;
  514.     }
  515.   else if (to->si_code < 0)
  516.     {
  517.       to->cpt_si_pid = from->si_pid;
  518.       to->cpt_si_uid = from->si_uid;
  519.       to->cpt_si_ptr = (intptr_t) from->si_ptr;
  520.     }
  521.   else
  522.     {
  523.       switch (to->si_signo)
  524.         {
  525.         case SIGCHLD:
  526.           to->cpt_si_pid = from->si_pid;
  527.           to->cpt_si_uid = from->si_uid;
  528.           to->cpt_si_status = from->si_status;
  529.           to->cpt_si_utime = from->si_utime;
  530.           to->cpt_si_stime = from->si_stime;
  531.           break;
  532.         case SIGILL:
  533.         case SIGFPE:
  534.         case SIGSEGV:
  535.         case SIGBUS:
  536.           to->cpt_si_addr = (intptr_t) from->si_addr;
  537.           break;
  538.         case SIGPOLL:
  539.           to->cpt_si_band = from->si_band;
  540.           to->cpt_si_fd = from->si_fd;
  541.           break;
  542.         default:
  543.           to->cpt_si_pid = from->si_pid;
  544.           to->cpt_si_uid = from->si_uid;
  545.           to->cpt_si_ptr = (intptr_t) from->si_ptr;
  546.           break;
  547.         }
  548.     }
  549. }

  551. static void
  552. ‌siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
  553. {
  554.   memset (to, 0, sizeof (*to));

  556.   to->si_signo = from->si_signo;
  557.   to->si_errno = from->si_errno;
  558.   to->si_code = from->si_code;

  560.   if (to->si_code == SI_TIMER)
  561.     {
  562.       to->si_timerid = from->cpt_si_timerid;
  563.       to->si_overrun = from->cpt_si_overrun;
  564.       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
  565.     }
  566.   else if (to->si_code == SI_USER)
  567.     {
  568.       to->si_pid = from->cpt_si_pid;
  569.       to->si_uid = from->cpt_si_uid;
  570.     }
  571.   if (to->si_code < 0)
  572.     {
  573.       to->si_pid = from->cpt_si_pid;
  574.       to->si_uid = from->cpt_si_uid;
  575.       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
  576.     }
  577.   else
  578.     {
  579.       switch (to->si_signo)
  580.         {
  581.         case SIGCHLD:
  582.           to->si_pid = from->cpt_si_pid;
  583.           to->si_uid = from->cpt_si_uid;
  584.           to->si_status = from->cpt_si_status;
  585.           to->si_utime = from->cpt_si_utime;
  586.           to->si_stime = from->cpt_si_stime;
  587.           break;
  588.         case SIGILL:
  589.         case SIGFPE:
  590.         case SIGSEGV:
  591.         case SIGBUS:
  592.           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
  593.           break;
  594.         case SIGPOLL:
  595.           to->si_band = from->cpt_si_band;
  596.           to->si_fd = from->cpt_si_fd;
  597.           break;
  598.         default:
  599.           to->si_pid = from->cpt_si_pid;
  600.           to->si_uid = from->cpt_si_uid;
  601.           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
  602.           break;
  603.         }
  604.     }
  605. }

  607. static void
  608. ‌compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to,
  609.                                  siginfo_t *from)
  610. {
  611.   memset (to, 0, sizeof (*to));

  613.   to->si_signo = from->si_signo;
  614.   to->si_errno = from->si_errno;
  615.   to->si_code = from->si_code;

  617.   if (to->si_code == SI_TIMER)
  618.     {
  619.       to->cpt_si_timerid = from->si_timerid;
  620.       to->cpt_si_overrun = from->si_overrun;
  621.       to->cpt_si_ptr = (intptr_t) from->si_ptr;
  622.     }
  623.   else if (to->si_code == SI_USER)
  624.     {
  625.       to->cpt_si_pid = from->si_pid;
  626.       to->cpt_si_uid = from->si_uid;
  627.     }
  628.   else if (to->si_code < 0)
  629.     {
  630.       to->cpt_si_pid = from->si_pid;
  631.       to->cpt_si_uid = from->si_uid;
  632.       to->cpt_si_ptr = (intptr_t) from->si_ptr;
  633.     }
  634.   else
  635.     {
  636.       switch (to->si_signo)
  637.         {
  638.         case SIGCHLD:
  639.           to->cpt_si_pid = from->si_pid;
  640.           to->cpt_si_uid = from->si_uid;
  641.           to->cpt_si_status = from->si_status;
  642.           memcpy (&to->cpt_si_utime, &from->si_utime,
  643.                   sizeof (to->cpt_si_utime));
  644.           memcpy (&to->cpt_si_stime, &from->si_stime,
  645.                   sizeof (to->cpt_si_stime));
  646.           break;
  647.         case SIGILL:
  648.         case SIGFPE:
  649.         case SIGSEGV:
  650.         case SIGBUS:
  651.           to->cpt_si_addr = (intptr_t) from->si_addr;
  652.           break;
  653.         case SIGPOLL:
  654.           to->cpt_si_band = from->si_band;
  655.           to->cpt_si_fd = from->si_fd;
  656.           break;
  657.         default:
  658.           to->cpt_si_pid = from->si_pid;
  659.           to->cpt_si_uid = from->si_uid;
  660.           to->cpt_si_ptr = (intptr_t) from->si_ptr;
  661.           break;
  662.         }
  663.     }
  664. }

  666. static void
  667. ‌siginfo_from_compat_x32_siginfo (siginfo_t *to,
  668.                                  compat_x32_siginfo_t *from)
  669. {
  670.   memset (to, 0, sizeof (*to));

  672.   to->si_signo = from->si_signo;
  673.   to->si_errno = from->si_errno;
  674.   to->si_code = from->si_code;

  676.   if (to->si_code == SI_TIMER)
  677.     {
  678.       to->si_timerid = from->cpt_si_timerid;
  679.       to->si_overrun = from->cpt_si_overrun;
  680.       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
  681.     }
  682.   else if (to->si_code == SI_USER)
  683.     {
  684.       to->si_pid = from->cpt_si_pid;
  685.       to->si_uid = from->cpt_si_uid;
  686.     }
  687.   if (to->si_code < 0)
  688.     {
  689.       to->si_pid = from->cpt_si_pid;
  690.       to->si_uid = from->cpt_si_uid;
  691.       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
  692.     }
  693.   else
  694.     {
  695.       switch (to->si_signo)
  696.         {
  697.         case SIGCHLD:
  698.           to->si_pid = from->cpt_si_pid;
  699.           to->si_uid = from->cpt_si_uid;
  700.           to->si_status = from->cpt_si_status;
  701.           memcpy (&to->si_utime, &from->cpt_si_utime,
  702.                   sizeof (to->si_utime));
  703.           memcpy (&to->si_stime, &from->cpt_si_stime,
  704.                   sizeof (to->si_stime));
  705.           break;
  706.         case SIGILL:
  707.         case SIGFPE:
  708.         case SIGSEGV:
  709.         case SIGBUS:
  710.           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
  711.           break;
  712.         case SIGPOLL:
  713.           to->si_band = from->cpt_si_band;
  714.           to->si_fd = from->cpt_si_fd;
  715.           break;
  716.         default:
  717.           to->si_pid = from->cpt_si_pid;
  718.           to->si_uid = from->cpt_si_uid;
  719.           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
  720.           break;
  721.         }
  722.     }
  723. }

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

  731. static int
  732. ‌amd64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction)
  733. {
  734.   struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());

  736.   /* Is the inferior 32-bit?  If so, then do fixup the siginfo
  737.      object.  */
  738.   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
  739.     {
  740.       gdb_assert (sizeof (siginfo_t) == sizeof (compat_siginfo_t));

  742.       if (direction == 0)
  743.         compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
  744.       else
  745.         siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);

  747.       return 1;
  748.     }
  749.   /* No fixup for native x32 GDB.  */
  750.   else if (gdbarch_addr_bit (gdbarch) == 32 && sizeof (void *) == 8)
  751.     {
  752.       gdb_assert (sizeof (siginfo_t) == sizeof (compat_x32_siginfo_t));

  754.       if (direction == 0)
  755.         compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf,
  756.                                          native);
  757.       else
  758.         siginfo_from_compat_x32_siginfo (native,
  759.                                          (struct compat_x32_siginfo *) inf);

  761.       return 1;
  762.     }
  763.   else
  764.     return 0;
  765. }


  768. /* Provide a prototype to silence -Wmissing-prototypes.  */
  769. void _initialize_amd64_linux_nat (void);

  771. void
  772. ‌_initialize_amd64_linux_nat (void)
  773. {
  774.   struct target_ops *t;

  776.   amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
  777.   amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
  778.   amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset;
  779.   amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS;

  781.   gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
  782.               == amd64_native_gregset32_num_regs);

  784.   /* Create a generic x86 GNU/Linux target.  */
  785.   t = x86_linux_create_target ();

  787.   /* Add our register access methods.  */
  788.   t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
  789.   t->to_store_registers = amd64_linux_store_inferior_registers;

  791.   /* Add the target.  */
  792.   x86_linux_add_target (t);

  794.   /* Add our siginfo layout converter.  */
  795.   linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup);
  796. }