gdb/i386bsd-nat.c

   1 /* Native-dependent code for modern i386 BSD's.
   2
   3    Copyright (C) 2000-2014 Free Software Foundation, Inc.
   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
  20 #include "defs.h"
  21 #include "inferior.h"
  22 #include "regcache.h"
  23
  24 #include <signal.h>
  25 #include <sys/types.h>
  26 #include <sys/ptrace.h>
  27 #include <machine/reg.h>
  28 #include <machine/frame.h>
  29
  30 #include "i386-tdep.h"
  31 #include "i387-tdep.h"
  32 #include "i386bsd-nat.h"
  33 #include "inf-ptrace.h"
  34 \f
  35
  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.  */
  40
  41 /* Offset in `struct reg' where MEMBER is stored.  */
  42 #define REG_OFFSET(member) offsetof (struct reg, member)
  43
  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 };
  74
  75 /* Macro to determine if a register is fetched with PT_GETREGS.  */
  76 #define GETREGS_SUPPLIES(regnum) \
  77   ((0 <= (regnum) && (regnum) <= 15))
  78
  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
  84 \f
  85
  86 /* Supply the general-purpose registers in GREGS, to REGCACHE.  */
  87
  88 static void
  89 i386bsd_supply_gregset (struct regcache *regcache, const void *gregs)
  90 {
  91   const char *regs = gregs;
  92   int regnum;
  93
  94   for (regnum = 0; regnum < ARRAY_SIZE (i386bsd_r_reg_offset); regnum++)
  95     {
  96       int offset = i386bsd_r_reg_offset[regnum];
  97
  98       if (offset != -1)
  99         regcache_raw_supply (regcache, regnum, regs + offset);
 100     }
 101 }
 102
 103 /* Collect register REGNUM from REGCACHE and store its contents in
 104    GREGS.  If REGNUM is -1, collect and store all appropriate
 105    registers.  */
 106
 107 static void
 108 i386bsd_collect_gregset (const struct regcache *regcache,
 109                          void *gregs, int regnum)
 110 {
 111   char *regs = gregs;
 112   int i;
 113
 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];
 119
 120           if (offset != -1)
 121             regcache_raw_collect (regcache, i, regs + offset);
 122         }
 123     }
 124 }
 125
 126 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 127    for all registers (including the floating point registers).  */
 128
 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;
 136
 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"));
 140
 141       i386bsd_supply_gregset (regcache, &regs);
 142       if (regnum != -1)
 143         return;
 144     }
 145
 146   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
 147     {
 148       struct fpreg fpregs;
 149 #ifdef HAVE_PT_GETXMMREGS
 150       char xmmregs[512];
 151
 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"));
 164
 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"));
 171
 172       i387_supply_fsave (regcache, -1, &fpregs);
 173 #endif
 174     }
 175 }
 176
 177 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 178    this for all registers (including the floating point registers).  */
 179
 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;
 187
 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"));
 191
 192       i386bsd_collect_gregset (regcache, &regs, regnum);
 193
 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"));
 197
 198       if (regnum != -1)
 199         return;
 200     }
 201
 202   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
 203     {
 204       struct fpreg fpregs;
 205 #ifdef HAVE_PT_GETXMMREGS
 206       char xmmregs[512];
 207
 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;
 213
 214           i387_collect_fxsave (regcache, regnum, xmmregs);
 215
 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"));
 227
 228           i387_collect_fsave (regcache, regnum, &fpregs);
 229
 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 }
 238
 239 /* Create a prototype *BSD/i386 target.  The client can override it
 240    with local methods.  */
 241
 242 struct target_ops *
 243 i386bsd_target (void)
 244 {
 245   struct target_ops *t;
 246
 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 }
 252 \f
 253
 254 /* Support for debug registers.  */
 255
 256 #ifdef HAVE_PT_GETDBREGS
 257
 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
 263
 264 static unsigned long
 265 i386bsd_dr_get (ptid_t ptid, int regnum)
 266 {
 267   struct dbreg dbregs;
 268
 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"));
 272
 273   return DBREG_DRX ((&dbregs), regnum);
 274 }
 275
 276 static void
 277 i386bsd_dr_set (int regnum, unsigned int value)
 278 {
 279   struct dbreg dbregs;
 280
 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"));
 284
 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);
 289
 290   DBREG_DRX ((&dbregs), regnum) = value;
 291
 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 }
 296
 297 void
 298 i386bsd_dr_set_control (unsigned long control)
 299 {
 300   i386bsd_dr_set (7, control);
 301 }
 302
 303 void
 304 i386bsd_dr_set_addr (int regnum, CORE_ADDR addr)
 305 {
 306   gdb_assert (regnum >= 0 && regnum <= 4);
 307
 308   i386bsd_dr_set (regnum, addr);
 309 }
 310
 311 CORE_ADDR
 312 i386bsd_dr_get_addr (int regnum)
 313 {
 314   return i386bsd_dr_get (inferior_ptid, regnum);
 315 }
 316
 317 unsigned long
 318 i386bsd_dr_get_status (void)
 319 {
 320   return i386bsd_dr_get (inferior_ptid, 6);
 321 }
 322
 323 unsigned long
 324 i386bsd_dr_get_control (void)
 325 {
 326   return i386bsd_dr_get (inferior_ptid, 7);
 327 }
 328
 329 #endif /* PT_GETDBREGS */
 330 \f
 331
 332 /* Provide a prototype to silence -Wmissing-prototypes.  */
 333 void _initialize_i386bsd_nat (void);
 334
 335 void
 336 _initialize_i386bsd_nat (void)
 337 {
 338   int offset;
 339
 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.  */
 345
 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
 355
 356 #ifdef SC_REG_OFFSET
 357
 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.  */
 363
 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]
 367
 368   /* Override the default value for the offset of the program counter
 369      in the sigcontext structure.  */
 370   offset = offsetof (struct sigcontext, sc_pc);
 371
 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     }
 379
 380   SC_PC_OFFSET = offset;
 381
 382   /* Likewise for the stack pointer.  */
 383   offset = offsetof (struct sigcontext, sc_sp);
 384
 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     }
 392
 393   SC_SP_OFFSET = offset;
 394
 395   /* And the frame pointer.  */
 396   offset = offsetof (struct sigcontext, sc_fp);
 397
 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     }
 405
 406   SC_FP_OFFSET = offset;
 407
 408 #endif /* SC_REG_OFFSET */
 409 }