gdb/i386-bsd-nat.c

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