gdb/i387-tdep.c

   1 /* Intel 387 floating point stuff.
   2    Copyright 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000,
   3    2001, 2002 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 "frame.h"
  24 #include "inferior.h"
  25 #include "language.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "floatformat.h"
  29 #include "regcache.h"
  30 #include "gdb_assert.h"
  31 #include "gdb_string.h"
  32 #include "doublest.h"
  33
  34 #include "i386-tdep.h"
  35
  36 /* FIXME: Eliminate the next two functions when we have the time to
  37    change all the callers.  */
  38
  39 void i387_to_double (char *from, char *to);
  40 void double_to_i387 (char *from, char *to);
  41
  42 void
  43 i387_to_double (char *from, char *to)
  44 {
  45   floatformat_to_double (&floatformat_i387_ext, from, (double *) to);
  46 }
  47
  48 void
  49 double_to_i387 (char *from, char *to)
  50 {
  51   floatformat_from_double (&floatformat_i387_ext, (double *) from, to);
  52 }
  53
  54 \f
  55 /* FIXME: The functions on this page are used by the old `info float'
  56    implementations that a few of the i386 targets provide.  These
  57    functions should be removed if all of these have been converted to
  58    use the generic implementation based on the new register file
  59    layout.  */
  60
  61 static void print_387_control_bits (unsigned int control);
  62 static void print_387_status_bits (unsigned int status);
  63
  64 static void
  65 print_387_control_bits (unsigned int control)
  66 {
  67   switch ((control >> 8) & 3)
  68     {
  69     case 0:
  70       puts_unfiltered (" 24 bit; ");
  71       break;
  72     case 1:
  73       puts_unfiltered (" (bad); ");
  74       break;
  75     case 2:
  76       puts_unfiltered (" 53 bit; ");
  77       break;
  78     case 3:
  79       puts_unfiltered (" 64 bit; ");
  80       break;
  81     }
  82   switch ((control >> 10) & 3)
  83     {
  84     case 0:
  85       puts_unfiltered ("NEAR; ");
  86       break;
  87     case 1:
  88       puts_unfiltered ("DOWN; ");
  89       break;
  90     case 2:
  91       puts_unfiltered ("UP; ");
  92       break;
  93     case 3:
  94       puts_unfiltered ("CHOP; ");
  95       break;
  96     }
  97   if (control & 0x3f)
  98     {
  99       puts_unfiltered ("mask");
 100       if (control & 0x0001)
 101         puts_unfiltered (" INVAL");
 102       if (control & 0x0002)
 103         puts_unfiltered (" DENOR");
 104       if (control & 0x0004)
 105         puts_unfiltered (" DIVZ");
 106       if (control & 0x0008)
 107         puts_unfiltered (" OVERF");
 108       if (control & 0x0010)
 109         puts_unfiltered (" UNDER");
 110       if (control & 0x0020)
 111         puts_unfiltered (" LOS");
 112       puts_unfiltered (";");
 113     }
 114
 115   if (control & 0xe080)
 116     warning ("\nreserved bits on: %s",
 117              local_hex_string (control & 0xe080));
 118 }
 119
 120 void
 121 print_387_control_word (unsigned int control)
 122 {
 123   printf_filtered ("control %s:", local_hex_string(control & 0xffff));
 124   print_387_control_bits (control);
 125   puts_unfiltered ("\n");
 126 }
 127
 128 static void
 129 print_387_status_bits (unsigned int status)
 130 {
 131   printf_unfiltered (" flags %d%d%d%d; ",
 132                      (status & 0x4000) != 0,
 133                      (status & 0x0400) != 0,
 134                      (status & 0x0200) != 0,
 135                      (status & 0x0100) != 0);
 136   printf_unfiltered ("top %d; ", (status >> 11) & 7);
 137   if (status & 0xff)
 138     {
 139       puts_unfiltered ("excep");
 140       if (status & 0x0001) puts_unfiltered (" INVAL");
 141       if (status & 0x0002) puts_unfiltered (" DENOR");
 142       if (status & 0x0004) puts_unfiltered (" DIVZ");
 143       if (status & 0x0008) puts_unfiltered (" OVERF");
 144       if (status & 0x0010) puts_unfiltered (" UNDER");
 145       if (status & 0x0020) puts_unfiltered (" LOS");
 146       if (status & 0x0040) puts_unfiltered (" STACK");
 147     }
 148 }
 149
 150 void
 151 print_387_status_word (unsigned int status)
 152 {
 153   printf_filtered ("status %s:", local_hex_string (status & 0xffff));
 154   print_387_status_bits (status);
 155   puts_unfiltered ("\n");
 156 }
 157
 158 \f
 159 /* Implement the `info float' layout based on the register definitions
 160    in `tm-i386.h'.  */
 161
 162 /* Print the floating point number specified by RAW.  */
 163 static void
 164 print_i387_value (char *raw, struct ui_file *file)
 165 {
 166   DOUBLEST value;
 167
 168   /* Using extract_typed_floating here might affect the representation
 169      of certain numbers such as NaNs, even if GDB is running natively.
 170      This is fine since our caller already detects such special
 171      numbers and we print the hexadecimal representation anyway.  */
 172   value = extract_typed_floating (raw, builtin_type_i387_ext);
 173
 174   /* We try to print 19 digits.  The last digit may or may not contain
 175      garbage, but we'd better print one too many.  We need enough room
 176      to print the value, 1 position for the sign, 1 for the decimal
 177      point, 19 for the digits and 6 for the exponent adds up to 27.  */
 178 #ifdef PRINTF_HAS_LONG_DOUBLE
 179   fprintf_filtered (file, " %-+27.19Lg", (long double) value);
 180 #else
 181   fprintf_filtered (file, " %-+27.19g", (double) value);
 182 #endif
 183 }
 184
 185 /* Print the classification for the register contents RAW.  */
 186 static void
 187 print_i387_ext (unsigned char *raw, struct ui_file *file)
 188 {
 189   int sign;
 190   int integer;
 191   unsigned int exponent;
 192   unsigned long fraction[2];
 193
 194   sign = raw[9] & 0x80;
 195   integer = raw[7] & 0x80;
 196   exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
 197   fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
 198   fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
 199                  | (raw[5] << 8) | raw[4]);
 200
 201   if (exponent == 0x7fff && integer)
 202     {
 203       if (fraction[0] == 0x00000000 && fraction[1] == 0x00000000)
 204         /* Infinity.  */
 205         fprintf_filtered (file, " %cInf", (sign ? '-' : '+'));
 206       else if (sign && fraction[0] == 0x00000000 && fraction[1] == 0x40000000)
 207         /* Real Indefinite (QNaN).  */
 208         fputs_unfiltered (" Real Indefinite (QNaN)", file);
 209       else if (fraction[1] & 0x40000000)
 210         /* QNaN.  */
 211         fputs_filtered (" QNaN", file);
 212       else
 213         /* SNaN.  */
 214         fputs_filtered (" SNaN", file);
 215     }
 216   else if (exponent < 0x7fff && exponent > 0x0000 && integer)
 217     /* Normal.  */
 218     print_i387_value (raw, file);
 219   else if (exponent == 0x0000)
 220     {
 221       /* Denormal or zero.  */
 222       print_i387_value (raw, file);
 223
 224       if (integer)
 225         /* Pseudo-denormal.  */
 226         fputs_filtered (" Pseudo-denormal", file);
 227       else if (fraction[0] || fraction[1])
 228         /* Denormal.  */
 229         fputs_filtered (" Denormal", file);
 230     }
 231   else
 232     /* Unsupported.  */
 233     fputs_filtered (" Unsupported", file);
 234 }
 235
 236 /* Print the status word STATUS.  */
 237 static void
 238 print_i387_status_word (unsigned int status, struct ui_file *file)
 239 {
 240   fprintf_filtered (file, "Status Word:         %s",
 241                    local_hex_string_custom (status, "04"));
 242   fputs_filtered ("  ", file);
 243   fprintf_filtered (file, " %s", (status & 0x0001) ? "IE" : "  ");
 244   fprintf_filtered (file, " %s", (status & 0x0002) ? "DE" : "  ");
 245   fprintf_filtered (file, " %s", (status & 0x0004) ? "ZE" : "  ");
 246   fprintf_filtered (file, " %s", (status & 0x0008) ? "OE" : "  ");
 247   fprintf_filtered (file, " %s", (status & 0x0010) ? "UE" : "  ");
 248   fprintf_filtered (file, " %s", (status & 0x0020) ? "PE" : "  ");
 249   fputs_filtered ("  ", file);
 250   fprintf_filtered (file, " %s", (status & 0x0080) ? "ES" : "  ");
 251   fputs_filtered ("  ", file);
 252   fprintf_filtered (file, " %s", (status & 0x0040) ? "SF" : "  ");
 253   fputs_filtered ("  ", file);
 254   fprintf_filtered (file, " %s", (status & 0x0100) ? "C0" : "  ");
 255   fprintf_filtered (file, " %s", (status & 0x0200) ? "C1" : "  ");
 256   fprintf_filtered (file, " %s", (status & 0x0400) ? "C2" : "  ");
 257   fprintf_filtered (file, " %s", (status & 0x4000) ? "C3" : "  ");
 258
 259   fputs_filtered ("\n", file);
 260
 261   fprintf_filtered (file,
 262                     "                       TOP: %d\n", ((status >> 11) & 7));
 263 }
 264
 265 /* Print the control word CONTROL.  */
 266 static void
 267 print_i387_control_word (unsigned int control, struct ui_file *file)
 268 {
 269   fprintf_filtered (file, "Control Word:        %s",
 270                    local_hex_string_custom (control, "04"));
 271   fputs_filtered ("  ", file);
 272   fprintf_filtered (file, " %s", (control & 0x0001) ? "IM" : "  ");
 273   fprintf_filtered (file, " %s", (control & 0x0002) ? "DM" : "  ");
 274   fprintf_filtered (file, " %s", (control & 0x0004) ? "ZM" : "  ");
 275   fprintf_filtered (file, " %s", (control & 0x0008) ? "OM" : "  ");
 276   fprintf_filtered (file, " %s", (control & 0x0010) ? "UM" : "  ");
 277   fprintf_filtered (file, " %s", (control & 0x0020) ? "PM" : "  ");
 278
 279   fputs_filtered ("\n", file);
 280
 281   fputs_filtered ("                       PC: ", file);
 282   switch ((control >> 8) & 3)
 283     {
 284     case 0:
 285       fputs_filtered ("Single Precision (24-bits)\n", file);
 286       break;
 287     case 1:
 288       fputs_filtered ("Reserved\n", file);
 289       break;
 290     case 2:
 291       fputs_filtered ("Double Precision (53-bits)\n", file);
 292       break;
 293     case 3:
 294       fputs_filtered ("Extended Precision (64-bits)\n", file);
 295       break;
 296     }
 297
 298   fputs_filtered ("                       RC: ", file);
 299   switch ((control >> 10) & 3)
 300     {
 301     case 0:
 302       fputs_filtered ("Round to nearest\n", file);
 303       break;
 304     case 1:
 305       fputs_filtered ("Round down\n", file);
 306       break;
 307     case 2:
 308       fputs_filtered ("Round up\n", file);
 309       break;
 310     case 3:
 311       fputs_filtered ("Round toward zero\n", file);
 312       break;
 313     }
 314 }
 315
 316 /* Print out the i387 floating point state.  Note that we ignore FRAME
 317    in the code below.  That's OK since floating-point registers are
 318    never saved on the stack.  */
 319
 320 void
 321 i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
 322                        struct frame_info *frame, const char *args)
 323 {
 324   char buf[4];
 325   ULONGEST fctrl;
 326   ULONGEST fstat;
 327   ULONGEST ftag;
 328   ULONGEST fiseg;
 329   ULONGEST fioff;
 330   ULONGEST foseg;
 331   ULONGEST fooff;
 332   ULONGEST fop;
 333   int fpreg;
 334   int top;
 335
 336   frame_register_read (frame, FCTRL_REGNUM, buf);
 337   fctrl = extract_unsigned_integer (buf, 4);
 338   frame_register_read (frame, FSTAT_REGNUM, buf);
 339   fstat = extract_unsigned_integer (buf, 4);
 340   frame_register_read (frame, FTAG_REGNUM, buf);
 341   ftag = extract_unsigned_integer (buf, 4);
 342   frame_register_read (frame, FISEG_REGNUM, buf);
 343   fiseg = extract_unsigned_integer (buf, 4);
 344   frame_register_read (frame, FIOFF_REGNUM, buf);
 345   fioff = extract_unsigned_integer (buf, 4);
 346   frame_register_read (frame, FOSEG_REGNUM, buf);
 347   foseg = extract_unsigned_integer (buf, 4);
 348   frame_register_read (frame, FOOFF_REGNUM, buf);
 349   fooff = extract_unsigned_integer (buf, 4);
 350   frame_register_read (frame, FOP_REGNUM, buf);
 351   fop = extract_unsigned_integer (buf, 4);
 352
 353   top = ((fstat >> 11) & 7);
 354
 355   for (fpreg = 7; fpreg >= 0; fpreg--)
 356     {
 357       unsigned char raw[FPU_REG_RAW_SIZE];
 358       int tag = (ftag >> (fpreg * 2)) & 3;
 359       int i;
 360
 361       fprintf_filtered (file, "%sR%d: ", fpreg == top ? "=>" : "  ", fpreg);
 362
 363       switch (tag)
 364         {
 365         case 0:
 366           fputs_filtered ("Valid   ", file);
 367           break;
 368         case 1:
 369           fputs_filtered ("Zero    ", file);
 370           break;
 371         case 2:
 372           fputs_filtered ("Special ", file);
 373           break;
 374         case 3:
 375           fputs_filtered ("Empty   ", file);
 376           break;
 377         }
 378
 379       frame_register_read (frame, (fpreg + 8 - top) % 8 + FP0_REGNUM, raw);
 380
 381       fputs_filtered ("0x", file);
 382       for (i = 9; i >= 0; i--)
 383         fprintf_filtered (file, "%02x", raw[i]);
 384
 385       if (tag != 3)
 386         print_i387_ext (raw, file);
 387
 388       fputs_filtered ("\n", file);
 389     }
 390
 391   fputs_filtered ("\n", file);
 392
 393   print_i387_status_word (fstat, file);
 394   print_i387_control_word (fctrl, file);
 395   fprintf_filtered (file, "Tag Word:            %s\n",
 396                     local_hex_string_custom (ftag, "04"));
 397   fprintf_filtered (file, "Instruction Pointer: %s:",
 398                     local_hex_string_custom (fiseg, "02"));
 399   fprintf_filtered (file, "%s\n", local_hex_string_custom (fioff, "08"));
 400   fprintf_filtered (file, "Operand Pointer:     %s:",
 401                     local_hex_string_custom (foseg, "02"));
 402   fprintf_filtered (file, "%s\n", local_hex_string_custom (fooff, "08"));
 403   fprintf_filtered (file, "Opcode:              %s\n",
 404                     local_hex_string_custom (fop ? (fop | 0xd800) : 0, "04"));
 405 }
 406
 407 /* FIXME: kettenis/2000-05-21: Right now more than a few i386 targets
 408    define their own routines to manage the floating-point registers in
 409    GDB's register array.  Most (if not all) of these targets use the
 410    format used by the "fsave" instruction in their communication with
 411    the OS.  They should all be converted to use the routines below.  */
 412
 413 /* At fsave_offset[REGNUM] you'll find the offset to the location in
 414    the data structure used by the "fsave" instruction where GDB
 415    register REGNUM is stored.  */
 416
 417 static int fsave_offset[] =
 418 {
 419   28 + 0 * FPU_REG_RAW_SIZE,    /* FP0_REGNUM through ...  */
 420   28 + 1 * FPU_REG_RAW_SIZE,
 421   28 + 2 * FPU_REG_RAW_SIZE,
 422   28 + 3 * FPU_REG_RAW_SIZE,
 423   28 + 4 * FPU_REG_RAW_SIZE,
 424   28 + 5 * FPU_REG_RAW_SIZE,
 425   28 + 6 * FPU_REG_RAW_SIZE,
 426   28 + 7 * FPU_REG_RAW_SIZE,    /* ... FP7_REGNUM.  */
 427   0,                            /* FCTRL_REGNUM (16 bits).  */
 428   4,                            /* FSTAT_REGNUM (16 bits).  */
 429   8,                            /* FTAG_REGNUM (16 bits).  */
 430   16,                           /* FISEG_REGNUM (16 bits).  */
 431   12,                           /* FIOFF_REGNUM.  */
 432   24,                           /* FOSEG_REGNUM.  */
 433   20,                           /* FOOFF_REGNUM.  */
 434   18                            /* FOP_REGNUM (bottom 11 bits).  */
 435 };
 436
 437 #define FSAVE_ADDR(fsave, regnum) (fsave + fsave_offset[regnum - FP0_REGNUM])
 438 \f
 439
 440 /* Fill register REGNUM in GDB's register array with the appropriate
 441    value from *FSAVE.  This function masks off any of the reserved
 442    bits in *FSAVE.  */
 443
 444 void
 445 i387_supply_register (int regnum, char *fsave)
 446 {
 447   /* Most of the FPU control registers occupy only 16 bits in
 448      the fsave area.  Give those a special treatment.  */
 449   if (regnum >= FPC_REGNUM
 450       && regnum != FIOFF_REGNUM && regnum != FOOFF_REGNUM)
 451     {
 452       unsigned char val[4];
 453
 454       memcpy (val, FSAVE_ADDR (fsave, regnum), 2);
 455       val[2] = val[3] = 0;
 456       if (regnum == FOP_REGNUM)
 457         val[1] &= ((1 << 3) - 1);
 458       supply_register (regnum, val);
 459     }
 460   else
 461     supply_register (regnum, FSAVE_ADDR (fsave, regnum));
 462 }
 463
 464 /* Fill GDB's register array with the floating-point register values
 465    in *FSAVE.  This function masks off any of the reserved
 466    bits in *FSAVE.  */
 467
 468 void
 469 i387_supply_fsave (char *fsave)
 470 {
 471   int i;
 472
 473   for (i = FP0_REGNUM; i < XMM0_REGNUM; i++)
 474     i387_supply_register (i, fsave);
 475 }
 476
 477 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
 478    with the value in GDB's register array.  If REGNUM is -1, do this
 479    for all registers.  This function doesn't touch any of the reserved
 480    bits in *FSAVE.  */
 481
 482 void
 483 i387_fill_fsave (char *fsave, int regnum)
 484 {
 485   int i;
 486
 487   for (i = FP0_REGNUM; i < XMM0_REGNUM; i++)
 488     if (regnum == -1 || regnum == i)
 489       {
 490         /* Most of the FPU control registers occupy only 16 bits in
 491            the fsave area.  Give those a special treatment.  */
 492         if (i >= FPC_REGNUM
 493             && i != FIOFF_REGNUM && i != FOOFF_REGNUM)
 494           {
 495             unsigned char buf[4];
 496
 497             regcache_collect (i, buf);
 498
 499             if (i == FOP_REGNUM)
 500               {
 501                 /* The opcode occupies only 11 bits.  Make sure we
 502                    don't touch the other bits.  */
 503                 buf[1] &= ((1 << 3) - 1);
 504                 buf[1] |= ((FSAVE_ADDR (fsave, i))[1] & ~((1 << 3) - 1));
 505               }
 506             memcpy (FSAVE_ADDR (fsave, i), buf, 2);
 507           }
 508         else
 509           regcache_collect (i, FSAVE_ADDR (fsave, i));
 510       }
 511 }
 512 \f
 513
 514 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
 515    the data structure used by the "fxsave" instruction where GDB
 516    register REGNUM is stored.  */
 517
 518 static int fxsave_offset[] =
 519 {
 520   32,                           /* FP0_REGNUM through ...  */
 521   48,
 522   64,
 523   80,
 524   96,
 525   112,
 526   128,
 527   144,                          /* ... FP7_REGNUM (80 bits each).  */
 528   0,                            /* FCTRL_REGNUM (16 bits).  */
 529   2,                            /* FSTAT_REGNUM (16 bits).  */
 530   4,                            /* FTAG_REGNUM (16 bits).  */
 531   12,                           /* FISEG_REGNUM (16 bits).  */
 532   8,                            /* FIOFF_REGNUM.  */
 533   20,                           /* FOSEG_REGNUM (16 bits).  */
 534   16,                           /* FOOFF_REGNUM.  */
 535   6,                            /* FOP_REGNUM (bottom 11 bits).  */
 536   160,                          /* XMM0_REGNUM through ...  */
 537   176,
 538   192,
 539   208,
 540   224,
 541   240,
 542   256,
 543   272,                          /* ... XMM7_REGNUM (128 bits each).  */
 544   24,                           /* MXCSR_REGNUM.  */
 545 };
 546
 547 #define FXSAVE_ADDR(fxsave, regnum) \
 548   (fxsave + fxsave_offset[regnum - FP0_REGNUM])
 549
 550 static int i387_tag (unsigned char *raw);
 551 \f
 552
 553 /* Fill GDB's register array with the floating-point and SSE register
 554    values in *FXSAVE.  This function masks off any of the reserved
 555    bits in *FXSAVE.  */
 556
 557 void
 558 i387_supply_fxsave (char *fxsave)
 559 {
 560   int i, last_regnum = MXCSR_REGNUM;
 561
 562   if (gdbarch_tdep (current_gdbarch)->num_xmm_regs == 0)
 563     last_regnum = FOP_REGNUM;
 564
 565   for (i = FP0_REGNUM; i <= last_regnum; i++)
 566     {
 567       /* Most of the FPU control registers occupy only 16 bits in
 568          the fxsave area.  Give those a special treatment.  */
 569       if (i >= FPC_REGNUM && i < XMM0_REGNUM
 570           && i != FIOFF_REGNUM && i != FOOFF_REGNUM)
 571         {
 572           unsigned char val[4];
 573
 574           memcpy (val, FXSAVE_ADDR (fxsave, i), 2);
 575           val[2] = val[3] = 0;
 576           if (i == FOP_REGNUM)
 577             val[1] &= ((1 << 3) - 1);
 578           else if (i== FTAG_REGNUM)
 579             {
 580               /* The fxsave area contains a simplified version of the
 581                  tag word.  We have to look at the actual 80-bit FP
 582                  data to recreate the traditional i387 tag word.  */
 583
 584               unsigned long ftag = 0;
 585               int fpreg;
 586               int top;
 587
 588               top = (((FXSAVE_ADDR (fxsave, FSTAT_REGNUM))[1] >> 3) & 0x7);
 589
 590               for (fpreg = 7; fpreg >= 0; fpreg--)
 591                 {
 592                   int tag;
 593
 594                   if (val[0] & (1 << fpreg))
 595                     {
 596                       int regnum = (fpreg + 8 - top) % 8 + FP0_REGNUM;
 597                       tag = i387_tag (FXSAVE_ADDR (fxsave, regnum));
 598                     }
 599                   else
 600                     tag = 3;            /* Empty */
 601
 602                   ftag |= tag << (2 * fpreg);
 603                 }
 604               val[0] = ftag & 0xff;
 605               val[1] = (ftag >> 8) & 0xff;
 606             }
 607           supply_register (i, val);
 608         }
 609       else
 610         supply_register (i, FXSAVE_ADDR (fxsave, i));
 611     }
 612 }
 613
 614 /* Fill register REGNUM (if it is a floating-point or SSE register) in
 615    *FXSAVE with the value in GDB's register array.  If REGNUM is -1, do
 616    this for all registers.  This function doesn't touch any of the
 617    reserved bits in *FXSAVE.  */
 618
 619 void
 620 i387_fill_fxsave (char *fxsave, int regnum)
 621 {
 622   int i, last_regnum = MXCSR_REGNUM;
 623
 624   if (gdbarch_tdep (current_gdbarch)->num_xmm_regs == 0)
 625     last_regnum = FOP_REGNUM;
 626
 627   for (i = FP0_REGNUM; i <= last_regnum; i++)
 628     if (regnum == -1 || regnum == i)
 629       {
 630         /* Most of the FPU control registers occupy only 16 bits in
 631            the fxsave area.  Give those a special treatment.  */
 632         if (i >= FPC_REGNUM && i < XMM0_REGNUM
 633             && i != FIOFF_REGNUM && i != FOOFF_REGNUM)
 634           {
 635             unsigned char buf[4];
 636
 637             regcache_collect (i, buf);
 638
 639             if (i == FOP_REGNUM)
 640               {
 641                 /* The opcode occupies only 11 bits.  Make sure we
 642                    don't touch the other bits.  */
 643                 buf[1] &= ((1 << 3) - 1);
 644                 buf[1] |= ((FXSAVE_ADDR (fxsave, i))[1] & ~((1 << 3) - 1));
 645               }
 646             else if (i == FTAG_REGNUM)
 647               {
 648                 /* Converting back is much easier.  */
 649
 650                 unsigned short ftag;
 651                 int fpreg;
 652
 653                 ftag = (buf[1] << 8) | buf[0];
 654                 buf[0] = 0;
 655                 buf[1] = 0;
 656
 657                 for (fpreg = 7; fpreg >= 0; fpreg--)
 658                   {
 659                     int tag = (ftag >> (fpreg * 2)) & 3;
 660
 661                     if (tag != 3)
 662                       buf[0] |= (1 << fpreg);
 663                   }
 664               }
 665             memcpy (FXSAVE_ADDR (fxsave, i), buf, 2);
 666           }
 667         else
 668           regcache_collect (i, FXSAVE_ADDR (fxsave, i));
 669       }
 670 }
 671
 672 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
 673    *RAW.  */
 674
 675 static int
 676 i387_tag (unsigned char *raw)
 677 {
 678   int integer;
 679   unsigned int exponent;
 680   unsigned long fraction[2];
 681
 682   integer = raw[7] & 0x80;
 683   exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
 684   fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
 685   fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
 686                  | (raw[5] << 8) | raw[4]);
 687
 688   if (exponent == 0x7fff)
 689     {
 690       /* Special.  */
 691       return (2);
 692     }
 693   else if (exponent == 0x0000)
 694     {
 695       if (fraction[0] == 0x0000 && fraction[1] == 0x0000 && !integer)
 696         {
 697           /* Zero.  */
 698           return (1);
 699         }
 700       else
 701         {
 702           /* Special.  */
 703           return (2);
 704         }
 705     }
 706   else
 707     {
 708       if (integer)
 709         {
 710           /* Valid.  */
 711           return (0);
 712         }
 713       else
 714         {
 715           /* Special.  */
 716           return (2);
 717         }
 718     }
 719 }