[thirdparty/gcc.git] / libiberty / floatformat.c

/* IEEE floating point support routines, for GDB, the GNU Debugger.
   Copyright 1991, 1994, 1999, 2000, 2003, 2005
   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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

/* This is needed to pick up the NAN macro on some systems.  */
#define _GNU_SOURCE

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <math.h>

#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include "ansidecl.h"
#include "libiberty.h"
#include "floatformat.h"

#ifndef INFINITY
#ifdef HUGE_VAL
#define INFINITY HUGE_VAL
#else
#define INFINITY (1.0 / 0.0)
#endif
#endif

#ifndef NAN
#define NAN (0.0 / 0.0)
#endif

static unsigned long get_field (const unsigned char *,
                                enum floatformat_byteorders,
                                unsigned int,
                                unsigned int,
                                unsigned int);
static int floatformat_always_valid (const struct floatformat *fmt,
                                     const void *from);

static int
floatformat_always_valid (const struct floatformat *fmt ATTRIBUTE_UNUSED,
                          const void *from ATTRIBUTE_UNUSED)
{
  return 1;
}

/* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
   going to bother with trying to muck around with whether it is defined in
   a system header, what we do if not, etc.  */
#define FLOATFORMAT_CHAR_BIT 8

/* floatformats for IEEE single and double, big and little endian.  */
const struct floatformat floatformat_ieee_single_big =
{
  floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
  floatformat_intbit_no,
  "floatformat_ieee_single_big",
  floatformat_always_valid
};
const struct floatformat floatformat_ieee_single_little =
{
  floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
  floatformat_intbit_no,
  "floatformat_ieee_single_little",
  floatformat_always_valid
};
const struct floatformat floatformat_ieee_double_big =
{
  floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
  floatformat_intbit_no,
  "floatformat_ieee_double_big",
  floatformat_always_valid
};
const struct floatformat floatformat_ieee_double_little =
{
  floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
  floatformat_intbit_no,
  "floatformat_ieee_double_little",
  floatformat_always_valid
};

/* floatformat for IEEE double, little endian byte order, with big endian word
   ordering, as on the ARM.  */

const struct floatformat floatformat_ieee_double_littlebyte_bigword =
{
  floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
  floatformat_intbit_no,
  "floatformat_ieee_double_littlebyte_bigword",
  floatformat_always_valid
};

/* floatformat for VAX.  Not quite IEEE, but close enough.  */

const struct floatformat floatformat_vax_f =
{
  floatformat_vax, 32, 0, 1, 8, 129, 0, 9, 23,
  floatformat_intbit_no,
  "floatformat_vax_f",
  floatformat_always_valid
};
const struct floatformat floatformat_vax_d =
{
  floatformat_vax, 64, 0, 1, 8, 129, 0, 9, 55,
  floatformat_intbit_no,
  "floatformat_vax_d",
  floatformat_always_valid
};
const struct floatformat floatformat_vax_g =
{
  floatformat_vax, 64, 0, 1, 11, 1025, 0, 12, 52,
  floatformat_intbit_no,
  "floatformat_vax_g",
  floatformat_always_valid
};

static int floatformat_i387_ext_is_valid (const struct floatformat *fmt,
					  const void *from);

static int
floatformat_i387_ext_is_valid (const struct floatformat *fmt, const void *from)
{
  /* In the i387 double-extended format, if the exponent is all ones,
     then the integer bit must be set.  If the exponent is neither 0
     nor ~0, the intbit must also be set.  Only if the exponent is
     zero can it be zero, and then it must be zero.  */
  unsigned long exponent, int_bit;
  const unsigned char *ufrom = (const unsigned char *) from;

  exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
			fmt->exp_start, fmt->exp_len);
  int_bit = get_field (ufrom, fmt->byteorder, fmt->totalsize,
		       fmt->man_start, 1);

  if ((exponent == 0) != (int_bit == 0))
    return 0;
  else
    return 1;
}

const struct floatformat floatformat_i387_ext =
{
  floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
  floatformat_intbit_yes,
  "floatformat_i387_ext",
  floatformat_i387_ext_is_valid
};
const struct floatformat floatformat_m68881_ext =
{
  /* Note that the bits from 16 to 31 are unused.  */
  floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
  floatformat_intbit_yes,
  "floatformat_m68881_ext",
  floatformat_always_valid
};
const struct floatformat floatformat_i960_ext =
{
  /* Note that the bits from 0 to 15 are unused.  */
  floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64,
  floatformat_intbit_yes,
  "floatformat_i960_ext",
  floatformat_always_valid
};
const struct floatformat floatformat_m88110_ext =
{
  floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
  floatformat_intbit_yes,
  "floatformat_m88110_ext",
  floatformat_always_valid
};
const struct floatformat floatformat_m88110_harris_ext =
{
  /* Harris uses raw format 128 bytes long, but the number is just an ieee
     double, and the last 64 bits are wasted. */
  floatformat_big,128, 0, 1, 11,  0x3ff,  0x7ff, 12, 52,
  floatformat_intbit_no,
  "floatformat_m88110_ext_harris",
  floatformat_always_valid
};
const struct floatformat floatformat_arm_ext_big =
{
  /* Bits 1 to 16 are unused.  */
  floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
  floatformat_intbit_yes,
  "floatformat_arm_ext_big",
  floatformat_always_valid
};
const struct floatformat floatformat_arm_ext_littlebyte_bigword =
{
  /* Bits 1 to 16 are unused.  */
  floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
  floatformat_intbit_yes,
  "floatformat_arm_ext_littlebyte_bigword",
  floatformat_always_valid
};
const struct floatformat floatformat_ia64_spill_big =
{
  floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
  floatformat_intbit_yes,
  "floatformat_ia64_spill_big",
  floatformat_always_valid
};
const struct floatformat floatformat_ia64_spill_little =
{
  floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
  floatformat_intbit_yes,
  "floatformat_ia64_spill_little",
  floatformat_always_valid
};
const struct floatformat floatformat_ia64_quad_big =
{
  floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
  floatformat_intbit_no,
  "floatformat_ia64_quad_big",
  floatformat_always_valid
};
const struct floatformat floatformat_ia64_quad_little =
{
  floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
  floatformat_intbit_no,
  "floatformat_ia64_quad_little",
  floatformat_always_valid
};
\f
/* Extract a field which starts at START and is LEN bits long.  DATA and
   TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
static unsigned long
get_field (const unsigned char *data, enum floatformat_byteorders order,
           unsigned int total_len, unsigned int start, unsigned int len)
{
  unsigned long result;
  unsigned int cur_byte;
  int cur_bitshift;

  /* Start at the least significant part of the field.  */
  cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
  if (order == floatformat_little)
    cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
  cur_bitshift =
    ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
  result = *(data + cur_byte) >> (-cur_bitshift);
  cur_bitshift += FLOATFORMAT_CHAR_BIT;
  if (order == floatformat_little)
    ++cur_byte;
  else
    --cur_byte;

  /* Move towards the most significant part of the field.  */
  while ((unsigned int) cur_bitshift < len)
    {
      if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
	/* This is the last byte; zero out the bits which are not part of
	   this field.  */
	result |=
	  (*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1))
	    << cur_bitshift;
      else
	result |= *(data + cur_byte) << cur_bitshift;
      cur_bitshift += FLOATFORMAT_CHAR_BIT;
      if (order == floatformat_little)
	++cur_byte;
      else
	--cur_byte;
    }
  return result;
}
  
#ifndef min
#define min(a, b) ((a) < (b) ? (a) : (b))
#endif

/* Convert from FMT to a double.
   FROM is the address of the extended float.
   Store the double in *TO.  */

void
floatformat_to_double (const struct floatformat *fmt,
                       const void *from, double *to)
{
  const unsigned char *ufrom = (const unsigned char *) from;
  double dto;
  long exponent;
  unsigned long mant;
  unsigned int mant_bits, mant_off;
  int mant_bits_left;
  int special_exponent;		/* It's a NaN, denorm or zero */

  exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
			fmt->exp_start, fmt->exp_len);

  /* If the exponent indicates a NaN, we don't have information to
     decide what to do.  So we handle it like IEEE, except that we
     don't try to preserve the type of NaN.  FIXME.  */
  if ((unsigned long) exponent == fmt->exp_nan)
    {
      int nan;

      mant_off = fmt->man_start;
      mant_bits_left = fmt->man_len;
      nan = 0;
      while (mant_bits_left > 0)
	{
	  mant_bits = min (mant_bits_left, 32);

	  if (get_field (ufrom, fmt->byteorder, fmt->totalsize,
			 mant_off, mant_bits) != 0)
	    {
	      /* This is a NaN.  */
	      nan = 1;
	      break;
	    }

	  mant_off += mant_bits;
	  mant_bits_left -= mant_bits;
	}

      /* On certain systems (such as GNU/Linux), the use of the
	 INFINITY macro below may generate a warning that can not be
	 silenced due to a bug in GCC (PR preprocessor/11931).  The
	 preprocessor fails to recognise the __extension__ keyword in
	 conjunction with the GNU/C99 extension for hexadecimal
	 floating point constants and will issue a warning when
	 compiling with -pedantic.  */
      if (nan)
	dto = NAN;
      else
	dto = INFINITY;

      if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
	dto = -dto;

      *to = dto;

      return;
    }

  mant_bits_left = fmt->man_len;
  mant_off = fmt->man_start;
  dto = 0.0;

  special_exponent = exponent == 0 || (unsigned long) exponent == fmt->exp_nan;

  /* Don't bias zero's, denorms or NaNs.  */
  if (!special_exponent)
    exponent -= fmt->exp_bias;

  /* Build the result algebraically.  Might go infinite, underflow, etc;
     who cares. */

  /* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
     increment the exponent by one to account for the integer bit.  */

  if (!special_exponent)
    {
      if (fmt->intbit == floatformat_intbit_no)
	dto = ldexp (1.0, exponent);
      else
	exponent++;
    }

  while (mant_bits_left > 0)
    {
      mant_bits = min (mant_bits_left, 32);

      mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
			 mant_off, mant_bits);

      /* Handle denormalized numbers.  FIXME: What should we do for
	 non-IEEE formats?  */
      if (exponent == 0 && mant != 0)
	dto += ldexp ((double)mant,
		      (- fmt->exp_bias
		       - mant_bits
		       - (mant_off - fmt->man_start)
		       + 1));
      else
	dto += ldexp ((double)mant, exponent - mant_bits);
      if (exponent != 0)
	exponent -= mant_bits;
      mant_off += mant_bits;
      mant_bits_left -= mant_bits;
    }

  /* Negate it if negative.  */
  if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
    dto = -dto;
  *to = dto;
}
\f
static void put_field (unsigned char *, enum floatformat_byteorders,
                       unsigned int,
                       unsigned int,
                       unsigned int,
                       unsigned long);

/* Set a field which starts at START and is LEN bits long.  DATA and
   TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
static void
put_field (unsigned char *data, enum floatformat_byteorders order,
           unsigned int total_len, unsigned int start, unsigned int len,
           unsigned long stuff_to_put)
{
  unsigned int cur_byte;
  int cur_bitshift;

  /* Start at the least significant part of the field.  */
  cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
  if (order == floatformat_little)
    cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
  cur_bitshift =
    ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
  *(data + cur_byte) &=
    ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
  *(data + cur_byte) |=
    (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
  cur_bitshift += FLOATFORMAT_CHAR_BIT;
  if (order == floatformat_little)
    ++cur_byte;
  else
    --cur_byte;

  /* Move towards the most significant part of the field.  */
  while ((unsigned int) cur_bitshift < len)
    {
      if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
	{
	  /* This is the last byte.  */
	  *(data + cur_byte) &=
	    ~((1 << (len - cur_bitshift)) - 1);
	  *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
	}
      else
	*(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
			      & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
      cur_bitshift += FLOATFORMAT_CHAR_BIT;
      if (order == floatformat_little)
	++cur_byte;
      else
	--cur_byte;
    }
}

/* The converse: convert the double *FROM to an extended float
   and store where TO points.  Neither FROM nor TO have any alignment
   restrictions.  */

void
floatformat_from_double (const struct floatformat *fmt,
                         const double *from, void *to)
{
  double dfrom;
  int exponent;
  double mant;
  unsigned int mant_bits, mant_off;
  int mant_bits_left;
  unsigned char *uto = (unsigned char *) to;

  dfrom = *from;
  memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);

  /* If negative, set the sign bit.  */
  if (dfrom < 0)
    {
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
      dfrom = -dfrom;
    }

  if (dfrom == 0)
    {
      /* 0.0.  */
      return;
    }

  if (dfrom != dfrom)
    {
      /* NaN.  */
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
		 fmt->exp_len, fmt->exp_nan);
      /* Be sure it's not infinity, but NaN value is irrelevant.  */
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
		 32, 1);
      return;
    }

  if (dfrom + dfrom == dfrom)
    {
      /* This can only happen for an infinite value (or zero, which we
	 already handled above).  */
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
		 fmt->exp_len, fmt->exp_nan);
      return;
    }

  mant = frexp (dfrom, &exponent);
  if (exponent + fmt->exp_bias - 1 > 0)
    put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
	       fmt->exp_len, exponent + fmt->exp_bias - 1);
  else
    {
      /* Handle a denormalized number.  FIXME: What should we do for
	 non-IEEE formats?  */
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
		 fmt->exp_len, 0);
      mant = ldexp (mant, exponent + fmt->exp_bias - 1);
    }

  mant_bits_left = fmt->man_len;
  mant_off = fmt->man_start;
  while (mant_bits_left > 0)
    {
      unsigned long mant_long;
      mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;

      mant *= 4294967296.0;
      mant_long = (unsigned long)mant;
      mant -= mant_long;

      /* If the integer bit is implicit, and we are not creating a
	 denormalized number, then we need to discard it.  */
      if ((unsigned int) mant_bits_left == fmt->man_len
	  && fmt->intbit == floatformat_intbit_no
	  && exponent + fmt->exp_bias - 1 > 0)
	{
	  mant_long &= 0x7fffffff;
	  mant_bits -= 1;
	}
      else if (mant_bits < 32)
	{
	  /* The bits we want are in the most significant MANT_BITS bits of
	     mant_long.  Move them to the least significant.  */
	  mant_long >>= 32 - mant_bits;
	}

      put_field (uto, fmt->byteorder, fmt->totalsize,
		 mant_off, mant_bits, mant_long);
      mant_off += mant_bits;
      mant_bits_left -= mant_bits;
    }
}

/* Return non-zero iff the data at FROM is a valid number in format FMT.  */

int
floatformat_is_valid (const struct floatformat *fmt, const void *from)
{
  return fmt->is_valid (fmt, from);
}


#ifdef IEEE_DEBUG

#include <stdio.h>

/* This is to be run on a host which uses IEEE floating point.  */

void
ieee_test (double n)
{
  double result;

  floatformat_to_double (&floatformat_ieee_double_little, &n, &result);
  if ((n != result && (! isnan (n) || ! isnan (result)))
      || (n < 0 && result >= 0)
      || (n >= 0 && result < 0))
    printf ("Differ(to): %.20g -> %.20g\n", n, result);

  floatformat_from_double (&floatformat_ieee_double_little, &n, &result);
  if ((n != result && (! isnan (n) || ! isnan (result)))
      || (n < 0 && result >= 0)
      || (n >= 0 && result < 0))
    printf ("Differ(from): %.20g -> %.20g\n", n, result);

#if 0
  {
    char exten[16];

    floatformat_from_double (&floatformat_m68881_ext, &n, exten);
    floatformat_to_double (&floatformat_m68881_ext, exten, &result);
    if (n != result)
      printf ("Differ(to+from): %.20g -> %.20g\n", n, result);
  }
#endif

#if IEEE_DEBUG > 1
  /* This is to be run on a host which uses 68881 format.  */
  {
    long double ex = *(long double *)exten;
    if (ex != n)
      printf ("Differ(from vs. extended): %.20g\n", n);
  }
#endif
}

int
main (void)
{
  ieee_test (0.0);
  ieee_test (0.5);
  ieee_test (256.0);
  ieee_test (0.12345);
  ieee_test (234235.78907234);
  ieee_test (-512.0);
  ieee_test (-0.004321);
  ieee_test (1.2E-70);
  ieee_test (1.2E-316);
  ieee_test (4.9406564584124654E-324);
  ieee_test (- 4.9406564584124654E-324);
  ieee_test (- 0.0);
  ieee_test (- INFINITY);
  ieee_test (- NAN);
  ieee_test (INFINITY);
  ieee_test (NAN);
  return 0;
}
#endif
Commit	Line	Data
6599da04	1	/* IEEE floating point support routines, for GDB, the GNU Debugger.
e89b6c1c MK	2	Copyright 1991, 1994, 1999, 2000, 2003, 2005
e89b6c1c MK	3	Free Software Foundation, Inc.
6599da04 JM	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
ee58dffd	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
6599da04	20
bee6ab3e ILT	21	/* This is needed to pick up the NAN macro on some systems. */
	22	#define _GNU_SOURCE
	23
	24	#ifdef HAVE_CONFIG_H
	25	#include "config.h"
	26	#endif
	27
	28	#include <math.h>
	29
	30	#ifdef HAVE_STRING_H
	31	#include <string.h>
	32	#endif
	33
c9ac9147	34	#include "ansidecl.h"
bee6ab3e	35	#include "libiberty.h"
6599da04	36	#include "floatformat.h"
bee6ab3e ILT	37
	38	#ifndef INFINITY
	39	#ifdef HUGE_VAL
	40	#define INFINITY HUGE_VAL
6599da04	41	#else
bee6ab3e ILT	42	#define INFINITY (1.0 / 0.0)
	43	#endif
	44	#endif
	45
	46	#ifndef NAN
	47	#define NAN (0.0 / 0.0)
6599da04 JM	48	#endif
6599da04 JM	49
6da879de GDR	50	static unsigned long get_field (const unsigned char *,
	51	enum floatformat_byteorders,
	52	unsigned int,
	53	unsigned int,
	54	unsigned int);
	55	static int floatformat_always_valid (const struct floatformat *fmt,
e89b6c1c	56	const void *from);
83c07342 AC	57
83c07342 AC	58	static int
6da879de	59	floatformat_always_valid (const struct floatformat *fmt ATTRIBUTE_UNUSED,
e89b6c1c	60	const void *from ATTRIBUTE_UNUSED)
83c07342 AC	61	{
	62	return 1;
	63	}
	64
6599da04 JM	65	/* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
	66	going to bother with trying to muck around with whether it is defined in
	67	a system header, what we do if not, etc. */
	68	#define FLOATFORMAT_CHAR_BIT 8
	69
	70	/* floatformats for IEEE single and double, big and little endian. */
	71	const struct floatformat floatformat_ieee_single_big =
	72	{
0b72c3df AC	73	floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
0b72c3df AC	74	floatformat_intbit_no,
83c07342 AC	75	"floatformat_ieee_single_big",
83c07342 AC	76	floatformat_always_valid
6599da04 JM	77	};
	78	const struct floatformat floatformat_ieee_single_little =
	79	{
0b72c3df AC	80	floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
0b72c3df AC	81	floatformat_intbit_no,
83c07342 AC	82	"floatformat_ieee_single_little",
83c07342 AC	83	floatformat_always_valid
6599da04 JM	84	};
	85	const struct floatformat floatformat_ieee_double_big =
	86	{
0b72c3df AC	87	floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
0b72c3df AC	88	floatformat_intbit_no,
83c07342 AC	89	"floatformat_ieee_double_big",
83c07342 AC	90	floatformat_always_valid
6599da04 JM	91	};
	92	const struct floatformat floatformat_ieee_double_little =
	93	{
0b72c3df AC	94	floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
0b72c3df AC	95	floatformat_intbit_no,
83c07342 AC	96	"floatformat_ieee_double_little",
83c07342 AC	97	floatformat_always_valid
6599da04 JM	98	};
	99
	100	/* floatformat for IEEE double, little endian byte order, with big endian word
	101	ordering, as on the ARM. */
	102
	103	const struct floatformat floatformat_ieee_double_littlebyte_bigword =
	104	{
0b72c3df AC	105	floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
0b72c3df AC	106	floatformat_intbit_no,
83c07342 AC	107	"floatformat_ieee_double_littlebyte_bigword",
83c07342 AC	108	floatformat_always_valid
6599da04 JM	109	};
6599da04 JM	110
0432a5de MK	111	/* floatformat for VAX. Not quite IEEE, but close enough. */
	112
	113	const struct floatformat floatformat_vax_f =
	114	{
	115	floatformat_vax, 32, 0, 1, 8, 129, 0, 9, 23,
	116	floatformat_intbit_no,
	117	"floatformat_vax_f",
	118	floatformat_always_valid
	119	};
	120	const struct floatformat floatformat_vax_d =
	121	{
	122	floatformat_vax, 64, 0, 1, 8, 129, 0, 9, 55,
	123	floatformat_intbit_no,
	124	"floatformat_vax_d",
	125	floatformat_always_valid
	126	};
	127	const struct floatformat floatformat_vax_g =
	128	{
	129	floatformat_vax, 64, 0, 1, 11, 1025, 0, 12, 52,
	130	floatformat_intbit_no,
	131	"floatformat_vax_g",
	132	floatformat_always_valid
	133	};
	134
e89b6c1c MK	135	static int floatformat_i387_ext_is_valid (const struct floatformat *fmt,
e89b6c1c MK	136	const void *from);
83c07342 AC	137
83c07342 AC	138	static int
e89b6c1c	139	floatformat_i387_ext_is_valid (const struct floatformat fmt, const void from)
83c07342 AC	140	{
	141	/* In the i387 double-extended format, if the exponent is all ones,
	142	then the integer bit must be set. If the exponent is neither 0
	143	nor ~0, the intbit must also be set. Only if the exponent is
	144	zero can it be zero, and then it must be zero. */
	145	unsigned long exponent, int_bit;
573b07c7	146	const unsigned char ufrom = (const unsigned char ) from;
e89b6c1c	147
83c07342 AC	148	exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
	149	fmt->exp_start, fmt->exp_len);
	150	int_bit = get_field (ufrom, fmt->byteorder, fmt->totalsize,
	151	fmt->man_start, 1);
e89b6c1c	152
83c07342 AC	153	if ((exponent == 0) != (int_bit == 0))
	154	return 0;
	155	else
	156	return 1;
	157	}
	158
6599da04 JM	159	const struct floatformat floatformat_i387_ext =
	160	{
	161	floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
0b72c3df	162	floatformat_intbit_yes,
83c07342 AC	163	"floatformat_i387_ext",
83c07342 AC	164	floatformat_i387_ext_is_valid
6599da04 JM	165	};
	166	const struct floatformat floatformat_m68881_ext =
	167	{
	168	/* Note that the bits from 16 to 31 are unused. */
0b72c3df AC	169	floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
0b72c3df AC	170	floatformat_intbit_yes,
83c07342 AC	171	"floatformat_m68881_ext",
83c07342 AC	172	floatformat_always_valid
6599da04 JM	173	};
	174	const struct floatformat floatformat_i960_ext =
	175	{
	176	/* Note that the bits from 0 to 15 are unused. */
	177	floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64,
0b72c3df	178	floatformat_intbit_yes,
83c07342 AC	179	"floatformat_i960_ext",
83c07342 AC	180	floatformat_always_valid
6599da04 JM	181	};
	182	const struct floatformat floatformat_m88110_ext =
	183	{
0310e5ac AC	184	floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
0310e5ac AC	185	floatformat_intbit_yes,
83c07342 AC	186	"floatformat_m88110_ext",
83c07342 AC	187	floatformat_always_valid
0310e5ac AC	188	};
	189	const struct floatformat floatformat_m88110_harris_ext =
	190	{
6599da04 JM	191	/* Harris uses raw format 128 bytes long, but the number is just an ieee
	192	double, and the last 64 bits are wasted. */
	193	floatformat_big,128, 0, 1, 11, 0x3ff, 0x7ff, 12, 52,
0b72c3df	194	floatformat_intbit_no,
83c07342 AC	195	"floatformat_m88110_ext_harris",
83c07342 AC	196	floatformat_always_valid
6599da04	197	};
0310e5ac AC	198	const struct floatformat floatformat_arm_ext_big =
	199	{
	200	/* Bits 1 to 16 are unused. */
	201	floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
	202	floatformat_intbit_yes,
83c07342 AC	203	"floatformat_arm_ext_big",
83c07342 AC	204	floatformat_always_valid
0310e5ac AC	205	};
	206	const struct floatformat floatformat_arm_ext_littlebyte_bigword =
	207	{
	208	/* Bits 1 to 16 are unused. */
	209	floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
	210	floatformat_intbit_yes,
83c07342 AC	211	"floatformat_arm_ext_littlebyte_bigword",
83c07342 AC	212	floatformat_always_valid
0310e5ac AC	213	};
	214	const struct floatformat floatformat_ia64_spill_big =
	215	{
	216	floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
	217	floatformat_intbit_yes,
83c07342 AC	218	"floatformat_ia64_spill_big",
83c07342 AC	219	floatformat_always_valid
0310e5ac AC	220	};
	221	const struct floatformat floatformat_ia64_spill_little =
	222	{
	223	floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
	224	floatformat_intbit_yes,
83c07342 AC	225	"floatformat_ia64_spill_little",
83c07342 AC	226	floatformat_always_valid
0310e5ac AC	227	};
	228	const struct floatformat floatformat_ia64_quad_big =
	229	{
	230	floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
	231	floatformat_intbit_no,
83c07342 AC	232	"floatformat_ia64_quad_big",
83c07342 AC	233	floatformat_always_valid
0310e5ac AC	234	};
	235	const struct floatformat floatformat_ia64_quad_little =
	236	{
	237	floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
	238	floatformat_intbit_no,
83c07342 AC	239	"floatformat_ia64_quad_little",
83c07342 AC	240	floatformat_always_valid
0310e5ac	241	};
6599da04	242	\f
9c8860c3	243	/* Extract a field which starts at START and is LEN bits long. DATA and
6599da04 JM	244	TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
6599da04 JM	245	static unsigned long
6da879de GDR	246	get_field (const unsigned char *data, enum floatformat_byteorders order,
6da879de GDR	247	unsigned int total_len, unsigned int start, unsigned int len)
6599da04 JM	248	{
	249	unsigned long result;
	250	unsigned int cur_byte;
	251	int cur_bitshift;
	252
	253	/* Start at the least significant part of the field. */
	254	cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
	255	if (order == floatformat_little)
	256	cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
	257	cur_bitshift =
	258	((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
	259	result = *(data + cur_byte) >> (-cur_bitshift);
	260	cur_bitshift += FLOATFORMAT_CHAR_BIT;
	261	if (order == floatformat_little)
	262	++cur_byte;
	263	else
	264	--cur_byte;
	265
	266	/* Move towards the most significant part of the field. */
5ad5a984	267	while ((unsigned int) cur_bitshift < len)
6599da04 JM	268	{
	269	if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
	270	/* This is the last byte; zero out the bits which are not part of
	271	this field. */
	272	result \|=
	273	(*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1))
	274	<< cur_bitshift;
	275	else
	276	result \|= *(data + cur_byte) << cur_bitshift;
	277	cur_bitshift += FLOATFORMAT_CHAR_BIT;
	278	if (order == floatformat_little)
	279	++cur_byte;
	280	else
	281	--cur_byte;
	282	}
	283	return result;
	284	}
	285
	286	#ifndef min
	287	#define min(a, b) ((a) < (b) ? (a) : (b))
	288	#endif
	289
	290	/* Convert from FMT to a double.
	291	FROM is the address of the extended float.
	292	Store the double in TO. /
	293
	294	void
6da879de	295	floatformat_to_double (const struct floatformat *fmt,
e89b6c1c	296	const void from, double to)
6599da04	297	{
573b07c7	298	const unsigned char ufrom = (const unsigned char ) from;
6599da04 JM	299	double dto;
	300	long exponent;
	301	unsigned long mant;
	302	unsigned int mant_bits, mant_off;
	303	int mant_bits_left;
	304	int special_exponent; /* It's a NaN, denorm or zero */
	305
	306	exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
	307	fmt->exp_start, fmt->exp_len);
bee6ab3e ILT	308
	309	/* If the exponent indicates a NaN, we don't have information to
	310	decide what to do. So we handle it like IEEE, except that we
	311	don't try to preserve the type of NaN. FIXME. */
	312	if ((unsigned long) exponent == fmt->exp_nan)
	313	{
	314	int nan;
	315
	316	mant_off = fmt->man_start;
	317	mant_bits_left = fmt->man_len;
	318	nan = 0;
	319	while (mant_bits_left > 0)
	320	{
	321	mant_bits = min (mant_bits_left, 32);
	322
	323	if (get_field (ufrom, fmt->byteorder, fmt->totalsize,
	324	mant_off, mant_bits) != 0)
	325	{
	326	/* This is a NaN. */
	327	nan = 1;
	328	break;
	329	}
	330
	331	mant_off += mant_bits;
	332	mant_bits_left -= mant_bits;
	333	}
	334
72f93778 BE	335	/* On certain systems (such as GNU/Linux), the use of the
	336	INFINITY macro below may generate a warning that can not be
	337	silenced due to a bug in GCC (PR preprocessor/11931). The
	338	preprocessor fails to recognise the __extension__ keyword in
	339	conjunction with the GNU/C99 extension for hexadecimal
	340	floating point constants and will issue a warning when
	341	compiling with -pedantic. */
bee6ab3e ILT	342	if (nan)
	343	dto = NAN;
	344	else
	345	dto = INFINITY;
	346
	347	if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
	348	dto = -dto;
	349
	350	*to = dto;
	351
	352	return;
	353	}
6599da04 JM	354
	355	mant_bits_left = fmt->man_len;
	356	mant_off = fmt->man_start;
	357	dto = 0.0;
	358
5ad5a984	359	special_exponent = exponent == 0 \|\| (unsigned long) exponent == fmt->exp_nan;
6599da04 JM	360
	361	/* Don't bias zero's, denorms or NaNs. */
	362	if (!special_exponent)
	363	exponent -= fmt->exp_bias;
	364
	365	/* Build the result algebraically. Might go infinite, underflow, etc;
	366	who cares. */
	367
	368	/* If this format uses a hidden bit, explicitly add it in now. Otherwise,
	369	increment the exponent by one to account for the integer bit. */
	370
	371	if (!special_exponent)
087aa398 KG	372	{
	373	if (fmt->intbit == floatformat_intbit_no)
	374	dto = ldexp (1.0, exponent);
	375	else
	376	exponent++;
	377	}
6599da04 JM	378
	379	while (mant_bits_left > 0)
	380	{
	381	mant_bits = min (mant_bits_left, 32);
	382
	383	mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
	384	mant_off, mant_bits);
	385
bee6ab3e ILT	386	/* Handle denormalized numbers. FIXME: What should we do for
	387	non-IEEE formats? */
	388	if (exponent == 0 && mant != 0)
	389	dto += ldexp ((double)mant,
	390	(- fmt->exp_bias
	391	- mant_bits
	392	- (mant_off - fmt->man_start)
	393	+ 1));
	394	else
	395	dto += ldexp ((double)mant, exponent - mant_bits);
	396	if (exponent != 0)
	397	exponent -= mant_bits;
6599da04 JM	398	mant_off += mant_bits;
	399	mant_bits_left -= mant_bits;
	400	}
	401
	402	/* Negate it if negative. */
	403	if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
	404	dto = -dto;
	405	*to = dto;
	406	}
	407	\f
6da879de GDR	408	static void put_field (unsigned char *, enum floatformat_byteorders,
	409	unsigned int,
	410	unsigned int,
	411	unsigned int,
	412	unsigned long);
6599da04	413
9c8860c3	414	/* Set a field which starts at START and is LEN bits long. DATA and
6599da04 JM	415	TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
6599da04 JM	416	static void
6da879de GDR	417	put_field (unsigned char *data, enum floatformat_byteorders order,
	418	unsigned int total_len, unsigned int start, unsigned int len,
	419	unsigned long stuff_to_put)
6599da04 JM	420	{
	421	unsigned int cur_byte;
	422	int cur_bitshift;
	423
	424	/* Start at the least significant part of the field. */
	425	cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
	426	if (order == floatformat_little)
	427	cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
	428	cur_bitshift =
	429	((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
	430	*(data + cur_byte) &=
	431	~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
	432	*(data + cur_byte) \|=
	433	(stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
	434	cur_bitshift += FLOATFORMAT_CHAR_BIT;
	435	if (order == floatformat_little)
	436	++cur_byte;
	437	else
	438	--cur_byte;
	439
	440	/* Move towards the most significant part of the field. */
5ad5a984	441	while ((unsigned int) cur_bitshift < len)
6599da04 JM	442	{
	443	if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
	444	{
	445	/* This is the last byte. */
	446	*(data + cur_byte) &=
	447	~((1 << (len - cur_bitshift)) - 1);
	448	*(data + cur_byte) \|= (stuff_to_put >> cur_bitshift);
	449	}
	450	else
	451	*(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
	452	& ((1 << FLOATFORMAT_CHAR_BIT) - 1));
	453	cur_bitshift += FLOATFORMAT_CHAR_BIT;
	454	if (order == floatformat_little)
	455	++cur_byte;
	456	else
	457	--cur_byte;
	458	}
	459	}
	460
	461	/* The converse: convert the double *FROM to an extended float
	462	and store where TO points. Neither FROM nor TO have any alignment
	463	restrictions. */
	464
	465	void
6da879de	466	floatformat_from_double (const struct floatformat *fmt,
e89b6c1c	467	const double from, void to)
6599da04 JM	468	{
	469	double dfrom;
	470	int exponent;
	471	double mant;
	472	unsigned int mant_bits, mant_off;
	473	int mant_bits_left;
573b07c7	474	unsigned char uto = (unsigned char ) to;
6599da04	475
bee6ab3e	476	dfrom = *from;
6599da04	477	memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
bee6ab3e ILT	478
	479	/* If negative, set the sign bit. */
	480	if (dfrom < 0)
	481	{
	482	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
	483	dfrom = -dfrom;
	484	}
	485
6599da04	486	if (dfrom == 0)
bee6ab3e ILT	487	{
	488	/* 0.0. */
	489	return;
	490	}
	491
6599da04 JM	492	if (dfrom != dfrom)
6599da04 JM	493	{
bee6ab3e	494	/* NaN. */
6599da04 JM	495	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
6599da04 JM	496	fmt->exp_len, fmt->exp_nan);
bee6ab3e	497	/* Be sure it's not infinity, but NaN value is irrelevant. */
6599da04 JM	498	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
	499	32, 1);
	500	return;
	501	}
	502
bee6ab3e	503	if (dfrom + dfrom == dfrom)
6599da04	504	{
bee6ab3e ILT	505	/* This can only happen for an infinite value (or zero, which we
	506	already handled above). */
	507	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
	508	fmt->exp_len, fmt->exp_nan);
	509	return;
6599da04 JM	510	}
6599da04 JM	511
6599da04	512	mant = frexp (dfrom, &exponent);
bee6ab3e ILT	513	if (exponent + fmt->exp_bias - 1 > 0)
	514	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
	515	fmt->exp_len, exponent + fmt->exp_bias - 1);
	516	else
	517	{
	518	/* Handle a denormalized number. FIXME: What should we do for
	519	non-IEEE formats? */
	520	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
	521	fmt->exp_len, 0);
	522	mant = ldexp (mant, exponent + fmt->exp_bias - 1);
	523	}
6599da04 JM	524
	525	mant_bits_left = fmt->man_len;
	526	mant_off = fmt->man_start;
	527	while (mant_bits_left > 0)
	528	{
	529	unsigned long mant_long;
	530	mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
	531
	532	mant *= 4294967296.0;
	533	mant_long = (unsigned long)mant;
	534	mant -= mant_long;
	535
bee6ab3e ILT	536	/* If the integer bit is implicit, and we are not creating a
bee6ab3e ILT	537	denormalized number, then we need to discard it. */
5ad5a984	538	if ((unsigned int) mant_bits_left == fmt->man_len
bee6ab3e ILT	539	&& fmt->intbit == floatformat_intbit_no
bee6ab3e ILT	540	&& exponent + fmt->exp_bias - 1 > 0)
6599da04 JM	541	{
	542	mant_long &= 0x7fffffff;
	543	mant_bits -= 1;
	544	}
	545	else if (mant_bits < 32)
	546	{
	547	/* The bits we want are in the most significant MANT_BITS bits of
	548	mant_long. Move them to the least significant. */
	549	mant_long >>= 32 - mant_bits;
	550	}
	551
	552	put_field (uto, fmt->byteorder, fmt->totalsize,
	553	mant_off, mant_bits, mant_long);
	554	mant_off += mant_bits;
	555	mant_bits_left -= mant_bits;
	556	}
	557	}
	558
9c8860c3 DJ	559	/* Return non-zero iff the data at FROM is a valid number in format FMT. */
	560
	561	int
e89b6c1c	562	floatformat_is_valid (const struct floatformat fmt, const void from)
9c8860c3	563	{
83c07342	564	return fmt->is_valid (fmt, from);
9c8860c3 DJ	565	}
9c8860c3 DJ	566
6599da04 JM	567
	568	#ifdef IEEE_DEBUG
	569
bee6ab3e ILT	570	#include <stdio.h>
bee6ab3e ILT	571
6599da04 JM	572	/* This is to be run on a host which uses IEEE floating point. */
	573
	574	void
6da879de	575	ieee_test (double n)
6599da04 JM	576	{
6599da04 JM	577	double result;
6599da04	578
e89b6c1c	579	floatformat_to_double (&floatformat_ieee_double_little, &n, &result);
bee6ab3e ILT	580	if ((n != result && (! isnan (n) \|\| ! isnan (result)))
	581	\|\| (n < 0 && result >= 0)
	582	\|\| (n >= 0 && result < 0))
6599da04	583	printf ("Differ(to): %.20g -> %.20g\n", n, result);
bee6ab3e	584
e89b6c1c	585	floatformat_from_double (&floatformat_ieee_double_little, &n, &result);
bee6ab3e ILT	586	if ((n != result && (! isnan (n) \|\| ! isnan (result)))
	587	\|\| (n < 0 && result >= 0)
	588	\|\| (n >= 0 && result < 0))
6599da04 JM	589	printf ("Differ(from): %.20g -> %.20g\n", n, result);
6599da04 JM	590
bee6ab3e ILT	591	#if 0
	592	{
	593	char exten[16];
	594
	595	floatformat_from_double (&floatformat_m68881_ext, &n, exten);
	596	floatformat_to_double (&floatformat_m68881_ext, exten, &result);
	597	if (n != result)
	598	printf ("Differ(to+from): %.20g -> %.20g\n", n, result);
	599	}
	600	#endif
6599da04 JM	601
	602	#if IEEE_DEBUG > 1
	603	/* This is to be run on a host which uses 68881 format. */
	604	{
	605	long double ex = (long double )exten;
	606	if (ex != n)
	607	printf ("Differ(from vs. extended): %.20g\n", n);
	608	}
	609	#endif
	610	}
	611
	612	int
6da879de	613	main (void)
6599da04	614	{
bee6ab3e	615	ieee_test (0.0);
6599da04 JM	616	ieee_test (0.5);
	617	ieee_test (256.0);
	618	ieee_test (0.12345);
	619	ieee_test (234235.78907234);
	620	ieee_test (-512.0);
	621	ieee_test (-0.004321);
bee6ab3e ILT	622	ieee_test (1.2E-70);
	623	ieee_test (1.2E-316);
	624	ieee_test (4.9406564584124654E-324);
	625	ieee_test (- 4.9406564584124654E-324);
	626	ieee_test (- 0.0);
	627	ieee_test (- INFINITY);
	628	ieee_test (- NAN);
	629	ieee_test (INFINITY);
	630	ieee_test (NAN);
6599da04 JM	631	return 0;
	632	}
	633	#endif