[deliverable/binutils-gdb.git] / libiberty / floatformat.c

/* IEEE floating point support routines, for GDB, the GNU Debugger.
   Copyright (C) 1991, 1994, 1999, 2000 Free Software Foundation, Inc.

This file is part of GDB.

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

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

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

#include "floatformat.h"
#include <math.h>		/* ldexp */
#ifdef __STDC__
#include <stddef.h>
extern void *memcpy (void *s1, const void *s2, size_t n);
extern void *memset (void *s, int c, size_t n);
#else
extern char *memcpy ();
extern char *memset ();
#endif

/* 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"
};
const struct floatformat floatformat_ieee_single_little =
{
  floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
  floatformat_intbit_no,
  "floatformat_ieee_single_little"
};
const struct floatformat floatformat_ieee_double_big =
{
  floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
  floatformat_intbit_no,
  "floatformat_ieee_double_big"
};
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 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"
};

const struct floatformat floatformat_i387_ext =
{
  floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
  floatformat_intbit_yes,
  "floatformat_i387_ext"
};
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"
};
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"
};
const struct floatformat floatformat_m88110_ext =
{
#ifdef HARRIS_FLOAT_FORMAT
  /* 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)"
#else
  floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
  floatformat_intbit_yes,
  "floatformat_m88110_ext"
#endif /* HARRIS_FLOAT_FORMAT */
};
const struct floatformat floatformat_arm_ext =
{
  /* Bits 1 to 16 are unused.  */
  floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
  floatformat_intbit_yes,
  "floatformat_arm_ext"
};
\f
static unsigned long get_field PARAMS ((unsigned char *,
					enum floatformat_byteorders,
					unsigned int,
					unsigned int,
					unsigned int));

/* Extract a field which starts at START and is LEN bytes long.  DATA and
   TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
static unsigned long
get_field (data, order, total_len, start, len)
     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 (fmt, from, to)
     const struct floatformat *fmt;
     char *from;
     double *to;
{
  unsigned char *ufrom = (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);
  /* Note that if exponent indicates a NaN, we can't really do anything useful
     (not knowing if the host has NaN's, or how to build one).  So it will
     end up as an infinity or something close; that is OK.  */

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

      dto += ldexp ((double)mant, exponent - mant_bits);
      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 PARAMS ((unsigned char *, enum floatformat_byteorders,
			       unsigned int,
			       unsigned int,
			       unsigned int,
			       unsigned long));

/* Set a field which starts at START and is LEN bytes long.  DATA and
   TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
static void
put_field (data, order, total_len, start, len, stuff_to_put)
     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 (fmt, from, to)
     const struct floatformat *fmt;
     double *from;
     char *to;
{
  double dfrom;
  int exponent;
  double mant;
  unsigned int mant_bits, mant_off;
  int mant_bits_left;
  unsigned char *uto = (unsigned char *)to;

  memcpy (&dfrom, from, sizeof (dfrom));
  memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
  if (dfrom == 0)
    return;			/* Result is zero */
  if (dfrom != dfrom)
    {
      /* From is 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 irrel */
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
		 32, 1);
      return;
    }

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

  /* How to tell an infinity from an ordinary number?  FIXME-someday */

  mant = frexp (dfrom, &exponent);
  put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
	     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, then we need to discard it.
	 If we are discarding a zero, we should be (but are not) creating
	 a denormalized	number which means adjusting the exponent
	 (I think).  */
      if ((unsigned int) mant_bits_left == fmt->man_len
	  && fmt->intbit == floatformat_intbit_no)
	{
	  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;
    }
}


#ifdef IEEE_DEBUG

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

void
ieee_test (n)
     double n;
{
  double result;
  char exten[16];

  floatformat_to_double (&floatformat_ieee_double_big, &n, &result);
  if (n != result)
    printf ("Differ(to): %.20g -> %.20g\n", n, result);
  floatformat_from_double (&floatformat_ieee_double_big, &n, &result);
  if (n != result)
    printf ("Differ(from): %.20g -> %.20g\n", n, result);

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

#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 ()
{
  ieee_test (0.5);
  ieee_test (256.0);
  ieee_test (0.12345);
  ieee_test (234235.78907234);
  ieee_test (-512.0);
  ieee_test (-0.004321);
  return 0;
}
#endif
Commit	Line	Data
252b5132	1	/* IEEE floating point support routines, for GDB, the GNU Debugger.
f03aa80d	2	Copyright (C) 1991, 1994, 1999, 2000 Free Software Foundation, Inc.
252b5132 RH	3
	4	This file is part of GDB.
	5
	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.
	10
	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.
	15
	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, Boston, MA 02111-1307, USA. */
	19
	20	#include "floatformat.h"
	21	#include <math.h> /* ldexp */
	22	#ifdef __STDC__
	23	#include <stddef.h>
	24	extern void memcpy (void s1, const void *s2, size_t n);
	25	extern void memset (void s, int c, size_t n);
	26	#else
	27	extern char *memcpy ();
	28	extern char *memset ();
	29	#endif
	30
	31	/* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
	32	going to bother with trying to muck around with whether it is defined in
	33	a system header, what we do if not, etc. */
	34	#define FLOATFORMAT_CHAR_BIT 8
	35
	36	/* floatformats for IEEE single and double, big and little endian. */
	37	const struct floatformat floatformat_ieee_single_big =
	38	{
f03aa80d AC	39	floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
	40	floatformat_intbit_no,
	41	"floatformat_ieee_single_big"
252b5132 RH	42	};
	43	const struct floatformat floatformat_ieee_single_little =
	44	{
f03aa80d AC	45	floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
	46	floatformat_intbit_no,
	47	"floatformat_ieee_single_little"
252b5132 RH	48	};
	49	const struct floatformat floatformat_ieee_double_big =
	50	{
f03aa80d AC	51	floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
	52	floatformat_intbit_no,
	53	"floatformat_ieee_double_big"
252b5132 RH	54	};
	55	const struct floatformat floatformat_ieee_double_little =
	56	{
f03aa80d AC	57	floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
	58	floatformat_intbit_no,
	59	"floatformat_ieee_double_little"
252b5132 RH	60	};
	61
	62	/* floatformat for IEEE double, little endian byte order, with big endian word
	63	ordering, as on the ARM. */
	64
	65	const struct floatformat floatformat_ieee_double_littlebyte_bigword =
	66	{
f03aa80d AC	67	floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
f03aa80d AC	68	floatformat_intbit_no,
16bad250	69	"floatformat_ieee_double_littlebyte_bigword"
252b5132 RH	70	};
	71
	72	const struct floatformat floatformat_i387_ext =
	73	{
	74	floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
f03aa80d AC	75	floatformat_intbit_yes,
f03aa80d AC	76	"floatformat_i387_ext"
252b5132 RH	77	};
	78	const struct floatformat floatformat_m68881_ext =
	79	{
	80	/* Note that the bits from 16 to 31 are unused. */
f03aa80d AC	81	floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
	82	floatformat_intbit_yes,
	83	"floatformat_m68881_ext"
252b5132 RH	84	};
	85	const struct floatformat floatformat_i960_ext =
	86	{
	87	/* Note that the bits from 0 to 15 are unused. */
	88	floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64,
f03aa80d AC	89	floatformat_intbit_yes,
f03aa80d AC	90	"floatformat_i960_ext"
252b5132 RH	91	};
	92	const struct floatformat floatformat_m88110_ext =
	93	{
	94	#ifdef HARRIS_FLOAT_FORMAT
	95	/* Harris uses raw format 128 bytes long, but the number is just an ieee
	96	double, and the last 64 bits are wasted. */
	97	floatformat_big,128, 0, 1, 11, 0x3ff, 0x7ff, 12, 52,
f03aa80d AC	98	floatformat_intbit_no,
f03aa80d AC	99	"floatformat_m88110_ext(harris)"
252b5132 RH	100	#else
252b5132 RH	101	floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
f03aa80d AC	102	floatformat_intbit_yes,
f03aa80d AC	103	"floatformat_m88110_ext"
252b5132 RH	104	#endif /* HARRIS_FLOAT_FORMAT */
	105	};
	106	const struct floatformat floatformat_arm_ext =
	107	{
	108	/* Bits 1 to 16 are unused. */
	109	floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
f03aa80d AC	110	floatformat_intbit_yes,
f03aa80d AC	111	"floatformat_arm_ext"
252b5132 RH	112	};
	113	\f
	114	static unsigned long get_field PARAMS ((unsigned char *,
	115	enum floatformat_byteorders,
	116	unsigned int,
	117	unsigned int,
	118	unsigned int));
	119
	120	/* Extract a field which starts at START and is LEN bytes long. DATA and
	121	TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
	122	static unsigned long
	123	get_field (data, order, total_len, start, len)
	124	unsigned char *data;
	125	enum floatformat_byteorders order;
	126	unsigned int total_len;
	127	unsigned int start;
	128	unsigned int len;
	129	{
	130	unsigned long result;
	131	unsigned int cur_byte;
	132	int cur_bitshift;
	133
	134	/* Start at the least significant part of the field. */
	135	cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
	136	if (order == floatformat_little)
	137	cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
	138	cur_bitshift =
	139	((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
	140	result = *(data + cur_byte) >> (-cur_bitshift);
	141	cur_bitshift += FLOATFORMAT_CHAR_BIT;
	142	if (order == floatformat_little)
	143	++cur_byte;
	144	else
	145	--cur_byte;
	146
	147	/* Move towards the most significant part of the field. */
08372f14	148	while ((unsigned int) cur_bitshift < len)
252b5132 RH	149	{
	150	if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
	151	/* This is the last byte; zero out the bits which are not part of
	152	this field. */
	153	result \|=
	154	(*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1))
	155	<< cur_bitshift;
	156	else
	157	result \|= *(data + cur_byte) << cur_bitshift;
	158	cur_bitshift += FLOATFORMAT_CHAR_BIT;
	159	if (order == floatformat_little)
	160	++cur_byte;
	161	else
	162	--cur_byte;
	163	}
	164	return result;
	165	}
	166
	167	#ifndef min
	168	#define min(a, b) ((a) < (b) ? (a) : (b))
	169	#endif
	170
	171	/* Convert from FMT to a double.
	172	FROM is the address of the extended float.
	173	Store the double in TO. /
	174
	175	void
	176	floatformat_to_double (fmt, from, to)
	177	const struct floatformat *fmt;
	178	char *from;
	179	double *to;
	180	{
	181	unsigned char ufrom = (unsigned char )from;
	182	double dto;
	183	long exponent;
	184	unsigned long mant;
	185	unsigned int mant_bits, mant_off;
	186	int mant_bits_left;
	187	int special_exponent; /* It's a NaN, denorm or zero */
	188
	189	exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
	190	fmt->exp_start, fmt->exp_len);
	191	/* Note that if exponent indicates a NaN, we can't really do anything useful
	192	(not knowing if the host has NaN's, or how to build one). So it will
	193	end up as an infinity or something close; that is OK. */
	194
	195	mant_bits_left = fmt->man_len;
	196	mant_off = fmt->man_start;
	197	dto = 0.0;
	198
08372f14	199	special_exponent = exponent == 0 \|\| (unsigned long) exponent == fmt->exp_nan;
252b5132 RH	200
	201	/* Don't bias zero's, denorms or NaNs. */
	202	if (!special_exponent)
	203	exponent -= fmt->exp_bias;
	204
	205	/* Build the result algebraically. Might go infinite, underflow, etc;
	206	who cares. */
	207
	208	/* If this format uses a hidden bit, explicitly add it in now. Otherwise,
	209	increment the exponent by one to account for the integer bit. */
	210
	211	if (!special_exponent)
	212	{
	213	if (fmt->intbit == floatformat_intbit_no)
	214	dto = ldexp (1.0, exponent);
	215	else
	216	exponent++;
	217	}
	218
	219	while (mant_bits_left > 0)
	220	{
	221	mant_bits = min (mant_bits_left, 32);
	222
	223	mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
	224	mant_off, mant_bits);
	225
	226	dto += ldexp ((double)mant, exponent - mant_bits);
	227	exponent -= mant_bits;
	228	mant_off += mant_bits;
	229	mant_bits_left -= mant_bits;
	230	}
	231
	232	/* Negate it if negative. */
	233	if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
	234	dto = -dto;
	235	*to = dto;
	236	}
	237	\f
	238	static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders,
	239	unsigned int,
	240	unsigned int,
	241	unsigned int,
	242	unsigned long));
	243
	244	/* Set a field which starts at START and is LEN bytes long. DATA and
	245	TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
	246	static void
	247	put_field (data, order, total_len, start, len, stuff_to_put)
	248	unsigned char *data;
	249	enum floatformat_byteorders order;
	250	unsigned int total_len;
	251	unsigned int start;
	252	unsigned int len;
	253	unsigned long stuff_to_put;
	254	{
	255	unsigned int cur_byte;
	256	int cur_bitshift;
	257
	258	/* Start at the least significant part of the field. */
	259	cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
	260	if (order == floatformat_little)
	261	cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
	262	cur_bitshift =
	263	((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
264	*(data + cur_byte) &=
265	~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
266	*(data + cur_byte) \|=
267	(stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
268	cur_bitshift += FLOATFORMAT_CHAR_BIT;
269	if (order == floatformat_little)
270	++cur_byte;
271	else
272	--cur_byte;
273
274	/* Move towards the most significant part of the field. */
08372f14	275	while ((unsigned int) cur_bitshift < len)
252b5132 RH	276	{
	277	if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
	278	{
	279	/* This is the last byte. */
	280	*(data + cur_byte) &=
	281	~((1 << (len - cur_bitshift)) - 1);
	282	*(data + cur_byte) \|= (stuff_to_put >> cur_bitshift);
	283	}
	284	else
	285	*(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
	286	& ((1 << FLOATFORMAT_CHAR_BIT) - 1));
	287	cur_bitshift += FLOATFORMAT_CHAR_BIT;
	288	if (order == floatformat_little)
	289	++cur_byte;
	290	else
	291	--cur_byte;
	292	}
	293	}
	294
	295	/* The converse: convert the double *FROM to an extended float
	296	and store where TO points. Neither FROM nor TO have any alignment
	297	restrictions. */
	298
	299	void
	300	floatformat_from_double (fmt, from, to)
	301	const struct floatformat *fmt;
	302	double *from;
	303	char *to;
	304	{
	305	double dfrom;
	306	int exponent;
	307	double mant;
	308	unsigned int mant_bits, mant_off;
	309	int mant_bits_left;
	310	unsigned char uto = (unsigned char )to;
	311
	312	memcpy (&dfrom, from, sizeof (dfrom));
	313	memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
	314	if (dfrom == 0)
	315	return; /* Result is zero */
	316	if (dfrom != dfrom)
	317	{
	318	/* From is NaN */
	319	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
	320	fmt->exp_len, fmt->exp_nan);
	321	/* Be sure it's not infinity, but NaN value is irrel */
	322	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
	323	32, 1);
	324	return;
	325	}
	326
	327	/* If negative, set the sign bit. */
	328	if (dfrom < 0)
	329	{
	330	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
	331	dfrom = -dfrom;
	332	}
	333
	334	/* How to tell an infinity from an ordinary number? FIXME-someday */
	335
	336	mant = frexp (dfrom, &exponent);
	337	put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
	338	exponent + fmt->exp_bias - 1);
	339
340	mant_bits_left = fmt->man_len;
341	mant_off = fmt->man_start;
342	while (mant_bits_left > 0)
343	{
344	unsigned long mant_long;
345	mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
346
347	mant *= 4294967296.0;
348	mant_long = (unsigned long)mant;
349	mant -= mant_long;
350
351	/* If the integer bit is implicit, then we need to discard it.
352	If we are discarding a zero, we should be (but are not) creating
353	a denormalized number which means adjusting the exponent
354	(I think). */
08372f14	355	if ((unsigned int) mant_bits_left == fmt->man_len
252b5132 RH	356	&& fmt->intbit == floatformat_intbit_no)
	357	{
	358	mant_long &= 0x7fffffff;
	359	mant_bits -= 1;
	360	}
	361	else if (mant_bits < 32)
	362	{
	363	/* The bits we want are in the most significant MANT_BITS bits of
	364	mant_long. Move them to the least significant. */
	365	mant_long >>= 32 - mant_bits;
	366	}
	367
	368	put_field (uto, fmt->byteorder, fmt->totalsize,
	369	mant_off, mant_bits, mant_long);
	370	mant_off += mant_bits;
	371	mant_bits_left -= mant_bits;
	372	}
	373	}
	374
	375
	376	#ifdef IEEE_DEBUG
	377
	378	/* This is to be run on a host which uses IEEE floating point. */
	379
	380	void
	381	ieee_test (n)
	382	double n;
	383	{
	384	double result;
	385	char exten[16];
	386
	387	floatformat_to_double (&floatformat_ieee_double_big, &n, &result);
	388	if (n != result)
	389	printf ("Differ(to): %.20g -> %.20g\n", n, result);
	390	floatformat_from_double (&floatformat_ieee_double_big, &n, &result);
	391	if (n != result)
	392	printf ("Differ(from): %.20g -> %.20g\n", n, result);
	393
	394	floatformat_from_double (&floatformat_m68881_ext, &n, exten);
	395	floatformat_to_double (&floatformat_m68881_ext, exten, &result);
	396	if (n != result)
	397	printf ("Differ(to+from): %.20g -> %.20g\n", n, result);
	398
	399	#if IEEE_DEBUG > 1
	400	/* This is to be run on a host which uses 68881 format. */
	401	{
	402	long double ex = (long double )exten;
	403	if (ex != n)
	404	printf ("Differ(from vs. extended): %.20g\n", n);
	405	}
	406	#endif
	407	}
	408
	409	int
	410	main ()
	411	{
	412	ieee_test (0.5);
	413	ieee_test (256.0);
	414	ieee_test (0.12345);
	415	ieee_test (234235.78907234);
	416	ieee_test (-512.0);
	417	ieee_test (-0.004321);
	418	return 0;
	419	}
420	#endif