gdb/i386-bsd-nat.c

   1 /* Native-dependent code for modern i386 BSD's.
   2
   3    Copyright (C) 2000-2023 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 "x86-bsd-nat.h"
  33 #include "i386-bsd-nat.h"
  34 #include "inf-ptrace.h"
  35 \f
  36
  37 static PTRACE_TYPE_RET
  38 gdb_ptrace (PTRACE_TYPE_ARG1 request, ptid_t ptid, PTRACE_TYPE_ARG3 addr,
  39             PTRACE_TYPE_ARG4 data)
  40 {
  41 #ifdef __NetBSD__
  42   gdb_assert (data == 0);
  43   /* Support for NetBSD threads: unlike other ptrace implementations in this
  44      file, NetBSD requires that we pass both the pid and lwp.  */
  45   return ptrace (request, ptid.pid (), addr, ptid.lwp ());
  46 #else
  47   pid_t pid = get_ptrace_pid (ptid);
  48   return ptrace (request, pid, addr, data);
  49 #endif
  50 }
  51
  52 /* In older BSD versions we cannot get at some of the segment
  53    registers.  FreeBSD for example didn't support the %fs and %gs
  54    registers until the 3.0 release.  We have autoconf checks for their
  55    presence, and deal gracefully with their absence.  */
  56
  57 /* Offset in `struct reg' where MEMBER is stored.  */
  58 #define REG_OFFSET(member) offsetof (struct reg, member)
  59
  60 /* At i386bsd_reg_offset[REGNUM] you'll find the offset in `struct
  61    reg' where the GDB register REGNUM is stored.  Unsupported
  62    registers are marked with `-1'.  */
  63 static int i386bsd_r_reg_offset[] =
  64 {
  65   REG_OFFSET (r_eax),
  66   REG_OFFSET (r_ecx),
  67   REG_OFFSET (r_edx),
  68   REG_OFFSET (r_ebx),
  69   REG_OFFSET (r_esp),
  70   REG_OFFSET (r_ebp),
  71   REG_OFFSET (r_esi),
  72   REG_OFFSET (r_edi),
  73   REG_OFFSET (r_eip),
  74   REG_OFFSET (r_eflags),
  75   REG_OFFSET (r_cs),
  76   REG_OFFSET (r_ss),
  77   REG_OFFSET (r_ds),
  78   REG_OFFSET (r_es),
  79 #ifdef HAVE_STRUCT_REG_R_FS
  80   REG_OFFSET (r_fs),
  81 #else
  82   -1,
  83 #endif
  84 #ifdef HAVE_STRUCT_REG_R_GS
  85   REG_OFFSET (r_gs)
  86 #else
  87   -1
  88 #endif
  89 };
  90
  91 /* Macro to determine if a register is fetched with PT_GETREGS.  */
  92 #define GETREGS_SUPPLIES(regnum) \
  93   ((0 <= (regnum) && (regnum) <= 15))
  94
  95 /* Set to 1 if the kernel supports PT_GETXMMREGS.  Initialized to -1
  96    so that we try PT_GETXMMREGS the first time around.  */
  97 static int have_ptrace_xmmregs = -1;
  98 \f
  99
 100 /* Supply the general-purpose registers in GREGS, to REGCACHE.  */
 101
 102 static void
 103 i386bsd_supply_gregset (struct regcache *regcache, const void *gregs)
 104 {
 105   const char *regs = (const char *) gregs;
 106   int regnum;
 107
 108   for (regnum = 0; regnum < ARRAY_SIZE (i386bsd_r_reg_offset); regnum++)
 109     {
 110       int offset = i386bsd_r_reg_offset[regnum];
 111
 112       if (offset != -1)
 113         regcache->raw_supply (regnum, regs + offset);
 114     }
 115 }
 116
 117 /* Collect register REGNUM from REGCACHE and store its contents in
 118    GREGS.  If REGNUM is -1, collect and store all appropriate
 119    registers.  */
 120
 121 static void
 122 i386bsd_collect_gregset (const struct regcache *regcache,
 123                          void *gregs, int regnum)
 124 {
 125   char *regs = (char *) gregs;
 126   int i;
 127
 128   for (i = 0; i < ARRAY_SIZE (i386bsd_r_reg_offset); i++)
 129     {
 130       if (regnum == -1 || regnum == i)
 131         {
 132           int offset = i386bsd_r_reg_offset[i];
 133
 134           if (offset != -1)
 135             regcache->raw_collect (i, regs + offset);
 136         }
 137     }
 138 }
 139
 140 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 141    for all registers (including the floating point registers).  */
 142
 143 void
 144 i386bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
 145 {
 146   ptid_t ptid = regcache->ptid ();
 147
 148   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
 149     {
 150       struct reg regs;
 151
 152       if (gdb_ptrace (PT_GETREGS, ptid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 153         perror_with_name (_("Couldn't get registers"));
 154
 155       i386bsd_supply_gregset (regcache, &regs);
 156       if (regnum != -1)
 157         return;
 158     }
 159
 160   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
 161     {
 162       struct fpreg fpregs;
 163       char xmmregs[512];
 164
 165       if (have_ptrace_xmmregs != 0
 166           && gdb_ptrace(PT_GETXMMREGS, ptid,
 167                         (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
 168         {
 169           have_ptrace_xmmregs = 1;
 170           i387_supply_fxsave (regcache, -1, xmmregs);
 171         }
 172       else
 173         {
 174           have_ptrace_xmmregs = 0;
 175           if (gdb_ptrace (PT_GETFPREGS, ptid,
 176                           (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 177             perror_with_name (_("Couldn't get floating point status"));
 178
 179           i387_supply_fsave (regcache, -1, &fpregs);
 180         }
 181     }
 182 }
 183
 184 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 185    this for all registers (including the floating point registers).  */
 186
 187 void
 188 i386bsd_store_inferior_registers (struct regcache *regcache, int regnum)
 189 {
 190   ptid_t ptid = regcache->ptid ();
 191
 192   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
 193     {
 194       struct reg regs;
 195
 196       if (gdb_ptrace (PT_GETREGS, ptid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 197         perror_with_name (_("Couldn't get registers"));
 198
 199       i386bsd_collect_gregset (regcache, &regs, regnum);
 200
 201       if (gdb_ptrace (PT_SETREGS, ptid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 202         perror_with_name (_("Couldn't write registers"));
 203
 204       if (regnum != -1)
 205         return;
 206     }
 207
 208   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
 209     {
 210       struct fpreg fpregs;
 211       char xmmregs[512];
 212
 213       if (have_ptrace_xmmregs != 0
 214           && gdb_ptrace(PT_GETXMMREGS, ptid,
 215                         (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
 216         {
 217           have_ptrace_xmmregs = 1;
 218
 219           i387_collect_fxsave (regcache, regnum, xmmregs);
 220
 221           if (gdb_ptrace (PT_SETXMMREGS, ptid,
 222                           (PTRACE_TYPE_ARG3) xmmregs, 0) == -1)
 223             perror_with_name (_("Couldn't write XMM registers"));
 224         }
 225       else
 226         {
 227           have_ptrace_xmmregs = 0;
 228           if (gdb_ptrace (PT_GETFPREGS, ptid,
 229                           (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 230             perror_with_name (_("Couldn't get floating point status"));
 231
 232           i387_collect_fsave (regcache, regnum, &fpregs);
 233
 234           if (gdb_ptrace (PT_SETFPREGS, ptid,
 235                           (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 236             perror_with_name (_("Couldn't write floating point status"));
 237         }
 238     }
 239 }
 240
 241 void _initialize_i386bsd_nat ();
 242 void
 243 _initialize_i386bsd_nat ()
 244 {
 245   /* To support the recognition of signal handlers, i386-bsd-tdep.c
 246      hardcodes some constants.  Inclusion of this file means that we
 247      are compiling a native debugger, which means that we can use the
 248      system header files and sysctl(3) to get at the relevant
 249      information.  */
 250
 251 #if defined (OpenBSD)
 252 #define SC_REG_OFFSET i386obsd_sc_reg_offset
 253 #endif
 254
 255 #ifdef SC_REG_OFFSET
 256
 257   /* We only check the program counter, stack pointer and frame
 258      pointer since these members of `struct sigcontext' are essential
 259      for providing backtraces.  More checks could be added, but would
 260      involve adding configure checks for the appropriate structure
 261      members, since older BSD's don't provide all of them.  */
 262
 263 #define SC_PC_OFFSET SC_REG_OFFSET[I386_EIP_REGNUM]
 264 #define SC_SP_OFFSET SC_REG_OFFSET[I386_ESP_REGNUM]
 265 #define SC_FP_OFFSET SC_REG_OFFSET[I386_EBP_REGNUM]
 266
 267   /* Override the default value for the offset of the program counter
 268      in the sigcontext structure.  */
 269   int offset = offsetof (struct sigcontext, sc_pc);
 270
 271   if (SC_PC_OFFSET != offset)
 272     {
 273       warning (_("\
 274 offsetof (struct sigcontext, sc_pc) yields %d instead of %d.\n\
 275 Please report this to <bug-gdb@gnu.org>."),
 276                offset, SC_PC_OFFSET);
 277     }
 278
 279   SC_PC_OFFSET = offset;
 280
 281   /* Likewise for the stack pointer.  */
 282   offset = offsetof (struct sigcontext, sc_sp);
 283
 284   if (SC_SP_OFFSET != offset)
 285     {
 286       warning (_("\
 287 offsetof (struct sigcontext, sc_sp) yields %d instead of %d.\n\
 288 Please report this to <bug-gdb@gnu.org>."),
 289                offset, SC_SP_OFFSET);
 290     }
 291
 292   SC_SP_OFFSET = offset;
 293
 294   /* And the frame pointer.  */
 295   offset = offsetof (struct sigcontext, sc_fp);
 296
 297   if (SC_FP_OFFSET != offset)
 298     {
 299       warning (_("\
 300 offsetof (struct sigcontext, sc_fp) yields %d instead of %d.\n\
 301 Please report this to <bug-gdb@gnu.org>."),
 302                offset, SC_FP_OFFSET);
 303     }
 304
 305   SC_FP_OFFSET = offset;
 306
 307 #endif /* SC_REG_OFFSET */
 308 }