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

/* IEEE floating point support routines, for GDB, the GNU Debugger.
   Copyright (C) 1991, 1994, 1999 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
};
const struct floatformat floatformat_ieee_single_little =
{
  floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23, floatformat_intbit_no
};
const struct floatformat floatformat_ieee_double_big =
{
  floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52, floatformat_intbit_no
};
const struct floatformat floatformat_ieee_double_little =
{
  floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52, floatformat_intbit_no
};

/* 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
};

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