home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / gnu / djgpp / src / binutils.2 / libibert / ieee-flo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-30  |  4.7 KB  |  149 lines
  1. /* IEEE floating point support routines, for GDB, the GNU Debugger.
  2.    Copyright (C) 1991 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "ieee-float.h"
  21. #include <math.h>        /* ldexp */
  22.  
  23. /* Convert an IEEE extended float to a double.
  24.    FROM is the address of the extended float.
  25.    Store the double in *TO.  */
  26.  
  27. void
  28. ieee_extended_to_double (ext_format, from, to)
  29.      CONST struct ext_format *ext_format;
  30.      char *from;
  31.      double *to;
  32. {
  33.   unsigned char *ufrom = (unsigned char *)from;
  34.   double dto;
  35.   unsigned long mant0, mant1, exponent;
  36.   
  37.   memcpy (&mant0, &from[MANBYTE_H], 4);
  38.   memcpy (&mant1, &from[MANBYTE_L], 4);
  39.   exponent = ((ufrom[EXPBYTE_H] & (unsigned char)~SIGNMASK) << 8) | ufrom[EXPBYTE_L];
  40.  
  41. #if 0
  42.   /* We can't do anything useful with a NaN anyway, so ignore its
  43.      difference.  It will end up as Infinity or something close.  */
  44.   if (exponent == EXT_EXP_NAN) {
  45.     /* We have a NaN source.  */
  46.     dto = 0.123456789;    /* Not much else useful to do -- we don't know if 
  47.                the host system even *has* NaNs, nor how to
  48.                generate an innocuous one if it does.  */
  49.   } else
  50. #endif
  51.          if (exponent == 0 && mant0 == 0 && mant1 == 0) {
  52.     dto = 0;
  53.   } else {
  54.     /* Build the result algebraically.  Might go infinite, underflow, etc;
  55.        who cares. */
  56.     mant0 |= 0x80000000;
  57.     dto = ldexp  ((double)mant0, exponent - EXT_EXP_BIAS - 31);
  58.     dto += ldexp ((double)mant1, exponent - EXT_EXP_BIAS - 31 - 32);
  59.     if (ufrom[EXPBYTE_H] & SIGNMASK)    /* If negative... */
  60.       dto = -dto;            /* ...negate.  */
  61.   }
  62.   *to = dto;
  63. }
  64.  
  65. /* The converse: convert the double *FROM to an extended float
  66.    and store where TO points.  */
  67.  
  68. void
  69. double_to_ieee_extended (ext_format, from, to)
  70.      CONST struct ext_format *ext_format;
  71.      double *from;
  72.      char *to;
  73. {
  74.   double dfrom = *from;
  75.   unsigned long twolongs[2];
  76.   unsigned long mant0, mant1, exponent;
  77.   unsigned char tobytes[8];
  78.  
  79.   memset (to, 0, TOTALSIZE);
  80.   if (dfrom == 0)
  81.     return;            /* Result is zero */
  82.   if (dfrom != dfrom) {
  83.     /* From is NaN */
  84.     to[EXPBYTE_H] = (unsigned char)(EXT_EXP_NAN >> 8);
  85.     to[EXPBYTE_L] = (unsigned char)EXT_EXP_NAN;
  86.     to[MANBYTE_H] = 1; /* Be sure it's not infinity, but NaN value is irrel */
  87.     return;            /* Result is NaN */
  88.   }
  89.   if (dfrom < 0)
  90.     to[SIGNBYTE] |= SIGNMASK;    /* Set negative sign */
  91.   /* How to tell an infinity from an ordinary number?  FIXME-someday */
  92.  
  93.   /* The following code assumes that the host has IEEE doubles.  FIXME-someday.
  94.      It also assumes longs are 32 bits!  FIXME-someday.  */
  95.   memcpy (twolongs, from, 8);
  96.   memcpy (tobytes, from, 8);
  97. #if HOST_BYTE_ORDER == BIG_ENDIAN
  98.   exponent = ((tobytes[1] & 0xF0) >> 4) | (tobytes[0] & 0x7F) << 4;
  99.   mant0 = (twolongs[0] << 11) | twolongs[1] >> 21;
  100.   mant1 = (twolongs[1] << 11);
  101. #else
  102.   exponent = ((tobytes[6] & 0xF0) >> 4) | (tobytes[7] & 0x7F) << 4;
  103.   mant0 = (twolongs[1] << 11) | twolongs[0] >> 21;
  104.   mant1 = (twolongs[0] << 11);
  105. #endif
  106.  
  107.   /* Fiddle with leading 1-bit, implied in double, explicit in extended. */
  108.   if (exponent == 0)
  109.     mant0 &= 0x7FFFFFFF;
  110.   else
  111.     mant0 |= 0x80000000;
  112.  
  113.   exponent -= DBL_EXP_BIAS;                /* Get integer exp */
  114.   exponent += EXT_EXP_BIAS;                /* Offset for extended */
  115.  
  116.   /* OK, now store it in extended format. */
  117.   to[EXPBYTE_H] |= (unsigned char)(exponent >> 8);    /* Retain sign */
  118.   to[EXPBYTE_L] =  (unsigned char) exponent;
  119.   
  120.   memcpy (&to[MANBYTE_H], &mant0, 4);
  121.   memcpy (&to[MANBYTE_L], &mant1, 4);
  122. }
  123.  
  124.  
  125. #ifdef IEEE_DEBUG
  126.  
  127. /* Test some numbers to see that extended/double conversion works for them.  */
  128.  
  129. ieee_test (n)
  130.      int n;
  131. {
  132.   union { double d; int i[2]; } di;
  133.   double result;
  134.   int i;
  135.   char exten[16];
  136.   extern struct ext_format ext_format_68881;
  137.  
  138.   for (i = 0; i < n; i++) {
  139.     di.i[0] = (random() << 16) | (random() & 0xffff);
  140.     di.i[1] = (random() << 16) | (random() & 0xffff);
  141.     double_to_ieee_extended (&ext_format_68881, &di.d, exten);
  142.     ieee_extended_to_double (&ext_format_68881, exten, &result);
  143.     if (di.d != result)
  144.       printf ("Differ: %x %x %g => %x %x %g\n", di.d, di.d, result, result);
  145.   }
  146. }
  147.  
  148. #endif
  149.