gdb/gdbserver/i387-fp.c

   1 /* i387-specific utility functions, for the remote server for GDB.
   2    Copyright (C) 2000, 2001, 2002, 2005, 2007 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "server.h"
  20 #include "i387-fp.h"
  21
  22 int num_xmm_registers = 8;
  23
  24 /* Note: These functions preserve the reserved bits in control registers.
  25    However, gdbserver promptly throws away that information.  */
  26
  27 /* These structs should have the proper sizes and alignment on both
  28    i386 and x86-64 machines.  */
  29
  30 struct i387_fsave {
  31   /* All these are only sixteen bits, plus padding, except for fop (which
  32      is only eleven bits), and fooff / fioff (which are 32 bits each).  */
  33   unsigned short fctrl;
  34   unsigned short pad1;
  35   unsigned short fstat;
  36   unsigned short pad2;
  37   unsigned short ftag;
  38   unsigned short pad3;
  39   unsigned int fioff;
  40   unsigned short fiseg;
  41   unsigned short fop;
  42   unsigned int fooff;
  43   unsigned short foseg;
  44   unsigned short pad4;
  45
  46   /* Space for eight 80-bit FP values.  */
  47   unsigned char st_space[80];
  48 };
  49
  50 struct i387_fxsave {
  51   /* All these are only sixteen bits, plus padding, except for fop (which
  52      is only eleven bits), and fooff / fioff (which are 32 bits each).  */
  53   unsigned short fctrl;
  54   unsigned short fstat;
  55   unsigned short ftag;
  56   unsigned short fop;
  57   unsigned int fioff;
  58   unsigned short fiseg;
  59   unsigned short pad1;
  60   unsigned int fooff;
  61   unsigned short foseg;
  62   unsigned short pad12;
  63
  64   unsigned int mxcsr;
  65   unsigned int pad3;
  66
  67   /* Space for eight 80-bit FP values in 128-bit spaces.  */
  68   unsigned char st_space[128];
  69
  70   /* Space for eight 128-bit XMM values, or 16 on x86-64.  */
  71   unsigned char xmm_space[256];
  72 };
  73
  74 void
  75 i387_cache_to_fsave (void *buf)
  76 {
  77   struct i387_fsave *fp = (struct i387_fsave *) buf;
  78   int i;
  79   int st0_regnum = find_regno ("st0");
  80   unsigned long val, val2;
  81
  82   for (i = 0; i < 8; i++)
  83     collect_register (i + st0_regnum, ((char *) &fp->st_space[0]) + i * 10);
  84
  85   collect_register_by_name ("fioff", &fp->fioff);
  86   collect_register_by_name ("fooff", &fp->fooff);
  87
  88   /* This one's 11 bits... */
  89   collect_register_by_name ("fop", &val2);
  90   fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800);
  91
  92   /* Some registers are 16-bit.  */
  93   collect_register_by_name ("fctrl", &val);
  94   fp->fctrl = val;
  95
  96   collect_register_by_name ("fstat", &val);
  97   val &= 0xFFFF;
  98   fp->fstat = val;
  99
 100   collect_register_by_name ("ftag", &val);
 101   val &= 0xFFFF;
 102   fp->ftag = val;
 103
 104   collect_register_by_name ("fiseg", &val);
 105   val &= 0xFFFF;
 106   fp->fiseg = val;
 107
 108   collect_register_by_name ("foseg", &val);
 109   val &= 0xFFFF;
 110   fp->foseg = val;
 111 }
 112
 113 void
 114 i387_fsave_to_cache (const void *buf)
 115 {
 116   struct i387_fsave *fp = (struct i387_fsave *) buf;
 117   int i;
 118   int st0_regnum = find_regno ("st0");
 119   unsigned long val;
 120
 121   for (i = 0; i < 8; i++)
 122     supply_register (i + st0_regnum, ((char *) &fp->st_space[0]) + i * 10);
 123
 124   supply_register_by_name ("fioff", &fp->fioff);
 125   supply_register_by_name ("fooff", &fp->fooff);
 126
 127   /* Some registers are 16-bit.  */
 128   val = fp->fctrl & 0xFFFF;
 129   supply_register_by_name ("fctrl", &val);
 130
 131   val = fp->fstat & 0xFFFF;
 132   supply_register_by_name ("fstat", &val);
 133
 134   val = fp->ftag & 0xFFFF;
 135   supply_register_by_name ("ftag", &val);
 136
 137   val = fp->fiseg & 0xFFFF;
 138   supply_register_by_name ("fiseg", &val);
 139
 140   val = fp->foseg & 0xFFFF;
 141   supply_register_by_name ("foseg", &val);
 142
 143   /* fop has only 11 valid bits.  */
 144   val = (fp->fop) & 0x7FF;
 145   supply_register_by_name ("fop", &val);
 146 }
 147
 148 void
 149 i387_cache_to_fxsave (void *buf)
 150 {
 151   struct i387_fxsave *fp = (struct i387_fxsave *) buf;
 152   int i;
 153   int st0_regnum = find_regno ("st0");
 154   int xmm0_regnum = find_regno ("xmm0");
 155   unsigned long val, val2;
 156
 157   for (i = 0; i < 8; i++)
 158     collect_register (i + st0_regnum, ((char *) &fp->st_space[0]) + i * 16);
 159   for (i = 0; i < num_xmm_registers; i++)
 160     collect_register (i + xmm0_regnum, ((char *) &fp->xmm_space[0]) + i * 16);
 161
 162   collect_register_by_name ("fioff", &fp->fioff);
 163   collect_register_by_name ("fooff", &fp->fooff);
 164   collect_register_by_name ("mxcsr", &fp->mxcsr);
 165
 166   /* This one's 11 bits... */
 167   collect_register_by_name ("fop", &val2);
 168   fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800);
 169
 170   /* Some registers are 16-bit.  */
 171   collect_register_by_name ("fctrl", &val);
 172   fp->fctrl = val;
 173
 174   collect_register_by_name ("fstat", &val);
 175   fp->fstat = val;
 176
 177   /* Convert to the simplifed tag form stored in fxsave data.  */
 178   collect_register_by_name ("ftag", &val);
 179   val &= 0xFFFF;
 180   val2 = 0;
 181   for (i = 7; i >= 0; i--)
 182     {
 183       int tag = (val >> (i * 2)) & 3;
 184
 185       if (tag != 3)
 186         val2 |= (1 << i);
 187     }
 188   fp->ftag = val2;
 189
 190   collect_register_by_name ("fiseg", &val);
 191   fp->fiseg = val;
 192
 193   collect_register_by_name ("foseg", &val);
 194   fp->foseg = val;
 195 }
 196
 197 static int
 198 i387_ftag (struct i387_fxsave *fp, int regno)
 199 {
 200   unsigned char *raw = &fp->st_space[regno * 16];
 201   unsigned int exponent;
 202   unsigned long fraction[2];
 203   int integer;
 204
 205   integer = raw[7] & 0x80;
 206   exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
 207   fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
 208   fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
 209                  | (raw[5] << 8) | raw[4]);
 210
 211   if (exponent == 0x7fff)
 212     {
 213       /* Special.  */
 214       return (2);
 215     }
 216   else if (exponent == 0x0000)
 217     {
 218       if (fraction[0] == 0x0000 && fraction[1] == 0x0000 && !integer)
 219         {
 220           /* Zero.  */
 221           return (1);
 222         }
 223       else
 224         {
 225           /* Special.  */
 226           return (2);
 227         }
 228     }
 229   else
 230     {
 231       if (integer)
 232         {
 233           /* Valid.  */
 234           return (0);
 235         }
 236       else
 237         {
 238           /* Special.  */
 239           return (2);
 240         }
 241     }
 242 }
 243
 244 void
 245 i387_fxsave_to_cache (const void *buf)
 246 {
 247   struct i387_fxsave *fp = (struct i387_fxsave *) buf;
 248   int i, top;
 249   int st0_regnum = find_regno ("st0");
 250   int xmm0_regnum = find_regno ("xmm0");
 251   unsigned long val;
 252
 253   for (i = 0; i < 8; i++)
 254     supply_register (i + st0_regnum, ((char *) &fp->st_space[0]) + i * 16);
 255   for (i = 0; i < num_xmm_registers; i++)
 256     supply_register (i + xmm0_regnum, ((char *) &fp->xmm_space[0]) + i * 16);
 257
 258   supply_register_by_name ("fioff", &fp->fioff);
 259   supply_register_by_name ("fooff", &fp->fooff);
 260   supply_register_by_name ("mxcsr", &fp->mxcsr);
 261
 262   /* Some registers are 16-bit.  */
 263   val = fp->fctrl & 0xFFFF;
 264   supply_register_by_name ("fctrl", &val);
 265
 266   val = fp->fstat & 0xFFFF;
 267   supply_register_by_name ("fstat", &val);
 268
 269   /* Generate the form of ftag data that GDB expects.  */
 270   top = (fp->fstat >> 11) & 0x7;
 271   val = 0;
 272   for (i = 7; i >= 0; i--)
 273     {
 274       int tag;
 275       if (fp->ftag & (1 << i))
 276         tag = i387_ftag (fp, (i + 8 - top) % 8);
 277       else
 278         tag = 3;
 279       val |= tag << (2 * i);
 280     }
 281   supply_register_by_name ("ftag", &val);
 282
 283   val = fp->fiseg & 0xFFFF;
 284   supply_register_by_name ("fiseg", &val);
 285
 286   val = fp->foseg & 0xFFFF;
 287   supply_register_by_name ("foseg", &val);
 288
 289   val = (fp->fop) & 0x7FF;
 290   supply_register_by_name ("fop", &val);
 291 }