gdb/i386v4-nat.c

   1 /* Native-dependent code for SVR4 Unix running on i386's, for GDB.
   2    Copyright 1988, 1989, 1991, 1992, 1996, 1997, 1998, 1999, 2000, 2001
   3    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 "value.h"
  24 #include "inferior.h"
  25 #include "regcache.h"
  26
  27 #ifdef HAVE_SYS_REG_H
  28 #include <sys/reg.h>
  29 #endif
  30 #include "i387-nat.h"
  31
  32
  33 #ifdef HAVE_SYS_PROCFS_H
  34
  35 #include <sys/procfs.h>
  36
  37 /* Prototypes for supply_gregset etc. */
  38 #include "gregset.h"
  39
  40 /*  The /proc interface divides the target machine's register set up into
  41    two different sets, the general register set (gregset) and the floating
  42    point register set (fpregset).  For each set, there is an ioctl to get
  43    the current register set and another ioctl to set the current values.
  44
  45    The actual structure passed through the ioctl interface is, of course,
  46    naturally machine dependent, and is different for each set of registers.
  47    For the i386 for example, the general register set is typically defined
  48    by:
  49
  50    typedef int gregset_t[19];           (in <sys/regset.h>)
  51
  52    #define GS   0                       (in <sys/reg.h>)
  53    #define FS   1
  54    ...
  55    #define UESP 17
  56    #define SS   18
  57
  58    and the floating point set by:
  59
  60    typedef struct fpregset
  61    {
  62    union
  63    {
  64    struct fpchip_state  // fp extension state //
  65    {
  66    int state[27];       // 287/387 saved state //
  67    int status;          // status word saved at exception //
  68    } fpchip_state;
  69    struct fp_emul_space // for emulators //
  70    {
  71    char fp_emul[246];
  72    char fp_epad[2];
  73    } fp_emul_space;
  74    int f_fpregs[62];    // union of the above //
  75    } fp_reg_set;
  76    long f_wregs[33];            // saved weitek state //
  77    } fpregset_t;
  78
  79    These routines provide the packing and unpacking of gregset_t and
  80    fpregset_t formatted data.
  81
  82  */
  83
  84 #ifdef HAVE_GREGSET_T
  85
  86 /* This is a duplicate of the table in i386-xdep.c. */
  87
  88 static int regmap[] =
  89 {
  90   EAX, ECX, EDX, EBX,
  91   UESP, EBP, ESI, EDI,
  92   EIP, EFL, CS, SS,
  93   DS, ES, FS, GS,
  94 };
  95
  96 /* Prototypes for local functions */
  97
  98 void fill_gregset (gregset_t *, int);
  99
 100 void supply_gregset (gregset_t *);
 101
 102 void supply_fpregset (fpregset_t *);
 103
 104 void fill_fpregset (fpregset_t *, int);
 105
 106
 107 /*  FIXME:  These routine absolutely depends upon (NUM_REGS - NUM_FREGS)
 108    being less than or equal to the number of registers that can be stored
 109    in a gregset_t.  Note that with the current scheme there will typically
 110    be more registers actually stored in a gregset_t that what we know
 111    about.  This is bogus and should be fixed. */
 112
 113 /*  Given a pointer to a general register set in /proc format (gregset_t *),
 114    unpack the register contents and supply them as gdb's idea of the current
 115    register values. */
 116
 117 void
 118 supply_gregset (gregset_t *gregsetp)
 119 {
 120   register int regi;
 121   register greg_t *regp = (greg_t *) gregsetp;
 122   extern int regmap[];
 123
 124   for (regi = 0; regi < (NUM_REGS - NUM_FREGS); regi++)
 125     {
 126       supply_register (regi, (char *) (regp + regmap[regi]));
 127     }
 128 }
 129
 130 void
 131 fill_gregset (gregset_t *gregsetp, int regno)
 132 {
 133   int regi;
 134   register greg_t *regp = (greg_t *) gregsetp;
 135   extern int regmap[];
 136
 137   for (regi = 0; regi < (NUM_REGS - NUM_FREGS); regi++)
 138     {
 139       if ((regno == -1) || (regno == regi))
 140         {
 141           *(regp + regmap[regi]) = *(int *) &registers[REGISTER_BYTE (regi)];
 142         }
 143     }
 144 }
 145
 146 #endif /* HAVE_GREGSET_T */
 147
 148 #if defined (HAVE_FPREGSET_T)
 149
 150 /*  Given a pointer to a floating point register set in /proc format
 151    (fpregset_t *), unpack the register contents and supply them as gdb's
 152    idea of the current floating point register values. */
 153
 154 /* FIXME: Assumes that fpregsetp contains an i387 FSAVE area. */
 155 static const int freg_offset_map[] =
 156 {
 157 #if !defined(FPREGSET_FSAVE_OFFSET)
 158 #define FPREGSET_FSAVE_OFFSET   0
 159 #endif
 160   FPREGSET_FSAVE_OFFSET + 28 + 0 * 10,
 161   FPREGSET_FSAVE_OFFSET + 28 + 1 * 10,
 162   FPREGSET_FSAVE_OFFSET + 28 + 2 * 10,
 163   FPREGSET_FSAVE_OFFSET + 28 + 3 * 10,
 164   FPREGSET_FSAVE_OFFSET + 28 + 4 * 10,
 165   FPREGSET_FSAVE_OFFSET + 28 + 5 * 10,
 166   FPREGSET_FSAVE_OFFSET + 28 + 6 * 10,
 167   FPREGSET_FSAVE_OFFSET + 28 + 7 * 10,
 168   FPREGSET_FSAVE_OFFSET + 0,
 169   FPREGSET_FSAVE_OFFSET + 4,
 170   FPREGSET_FSAVE_OFFSET + 8,
 171   FPREGSET_FSAVE_OFFSET + 16,
 172   FPREGSET_FSAVE_OFFSET + 12,
 173   FPREGSET_FSAVE_OFFSET + 24,
 174   FPREGSET_FSAVE_OFFSET + 20,
 175   FPREGSET_FSAVE_OFFSET + 16
 176 };
 177
 178 void
 179 supply_fpregset (fpregset_t *fpregsetp)
 180 {
 181   int regi;
 182
 183   if (NUM_FREGS == 0)
 184     return;
 185   for (regi = FP0_REGNUM; regi <= LAST_FPU_CTRL_REGNUM; regi++)
 186     {
 187       char tbuf[4];
 188       ULONGEST tval;
 189       char *from = (char *) fpregsetp + freg_offset_map[regi - FP0_REGNUM];
 190
 191       if (regi == FCS_REGNUM)
 192         {
 193           tval = extract_unsigned_integer (from, 4) & 0xffff;
 194           store_unsigned_integer (tbuf, 4, tval);
 195           supply_register (regi, tbuf);
 196         }
 197       else if (regi == FOP_REGNUM)
 198         {
 199           tval = (extract_unsigned_integer (from, 4) >> 16) & ((1 << 11) - 1);
 200           store_unsigned_integer (tbuf, 4, tval);
 201           supply_register (regi, tbuf);
 202         }
 203       else
 204         supply_register (regi, from);
 205     }
 206 }
 207
 208 /*  Given a pointer to a floating point register set in /proc format
 209    (fpregset_t *), update the register specified by REGNO from gdb's idea
 210    of the current floating point register set.  If REGNO is -1, update
 211    them all. */
 212
 213 void
 214 fill_fpregset (fpregset_t *fpregsetp, int regno)
 215 {
 216   int regi;
 217
 218   if (NUM_FREGS == 0)
 219     return;
 220   for (regi = FP0_REGNUM; regi <= LAST_FPU_CTRL_REGNUM; regi++)
 221     {
 222       if ((regno == -1) || (regno == regi))
 223         {
 224           char *to = (char *) fpregsetp + freg_offset_map[regi - FP0_REGNUM];
 225           char *from = (char *) &registers[REGISTER_BYTE (regi)];
 226           ULONGEST valto;
 227           ULONGEST valfrom;
 228
 229           if (regi == FCS_REGNUM)
 230             {
 231               valto = extract_unsigned_integer (to, 4);
 232               valfrom = extract_unsigned_integer (from, 4);
 233               valto = (valto & ~0xffff) | (valfrom & 0xffff);
 234               store_unsigned_integer (to, 4, valto);
 235             }
 236           else if (regi == FOP_REGNUM)
 237             {
 238               valto = extract_unsigned_integer (to, 4);
 239               valfrom = extract_unsigned_integer (from, 4);
 240               valto = (valto & 0xffff) | ((valfrom & ((1 << 11) - 1)) << 16);
 241               store_unsigned_integer (to, 4, valto);
 242             }
 243           else
 244             {
 245               memcpy (to, from, REGISTER_RAW_SIZE (regi));
 246             }
 247         }
 248     }
 249 }
 250
 251 #endif /* defined (HAVE_FPREGSET_T) */
 252
 253 #endif /* HAVE_SYS_PROCFS_H */