gdb/i386-bsd-nat.c

   1 /* Native-dependent code for modern i386 BSD's.
   2
   3    Copyright (C) 2000-2021 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 #ifdef HAVE_PT_GETXMMREGS
  96 /* Set to 1 if the kernel supports PT_GETXMMREGS.  Initialized to -1
  97    so that we try PT_GETXMMREGS the first time around.  */
  98 static int have_ptrace_xmmregs = -1;
  99 #endif
 100 \f
 101
 102 /* Supply the general-purpose registers in GREGS, to REGCACHE.  */
 103
 104 static void
 105 i386bsd_supply_gregset (struct regcache *regcache, const void *gregs)
 106 {
 107   const char *regs = (const char *) gregs;
 108   int regnum;
 109
 110   for (regnum = 0; regnum < ARRAY_SIZE (i386bsd_r_reg_offset); regnum++)
 111     {
 112       int offset = i386bsd_r_reg_offset[regnum];
 113
 114       if (offset != -1)
 115         regcache->raw_supply (regnum, regs + offset);
 116     }
 117 }
 118
 119 /* Collect register REGNUM from REGCACHE and store its contents in
 120    GREGS.  If REGNUM is -1, collect and store all appropriate
 121    registers.  */
 122
 123 static void
 124 i386bsd_collect_gregset (const struct regcache *regcache,
 125                          void *gregs, int regnum)
 126 {
 127   char *regs = (char *) gregs;
 128   int i;
 129
 130   for (i = 0; i < ARRAY_SIZE (i386bsd_r_reg_offset); i++)
 131     {
 132       if (regnum == -1 || regnum == i)
 133         {
 134           int offset = i386bsd_r_reg_offset[i];
 135
 136           if (offset != -1)
 137             regcache->raw_collect (i, regs + offset);
 138         }
 139     }
 140 }
 141
 142 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 143    for all registers (including the floating point registers).  */
 144
 145 void
 146 i386bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
 147 {
 148   ptid_t ptid = regcache->ptid ();
 149
 150   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
 151     {
 152       struct reg regs;
 153
 154       if (gdb_ptrace (PT_GETREGS, ptid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 155         perror_with_name (_("Couldn't get registers"));
 156
 157       i386bsd_supply_gregset (regcache, &regs);
 158       if (regnum != -1)
 159         return;
 160     }
 161
 162 #ifdef PT_GETFSBASE
 163   if (regnum == -1 || regnum == I386_FSBASE_REGNUM)
 164     {
 165       register_t base;
 166
 167       if (gdb_ptrace (PT_GETFSBASE, ptid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
 168         perror_with_name (_("Couldn't get segment register fs_base"));
 169
 170       regcache->raw_supply (I386_FSBASE_REGNUM, &base);
 171       if (regnum != -1)
 172         return;
 173     }
 174 #endif
 175 #ifdef PT_GETGSBASE
 176   if (regnum == -1 || regnum == I386_GSBASE_REGNUM)
 177     {
 178       register_t base;
 179
 180       if (gdb_ptrace (PT_GETGSBASE, ptid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
 181         perror_with_name (_("Couldn't get segment register gs_base"));
 182
 183       regcache->raw_supply (I386_GSBASE_REGNUM, &base);
 184       if (regnum != -1)
 185         return;
 186     }
 187 #endif
 188
 189   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
 190     {
 191       struct fpreg fpregs;
 192 #ifdef HAVE_PT_GETXMMREGS
 193       char xmmregs[512];
 194 #endif
 195
 196 #ifdef PT_GETXSTATE_INFO
 197       if (x86bsd_xsave_len != 0)
 198         {
 199           void *xstateregs;
 200
 201           xstateregs = alloca (x86bsd_xsave_len);
 202           if (gdb_ptrace (PT_GETXSTATE, ptid,
 203                           (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
 204             perror_with_name (_("Couldn't get extended state status"));
 205
 206           i387_supply_xsave (regcache, -1, xstateregs);
 207           return;
 208         }
 209 #endif
 210
 211 #ifdef HAVE_PT_GETXMMREGS
 212       if (have_ptrace_xmmregs != 0
 213           && gdb_ptrace(PT_GETXMMREGS, ptid,
 214                         (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
 215         {
 216           have_ptrace_xmmregs = 1;
 217           i387_supply_fxsave (regcache, -1, xmmregs);
 218         }
 219       else
 220         {
 221           have_ptrace_xmmregs = 0;
 222 #endif
 223           if (gdb_ptrace (PT_GETFPREGS, ptid,
 224                           (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 225             perror_with_name (_("Couldn't get floating point status"));
 226
 227           i387_supply_fsave (regcache, -1, &fpregs);
 228 #ifdef HAVE_PT_GETXMMREGS
 229         }
 230 #endif
 231     }
 232 }
 233
 234 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 235    this for all registers (including the floating point registers).  */
 236
 237 void
 238 i386bsd_store_inferior_registers (struct regcache *regcache, int regnum)
 239 {
 240   ptid_t ptid = regcache->ptid ();
 241
 242   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
 243     {
 244       struct reg regs;
 245
 246       if (gdb_ptrace (PT_GETREGS, ptid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 247         perror_with_name (_("Couldn't get registers"));
 248
 249       i386bsd_collect_gregset (regcache, &regs, regnum);
 250
 251       if (gdb_ptrace (PT_SETREGS, ptid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 252         perror_with_name (_("Couldn't write registers"));
 253
 254       if (regnum != -1)
 255         return;
 256     }
 257
 258 #ifdef PT_SETFSBASE
 259   if (regnum == -1 || regnum == I386_FSBASE_REGNUM)
 260     {
 261       register_t base;
 262
 263       regcache->raw_collect (I386_FSBASE_REGNUM, &base);
 264
 265       if (gdb_ptrace (PT_SETFSBASE, ptid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
 266         perror_with_name (_("Couldn't write segment register fs_base"));
 267       if (regnum != -1)
 268         return;
 269     }
 270 #endif
 271 #ifdef PT_SETGSBASE
 272   if (regnum == -1 || regnum == I386_GSBASE_REGNUM)
 273     {
 274       register_t base;
 275
 276       regcache->raw_collect (I386_GSBASE_REGNUM, &base);
 277
 278       if (gdb_ptrace (PT_SETGSBASE, ptid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
 279         perror_with_name (_("Couldn't write segment register gs_base"));
 280       if (regnum != -1)
 281         return;
 282     }
 283 #endif
 284
 285   if (regnum == -1 || regnum >= I386_ST0_REGNUM)
 286     {
 287       struct fpreg fpregs;
 288 #ifdef HAVE_PT_GETXMMREGS
 289       char xmmregs[512];
 290 #endif
 291
 292 #ifdef PT_GETXSTATE_INFO
 293       if (x86bsd_xsave_len != 0)
 294         {
 295           void *xstateregs;
 296
 297           xstateregs = alloca (x86bsd_xsave_len);
 298           if (gdb_ptrace (PT_GETXSTATE, ptid,
 299                           (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
 300             perror_with_name (_("Couldn't get extended state status"));
 301
 302           i387_collect_xsave (regcache, -1, xstateregs, 0);
 303
 304           if (gdb_ptrace (PT_SETXSTATE, ptid, (PTRACE_TYPE_ARG3) xstateregs,
 305                           x86bsd_xsave_len) == -1)
 306             perror_with_name (_("Couldn't write extended state status"));
 307           return;
 308         }
 309 #endif
 310
 311 #ifdef HAVE_PT_GETXMMREGS
 312       if (have_ptrace_xmmregs != 0
 313           && gdb_ptrace(PT_GETXMMREGS, ptid,
 314                         (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
 315         {
 316           have_ptrace_xmmregs = 1;
 317
 318           i387_collect_fxsave (regcache, regnum, xmmregs);
 319
 320           if (gdb_ptrace (PT_SETXMMREGS, ptid,
 321                           (PTRACE_TYPE_ARG3) xmmregs, 0) == -1)
 322             perror_with_name (_("Couldn't write XMM registers"));
 323         }
 324       else
 325         {
 326           have_ptrace_xmmregs = 0;
 327 #endif
 328           if (gdb_ptrace (PT_GETFPREGS, ptid,
 329                           (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 330             perror_with_name (_("Couldn't get floating point status"));
 331
 332           i387_collect_fsave (regcache, regnum, &fpregs);
 333
 334           if (gdb_ptrace (PT_SETFPREGS, ptid,
 335                           (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 336             perror_with_name (_("Couldn't write floating point status"));
 337 #ifdef HAVE_PT_GETXMMREGS
 338         }
 339 #endif
 340     }
 341 }
 342
 343 void _initialize_i386bsd_nat ();
 344 void
 345 _initialize_i386bsd_nat ()
 346 {
 347   /* To support the recognition of signal handlers, i386-bsd-tdep.c
 348      hardcodes some constants.  Inclusion of this file means that we
 349      are compiling a native debugger, which means that we can use the
 350      system header files and sysctl(3) to get at the relevant
 351      information.  */
 352
 353 #if defined (__FreeBSD_version) && __FreeBSD_version >= 400011
 354 #define SC_REG_OFFSET i386fbsd4_sc_reg_offset
 355 #elif defined (__FreeBSD_version) && __FreeBSD_version >= 300005
 356 #define SC_REG_OFFSET i386fbsd_sc_reg_offset
 357 #elif defined (OpenBSD)
 358 #define SC_REG_OFFSET i386obsd_sc_reg_offset
 359 #endif
 360
 361 #ifdef SC_REG_OFFSET
 362
 363   /* We only check the program counter, stack pointer and frame
 364      pointer since these members of `struct sigcontext' are essential
 365      for providing backtraces.  More checks could be added, but would
 366      involve adding configure checks for the appropriate structure
 367      members, since older BSD's don't provide all of them.  */
 368
 369 #define SC_PC_OFFSET SC_REG_OFFSET[I386_EIP_REGNUM]
 370 #define SC_SP_OFFSET SC_REG_OFFSET[I386_ESP_REGNUM]
 371 #define SC_FP_OFFSET SC_REG_OFFSET[I386_EBP_REGNUM]
 372
 373   /* Override the default value for the offset of the program counter
 374      in the sigcontext structure.  */
 375   int offset = offsetof (struct sigcontext, sc_pc);
 376
 377   if (SC_PC_OFFSET != offset)
 378     {
 379       warning (_("\
 380 offsetof (struct sigcontext, sc_pc) yields %d instead of %d.\n\
 381 Please report this to <bug-gdb@gnu.org>."),
 382                offset, SC_PC_OFFSET);
 383     }
 384
 385   SC_PC_OFFSET = offset;
 386
 387   /* Likewise for the stack pointer.  */
 388   offset = offsetof (struct sigcontext, sc_sp);
 389
 390   if (SC_SP_OFFSET != offset)
 391     {
 392       warning (_("\
 393 offsetof (struct sigcontext, sc_sp) yields %d instead of %d.\n\
 394 Please report this to <bug-gdb@gnu.org>."),
 395                offset, SC_SP_OFFSET);
 396     }
 397
 398   SC_SP_OFFSET = offset;
 399
 400   /* And the frame pointer.  */
 401   offset = offsetof (struct sigcontext, sc_fp);
 402
 403   if (SC_FP_OFFSET != offset)
 404     {
 405       warning (_("\
 406 offsetof (struct sigcontext, sc_fp) yields %d instead of %d.\n\
 407 Please report this to <bug-gdb@gnu.org>."),
 408                offset, SC_FP_OFFSET);
 409     }
 410
 411   SC_FP_OFFSET = offset;
 412
 413 #endif /* SC_REG_OFFSET */
 414 }