[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
28e9041c	1	/* IEEE floating point support routines, for GDB, the GNU Debugger.
5a929093	2	Copyright 1991, 1994, 1999, 2000, 2003, 2005
5a929093	3	Free Software Foundation, Inc.
28e9041c	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
95b8d1bc	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
28e9041c	20
fa152dff	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
ca3ccdf6	34	#include "ansidecl.h"
fa152dff	35	#include "libiberty.h"
28e9041c	36	#include "floatformat.h"
fa152dff	37
	38	#ifndef INFINITY
	39	#ifdef HUGE_VAL
	40	#define INFINITY HUGE_VAL
28e9041c	41	#else
fa152dff	42	#define INFINITY (1.0 / 0.0)
	43	#endif
	44	#endif
	45
	46	#ifndef NAN
	47	#define NAN (0.0 / 0.0)
28e9041c	48	#endif
28e9041c	49
8858115e	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,
5a929093	56	const void *from);
63cb126c	57
63cb126c	58	static int
8858115e	59	floatformat_always_valid (const struct floatformat *fmt ATTRIBUTE_UNUSED,
5a929093	60	const void *from ATTRIBUTE_UNUSED)
63cb126c	61	{
	62	return 1;
	63	}
	64
28e9041c	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	{
b5495c1d	73	floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
b5495c1d	74	floatformat_intbit_no,
63cb126c	75	"floatformat_ieee_single_big",
63cb126c	76	floatformat_always_valid
28e9041c	77	};
	78	const struct floatformat floatformat_ieee_single_little =
	79	{
b5495c1d	80	floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
b5495c1d	81	floatformat_intbit_no,
63cb126c	82	"floatformat_ieee_single_little",
63cb126c	83	floatformat_always_valid
28e9041c	84	};
	85	const struct floatformat floatformat_ieee_double_big =
	86	{
b5495c1d	87	floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
b5495c1d	88	floatformat_intbit_no,
63cb126c	89	"floatformat_ieee_double_big",
63cb126c	90	floatformat_always_valid
28e9041c	91	};
	92	const struct floatformat floatformat_ieee_double_little =
	93	{
b5495c1d	94	floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
b5495c1d	95	floatformat_intbit_no,
63cb126c	96	"floatformat_ieee_double_little",
63cb126c	97	floatformat_always_valid
28e9041c	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	{
b5495c1d	105	floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
b5495c1d	106	floatformat_intbit_no,
63cb126c	107	"floatformat_ieee_double_littlebyte_bigword",
63cb126c	108	floatformat_always_valid
28e9041c	109	};
28e9041c	110
c38d39c9	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
5a929093	135	static int floatformat_i387_ext_is_valid (const struct floatformat *fmt,
5a929093	136	const void *from);
63cb126c	137
63cb126c	138	static int
5a929093	139	floatformat_i387_ext_is_valid (const struct floatformat fmt, const void from)
63cb126c	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;
0ff8da43	146	const unsigned char ufrom = (const unsigned char ) from;
5a929093	147
63cb126c	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);
5a929093	152
63cb126c	153	if ((exponent == 0) != (int_bit == 0))
	154	return 0;
	155	else
	156	return 1;
	157	}
	158
28e9041c	159	const struct floatformat floatformat_i387_ext =
	160	{
	161	floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
b5495c1d	162	floatformat_intbit_yes,
63cb126c	163	"floatformat_i387_ext",
63cb126c	164	floatformat_i387_ext_is_valid
28e9041c	165	};
	166	const struct floatformat floatformat_m68881_ext =
	167	{
	168	/* Note that the bits from 16 to 31 are unused. */
b5495c1d	169	floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
b5495c1d	170	floatformat_intbit_yes,
63cb126c	171	"floatformat_m68881_ext",
63cb126c	172	floatformat_always_valid
28e9041c	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,
b5495c1d	178	floatformat_intbit_yes,
63cb126c	179	"floatformat_i960_ext",
63cb126c	180	floatformat_always_valid
28e9041c	181	};
	182	const struct floatformat floatformat_m88110_ext =
	183	{
95f0a124	184	floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
95f0a124	185	floatformat_intbit_yes,
63cb126c	186	"floatformat_m88110_ext",
63cb126c	187	floatformat_always_valid
95f0a124	188	};
	189	const struct floatformat floatformat_m88110_harris_ext =
	190	{
28e9041c	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,
b5495c1d	194	floatformat_intbit_no,
63cb126c	195	"floatformat_m88110_ext_harris",
63cb126c	196	floatformat_always_valid
28e9041c	197	};
95f0a124	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,
63cb126c	203	"floatformat_arm_ext_big",
63cb126c	204	floatformat_always_valid
95f0a124	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,
63cb126c	211	"floatformat_arm_ext_littlebyte_bigword",
63cb126c	212	floatformat_always_valid
95f0a124	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,
63cb126c	218	"floatformat_ia64_spill_big",
63cb126c	219	floatformat_always_valid
95f0a124	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,
63cb126c	225	"floatformat_ia64_spill_little",
63cb126c	226	floatformat_always_valid
95f0a124	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,
63cb126c	232	"floatformat_ia64_quad_big",
63cb126c	233	floatformat_always_valid
95f0a124	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,
63cb126c	239	"floatformat_ia64_quad_little",
63cb126c	240	floatformat_always_valid
95f0a124	241	};
28e9041c	242	\f
8109b385	243	/* Extract a field which starts at START and is LEN bits long. DATA and
28e9041c	244	TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
28e9041c	245	static unsigned long
8858115e	246	get_field (const unsigned char *data, enum floatformat_byteorders order,
8858115e	247	unsigned int total_len, unsigned int start, unsigned int len)
28e9041c	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. */
1f33a375	267	while ((unsigned int) cur_bitshift < len)
28e9041c	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
8858115e	295	floatformat_to_double (const struct floatformat *fmt,
5a929093	296	const void from, double to)
28e9041c	297	{
0ff8da43	298	const unsigned char ufrom = (const unsigned char ) from;
28e9041c	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);
fa152dff	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
88618d58	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. */
fa152dff	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	}
28e9041c	354
	355	mant_bits_left = fmt->man_len;
	356	mant_off = fmt->man_start;
	357	dto = 0.0;
	358
1f33a375	359	special_exponent = exponent == 0 \|\| (unsigned long) exponent == fmt->exp_nan;
28e9041c	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)
7c8c70e9	372	{
	373	if (fmt->intbit == floatformat_intbit_no)
	374	dto = ldexp (1.0, exponent);
	375	else
	376	exponent++;
	377	}
28e9041c	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
fa152dff	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;
28e9041c	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
8858115e	408	static void put_field (unsigned char *, enum floatformat_byteorders,
	409	unsigned int,
	410	unsigned int,
	411	unsigned int,
	412	unsigned long);
28e9041c	413
8109b385	414	/* Set a field which starts at START and is LEN bits long. DATA and
28e9041c	415	TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
28e9041c	416	static void
8858115e	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)
28e9041c	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. */
1f33a375	441	while ((unsigned int) cur_bitshift < len)
28e9041c	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
8858115e	466	floatformat_from_double (const struct floatformat *fmt,
5a929093	467	const double from, void to)
28e9041c	468	{
	469	double dfrom;
	470	int exponent;
	471	double mant;
	472	unsigned int mant_bits, mant_off;
	473	int mant_bits_left;
0ff8da43	474	unsigned char uto = (unsigned char ) to;
28e9041c	475
fa152dff	476	dfrom = *from;
28e9041c	477	memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
fa152dff	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
28e9041c	486	if (dfrom == 0)
fa152dff	487	{
	488	/* 0.0. */
	489	return;
	490	}
	491
28e9041c	492	if (dfrom != dfrom)
28e9041c	493	{
fa152dff	494	/* NaN. */
28e9041c	495	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
28e9041c	496	fmt->exp_len, fmt->exp_nan);
fa152dff	497	/* Be sure it's not infinity, but NaN value is irrelevant. */
28e9041c	498	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
	499	32, 1);
	500	return;
	501	}
	502
fa152dff	503	if (dfrom + dfrom == dfrom)
28e9041c	504	{
fa152dff	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;
28e9041c	510	}
28e9041c	511
28e9041c	512	mant = frexp (dfrom, &exponent);
fa152dff	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	}
28e9041c	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
fa152dff	536	/* If the integer bit is implicit, and we are not creating a
fa152dff	537	denormalized number, then we need to discard it. */
1f33a375	538	if ((unsigned int) mant_bits_left == fmt->man_len
fa152dff	539	&& fmt->intbit == floatformat_intbit_no
fa152dff	540	&& exponent + fmt->exp_bias - 1 > 0)
28e9041c	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
8109b385	559	/* Return non-zero iff the data at FROM is a valid number in format FMT. */
	560
	561	int
5a929093	562	floatformat_is_valid (const struct floatformat fmt, const void from)
8109b385	563	{
63cb126c	564	return fmt->is_valid (fmt, from);
8109b385	565	}
8109b385	566
28e9041c	567
	568	#ifdef IEEE_DEBUG
	569
fa152dff	570	#include <stdio.h>
fa152dff	571
28e9041c	572	/* This is to be run on a host which uses IEEE floating point. */
	573
	574	void
8858115e	575	ieee_test (double n)
28e9041c	576	{
28e9041c	577	double result;
28e9041c	578
5a929093	579	floatformat_to_double (&floatformat_ieee_double_little, &n, &result);
fa152dff	580	if ((n != result && (! isnan (n) \|\| ! isnan (result)))
	581	\|\| (n < 0 && result >= 0)
	582	\|\| (n >= 0 && result < 0))
28e9041c	583	printf ("Differ(to): %.20g -> %.20g\n", n, result);
fa152dff	584
5a929093	585	floatformat_from_double (&floatformat_ieee_double_little, &n, &result);
fa152dff	586	if ((n != result && (! isnan (n) \|\| ! isnan (result)))
	587	\|\| (n < 0 && result >= 0)
	588	\|\| (n >= 0 && result < 0))
28e9041c	589	printf ("Differ(from): %.20g -> %.20g\n", n, result);
28e9041c	590
fa152dff	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
28e9041c	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
8858115e	613	main (void)
28e9041c	614	{
fa152dff	615	ieee_test (0.0);
28e9041c	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);
fa152dff	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);
28e9041c	631	return 0;
	632	}
	633	#endif