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