[deliverable/binutils-gdb.git] / gdb / i387-tdep.c

/* Intel 387 floating point stuff.
   Copyright (C) 1988, 89, 91, 98, 99, 2000 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "language.h"
#include "value.h"
#include "gdbcore.h"
#include "floatformat.h"


/* FIXME: Eliminate the next two functions when we have the time to
   change all the callers.  */

void i387_to_double PARAMS ((char *from, char *to));
void double_to_i387 PARAMS ((char *from, char *to));

void
i387_to_double (from, to)
     char *from;
     char *to;
{
  floatformat_to_double (&floatformat_i387_ext, from, (double *) to);
}

void
double_to_i387 (from, to)
     char *from;
     char *to;
{
  floatformat_from_double (&floatformat_i387_ext, (double *) from, to);
}

\f
/* FIXME: The functions on this page are used by the old `info float'
   implementations that a few of the i386 targets provide.  These
   functions should be removed if all of these have been converted to
   use the generic implementation based on the new register file
   layout.  */

static void print_387_control_bits PARAMS ((unsigned int control));
static void print_387_status_bits PARAMS ((unsigned int status));

static void
print_387_control_bits (control)
     unsigned int control;
{
  switch ((control >> 8) & 3)
    {
    case 0:
      puts_unfiltered (" 24 bit; ");
      break;
    case 1:
      puts_unfiltered (" (bad); ");
      break;
    case 2:
      puts_unfiltered (" 53 bit; ");
      break;
    case 3:
      puts_unfiltered (" 64 bit; ");
      break;
    }
  switch ((control >> 10) & 3)
    {
    case 0:
      puts_unfiltered ("NEAR; ");
      break;
    case 1:
      puts_unfiltered ("DOWN; ");
      break;
    case 2:
      puts_unfiltered ("UP; ");
      break;
    case 3:
      puts_unfiltered ("CHOP; ");
      break;
    }
  if (control & 0x3f)
    {
      puts_unfiltered ("mask");
      if (control & 0x0001)
	puts_unfiltered (" INVAL");
      if (control & 0x0002)
	puts_unfiltered (" DENOR");
      if (control & 0x0004)
	puts_unfiltered (" DIVZ");
      if (control & 0x0008)
	puts_unfiltered (" OVERF");
      if (control & 0x0010)
	puts_unfiltered (" UNDER");
      if (control & 0x0020)
	puts_unfiltered (" LOS");
      puts_unfiltered (";");
    }

  if (control & 0xe080)
    warning ("\nreserved bits on: %s",
	     local_hex_string (control & 0xe080));
}

void
print_387_control_word (control)
     unsigned int control;
{
  printf_filtered ("control %s:", local_hex_string(control & 0xffff));
  print_387_control_bits (control);
  puts_unfiltered ("\n");
}

static void
print_387_status_bits (status)
     unsigned int status;
{
  printf_unfiltered (" flags %d%d%d%d; ",
		     (status & 0x4000) != 0,
		     (status & 0x0400) != 0,
		     (status & 0x0200) != 0,
		     (status & 0x0100) != 0);
  printf_unfiltered ("top %d; ", (status >> 11) & 7);
  if (status & 0xff) 
    {
      puts_unfiltered ("excep");
      if (status & 0x0001) puts_unfiltered (" INVAL");
      if (status & 0x0002) puts_unfiltered (" DENOR");
      if (status & 0x0004) puts_unfiltered (" DIVZ");
      if (status & 0x0008) puts_unfiltered (" OVERF");
      if (status & 0x0010) puts_unfiltered (" UNDER");
      if (status & 0x0020) puts_unfiltered (" LOS");
      if (status & 0x0040) puts_unfiltered (" STACK");
    }
}

void
print_387_status_word (status)
     unsigned int status;
{
  printf_filtered ("status %s:", local_hex_string (status & 0xffff));
  print_387_status_bits (status);
  puts_unfiltered ("\n");
}

\f
/* Implement the `info float' layout based on the register definitions
   in `tm-i386.h'.  */

/* Print the floating point number specified by RAW.  */
static void
print_i387_value (char *raw)
{
  DOUBLEST value;

  /* Avoid call to floatformat_to_doublest if possible to preserve as
     much information as possible.  */

#ifdef HAVE_LONG_DOUBLE
  if (sizeof (value) == sizeof (long double)
      && HOST_LONG_DOUBLE_FORMAT == &floatformat_i387_ext)
    {
      /* Copy straight over, but take care of the padding.  */
      memcpy (&value, raw, FPU_REG_RAW_SIZE);
      memset (&value + FPU_REG_RAW_SIZE, 0, sizeof (value) - FPU_REG_RAW_SIZE);
    }
  else
#endif
    floatformat_to_doublest (&floatformat_i387_ext, raw, &value);

  /* We try to print 19 digits.  The last digit may or may not contain
     garbage, but we'd better print one too many.  We need enough room
     to print the value, 1 position for the sign, 1 for the decimal
     point, 19 for the digits and 6 for the exponent adds up to 27.  */
#ifdef PRINTF_HAS_LONG_DOUBLE
  printf_filtered (" %-+27.19Lg", (long double) value);
#else
  printf_filtered (" %-+27.19g", (double) value);
#endif
}

/* Print the classification for the register contents RAW.  */
static void
print_i387_ext (unsigned char *raw)
{
  int sign;
  int integer;
  unsigned int exponent;
  unsigned long fraction[2];

  sign = raw[9] & 0x80;
  integer = raw[7] & 0x80;
  exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
  fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
  fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
		 | (raw[5] << 8) | raw[4]);

  if (exponent == 0x7fff && integer)
    {
      if (fraction[0] == 0x00000000 && fraction[1] == 0x00000000)
	/* Infinity.  */
	printf_filtered (" %cInf", (sign ? '-' : '+'));
      else if (sign && fraction[0] == 0x00000000 && fraction[1] == 0x40000000)
	/* Real Indefinite (QNaN).  */
	puts_unfiltered (" Real Indefinite (QNaN)");
      else if (fraction[1] & 0x40000000)
	/* QNaN.  */
	puts_filtered (" QNaN");
      else
	/* SNaN.  */
	puts_filtered (" SNaN");
    }
  else if (exponent < 0x7fff && exponent > 0x0000 && integer)
    /* Normal.  */
    print_i387_value (raw);
  else if (exponent == 0x0000)
    {
      /* Denormal or zero.  */
      print_i387_value (raw);
      
      if (integer)
	/* Pseudo-denormal.  */
	puts_filtered (" Pseudo-denormal");
      else if (fraction[0] || fraction[1])
	/* Denormal.  */
	puts_filtered (" Denormal");
    }
  else
    /* Unsupported.  */
    puts_filtered (" Unsupported");
}

/* Print the status word STATUS.  */
static void
print_i387_status_word (unsigned int status)
{
  printf_filtered ("Status Word:         %s",
		   local_hex_string_custom (status, "04"));
  puts_filtered ("  ");
  printf_filtered (" %s", (status & 0x0001) ? "IE" : "  ");
  printf_filtered (" %s", (status & 0x0002) ? "DE" : "  ");
  printf_filtered (" %s", (status & 0x0004) ? "ZE" : "  ");
  printf_filtered (" %s", (status & 0x0008) ? "OE" : "  ");
  printf_filtered (" %s", (status & 0x0010) ? "UE" : "  ");
  printf_filtered (" %s", (status & 0x0020) ? "PE" : "  ");
  puts_filtered ("  ");
  printf_filtered (" %s", (status & 0x0080) ? "ES" : "  ");
  puts_filtered ("  ");
  printf_filtered (" %s", (status & 0x0080) ? "SF" : "  ");
  puts_filtered ("  ");
  printf_filtered (" %s", (status & 0x0100) ? "C0" : "  ");
  printf_filtered (" %s", (status & 0x0200) ? "C1" : "  ");
  printf_filtered (" %s", (status & 0x0400) ? "C2" : "  ");
  printf_filtered (" %s", (status & 0x4000) ? "C3" : "  ");

  puts_filtered ("\n");

  printf_filtered ("                       TOP: %d\n", ((status >> 11) & 7));
}

/* Print the control word CONTROL.  */
static void
print_i387_control_word (unsigned int control)
{
  printf_filtered ("Control Word:        %s",
		   local_hex_string_custom (control, "04"));
  puts_filtered ("  ");
  printf_filtered (" %s", (control & 0x0001) ? "IM" : "  ");
  printf_filtered (" %s", (control & 0x0002) ? "DM" : "  ");
  printf_filtered (" %s", (control & 0x0004) ? "ZM" : "  ");
  printf_filtered (" %s", (control & 0x0008) ? "OM" : "  ");
  printf_filtered (" %s", (control & 0x0010) ? "UM" : "  ");
  printf_filtered (" %s", (control & 0x0020) ? "PM" : "  ");

  puts_filtered ("\n");

  puts_filtered ("                       PC: ");
  switch ((control >> 8) & 3)
    {
    case 0:
      puts_filtered ("Single Precision (24-bits)\n");
      break;
    case 1:
      puts_filtered ("Reserved\n");
      break;
    case 2:
      puts_filtered ("Double Precision (53-bits)\n");
      break;
    case 3:
      puts_filtered ("Extended Precision (64-bits)\n");
      break;
    }
      
  puts_filtered ("                       RC: ");
  switch ((control >> 10) & 3)
    {
    case 0:
      puts_filtered ("Round to nearest\n");
      break;
    case 1:
      puts_filtered ("Round down\n");
      break;
    case 2:
      puts_filtered ("Round up\n");
      break;
    case 3:
      puts_filtered ("Round toward zero\n");
      break;
    }
}

/* Print out the i387 floating poin state.  */
void
i387_float_info (void)
{
  unsigned int fctrl;
  unsigned int fstat;
  unsigned int ftag;
  unsigned int fiseg;
  unsigned int fioff;
  unsigned int foseg;
  unsigned int fooff;
  unsigned int fop;
  int fpreg;
  int top;

  fctrl = read_register (FCTRL_REGNUM);
  fstat = read_register (FSTAT_REGNUM);
  ftag  = read_register (FTAG_REGNUM);
  fiseg = read_register (FCS_REGNUM);
  fioff = read_register (FCOFF_REGNUM);
  foseg = read_register (FDS_REGNUM);
  fooff = read_register (FDOFF_REGNUM);
  fop   = read_register (FOP_REGNUM);
  
  top = ((fstat >> 11) & 7);

  for (fpreg = 7; fpreg >= 0; fpreg--)
    {
      unsigned char raw[FPU_REG_RAW_SIZE];
      int tag = (ftag >> (fpreg * 2)) & 3;
      int i;

      printf_filtered ("%sR%d: ", fpreg == top ? "=>" : "  ", fpreg);

      switch (tag)
	{
	case 0:
	  puts_filtered ("Valid   ");
	  break;
	case 1:
	  puts_filtered ("Zero    ");
	  break;
	case 2:
	  puts_filtered ("Special ");
	  break;
	case 3:
	  puts_filtered ("Empty   ");
	  break;
	}

      read_register_gen ((fpreg + 8 - top) % 8 + FP0_REGNUM, raw);

      puts_filtered ("0x");
      for (i = 9; i >= 0; i--)
	printf_filtered ("%02x", raw[i]);

      if (tag != 3)
	print_i387_ext (raw);

      puts_filtered ("\n");
    }

  puts_filtered ("\n");

  print_i387_status_word (fstat);
  print_i387_control_word (fctrl);
  printf_filtered ("Tag Word:            %s\n",
		   local_hex_string_custom (ftag, "04"));
  printf_filtered ("Instruction Pointer: %s:",
		   local_hex_string_custom (fiseg, "02"));
  printf_filtered ("%s\n", local_hex_string_custom (fioff, "08"));
  printf_filtered ("Operand Pointer:     %s:",
		   local_hex_string_custom (foseg, "02"));
  printf_filtered ("%s\n", local_hex_string_custom (fooff, "08"));
  printf_filtered ("Opcode:              %s\n",
		   local_hex_string_custom (fop ? (fop | 0xd800) : 0, "04"));
}
Commit	Line	Data
c906108c	1	/* Intel 387 floating point stuff.
ac27f131	2	Copyright (C) 1988, 89, 91, 98, 99, 2000 Free Software Foundation, Inc.
c906108c	3
c5aa993b	4	This file is part of GDB.
c906108c	5
c5aa993b JM	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 2 of the License, or
	9	(at your option) any later version.
c906108c	10
c5aa993b JM	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.
c906108c	15
c5aa993b JM	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
c906108c SS	20
	21	#include "defs.h"
	22	#include "frame.h"
	23	#include "inferior.h"
	24	#include "language.h"
d4f3574e	25	#include "value.h"
c906108c SS	26	#include "gdbcore.h"
	27	#include "floatformat.h"
	28
c906108c	29
de57eccd JM	30	/* FIXME: Eliminate the next two functions when we have the time to
de57eccd JM	31	change all the callers. */
d4f3574e	32
de57eccd JM	33	void i387_to_double PARAMS ((char from, char to));
de57eccd JM	34	void double_to_i387 PARAMS ((char from, char to));
c906108c SS	35
	36	void
	37	i387_to_double (from, to)
	38	char *from;
	39	char *to;
	40	{
c5aa993b	41	floatformat_to_double (&floatformat_i387_ext, from, (double *) to);
c906108c SS	42	}
	43
	44	void
	45	double_to_i387 (from, to)
	46	char *from;
	47	char *to;
	48	{
c5aa993b	49	floatformat_from_double (&floatformat_i387_ext, (double *) from, to);
c906108c SS	50	}
c906108c SS	51
de57eccd JM	52	\f
	53	/* FIXME: The functions on this page are used by the old `info float'
	54	implementations that a few of the i386 targets provide. These
	55	functions should be removed if all of these have been converted to
	56	use the generic implementation based on the new register file
	57	layout. */
	58
	59	static void print_387_control_bits PARAMS ((unsigned int control));
	60	static void print_387_status_bits PARAMS ((unsigned int status));
	61
d4f3574e SS	62	static void
d4f3574e SS	63	print_387_control_bits (control)
c906108c SS	64	unsigned int control;
c906108c SS	65	{
c5aa993b	66	switch ((control >> 8) & 3)
c906108c	67	{
c5aa993b	68	case 0:
d4f3574e	69	puts_unfiltered (" 24 bit; ");
c5aa993b JM	70	break;
c5aa993b JM	71	case 1:
d4f3574e	72	puts_unfiltered (" (bad); ");
c5aa993b JM	73	break;
c5aa993b JM	74	case 2:
d4f3574e	75	puts_unfiltered (" 53 bit; ");
c5aa993b JM	76	break;
c5aa993b JM	77	case 3:
d4f3574e	78	puts_unfiltered (" 64 bit; ");
c5aa993b	79	break;
c906108c	80	}
c5aa993b	81	switch ((control >> 10) & 3)
c906108c	82	{
c5aa993b	83	case 0:
d4f3574e	84	puts_unfiltered ("NEAR; ");
c5aa993b JM	85	break;
c5aa993b JM	86	case 1:
d4f3574e	87	puts_unfiltered ("DOWN; ");
c5aa993b JM	88	break;
c5aa993b JM	89	case 2:
d4f3574e	90	puts_unfiltered ("UP; ");
c5aa993b JM	91	break;
c5aa993b JM	92	case 3:
d4f3574e	93	puts_unfiltered ("CHOP; ");
c5aa993b	94	break;
c906108c	95	}
c5aa993b	96	if (control & 0x3f)
c906108c	97	{
d4f3574e	98	puts_unfiltered ("mask");
c5aa993b	99	if (control & 0x0001)
d4f3574e	100	puts_unfiltered (" INVAL");
c5aa993b	101	if (control & 0x0002)
d4f3574e	102	puts_unfiltered (" DENOR");
c5aa993b	103	if (control & 0x0004)
d4f3574e	104	puts_unfiltered (" DIVZ");
c5aa993b	105	if (control & 0x0008)
d4f3574e	106	puts_unfiltered (" OVERF");
c5aa993b	107	if (control & 0x0010)
d4f3574e	108	puts_unfiltered (" UNDER");
c5aa993b	109	if (control & 0x0020)
d4f3574e SS	110	puts_unfiltered (" LOS");
d4f3574e SS	111	puts_unfiltered (";");
c906108c	112	}
cff3e48b	113
c5aa993b	114	if (control & 0xe080)
d4f3574e	115	warning ("\nreserved bits on: %s",
c5aa993b	116	local_hex_string (control & 0xe080));
c906108c SS	117	}
	118
	119	void
d4f3574e SS	120	print_387_control_word (control)
	121	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 (status)
c906108c SS	130	unsigned int status;
c906108c SS	131	{
d4f3574e	132	printf_unfiltered (" flags %d%d%d%d; ",
c5aa993b JM	133	(status & 0x4000) != 0,
	134	(status & 0x0400) != 0,
	135	(status & 0x0200) != 0,
	136	(status & 0x0100) != 0);
d4f3574e SS	137	printf_unfiltered ("top %d; ", (status >> 11) & 7);
	138	if (status & 0xff)
	139	{
	140	puts_unfiltered ("excep");
	141	if (status & 0x0001) puts_unfiltered (" INVAL");
	142	if (status & 0x0002) puts_unfiltered (" DENOR");
	143	if (status & 0x0004) puts_unfiltered (" DIVZ");
	144	if (status & 0x0008) puts_unfiltered (" OVERF");
	145	if (status & 0x0010) puts_unfiltered (" UNDER");
	146	if (status & 0x0020) puts_unfiltered (" LOS");
	147	if (status & 0x0040) puts_unfiltered (" STACK");
	148	}
	149	}
	150
	151	void
	152	print_387_status_word (status)
	153	unsigned int status;
	154	{
	155	printf_filtered ("status %s:", local_hex_string (status & 0xffff));
	156	print_387_status_bits (status);
	157	puts_unfiltered ("\n");
	158	}
	159
de57eccd JM	160	\f
	161	/* Implement the `info float' layout based on the register definitions
	162	in `tm-i386.h'. */
	163
	164	/* Print the floating point number specified by RAW. */
	165	static void
	166	print_i387_value (char *raw)
	167	{
	168	DOUBLEST value;
1d77867f MK	169
	170	/* Avoid call to floatformat_to_doublest if possible to preserve as
	171	much information as possible. */
	172
	173	#ifdef HAVE_LONG_DOUBLE
	174	if (sizeof (value) == sizeof (long double)
	175	&& HOST_LONG_DOUBLE_FORMAT == &floatformat_i387_ext)
	176	{
	177	/* Copy straight over, but take care of the padding. */
	178	memcpy (&value, raw, FPU_REG_RAW_SIZE);
	179	memset (&value + FPU_REG_RAW_SIZE, 0, sizeof (value) - FPU_REG_RAW_SIZE);
	180	}
	181	else
	182	#endif
	183	floatformat_to_doublest (&floatformat_i387_ext, raw, &value);
de57eccd JM	184
	185	/* We try to print 19 digits. The last digit may or may not contain
	186	garbage, but we'd better print one too many. We need enough room
	187	to print the value, 1 position for the sign, 1 for the decimal
	188	point, 19 for the digits and 6 for the exponent adds up to 27. */
	189	#ifdef PRINTF_HAS_LONG_DOUBLE
	190	printf_filtered (" %-+27.19Lg", (long double) value);
	191	#else
	192	printf_filtered (" %-+27.19g", (double) value);
	193	#endif
	194	}
	195
	196	/* Print the classification for the register contents RAW. */
	197	static void
	198	print_i387_ext (unsigned char *raw)
	199	{
	200	int sign;
	201	int integer;
	202	unsigned int exponent;
	203	unsigned long fraction[2];
	204
	205	sign = raw[9] & 0x80;
	206	integer = raw[7] & 0x80;
	207	exponent = (((raw[9] & 0x7f) << 8) \| raw[8]);
	208	fraction[0] = ((raw[3] << 24) \| (raw[2] << 16) \| (raw[1] << 8) \| raw[0]);
	209	fraction[1] = (((raw[7] & 0x7f) << 24) \| (raw[6] << 16)
	210	\| (raw[5] << 8) \| raw[4]);
	211
	212	if (exponent == 0x7fff && integer)
	213	{
	214	if (fraction[0] == 0x00000000 && fraction[1] == 0x00000000)
	215	/* Infinity. */
	216	printf_filtered (" %cInf", (sign ? '-' : '+'));
	217	else if (sign && fraction[0] == 0x00000000 && fraction[1] == 0x40000000)
	218	/* Real Indefinite (QNaN). */
	219	puts_unfiltered (" Real Indefinite (QNaN)");
	220	else if (fraction[1] & 0x40000000)
	221	/* QNaN. */
	222	puts_filtered (" QNaN");
	223	else
	224	/* SNaN. */
	225	puts_filtered (" SNaN");
	226	}
	227	else if (exponent < 0x7fff && exponent > 0x0000 && integer)
	228	/* Normal. */
	229	print_i387_value (raw);
	230	else if (exponent == 0x0000)
	231	{
	232	/* Denormal or zero. */
	233	print_i387_value (raw);
	234
	235	if (integer)
	236	/* Pseudo-denormal. */
	237	puts_filtered (" Pseudo-denormal");
	238	else if (fraction[0] \|\| fraction[1])
	239	/* Denormal. */
	240	puts_filtered (" Denormal");
	241	}
	242	else
	243	/* Unsupported. */
	244	puts_filtered (" Unsupported");
	245	}
	246
	247	/* Print the status word STATUS. */
248	static void
249	print_i387_status_word (unsigned int status)
250	{
251	printf_filtered ("Status Word: %s",
252	local_hex_string_custom (status, "04"));
253	puts_filtered (" ");
254	printf_filtered (" %s", (status & 0x0001) ? "IE" : " ");
255	printf_filtered (" %s", (status & 0x0002) ? "DE" : " ");
256	printf_filtered (" %s", (status & 0x0004) ? "ZE" : " ");
257	printf_filtered (" %s", (status & 0x0008) ? "OE" : " ");
258	printf_filtered (" %s", (status & 0x0010) ? "UE" : " ");
259	printf_filtered (" %s", (status & 0x0020) ? "PE" : " ");
260	puts_filtered (" ");
261	printf_filtered (" %s", (status & 0x0080) ? "ES" : " ");
262	puts_filtered (" ");
263	printf_filtered (" %s", (status & 0x0080) ? "SF" : " ");
264	puts_filtered (" ");
265	printf_filtered (" %s", (status & 0x0100) ? "C0" : " ");
266	printf_filtered (" %s", (status & 0x0200) ? "C1" : " ");
267	printf_filtered (" %s", (status & 0x0400) ? "C2" : " ");
268	printf_filtered (" %s", (status & 0x4000) ? "C3" : " ");
269
270	puts_filtered ("\n");
271
272	printf_filtered (" TOP: %d\n", ((status >> 11) & 7));
273	}
274
275	/* Print the control word CONTROL. */
276	static void
277	print_i387_control_word (unsigned int control)
278	{
279	printf_filtered ("Control Word: %s",
280	local_hex_string_custom (control, "04"));
281	puts_filtered (" ");
282	printf_filtered (" %s", (control & 0x0001) ? "IM" : " ");
283	printf_filtered (" %s", (control & 0x0002) ? "DM" : " ");
284	printf_filtered (" %s", (control & 0x0004) ? "ZM" : " ");
285	printf_filtered (" %s", (control & 0x0008) ? "OM" : " ");
286	printf_filtered (" %s", (control & 0x0010) ? "UM" : " ");
287	printf_filtered (" %s", (control & 0x0020) ? "PM" : " ");
288
289	puts_filtered ("\n");
290
291	puts_filtered (" PC: ");
292	switch ((control >> 8) & 3)
293	{
294	case 0:
295	puts_filtered ("Single Precision (24-bits)\n");
296	break;
297	case 1:
298	puts_filtered ("Reserved\n");
299	break;
300	case 2:
301	puts_filtered ("Double Precision (53-bits)\n");
302	break;
303	case 3:
304	puts_filtered ("Extended Precision (64-bits)\n");
305	break;
306	}
307
308	puts_filtered (" RC: ");
309	switch ((control >> 10) & 3)
310	{
311	case 0:
312	puts_filtered ("Round to nearest\n");
313	break;
314	case 1:
315	puts_filtered ("Round down\n");
316	break;
317	case 2:
318	puts_filtered ("Round up\n");
319	break;
320	case 3:
321	puts_filtered ("Round toward zero\n");
322	break;
323	}
324	}
325
326	/* Print out the i387 floating poin state. */
327	void
328	i387_float_info (void)
329	{
330	unsigned int fctrl;
331	unsigned int fstat;
332	unsigned int ftag;
333	unsigned int fiseg;
334	unsigned int fioff;
335	unsigned int foseg;
336	unsigned int fooff;
337	unsigned int fop;
338	int fpreg;
339	int top;
340
341	fctrl = read_register (FCTRL_REGNUM);
342	fstat = read_register (FSTAT_REGNUM);
343	ftag = read_register (FTAG_REGNUM);
344	fiseg = read_register (FCS_REGNUM);
345	fioff = read_register (FCOFF_REGNUM);
346	foseg = read_register (FDS_REGNUM);
347	fooff = read_register (FDOFF_REGNUM);
348	fop = read_register (FOP_REGNUM);
349
350	top = ((fstat >> 11) & 7);
351
352	for (fpreg = 7; fpreg >= 0; fpreg--)
353	{
354	unsigned char raw[FPU_REG_RAW_SIZE];
355	int tag = (ftag >> (fpreg * 2)) & 3;
356	int i;
357
358	printf_filtered ("%sR%d: ", fpreg == top ? "=>" : " ", fpreg);
359
360	switch (tag)
361	{
362	case 0:
363	puts_filtered ("Valid ");
364	break;
365	case 1:
366	puts_filtered ("Zero ");
367	break;
368	case 2:
369	puts_filtered ("Special ");
370	break;
371	case 3:
372	puts_filtered ("Empty ");
373	break;
374	}
375
376	read_register_gen ((fpreg + 8 - top) % 8 + FP0_REGNUM, raw);
377
378	puts_filtered ("0x");
379	for (i = 9; i >= 0; i--)
380	printf_filtered ("%02x", raw[i]);
381
382	if (tag != 3)
383	print_i387_ext (raw);
384
385	puts_filtered ("\n");
386	}
387
388	puts_filtered ("\n");
389
390	print_i387_status_word (fstat);
391	print_i387_control_word (fctrl);
392	printf_filtered ("Tag Word: %s\n",
393	local_hex_string_custom (ftag, "04"));
394	printf_filtered ("Instruction Pointer: %s:",
395	local_hex_string_custom (fiseg, "02"));
396	printf_filtered ("%s\n", local_hex_string_custom (fioff, "08"));
397	printf_filtered ("Operand Pointer: %s:",
398	local_hex_string_custom (foseg, "02"));
399	printf_filtered ("%s\n", local_hex_string_custom (fooff, "08"));
400	printf_filtered ("Opcode: %s\n",
401	local_hex_string_custom (fop ? (fop \| 0xd800) : 0, "04"));
402	}