src/disass/floatformat.c

/* IEEE floating point support routines, for GDB, the GNU Debugger.
   Copyright (C) 1991, 1994 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
};

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

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 (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 (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
Revision:	1.1
Committed:	2000-09-25T12:44:37Z (24 years, 1 month ago) by cebix
Content type:	text/plain
Branch:	MAIN
CVS Tags:	release_3-1, release_3-2, HEAD
Log Message:	- replaced 680x0 and 80x86 disassemblers with the ones from GNU binutils - 680x0 disassembler shows symbolic MacOS low memory globals
#	User	Rev	Content
1	cebix	1.1	/* IEEE floating point support routines, for GDB, the GNU Debugger.
2			Copyright (C) 1991, 1994 Free Software Foundation, Inc.
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
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. */
131			while (cur_bitshift < len)
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
182			special_exponent = exponent == 0 \|\| exponent == fmt->exp_nan;
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)
195			if (fmt->intbit == floatformat_intbit_no)
196			dto = ldexp (1.0, exponent);
197			else
198			exponent++;
199
200			while (mant_bits_left > 0)
201			{
202			mant_bits = min (mant_bits_left, 32);
203
204			mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
205			mant_off, mant_bits);
206
207			dto += ldexp ((double)mant, exponent - mant_bits);
208			exponent -= mant_bits;
209			mant_off += mant_bits;
210			mant_bits_left -= mant_bits;
211			}
212
213			/* Negate it if negative. */
214			if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
215			dto = -dto;
216			*to = dto;
217			}
218
219			static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders,
220			unsigned int,
221			unsigned int,
222			unsigned int,
223			unsigned long));
224
225			/* Set a field which starts at START and is LEN bytes long. DATA and
226			TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
227			static void
228			put_field (data, order, total_len, start, len, stuff_to_put)
229			unsigned char *data;
230			enum floatformat_byteorders order;
231			unsigned int total_len;
232			unsigned int start;
233			unsigned int len;
234			unsigned long stuff_to_put;
235			{
236			unsigned int cur_byte;
237			int cur_bitshift;
238
239			/* Start at the least significant part of the field. */
240			cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
241			if (order == floatformat_little)
242			cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
243			cur_bitshift =
244			((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
245			*(data + cur_byte) &=
246			~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
247			*(data + cur_byte) \|=
248			(stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
249			cur_bitshift += FLOATFORMAT_CHAR_BIT;
250			if (order == floatformat_little)
251			++cur_byte;
252			else
253			--cur_byte;
254
255			/* Move towards the most significant part of the field. */
256			while (cur_bitshift < len)
257			{
258			if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
259			{
260			/* This is the last byte. */
261			*(data + cur_byte) &=
262			~((1 << (len - cur_bitshift)) - 1);
263			*(data + cur_byte) \|= (stuff_to_put >> cur_bitshift);
264			}
265			else
266			*(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
267			& ((1 << FLOATFORMAT_CHAR_BIT) - 1));
268			cur_bitshift += FLOATFORMAT_CHAR_BIT;
269			if (order == floatformat_little)
270			++cur_byte;
271			else
272			--cur_byte;
273			}
274			}
275
276			/* The converse: convert the double *FROM to an extended float
277			and store where TO points. Neither FROM nor TO have any alignment
278			restrictions. */
279
280			void
281			floatformat_from_double (fmt, from, to)
282			CONST struct floatformat *fmt;
283			double *from;
284			char *to;
285			{
286			double dfrom;
287			int exponent;
288			double mant;
289			unsigned int mant_bits, mant_off;
290			int mant_bits_left;
291			unsigned char uto = (unsigned char )to;
292
293			memcpy (&dfrom, from, sizeof (dfrom));
294			memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
295			if (dfrom == 0)
296			return; /* Result is zero */
297			if (dfrom != dfrom)
298			{
299			/* From is NaN */
300			put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
301			fmt->exp_len, fmt->exp_nan);
302			/* Be sure it's not infinity, but NaN value is irrel */
303			put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
304			32, 1);
305			return;
306			}
307
308			/* If negative, set the sign bit. */
309			if (dfrom < 0)
310			{
311			put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
312			dfrom = -dfrom;
313			}
314
315			/* How to tell an infinity from an ordinary number? FIXME-someday */
316
317			mant = frexp (dfrom, &exponent);
318			put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
319			exponent + fmt->exp_bias - 1);
320
321			mant_bits_left = fmt->man_len;
322			mant_off = fmt->man_start;
323			while (mant_bits_left > 0)
324			{
325			unsigned long mant_long;
326			mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
327
328			mant *= 4294967296.0;
329			mant_long = (unsigned long)mant;
330			mant -= mant_long;
331
332			/* If the integer bit is implicit, then we need to discard it.
333			If we are discarding a zero, we should be (but are not) creating
334			a denormalized number which means adjusting the exponent
335			(I think). */
336			if (mant_bits_left == fmt->man_len
337			&& fmt->intbit == floatformat_intbit_no)
338			{
339			mant_long &= 0x7fffffff;
340			mant_bits -= 1;
341			}
342			else if (mant_bits < 32)
343			{
344			/* The bits we want are in the most significant MANT_BITS bits of
345			mant_long. Move them to the least significant. */
346			mant_long >>= 32 - mant_bits;
347			}
348
349			put_field (uto, fmt->byteorder, fmt->totalsize,
350			mant_off, mant_bits, mant_long);
351			mant_off += mant_bits;
352			mant_bits_left -= mant_bits;
353			}
354			}
355
356
357			#ifdef IEEE_DEBUG
358
359			/* This is to be run on a host which uses IEEE floating point. */
360
361			void
362			ieee_test (n)
363			double n;
364			{
365			double result;
366			char exten[16];
367
368			floatformat_to_double (&floatformat_ieee_double_big, &n, &result);
369			if (n != result)
370			printf ("Differ(to): %.20g -> %.20g\n", n, result);
371			floatformat_from_double (&floatformat_ieee_double_big, &n, &result);
372			if (n != result)
373			printf ("Differ(from): %.20g -> %.20g\n", n, result);
374
375			floatformat_from_double (&floatformat_m68881_ext, &n, exten);
376			floatformat_to_double (&floatformat_m68881_ext, exten, &result);
377			if (n != result)
378			printf ("Differ(to+from): %.20g -> %.20g\n", n, result);
379
380			#if IEEE_DEBUG > 1
381			/* This is to be run on a host which uses 68881 format. */
382			{
383			long double ex = (long double )exten;
384			if (ex != n)
385			printf ("Differ(from vs. extended): %.20g\n", n);
386			}
387			#endif
388			}
389
390			int
391			main ()
392			{
393			ieee_test (0.5);
394			ieee_test (256.0);
395			ieee_test (0.12345);
396			ieee_test (234235.78907234);
397			ieee_test (-512.0);
398			ieee_test (-0.004321);
399			return 0;
400			}
401			#endif