gdb/i386bsd-nat.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* Native-dependent code for modern i386 BSD's.

  3.    Copyright (C) 2000-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

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

  20. #include "defs.h"
  21. #include "inferior.h"
  22. #include "regcache.h"

  24. #include <signal.h>
  25. #include <sys/types.h>
  26. #include <sys/ptrace.h>
  27. #include <machine/reg.h>
  28. #include <machine/frame.h>

  30. #include "i386-tdep.h"
  31. #include "i387-tdep.h"
  32. #include "i386bsd-nat.h"
  33. #include "inf-ptrace.h"


  36. /* In older BSD versions we cannot get at some of the segment
  37.    registers.  FreeBSD for example didn't support the %fs and %gs
  38.    registers until the 3.0 release.  We have autoconf checks for their
  39.    presence, and deal gracefully with their absence.  */

  41. /* Offset in `struct reg' where MEMBER is stored.  */
  42. ‌#define REG_OFFSET(member) offsetof (struct reg, member)

  44. /* At i386bsd_reg_offset[REGNUM] you'll find the offset in `struct
  45.    reg' where the GDB register REGNUM is stored.  Unsupported
  46.    registers are marked with `-1'.  */
  47. ‌static int i386bsd_r_reg_offset[] =
  48. {
  49.   REG_OFFSET (r_eax),
  50.   REG_OFFSET (r_ecx),
  51.   REG_OFFSET (r_edx),
  52.   REG_OFFSET (r_ebx),
  53.   REG_OFFSET (r_esp),
  54.   REG_OFFSET (r_ebp),
  55.   REG_OFFSET (r_esi),
  56.   REG_OFFSET (r_edi),
  57.   REG_OFFSET (r_eip),
  58.   REG_OFFSET (r_eflags),
  59.   REG_OFFSET (r_cs),
  60.   REG_OFFSET (r_ss),
  61.   REG_OFFSET (r_ds),
  62.   REG_OFFSET (r_es),
  63. #ifdef HAVE_STRUCT_REG_R_FS
  64.   REG_OFFSET (r_fs),
  65. #else
  66.   -1,
  67. #endif
  68. #ifdef HAVE_STRUCT_REG_R_GS
  69.   REG_OFFSET (r_gs)
  70. #else
  71.   -1
  72. #endif
  73. };

  75. /* Macro to determine if a register is fetched with PT_GETREGS.  */
  76. ‌#define GETREGS_SUPPLIES(regnum) \
  77.   ((0 <= (regnum) && (regnum) <= 15))

  79. #ifdef HAVE_PT_GETXMMREGS
  80. /* Set to 1 if the kernel supports PT_GETXMMREGS.  Initialized to -1
  81.    so that we try PT_GETXMMREGS the first time around.  */
  82. ‌static int have_ptrace_xmmregs = -1;
  83. #endif


  86. /* Supply the general-purpose registers in GREGS, to REGCACHE.  */

  88. static void
  89. ‌i386bsd_supply_gregset (struct regcache *regcache, const void *gregs)
  90. {
  91.   const char *regs = gregs;
  92.   int regnum;

  94.   for (regnum = 0; regnum < ARRAY_SIZE (i386bsd_r_reg_offset); regnum++)
  95.     {
  96.       int offset = i386bsd_r_reg_offset[regnum];

  98.       if (offset != -1)
  99.         regcache_raw_supply (regcache, regnum, regs + offset);
  100.     }
  101. }

  103. /* Collect register REGNUM from REGCACHE and store its contents in
  104.    GREGS.  If REGNUM is -1, collect and store all appropriate
  105.    registers.  */

  107. static void
  108. ‌i386bsd_collect_gregset (const struct regcache *regcache,
  109.                          void *gregs, int regnum)
  110. {
  111.   char *regs = gregs;
  112.   int i;

  114.   for (i = 0; i < ARRAY_SIZE (i386bsd_r_reg_offset); i++)
  115.     {
  116.       if (regnum == -1 || regnum == i)
  117.         {
  118.           int offset = i386bsd_r_reg_offset[i];

  120.           if (offset != -1)
  121.             regcache_raw_collect (regcache, i, regs + offset);
  122.         }
  123.     }
  124. }

  126. /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
  127.    for all registers (including the floating point registers).  */

  129. static void
  130. ‌i386bsd_fetch_inferior_registers (struct target_ops *ops,
  131.                                   struct regcache *regcache, int regnum)
  132. {
  133.   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
  134.     {
  135.       struct reg regs;

  137.       if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
  138.                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)
  139.         perror_with_name (_("Couldn't get registers"));

  141.       i386bsd_supply_gregset (regcache, &regs);
  142.       if (regnum != -1)
  143.         return;
  144.     }

  146.   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
  147.     {
  148.       struct fpreg fpregs;
  149. #ifdef HAVE_PT_GETXMMREGS
  150.       char xmmregs[512];

  152.       if (have_ptrace_xmmregs != 0
  153.           && ptrace(PT_GETXMMREGS, ptid_get_pid (inferior_ptid),
  154.                     (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
  155.         {
  156.           have_ptrace_xmmregs = 1;
  157.           i387_supply_fxsave (regcache, -1, xmmregs);
  158.         }
  159.       else
  160.         {
  161.           if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
  162.                       (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
  163.             perror_with_name (_("Couldn't get floating point status"));

  165.           i387_supply_fsave (regcache, -1, &fpregs);
  166.         }
  167. #else
  168.       if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
  169.                   (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
  170.         perror_with_name (_("Couldn't get floating point status"));

  172.       i387_supply_fsave (regcache, -1, &fpregs);
  173. #endif
  174.     }
  175. }

  177. /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
  178.    this for all registers (including the floating point registers).  */

  180. static void
  181. ‌i386bsd_store_inferior_registers (struct target_ops *ops,
  182.                                   struct regcache *regcache, int regnum)
  183. {
  184.   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
  185.     {
  186.       struct reg regs;

  188.       if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
  189.                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)
  190.         perror_with_name (_("Couldn't get registers"));

  192.       i386bsd_collect_gregset (regcache, &regs, regnum);

  194.       if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
  195.                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)
  196.         perror_with_name (_("Couldn't write registers"));

  198.       if (regnum != -1)
  199.         return;
  200.     }

  202.   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
  203.     {
  204.       struct fpreg fpregs;
  205. #ifdef HAVE_PT_GETXMMREGS
  206.       char xmmregs[512];

  208.       if (have_ptrace_xmmregs != 0
  209.           && ptrace(PT_GETXMMREGS, ptid_get_pid (inferior_ptid),
  210.                     (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
  211.         {
  212.           have_ptrace_xmmregs = 1;

  214.           i387_collect_fxsave (regcache, regnum, xmmregs);

  216.           if (ptrace (PT_SETXMMREGS, ptid_get_pid (inferior_ptid),
  217.                       (PTRACE_TYPE_ARG3) xmmregs, 0) == -1)
  218.             perror_with_name (_("Couldn't write XMM registers"));
  219.         }
  220.       else
  221.         {
  222.           have_ptrace_xmmregs = 0;
  223. #endif
  224.           if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
  225.                       (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
  226.             perror_with_name (_("Couldn't get floating point status"));

  228.           i387_collect_fsave (regcache, regnum, &fpregs);

  230.           if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
  231.                       (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
  232.             perror_with_name (_("Couldn't write floating point status"));
  233. #ifdef HAVE_PT_GETXMMREGS
  234.         }
  235. #endif
  236.     }
  237. }

  239. /* Create a prototype *BSD/i386 target.  The client can override it
  240.    with local methods.  */

  242. struct target_ops *
  243. ‌i386bsd_target (void)
  244. {
  245.   struct target_ops *t;

  247.   t = inf_ptrace_target ();
  248.   t->to_fetch_registers = i386bsd_fetch_inferior_registers;
  249.   t->to_store_registers = i386bsd_store_inferior_registers;
  250.   return t;
  251. }


  254. /* Support for debug registers.  */

  256. #ifdef HAVE_PT_GETDBREGS

  258. /* Not all versions of FreeBSD/i386 that support the debug registers
  259.    have this macro.  */
  260. #ifndef DBREG_DRX
  261. ‌#define DBREG_DRX(d, x) ((&d->dr0)[x])
  262. #endif

  264. static unsigned long
  265. ‌i386bsd_dr_get (ptid_t ptid, int regnum)
  266. {
  267.   struct dbreg dbregs;

  269.   if (ptrace (PT_GETDBREGS, ptid_get_pid (inferior_ptid),
  270.               (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)
  271.     perror_with_name (_("Couldn't read debug registers"));

  273.   return DBREG_DRX ((&dbregs), regnum);
  274. }

  276. static void
  277. ‌i386bsd_dr_set (int regnum, unsigned int value)
  278. {
  279.   struct dbreg dbregs;

  281.   if (ptrace (PT_GETDBREGS, ptid_get_pid (inferior_ptid),
  282.               (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)
  283.     perror_with_name (_("Couldn't get debug registers"));

  285.   /* For some mysterious reason, some of the reserved bits in the
  286.      debug control register get set.  Mask these off, otherwise the
  287.      ptrace call below will fail.  */
  288.   DBREG_DRX ((&dbregs), 7) &= ~(0x0000fc00);

  290.   DBREG_DRX ((&dbregs), regnum) = value;

  292.   if (ptrace (PT_SETDBREGS, ptid_get_pid (inferior_ptid),
  293.               (PTRACE_TYPE_ARG3) &dbregs, 0) == -1)
  294.     perror_with_name (_("Couldn't write debug registers"));
  295. }

  297. void
  298. ‌i386bsd_dr_set_control (unsigned long control)
  299. {
  300.   i386bsd_dr_set (7, control);
  301. }

  303. void
  304. ‌i386bsd_dr_set_addr (int regnum, CORE_ADDR addr)
  305. {
  306.   gdb_assert (regnum >= 0 && regnum <= 4);

  308.   i386bsd_dr_set (regnum, addr);
  309. }

  311. CORE_ADDR
  312. ‌i386bsd_dr_get_addr (int regnum)
  313. {
  314.   return i386bsd_dr_get (inferior_ptid, regnum);
  315. }

  317. unsigned long
  318. ‌i386bsd_dr_get_status (void)
  319. {
  320.   return i386bsd_dr_get (inferior_ptid, 6);
  321. }

  323. unsigned long
  324. ‌i386bsd_dr_get_control (void)
  325. {
  326.   return i386bsd_dr_get (inferior_ptid, 7);
  327. }

  329. #endif /* PT_GETDBREGS */


  332. /* Provide a prototype to silence -Wmissing-prototypes.  */
  333. void _initialize_i386bsd_nat (void);

  335. void
  336. ‌_initialize_i386bsd_nat (void)
  337. {
  338.   int offset;

  340.   /* To support the recognition of signal handlers, i386bsd-tdep.c
  341.      hardcodes some constants.  Inclusion of this file means that we
  342.      are compiling a native debugger, which means that we can use the
  343.      system header files and sysctl(3) to get at the relevant
  344.      information.  */

  346. #if defined (__FreeBSD_version) && __FreeBSD_version >= 400011
  347. ‌#define SC_REG_OFFSET i386fbsd4_sc_reg_offset
  348. #elif defined (__FreeBSD_version) && __FreeBSD_version >= 300005
  349. #define SC_REG_OFFSET i386fbsd_sc_reg_offset
  350. #elif defined (NetBSD) || defined (__NetBSD_Version__)
  351. #define SC_REG_OFFSET i386nbsd_sc_reg_offset
  352. #elif defined (OpenBSD)
  353. #define SC_REG_OFFSET i386obsd_sc_reg_offset
  354. #endif

  356. #ifdef SC_REG_OFFSET

  358.   /* We only check the program counter, stack pointer and frame
  359.      pointer since these members of `struct sigcontext' are essential
  360.      for providing backtraces.  More checks could be added, but would
  361.      involve adding configure checks for the appropriate structure
  362.      members, since older BSD's don't provide all of them.  */

  364. ‌#define SC_PC_OFFSET SC_REG_OFFSET[I386_EIP_REGNUM]
  365. ‌#define SC_SP_OFFSET SC_REG_OFFSET[I386_ESP_REGNUM]
  366. ‌#define SC_FP_OFFSET SC_REG_OFFSET[I386_EBP_REGNUM]

  368.   /* Override the default value for the offset of the program counter
  369.      in the sigcontext structure.  */
  370.   offset = offsetof (struct sigcontext, sc_pc);

  372.   if (SC_PC_OFFSET != offset)
  373.     {
  374.       warning (_("\
  375. offsetof (struct sigcontext, sc_pc) yields %d instead of %d.\n\
  376. Please report this to <bug-gdb@gnu.org>."),
  377.                offset, SC_PC_OFFSET);
  378.     }

  380.   SC_PC_OFFSET = offset;

  382.   /* Likewise for the stack pointer.  */
  383.   offset = offsetof (struct sigcontext, sc_sp);

  385.   if (SC_SP_OFFSET != offset)
  386.     {
  387.       warning (_("\
  388. offsetof (struct sigcontext, sc_sp) yields %d instead of %d.\n\
  389. Please report this to <bug-gdb@gnu.org>."),
  390.                offset, SC_SP_OFFSET);
  391.     }

  393.   SC_SP_OFFSET = offset;

  395.   /* And the frame pointer.  */
  396.   offset = offsetof (struct sigcontext, sc_fp);

  398.   if (SC_FP_OFFSET != offset)
  399.     {
  400.       warning (_("\
  401. offsetof (struct sigcontext, sc_fp) yields %d instead of %d.\n\
  402. Please report this to <bug-gdb@gnu.org>."),
  403.                offset, SC_FP_OFFSET);
  404.     }

  406.   SC_FP_OFFSET = offset;

  408. #endif /* SC_REG_OFFSET */
  409. }