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

/* Intel 387 floating point stuff.
   Copyright (C) 1988, 1989, 1991, 1998 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"

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

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

/* FIXME:  Eliminate these routines when we have the time to change all
   the callers.  */

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);
}

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 (";");
    }
  printf_unfiltered ("\n");
  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");
}

void
i387_print_register (raw_regs, regnum)
     char *raw_regs;
     int regnum;
{
  unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
  unsigned long val;
  int j, sign, special;
  unsigned swd, tags, expon, top, norm, ls, ms;
  char string[12];

#if (FPREG_RAW_SIZE != 10)
#error "Bad FPREG_RAW_SIZE"
#endif

  printf_filtered ("%8.8s: ", REGISTER_NAME (regnum));
  if (regnum < FPDATA_REGNUM)
    {
      val = extract_unsigned_integer (raw_regs + REGISTER_BYTE (regnum), 4);
      if ( (regnum < FPSTART_REGNUM + 3) ||
	   (regnum == FPSTART_REGNUM + 6) )
	/* Don't print the un-modifiable bytes. */
	sprintf(string, "0x%04x", val & 0xffff);
      else
	sprintf(string, "0x%08x", val);

      printf_unfiltered ("%10.10s", string);

      if (regnum == FPCONTROL_REGNUM)
	print_387_control_bits (val);
      else if (regnum == FPSTATUS_REGNUM)
	print_387_status_bits (val);
    }
  else
    {
      /* An FPU stack register. */
      if ( REGISTER_RAW_SIZE (regnum) != FPREG_RAW_SIZE )
	error ("GDB bug: i387-tdep.c (i387_print_register): wrong size for FPU stack register");

      /* Put the data in the buffer.  No conversions are ever necessary. */
      memcpy (virtual_buffer, raw_regs + REGISTER_BYTE (regnum),
	      FPREG_RAW_SIZE);

      swd = extract_signed_integer (raw_regs + REGISTER_BYTE (FPSTATUS_REGNUM),
				    4);
      top = (swd >> 11) & 7;
      tags = extract_signed_integer (raw_regs + REGISTER_BYTE (FPTAG_REGNUM),
				     4);

      puts_unfiltered ("0x");
      for (j = 0; j < FPREG_RAW_SIZE; j++)
	printf_unfiltered ("%02x",
			   (unsigned char)raw_regs[REGISTER_BYTE (regnum)
						  + FPREG_RAW_SIZE - 1 - j]);
      
      puts_unfiltered ("  ");
      special = 0;
      switch ((tags >> (((regnum - FPDATA_REGNUM + top) & 7) * 2)) & 3) 
	{
	case 0: puts_unfiltered ("Valid "); break;
	case 1: puts_unfiltered ("Zero  "); break;
	case 2: puts_unfiltered ("Spec  ");
	  special = 1;
	  break;
	case 3: puts_unfiltered ("Empty "); break;
	}

      expon = extract_unsigned_integer (raw_regs + REGISTER_BYTE (regnum)
					+ FPREG_RAW_SIZE - 2, 2);
      sign = expon & 0x8000;
      expon &= 0x7fff;
      ms = extract_unsigned_integer (raw_regs + REGISTER_BYTE (regnum) + 4, 4);
      ls = extract_signed_integer (raw_regs + REGISTER_BYTE (regnum), 4);
      norm = ms & 0x80000000;

      if ( expon == 0 )
	{
	  if ( ms | ls )
	    {
	      /* Denormal or Pseudodenormal. */
	      if ( norm )
		puts_unfiltered ("Pseudo ");
	      else
		puts_unfiltered ("Denorm ");
	    }
	  else
	    {
	      /* Zero. */
	      puts_unfiltered ("Zero   ");
	    }
	}
      else if ( expon == 0x7fff )
	{
	  /* Infinity, NaN or unsupported. */
	  if ( (ms == 0x80000000) &&
	       (ls == 0) )
	    {
              puts_unfiltered ("Infty  ");
	    }
	  else if ( norm )
	    {
	      if ( ms & 0x40000000 )
		puts_unfiltered ("QNaN   ");
	      else
		puts_unfiltered ("SNaN   ");
	    }
	  else
	    {
              puts_unfiltered ("Unsupp ");
	    }
	}
      else
	{
	  /* Normal or unsupported. */
	  if ( norm )
	    puts_unfiltered ("Normal ");
	  else
	    puts_unfiltered ("Unsupp ");
	}

      val_print (REGISTER_VIRTUAL_TYPE (regnum), virtual_buffer, 0, 0,
		 gdb_stdout, 0,
		 1, 0, Val_pretty_default);
    }
  puts_filtered ("\n");
}

void i387_float_info(void)
{
  char raw_regs [REGISTER_BYTES];
  int i;

  for (i = FPSTART_REGNUM; i <= FPEND_REGNUM; i++)
    read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));

  for (i = FPSTART_REGNUM; i <= FPEND_REGNUM; i++)
    i387_print_register (raw_regs, i);
}

#ifdef LD_I387
int
i387_extract_floating (PTR addr, int len, DOUBLEST *dretptr)
{
  if (len == TARGET_LONG_DOUBLE_BIT / 8)
    {
      if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
	{
	  DOUBLEST retval;

	  memcpy (dretptr, addr, sizeof (retval));
	}
      else
	floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, dretptr);

      return 1;
    }
  else
    return 0;
}

int
i387_store_floating (PTR addr, int len, DOUBLEST val)
{
  if (len == TARGET_LONG_DOUBLE_BIT / 8)
    {
      /* This `if' may be totally stupid.  I just put it in here to be
	 absolutely sure I'm preserving the semantics of the code I'm
	 frobbing, while I try to maintain portability boundaries; I
	 don't actually know exactly what it's doing.  -JimB, May 1999 */
      if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
	memcpy (addr, &val, sizeof (val));
      else
	floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);

      return 1;
    }
  else
    return 0;
}
#endif /* LD_I387 */
Commit	Line	Data
c906108c SS	1	/* Intel 387 floating point stuff.
	2	Copyright (C) 1988, 1989, 1991, 1998 Free Software Foundation, Inc.
	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
	29	void i387_to_double PARAMS ((char , char ));
c906108c SS	30	void double_to_i387 PARAMS ((char , char ));
c906108c SS	31
d4f3574e SS	32	static void print_387_control_bits PARAMS ((unsigned int control));
	33	static void print_387_status_bits PARAMS ((unsigned int status));
	34
c906108c SS	35	/* FIXME: Eliminate these routines when we have the time to change all
	36	the callers. */
	37
	38	void
	39	i387_to_double (from, to)
	40	char *from;
	41	char *to;
	42	{
c5aa993b	43	floatformat_to_double (&floatformat_i387_ext, from, (double *) to);
c906108c SS	44	}
	45
	46	void
	47	double_to_i387 (from, to)
	48	char *from;
	49	char *to;
	50	{
c5aa993b	51	floatformat_from_double (&floatformat_i387_ext, (double *) from, to);
c906108c SS	52	}
c906108c SS	53
d4f3574e SS	54	static void
d4f3574e SS	55	print_387_control_bits (control)
c906108c SS	56	unsigned int control;
c906108c SS	57	{
c5aa993b	58	switch ((control >> 8) & 3)
c906108c	59	{
c5aa993b	60	case 0:
d4f3574e	61	puts_unfiltered (" 24 bit; ");
c5aa993b JM	62	break;
c5aa993b JM	63	case 1:
d4f3574e	64	puts_unfiltered (" (bad); ");
c5aa993b JM	65	break;
c5aa993b JM	66	case 2:
d4f3574e	67	puts_unfiltered (" 53 bit; ");
c5aa993b JM	68	break;
c5aa993b JM	69	case 3:
d4f3574e	70	puts_unfiltered (" 64 bit; ");
c5aa993b	71	break;
c906108c	72	}
c5aa993b	73	switch ((control >> 10) & 3)
c906108c	74	{
c5aa993b	75	case 0:
d4f3574e	76	puts_unfiltered ("NEAR; ");
c5aa993b JM	77	break;
c5aa993b JM	78	case 1:
d4f3574e	79	puts_unfiltered ("DOWN; ");
c5aa993b JM	80	break;
c5aa993b JM	81	case 2:
d4f3574e	82	puts_unfiltered ("UP; ");
c5aa993b JM	83	break;
c5aa993b JM	84	case 3:
d4f3574e	85	puts_unfiltered ("CHOP; ");
c5aa993b	86	break;
c906108c	87	}
c5aa993b	88	if (control & 0x3f)
c906108c	89	{
d4f3574e	90	puts_unfiltered ("mask");
c5aa993b	91	if (control & 0x0001)
d4f3574e	92	puts_unfiltered (" INVAL");
c5aa993b	93	if (control & 0x0002)
d4f3574e	94	puts_unfiltered (" DENOR");
c5aa993b	95	if (control & 0x0004)
d4f3574e	96	puts_unfiltered (" DIVZ");
c5aa993b	97	if (control & 0x0008)
d4f3574e	98	puts_unfiltered (" OVERF");
c5aa993b	99	if (control & 0x0010)
d4f3574e	100	puts_unfiltered (" UNDER");
c5aa993b	101	if (control & 0x0020)
d4f3574e SS	102	puts_unfiltered (" LOS");
d4f3574e SS	103	puts_unfiltered (";");
c906108c SS	104	}
c906108c SS	105	printf_unfiltered ("\n");
c5aa993b	106	if (control & 0xe080)
d4f3574e	107	warning ("\nreserved bits on: %s",
c5aa993b	108	local_hex_string (control & 0xe080));
c906108c SS	109	}
	110
	111	void
d4f3574e SS	112	print_387_control_word (control)
	113	unsigned int control;
	114	{
	115	printf_filtered ("control %s:", local_hex_string(control & 0xffff));
	116	print_387_control_bits (control);
	117	puts_unfiltered ("\n");
	118	}
	119
	120	static void
	121	print_387_status_bits (status)
c906108c SS	122	unsigned int status;
c906108c SS	123	{
d4f3574e	124	printf_unfiltered (" flags %d%d%d%d; ",
c5aa993b JM	125	(status & 0x4000) != 0,
	126	(status & 0x0400) != 0,
	127	(status & 0x0200) != 0,
	128	(status & 0x0100) != 0);
d4f3574e SS	129	printf_unfiltered ("top %d; ", (status >> 11) & 7);
	130	if (status & 0xff)
	131	{
	132	puts_unfiltered ("excep");
	133	if (status & 0x0001) puts_unfiltered (" INVAL");
	134	if (status & 0x0002) puts_unfiltered (" DENOR");
	135	if (status & 0x0004) puts_unfiltered (" DIVZ");
	136	if (status & 0x0008) puts_unfiltered (" OVERF");
	137	if (status & 0x0010) puts_unfiltered (" UNDER");
	138	if (status & 0x0020) puts_unfiltered (" LOS");
	139	if (status & 0x0040) puts_unfiltered (" STACK");
	140	}
	141	}
	142
	143	void
	144	print_387_status_word (status)
	145	unsigned int status;
	146	{
	147	printf_filtered ("status %s:", local_hex_string (status & 0xffff));
	148	print_387_status_bits (status);
	149	puts_unfiltered ("\n");
	150	}
	151
	152	void
	153	i387_print_register (raw_regs, regnum)
	154	char *raw_regs;
	155	int regnum;
	156	{
	157	unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
	158	unsigned long val;
	159	int j, sign, special;
	160	unsigned swd, tags, expon, top, norm, ls, ms;
	161	char string[12];
	162
	163	#if (FPREG_RAW_SIZE != 10)
	164	#error "Bad FPREG_RAW_SIZE"
	165	#endif
	166
	167	printf_filtered ("%8.8s: ", REGISTER_NAME (regnum));
	168	if (regnum < FPDATA_REGNUM)
	169	{
	170	val = extract_unsigned_integer (raw_regs + REGISTER_BYTE (regnum), 4);
	171	if ( (regnum < FPSTART_REGNUM + 3) \|\|
	172	(regnum == FPSTART_REGNUM + 6) )
	173	/* Don't print the un-modifiable bytes. */
	174	sprintf(string, "0x%04x", val & 0xffff);
	175	else
	176	sprintf(string, "0x%08x", val);
	177
	178	printf_unfiltered ("%10.10s", string);
c906108c	179
d4f3574e SS	180	if (regnum == FPCONTROL_REGNUM)
	181	print_387_control_bits (val);
	182	else if (regnum == FPSTATUS_REGNUM)
	183	print_387_status_bits (val);
	184	}
	185	else
	186	{
	187	/* An FPU stack register. */
	188	if ( REGISTER_RAW_SIZE (regnum) != FPREG_RAW_SIZE )
	189	error ("GDB bug: i387-tdep.c (i387_print_register): wrong size for FPU stack register");
	190
	191	/* Put the data in the buffer. No conversions are ever necessary. */
	192	memcpy (virtual_buffer, raw_regs + REGISTER_BYTE (regnum),
	193	FPREG_RAW_SIZE);
	194
	195	swd = extract_signed_integer (raw_regs + REGISTER_BYTE (FPSTATUS_REGNUM),
	196	4);
	197	top = (swd >> 11) & 7;
	198	tags = extract_signed_integer (raw_regs + REGISTER_BYTE (FPTAG_REGNUM),
	199	4);
	200
	201	puts_unfiltered ("0x");
	202	for (j = 0; j < FPREG_RAW_SIZE; j++)
	203	printf_unfiltered ("%02x",
	204	(unsigned char)raw_regs[REGISTER_BYTE (regnum)
	205	+ FPREG_RAW_SIZE - 1 - j]);
	206
	207	puts_unfiltered (" ");
	208	special = 0;
	209	switch ((tags >> (((regnum - FPDATA_REGNUM + top) & 7) * 2)) & 3)
	210	{
	211	case 0: puts_unfiltered ("Valid "); break;
	212	case 1: puts_unfiltered ("Zero "); break;
	213	case 2: puts_unfiltered ("Spec ");
	214	special = 1;
	215	break;
	216	case 3: puts_unfiltered ("Empty "); break;
	217	}
	218
	219	expon = extract_unsigned_integer (raw_regs + REGISTER_BYTE (regnum)
	220	+ FPREG_RAW_SIZE - 2, 2);
	221	sign = expon & 0x8000;
	222	expon &= 0x7fff;
	223	ms = extract_unsigned_integer (raw_regs + REGISTER_BYTE (regnum) + 4, 4);
	224	ls = extract_signed_integer (raw_regs + REGISTER_BYTE (regnum), 4);
	225	norm = ms & 0x80000000;
	226
	227	if ( expon == 0 )
	228	{
	229	if ( ms \| ls )
	230	{
	231	/* Denormal or Pseudodenormal. */
	232	if ( norm )
	233	puts_unfiltered ("Pseudo ");
	234	else
	235	puts_unfiltered ("Denorm ");
	236	}
	237	else
	238	{
	239	/* Zero. */
	240	puts_unfiltered ("Zero ");
	241	}
	242	}
	243	else if ( expon == 0x7fff )
244	{
245	/* Infinity, NaN or unsupported. */
246	if ( (ms == 0x80000000) &&
247	(ls == 0) )
248	{
249	puts_unfiltered ("Infty ");
250	}
251	else if ( norm )
252	{
253	if ( ms & 0x40000000 )
254	puts_unfiltered ("QNaN ");
255	else
256	puts_unfiltered ("SNaN ");
257	}
258	else
259	{
260	puts_unfiltered ("Unsupp ");
261	}
262	}
263	else
264	{
265	/* Normal or unsupported. */
266	if ( norm )
267	puts_unfiltered ("Normal ");
268	else
269	puts_unfiltered ("Unsupp ");
270	}
271
272	val_print (REGISTER_VIRTUAL_TYPE (regnum), virtual_buffer, 0, 0,
273	gdb_stdout, 0,
274	1, 0, Val_pretty_default);
275	}
276	puts_filtered ("\n");
277	}
278
279	void i387_float_info(void)
280	{
281	char raw_regs [REGISTER_BYTES];
282	int i;
283
284	for (i = FPSTART_REGNUM; i <= FPEND_REGNUM; i++)
285	read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
286
287	for (i = FPSTART_REGNUM; i <= FPEND_REGNUM; i++)
288	i387_print_register (raw_regs, i);
289	}
290
291	#ifdef LD_I387
292	int
293	i387_extract_floating (PTR addr, int len, DOUBLEST *dretptr)
294	{
295	if (len == TARGET_LONG_DOUBLE_BIT / 8)
296	{
297	if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
298	{
299	DOUBLEST retval;
300
301	memcpy (dretptr, addr, sizeof (retval));
302	}
303	else
304	floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, dretptr);
305
306	return 1;
307	}
308	else
309	return 0;
310	}
311
312	int
313	i387_store_floating (PTR addr, int len, DOUBLEST val)
314	{
315	if (len == TARGET_LONG_DOUBLE_BIT / 8)
316	{
317	/* This `if' may be totally stupid. I just put it in here to be
318	absolutely sure I'm preserving the semantics of the code I'm
319	frobbing, while I try to maintain portability boundaries; I
320	don't actually know exactly what it's doing. -JimB, May 1999 */
321	if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
322	memcpy (addr, &val, sizeof (val));
323	else
324	floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
325
326	return 1;
327	}
328	else
329	return 0;
c906108c	330	}
d4f3574e	331	#endif /* LD_I387 */