gdb/i386bsd-nat.c

   1 /* Native-dependent code for modern i386 BSD's.
   2
   3    Copyright 2000, 2001, 2002, 2003, 2004 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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "regcache.h"
  25
  26 #include "gdb_assert.h"
  27 #include <signal.h>
  28 #include <stddef.h>
  29 #include <sys/types.h>
  30 #include <sys/ptrace.h>
  31 #include <machine/reg.h>
  32 #include <machine/frame.h>
  33
  34 #ifdef HAVE_SYS_PROCFS_H
  35 #include <sys/procfs.h>
  36 #endif
  37
  38 #ifndef HAVE_GREGSET_T
  39 typedef struct reg gregset_t;
  40 #endif
  41
  42 #ifndef HAVE_FPREGSET_T
  43 typedef struct fpreg fpregset_t;
  44 #endif
  45
  46 #include "gregset.h"
  47 #include "i386-tdep.h"
  48 \f
  49
  50 /* In older BSD versions we cannot get at some of the segment
  51    registers.  FreeBSD for example didn't support the %fs and %gs
  52    registers until the 3.0 release.  We have autoconf checks for their
  53    presence, and deal gracefully with their absence.  */
  54
  55 /* Registers we shouldn't try to fetch.  */
  56 #undef CANNOT_FETCH_REGISTER
  57 #define CANNOT_FETCH_REGISTER(regnum) cannot_fetch_register (regnum)
  58
  59 /* Registers we shouldn't try to store.  */
  60 #undef CANNOT_STORE_REGISTER
  61 #define CANNOT_STORE_REGISTER(regnum) cannot_fetch_register (regnum)
  62
  63 /* Offset to the gregset_t location where REG is stored.  */
  64 #define REG_OFFSET(reg) offsetof (gregset_t, reg)
  65
  66 /* At reg_offset[REGNUM] you'll find the offset to the gregset_t
  67    location where the GDB register REGNUM is stored.  Unsupported
  68    registers are marked with `-1'.  */
  69 static int reg_offset[] =
  70 {
  71   REG_OFFSET (r_eax),
  72   REG_OFFSET (r_ecx),
  73   REG_OFFSET (r_edx),
  74   REG_OFFSET (r_ebx),
  75   REG_OFFSET (r_esp),
  76   REG_OFFSET (r_ebp),
  77   REG_OFFSET (r_esi),
  78   REG_OFFSET (r_edi),
  79   REG_OFFSET (r_eip),
  80   REG_OFFSET (r_eflags),
  81   REG_OFFSET (r_cs),
  82   REG_OFFSET (r_ss),
  83   REG_OFFSET (r_ds),
  84   REG_OFFSET (r_es),
  85 #ifdef HAVE_STRUCT_REG_R_FS
  86   REG_OFFSET (r_fs),
  87 #else
  88   -1,
  89 #endif
  90 #ifdef HAVE_STRUCT_REG_R_GS
  91   REG_OFFSET (r_gs)
  92 #else
  93   -1
  94 #endif
  95 };
  96
  97 #define REG_ADDR(regset, regnum) ((char *) (regset) + reg_offset[regnum])
  98
  99 /* Macro to determine if a register is fetched with PT_GETREGS.  */
 100 #define GETREGS_SUPPLIES(regnum) \
 101   ((0 <= (regnum) && (regnum) <= 15))
 102
 103 #ifdef HAVE_PT_GETXMMREGS
 104 /* Set to 1 if the kernel supports PT_GETXMMREGS.  Initialized to -1
 105    so that we try PT_GETXMMREGS the first time around.  */
 106 static int have_ptrace_xmmregs = -1;
 107 #endif
 108
 109 /* Return nonzero if we shouldn't try to fetch register REGNUM.  */
 110
 111 static int
 112 cannot_fetch_register (int regnum)
 113 {
 114   return (reg_offset[regnum] == -1);
 115 }
 116 \f
 117
 118 /* Transfering the registers between GDB, inferiors and core files.  */
 119
 120 /* Fill GDB's register array with the general-purpose register values
 121    in *GREGSETP.  */
 122
 123 void
 124 supply_gregset (gregset_t *gregsetp)
 125 {
 126   struct regcache *regcache = current_regcache;
 127   int regnum;
 128
 129   for (regnum = 0; regnum < I386_NUM_GREGS; regnum++)
 130     {
 131       if (CANNOT_FETCH_REGISTER (regnum))
 132         regcache_raw_supply (regcache, regnum, NULL);
 133       else
 134         regcache_raw_supply (regcache, regnum, REG_ADDR (gregsetp, regnum));
 135     }
 136 }
 137
 138 /* Fill register REGNUM (if it is a general-purpose register) in
 139    *GREGSETPS with the value in GDB's register array.  If REGNUM is -1,
 140    do this for all registers.  */
 141
 142 void
 143 fill_gregset (gregset_t *gregsetp, int regnum)
 144 {
 145   struct regcache *regcache = current_regcache;
 146   int i;
 147
 148   for (i = 0; i < I386_NUM_GREGS; i++)
 149     if ((regnum == -1 || regnum == i) && ! CANNOT_STORE_REGISTER (i))
 150       regcache_raw_collect (regcache, i, REG_ADDR (gregsetp, i));
 151 }
 152
 153 #include "i387-tdep.h"
 154
 155 /* Fill GDB's register array with the floating-point register values
 156    in *FPREGSETP.  */
 157
 158 void
 159 supply_fpregset (fpregset_t *fpregsetp)
 160 {
 161   i387_supply_fsave (current_regcache, -1, fpregsetp);
 162 }
 163
 164 /* Fill register REGNUM (if it is a floating-point register) in
 165    *FPREGSETP with the value in GDB's register array.  If REGNUM is
 166    -1, do this for all registers.  */
 167
 168 void
 169 fill_fpregset (fpregset_t *fpregsetp, int regnum)
 170 {
 171   i387_collect_fsave (current_regcache, regnum, fpregsetp);
 172 }
 173
 174 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 175    for all registers (including the floating point registers).  */
 176
 177 void
 178 fetch_inferior_registers (int regnum)
 179 {
 180   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
 181     {
 182       gregset_t gregs;
 183
 184       if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
 185                   (PTRACE_ARG3_TYPE) &gregs, 0) == -1)
 186         perror_with_name ("Couldn't get registers");
 187
 188       supply_gregset (&gregs);
 189       if (regnum != -1)
 190         return;
 191     }
 192
 193   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
 194     {
 195       fpregset_t fpregs;
 196 #ifdef HAVE_PT_GETXMMREGS
 197       char xmmregs[512];
 198
 199       if (have_ptrace_xmmregs != 0
 200           && ptrace(PT_GETXMMREGS, PIDGET (inferior_ptid),
 201                     (PTRACE_ARG3_TYPE) xmmregs, 0) == 0)
 202         {
 203           have_ptrace_xmmregs = 1;
 204           i387_supply_fxsave (current_regcache, -1, xmmregs);
 205         }
 206       else
 207         {
 208           if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
 209                       (PTRACE_ARG3_TYPE) &fpregs, 0) == -1)
 210             perror_with_name ("Couldn't get floating point status");
 211
 212           i387_supply_fsave (current_regcache, -1, &fpregs);
 213         }
 214 #else
 215       if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
 216                   (PTRACE_ARG3_TYPE) &fpregs, 0) == -1)
 217         perror_with_name ("Couldn't get floating point status");
 218
 219       i387_supply_fsave (current_regcache, -1, &fpregs);
 220 #endif
 221     }
 222 }
 223
 224 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 225    this for all registers (including the floating point registers).  */
 226
 227 void
 228 store_inferior_registers (int regnum)
 229 {
 230   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
 231     {
 232       gregset_t gregs;
 233
 234       if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
 235                   (PTRACE_ARG3_TYPE) &gregs, 0) == -1)
 236         perror_with_name ("Couldn't get registers");
 237
 238       fill_gregset (&gregs, regnum);
 239
 240       if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
 241                   (PTRACE_ARG3_TYPE) &gregs, 0) == -1)
 242         perror_with_name ("Couldn't write registers");
 243
 244       if (regnum != -1)
 245         return;
 246     }
 247
 248   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
 249     {
 250       fpregset_t fpregs;
 251 #ifdef HAVE_PT_GETXMMREGS
 252       char xmmregs[512];
 253
 254       if (have_ptrace_xmmregs != 0
 255           && ptrace(PT_GETXMMREGS, PIDGET (inferior_ptid),
 256                     (PTRACE_ARG3_TYPE) xmmregs, 0) == 0)
 257         {
 258           have_ptrace_xmmregs = 1;
 259
 260           i387_collect_fxsave (current_regcache, regnum, xmmregs);
 261
 262           if (ptrace (PT_SETXMMREGS, PIDGET (inferior_ptid),
 263                       (PTRACE_ARG3_TYPE) xmmregs, 0) == -1)
 264             perror_with_name ("Couldn't write XMM registers");
 265         }
 266       else
 267         {
 268           have_ptrace_xmmregs = 0;
 269 #endif
 270           if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
 271                       (PTRACE_ARG3_TYPE) &fpregs, 0) == -1)
 272             perror_with_name ("Couldn't get floating point status");
 273
 274           i387_collect_fsave (current_regcache, regnum, &fpregs);
 275
 276           if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
 277                       (PTRACE_ARG3_TYPE) &fpregs, 0) == -1)
 278             perror_with_name ("Couldn't write floating point status");
 279 #ifdef HAVE_PT_GETXMMREGS
 280         }
 281 #endif
 282     }
 283 }
 284 \f
 285
 286 /* Support for debug registers.  */
 287
 288 #ifdef HAVE_PT_GETDBREGS
 289
 290 /* Not all versions of FreeBSD/i386 that support the debug registers
 291    have this macro.  */
 292 #ifndef DBREG_DRX
 293 #define DBREG_DRX(d, x) ((&d->dr0)[x])
 294 #endif
 295
 296 static void
 297 i386bsd_dr_set (int regnum, unsigned int value)
 298 {
 299   struct dbreg dbregs;
 300
 301   if (ptrace (PT_GETDBREGS, PIDGET (inferior_ptid),
 302               (PTRACE_ARG3_TYPE) &dbregs, 0) == -1)
 303     perror_with_name ("Couldn't get debug registers");
 304
 305   /* For some mysterious reason, some of the reserved bits in the
 306      debug control register get set.  Mask these off, otherwise the
 307      ptrace call below will fail.  */
 308   DBREG_DRX ((&dbregs), 7) &= ~(0x0000fc00);
 309
 310   DBREG_DRX ((&dbregs), regnum) = value;
 311
 312   if (ptrace (PT_SETDBREGS, PIDGET (inferior_ptid),
 313               (PTRACE_ARG3_TYPE) &dbregs, 0) == -1)
 314     perror_with_name ("Couldn't write debug registers");
 315 }
 316
 317 void
 318 i386bsd_dr_set_control (unsigned long control)
 319 {
 320   i386bsd_dr_set (7, control);
 321 }
 322
 323 void
 324 i386bsd_dr_set_addr (int regnum, CORE_ADDR addr)
 325 {
 326   gdb_assert (regnum >= 0 && regnum <= 4);
 327
 328   i386bsd_dr_set (regnum, addr);
 329 }
 330
 331 void
 332 i386bsd_dr_reset_addr (int regnum)
 333 {
 334   gdb_assert (regnum >= 0 && regnum <= 4);
 335
 336   i386bsd_dr_set (regnum, 0);
 337 }
 338
 339 unsigned long
 340 i386bsd_dr_get_status (void)
 341 {
 342   struct dbreg dbregs;
 343
 344   /* FIXME: kettenis/2001-03-31: Calling perror_with_name if the
 345      ptrace call fails breaks debugging remote targets.  The correct
 346      way to fix this is to add the hardware breakpoint and watchpoint
 347      stuff to the target vector.  For now, just return zero if the
 348      ptrace call fails.  */
 349   if (ptrace (PT_GETDBREGS, PIDGET (inferior_ptid),
 350               (PTRACE_ARG3_TYPE) & dbregs, 0) == -1)
 351 #if 0
 352     perror_with_name ("Couldn't read debug registers");
 353 #else
 354     return 0;
 355 #endif
 356
 357   return DBREG_DRX ((&dbregs), 6);
 358 }
 359
 360 #endif /* PT_GETDBREGS */
 361 \f
 362
 363 /* Support for the user struct.  */
 364
 365 /* Return the address register REGNUM.  BLOCKEND is the value of
 366    u.u_ar0, which should point to the registers.  */
 367
 368 CORE_ADDR
 369 register_u_addr (CORE_ADDR blockend, int regnum)
 370 {
 371   return (CORE_ADDR) REG_ADDR (blockend, regnum);
 372 }
 373
 374 #include <sys/param.h>
 375 #include <sys/user.h>
 376
 377 /* Return the size of the user struct.  */
 378
 379 int
 380 kernel_u_size (void)
 381 {
 382   return (sizeof (struct user));
 383 }
 384 \f
 385 void
 386 _initialize_i386bsd_nat (void)
 387 {
 388   int offset;
 389
 390   /* To support the recognition of signal handlers, i386bsd-tdep.c
 391      hardcodes some constants.  Inclusion of this file means that we
 392      are compiling a native debugger, which means that we can use the
 393      system header files and sysctl(3) to get at the relevant
 394      information.  */
 395
 396 #if defined (__FreeBSD_version) && __FreeBSD_version >= 400011
 397 #define SC_REG_OFFSET i386fbsd4_sc_reg_offset
 398 #elif defined (__FreeBSD_version) && __FreeBSD_version >= 300005
 399 #define SC_REG_OFFSET i386fbsd_sc_reg_offset
 400 #elif defined (NetBSD) || defined (__NetBSD_Version__)
 401 #define SC_REG_OFFSET i386nbsd_sc_reg_offset
 402 #elif defined (OpenBSD)
 403 #define SC_REG_OFFSET i386obsd_sc_reg_offset
 404 #else
 405 #define SC_REG_OFFSET i386bsd_sc_reg_offset
 406 #endif
 407
 408   /* We only check the program counter, stack pointer and frame
 409      pointer since these members of `struct sigcontext' are essential
 410      for providing backtraces.  More checks could be added, but would
 411      involve adding configure checks for the appropriate structure
 412      members, since older BSD's don't provide all of them.  */
 413
 414 #define SC_PC_OFFSET SC_REG_OFFSET[I386_EIP_REGNUM]
 415 #define SC_SP_OFFSET SC_REG_OFFSET[I386_ESP_REGNUM]
 416 #define SC_FP_OFFSET SC_REG_OFFSET[I386_EBP_REGNUM]
 417
 418   /* Override the default value for the offset of the program counter
 419      in the sigcontext structure.  */
 420   offset = offsetof (struct sigcontext, sc_pc);
 421
 422   if (SC_PC_OFFSET != offset)
 423     {
 424       warning ("\
 425 offsetof (struct sigcontext, sc_pc) yields %d instead of %d.\n\
 426 Please report this to <bug-gdb@gnu.org>.",
 427                offset, SC_PC_OFFSET);
 428     }
 429
 430   SC_PC_OFFSET = offset;
 431
 432   /* Likewise for the stack pointer.  */
 433   offset = offsetof (struct sigcontext, sc_sp);
 434
 435   if (SC_SP_OFFSET != offset)
 436     {
 437       warning ("\
 438 offsetof (struct sigcontext, sc_sp) yields %d instead of %d.\n\
 439 Please report this to <bug-gdb@gnu.org>.",
 440                offset, SC_SP_OFFSET);
 441     }
 442
 443   SC_SP_OFFSET = offset;
 444
 445   /* And the frame pointer.  */
 446   offset = offsetof (struct sigcontext, sc_fp);
 447
 448   if (SC_FP_OFFSET != offset)
 449     {
 450       warning ("\
 451 offsetof (struct sigcontext, sc_fp) yields %d instead of %d.\n\
 452 Please report this to <bug-gdb@gnu.org>.",
 453                offset, SC_FP_OFFSET);
 454     }
 455
 456   SC_FP_OFFSET = offset;
 457 }