binutils-gdb/libiberty/floatformat.c

621 lines
17 KiB
C
Raw Normal View History

1999-05-03 09:29:11 +02:00
/* IEEE floating point support routines, for GDB, the GNU Debugger.
Copyright (C) 1991, 1994, 1999, 2000, 2003 Free Software Foundation, Inc.
1999-05-03 09:29:11 +02:00
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. */
2003-12-03 20:03:29 +01:00
/* 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
2003-04-15 23:29:34 +02:00
#include "ansidecl.h"
2003-12-03 20:03:29 +01:00
#include "libiberty.h"
1999-05-03 09:29:11 +02:00
#include "floatformat.h"
2003-12-03 20:03:29 +01:00
#ifndef INFINITY
#ifdef HUGE_VAL
#define INFINITY HUGE_VAL
1999-05-03 09:29:11 +02:00
#else
2003-12-03 20:03:29 +01:00
#define INFINITY (1.0 / 0.0)
#endif
#endif
#ifndef NAN
#define NAN (0.0 / 0.0)
1999-05-03 09:29:11 +02:00
#endif
static unsigned long get_field PARAMS ((const unsigned char *,
enum floatformat_byteorders,
unsigned int,
unsigned int,
unsigned int));
static int floatformat_always_valid PARAMS ((const struct floatformat *fmt,
const char *from));
static int
floatformat_always_valid (fmt, from)
2003-10-31 14:10:32 +01:00
const struct floatformat *fmt ATTRIBUTE_UNUSED;
const char *from ATTRIBUTE_UNUSED;
{
return 1;
}
1999-05-03 09:29:11 +02:00
/* 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 =
{
2000-05-31 12:55:00 +02:00
floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
floatformat_intbit_no,
"floatformat_ieee_single_big",
floatformat_always_valid
1999-05-03 09:29:11 +02:00
};
const struct floatformat floatformat_ieee_single_little =
{
2000-05-31 12:55:00 +02:00
floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
floatformat_intbit_no,
"floatformat_ieee_single_little",
floatformat_always_valid
1999-05-03 09:29:11 +02:00
};
const struct floatformat floatformat_ieee_double_big =
{
2000-05-31 12:55:00 +02:00
floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
floatformat_intbit_no,
"floatformat_ieee_double_big",
floatformat_always_valid
1999-05-03 09:29:11 +02:00
};
const struct floatformat floatformat_ieee_double_little =
{
2000-05-31 12:55:00 +02:00
floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
floatformat_intbit_no,
"floatformat_ieee_double_little",
floatformat_always_valid
1999-05-03 09:29:11 +02:00
};
/* 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 =
{
2000-05-31 12:55:00 +02:00
floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
floatformat_intbit_no,
"floatformat_ieee_double_littlebyte_bigword",
floatformat_always_valid
1999-05-03 09:29:11 +02:00
};
static int floatformat_i387_ext_is_valid PARAMS ((const struct floatformat *fmt, const char *from));
static int
floatformat_i387_ext_is_valid (fmt, from)
const struct floatformat *fmt;
const char *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;
}
1999-05-03 09:29:11 +02:00
const struct floatformat floatformat_i387_ext =
{
floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
2000-05-31 12:55:00 +02:00
floatformat_intbit_yes,
"floatformat_i387_ext",
floatformat_i387_ext_is_valid
1999-05-03 09:29:11 +02:00
};
const struct floatformat floatformat_m68881_ext =
{
/* Note that the bits from 16 to 31 are unused. */
2000-05-31 12:55:00 +02:00
floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
floatformat_intbit_yes,
"floatformat_m68881_ext",
floatformat_always_valid
1999-05-03 09:29:11 +02:00
};
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,
2000-05-31 12:55:00 +02:00
floatformat_intbit_yes,
"floatformat_i960_ext",
floatformat_always_valid
1999-05-03 09:29:11 +02:00
};
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 =
{
1999-05-03 09:29:11 +02:00
/* 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,
2000-05-31 12:55:00 +02:00
floatformat_intbit_no,
"floatformat_m88110_ext_harris",
floatformat_always_valid
1999-05-03 09:29:11 +02:00
};
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
};
1999-05-03 09:29:11 +02:00
/* Extract a field which starts at START and is LEN bits long. DATA and
1999-05-03 09:29:11 +02:00
TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
static unsigned long
get_field (data, order, total_len, start, len)
const unsigned char *data;
1999-05-03 09:29:11 +02:00
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)
1999-05-03 09:29:11 +02:00
{
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;
const char *from;
1999-05-03 09:29:11 +02:00
double *to;
{
const unsigned char *ufrom = (const unsigned char *)from;
1999-05-03 09:29:11 +02:00
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);
2003-12-03 20:03:29 +01:00
/* 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;
}
if (nan)
dto = NAN;
else
dto = INFINITY;
if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
dto = -dto;
*to = dto;
return;
}
1999-05-03 09:29:11 +02:00
mant_bits_left = fmt->man_len;
mant_off = fmt->man_start;
dto = 0.0;
special_exponent = exponent == 0 || (unsigned long) exponent == fmt->exp_nan;
1999-05-03 09:29:11 +02:00
/* 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);
2003-12-03 20:03:29 +01:00
/* 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;
1999-05-03 09:29:11 +02:00
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 bits long. DATA and
1999-05-03 09:29:11 +02:00
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)
1999-05-03 09:29:11 +02:00
{
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;
const double *from;
1999-05-03 09:29:11 +02:00
char *to;
{
double dfrom;
int exponent;
double mant;
unsigned int mant_bits, mant_off;
int mant_bits_left;
unsigned char *uto = (unsigned char *)to;
2003-12-03 20:03:29 +01:00
dfrom = *from;
1999-05-03 09:29:11 +02:00
memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
2003-12-03 20:03:29 +01:00
/* If negative, set the sign bit. */
if (dfrom < 0)
{
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
dfrom = -dfrom;
}
1999-05-03 09:29:11 +02:00
if (dfrom == 0)
2003-12-03 20:03:29 +01:00
{
/* 0.0. */
return;
}
1999-05-03 09:29:11 +02:00
if (dfrom != dfrom)
{
2003-12-03 20:03:29 +01:00
/* NaN. */
1999-05-03 09:29:11 +02:00
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
fmt->exp_len, fmt->exp_nan);
2003-12-03 20:03:29 +01:00
/* Be sure it's not infinity, but NaN value is irrelevant. */
1999-05-03 09:29:11 +02:00
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
32, 1);
return;
}
2003-12-03 20:03:29 +01:00
if (dfrom + dfrom == dfrom)
1999-05-03 09:29:11 +02:00
{
2003-12-03 20:03:29 +01:00
/* 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;
1999-05-03 09:29:11 +02:00
}
mant = frexp (dfrom, &exponent);
2003-12-03 20:03:29 +01:00
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);
}
1999-05-03 09:29:11 +02:00
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;
2003-12-03 20:03:29 +01:00
/* 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
2003-12-03 20:03:29 +01:00
&& fmt->intbit == floatformat_intbit_no
&& exponent + fmt->exp_bias - 1 > 0)
1999-05-03 09:29:11 +02:00
{
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 (fmt, from)
const struct floatformat *fmt;
const char *from;
{
return fmt->is_valid (fmt, from);
}
1999-05-03 09:29:11 +02:00
#ifdef IEEE_DEBUG
2003-12-03 20:03:29 +01:00
#include <stdio.h>
1999-05-03 09:29:11 +02:00
/* This is to be run on a host which uses IEEE floating point. */
void
ieee_test (n)
double n;
{
double result;
2003-12-03 20:03:29 +01:00
floatformat_to_double (&floatformat_ieee_double_little, (char *) &n,
&result);
if ((n != result && (! isnan (n) || ! isnan (result)))
|| (n < 0 && result >= 0)
|| (n >= 0 && result < 0))
1999-05-03 09:29:11 +02:00
printf ("Differ(to): %.20g -> %.20g\n", n, result);
2003-12-03 20:03:29 +01:00
floatformat_from_double (&floatformat_ieee_double_little, &n,
(char *) &result);
if ((n != result && (! isnan (n) || ! isnan (result)))
|| (n < 0 && result >= 0)
|| (n >= 0 && result < 0))
1999-05-03 09:29:11 +02:00
printf ("Differ(from): %.20g -> %.20g\n", n, result);
2003-12-03 20:03:29 +01:00
#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
1999-05-03 09:29:11 +02:00
#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 ()
{
2003-12-03 20:03:29 +01:00
ieee_test (0.0);
1999-05-03 09:29:11 +02:00
ieee_test (0.5);
ieee_test (256.0);
ieee_test (0.12345);
ieee_test (234235.78907234);
ieee_test (-512.0);
ieee_test (-0.004321);
2003-12-03 20:03:29 +01:00
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);
1999-05-03 09:29:11 +02:00
return 0;
}
#endif