OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [doublest.c] - Diff between revs 827 and 840

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 827 Rev 840
/* Floating point routines for GDB, the GNU debugger.
/* Floating point routines for GDB, the GNU debugger.
 
 
   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008
   1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
 
 
   This file is part of GDB.
   This file is part of GDB.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
/* Support for converting target fp numbers into host DOUBLEST format.  */
/* Support for converting target fp numbers into host DOUBLEST format.  */
 
 
/* XXX - This code should really be in libiberty/floatformat.c,
/* XXX - This code should really be in libiberty/floatformat.c,
   however configuration issues with libiberty made this very
   however configuration issues with libiberty made this very
   difficult to do in the available time.  */
   difficult to do in the available time.  */
 
 
#include "defs.h"
#include "defs.h"
#include "doublest.h"
#include "doublest.h"
#include "floatformat.h"
#include "floatformat.h"
#include "gdb_assert.h"
#include "gdb_assert.h"
#include "gdb_string.h"
#include "gdb_string.h"
#include "gdbtypes.h"
#include "gdbtypes.h"
#include <math.h>               /* ldexp */
#include <math.h>               /* ldexp */
 
 
/* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
/* 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
   going to bother with trying to muck around with whether it is defined in
   a system header, what we do if not, etc.  */
   a system header, what we do if not, etc.  */
#define FLOATFORMAT_CHAR_BIT 8
#define FLOATFORMAT_CHAR_BIT 8
 
 
/* The number of bytes that the largest floating-point type that we
/* The number of bytes that the largest floating-point type that we
   can convert to doublest will need.  */
   can convert to doublest will need.  */
#define FLOATFORMAT_LARGEST_BYTES 16
#define FLOATFORMAT_LARGEST_BYTES 16
 
 
/* Extract a field which starts at START and is LEN bytes long.  DATA and
/* 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.  */
   TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
static unsigned long
static unsigned long
get_field (const bfd_byte *data, enum floatformat_byteorders order,
get_field (const bfd_byte *data, enum floatformat_byteorders order,
           unsigned int total_len, unsigned int start, unsigned int len)
           unsigned int total_len, unsigned int start, unsigned int len)
{
{
  unsigned long result;
  unsigned long result;
  unsigned int cur_byte;
  unsigned int cur_byte;
  int cur_bitshift;
  int cur_bitshift;
 
 
  /* Caller must byte-swap words before calling this routine.  */
  /* Caller must byte-swap words before calling this routine.  */
  gdb_assert (order == floatformat_little || order == floatformat_big);
  gdb_assert (order == floatformat_little || order == floatformat_big);
 
 
  /* Start at the least significant part of the field.  */
  /* Start at the least significant part of the field.  */
  if (order == floatformat_little)
  if (order == floatformat_little)
    {
    {
      /* We start counting from the other end (i.e, from the high bytes
      /* We start counting from the other end (i.e, from the high bytes
         rather than the low bytes).  As such, we need to be concerned
         rather than the low bytes).  As such, we need to be concerned
         with what happens if bit 0 doesn't start on a byte boundary.
         with what happens if bit 0 doesn't start on a byte boundary.
         I.e, we need to properly handle the case where total_len is
         I.e, we need to properly handle the case where total_len is
         not evenly divisible by 8.  So we compute ``excess'' which
         not evenly divisible by 8.  So we compute ``excess'' which
         represents the number of bits from the end of our starting
         represents the number of bits from the end of our starting
         byte needed to get to bit 0. */
         byte needed to get to bit 0. */
      int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
      int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
      cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
      cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
                 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
                 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
      cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
      cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
                     - FLOATFORMAT_CHAR_BIT;
                     - FLOATFORMAT_CHAR_BIT;
    }
    }
  else
  else
    {
    {
      cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
      cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
      cur_bitshift =
      cur_bitshift =
        ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
        ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
    }
    }
  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
    result = *(data + cur_byte) >> (-cur_bitshift);
    result = *(data + cur_byte) >> (-cur_bitshift);
  else
  else
    result = 0;
    result = 0;
  cur_bitshift += FLOATFORMAT_CHAR_BIT;
  cur_bitshift += FLOATFORMAT_CHAR_BIT;
  if (order == floatformat_little)
  if (order == floatformat_little)
    ++cur_byte;
    ++cur_byte;
  else
  else
    --cur_byte;
    --cur_byte;
 
 
  /* Move towards the most significant part of the field.  */
  /* Move towards the most significant part of the field.  */
  while (cur_bitshift < len)
  while (cur_bitshift < len)
    {
    {
      result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
      result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
      cur_bitshift += FLOATFORMAT_CHAR_BIT;
      cur_bitshift += FLOATFORMAT_CHAR_BIT;
      switch (order)
      switch (order)
        {
        {
        case floatformat_little:
        case floatformat_little:
          ++cur_byte;
          ++cur_byte;
          break;
          break;
        case floatformat_big:
        case floatformat_big:
          --cur_byte;
          --cur_byte;
          break;
          break;
        }
        }
    }
    }
  if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
  if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
    /* Mask out bits which are not part of the field */
    /* Mask out bits which are not part of the field */
    result &= ((1UL << len) - 1);
    result &= ((1UL << len) - 1);
  return result;
  return result;
}
}
 
 
/* Normalize the byte order of FROM into TO.  If no normalization is
/* Normalize the byte order of FROM into TO.  If no normalization is
   needed then FMT->byteorder is returned and TO is not changed;
   needed then FMT->byteorder is returned and TO is not changed;
   otherwise the format of the normalized form in TO is returned.  */
   otherwise the format of the normalized form in TO is returned.  */
 
 
static enum floatformat_byteorders
static enum floatformat_byteorders
floatformat_normalize_byteorder (const struct floatformat *fmt,
floatformat_normalize_byteorder (const struct floatformat *fmt,
                                 const void *from, void *to)
                                 const void *from, void *to)
{
{
  const unsigned char *swapin;
  const unsigned char *swapin;
  unsigned char *swapout;
  unsigned char *swapout;
  int words;
  int words;
 
 
  if (fmt->byteorder == floatformat_little
  if (fmt->byteorder == floatformat_little
      || fmt->byteorder == floatformat_big)
      || fmt->byteorder == floatformat_big)
    return fmt->byteorder;
    return fmt->byteorder;
 
 
  words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
  words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
  words >>= 2;
  words >>= 2;
 
 
  swapout = (unsigned char *)to;
  swapout = (unsigned char *)to;
  swapin = (const unsigned char *)from;
  swapin = (const unsigned char *)from;
 
 
  if (fmt->byteorder == floatformat_vax)
  if (fmt->byteorder == floatformat_vax)
    {
    {
      while (words-- > 0)
      while (words-- > 0)
        {
        {
          *swapout++ = swapin[1];
          *swapout++ = swapin[1];
          *swapout++ = swapin[0];
          *swapout++ = swapin[0];
          *swapout++ = swapin[3];
          *swapout++ = swapin[3];
          *swapout++ = swapin[2];
          *swapout++ = swapin[2];
          swapin += 4;
          swapin += 4;
        }
        }
      /* This may look weird, since VAX is little-endian, but it is
      /* This may look weird, since VAX is little-endian, but it is
         easier to translate to big-endian than to little-endian.  */
         easier to translate to big-endian than to little-endian.  */
      return floatformat_big;
      return floatformat_big;
    }
    }
  else
  else
    {
    {
      gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
      gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
 
 
      while (words-- > 0)
      while (words-- > 0)
        {
        {
          *swapout++ = swapin[3];
          *swapout++ = swapin[3];
          *swapout++ = swapin[2];
          *swapout++ = swapin[2];
          *swapout++ = swapin[1];
          *swapout++ = swapin[1];
          *swapout++ = swapin[0];
          *swapout++ = swapin[0];
          swapin += 4;
          swapin += 4;
        }
        }
      return floatformat_big;
      return floatformat_big;
    }
    }
}
}
 
 
/* Convert from FMT to a DOUBLEST.
/* Convert from FMT to a DOUBLEST.
   FROM is the address of the extended float.
   FROM is the address of the extended float.
   Store the DOUBLEST in *TO.  */
   Store the DOUBLEST in *TO.  */
 
 
static void
static void
convert_floatformat_to_doublest (const struct floatformat *fmt,
convert_floatformat_to_doublest (const struct floatformat *fmt,
                                 const void *from,
                                 const void *from,
                                 DOUBLEST *to)
                                 DOUBLEST *to)
{
{
  unsigned char *ufrom = (unsigned char *) from;
  unsigned char *ufrom = (unsigned char *) from;
  DOUBLEST dto;
  DOUBLEST dto;
  long exponent;
  long exponent;
  unsigned long mant;
  unsigned long mant;
  unsigned int mant_bits, mant_off;
  unsigned int mant_bits, mant_off;
  int mant_bits_left;
  int mant_bits_left;
  int special_exponent;         /* It's a NaN, denorm or zero */
  int special_exponent;         /* It's a NaN, denorm or zero */
  enum floatformat_byteorders order;
  enum floatformat_byteorders order;
  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
  enum float_kind kind;
  enum float_kind kind;
 
 
  gdb_assert (fmt->totalsize
  gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 
 
  /* For non-numbers, reuse libiberty's logic to find the correct
  /* For non-numbers, reuse libiberty's logic to find the correct
     format.  We do not lose any precision in this case by passing
     format.  We do not lose any precision in this case by passing
     through a double.  */
     through a double.  */
  kind = floatformat_classify (fmt, from);
  kind = floatformat_classify (fmt, from);
  if (kind == float_infinite || kind == float_nan)
  if (kind == float_infinite || kind == float_nan)
    {
    {
      double dto;
      double dto;
      floatformat_to_double (fmt, from, &dto);
      floatformat_to_double (fmt, from, &dto);
      *to = (DOUBLEST) dto;
      *to = (DOUBLEST) dto;
      return;
      return;
    }
    }
 
 
  order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
  order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
 
 
  if (order != fmt->byteorder)
  if (order != fmt->byteorder)
    ufrom = newfrom;
    ufrom = newfrom;
 
 
  if (fmt->split_half)
  if (fmt->split_half)
    {
    {
      DOUBLEST dtop, dbot;
      DOUBLEST dtop, dbot;
      floatformat_to_doublest (fmt->split_half, ufrom, &dtop);
      floatformat_to_doublest (fmt->split_half, ufrom, &dtop);
      /* Preserve the sign of 0, which is the sign of the top
      /* Preserve the sign of 0, which is the sign of the top
         half.  */
         half.  */
      if (dtop == 0.0)
      if (dtop == 0.0)
        {
        {
          *to = dtop;
          *to = dtop;
          return;
          return;
        }
        }
      floatformat_to_doublest (fmt->split_half,
      floatformat_to_doublest (fmt->split_half,
                             ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
                             ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
                             &dbot);
                             &dbot);
      *to = dtop + dbot;
      *to = dtop + dbot;
      return;
      return;
    }
    }
 
 
  exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
  exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
                        fmt->exp_len);
                        fmt->exp_len);
  /* Note that if exponent indicates a NaN, we can't really do anything useful
  /* 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
     (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.  */
     end up as an infinity or something close; that is OK.  */
 
 
  mant_bits_left = fmt->man_len;
  mant_bits_left = fmt->man_len;
  mant_off = fmt->man_start;
  mant_off = fmt->man_start;
  dto = 0.0;
  dto = 0.0;
 
 
  special_exponent = exponent == 0 || exponent == fmt->exp_nan;
  special_exponent = exponent == 0 || exponent == fmt->exp_nan;
 
 
  /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
  /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
     we don't check for zero as the exponent doesn't matter.  Note the cast
     we don't check for zero as the exponent doesn't matter.  Note the cast
     to int; exp_bias is unsigned, so it's important to make sure the
     to int; exp_bias is unsigned, so it's important to make sure the
     operation is done in signed arithmetic.  */
     operation is done in signed arithmetic.  */
  if (!special_exponent)
  if (!special_exponent)
    exponent -= fmt->exp_bias;
    exponent -= fmt->exp_bias;
  else if (exponent == 0)
  else if (exponent == 0)
    exponent = 1 - fmt->exp_bias;
    exponent = 1 - fmt->exp_bias;
 
 
  /* Build the result algebraically.  Might go infinite, underflow, etc;
  /* Build the result algebraically.  Might go infinite, underflow, etc;
     who cares. */
     who cares. */
 
 
/* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
/* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
   increment the exponent by one to account for the integer bit.  */
   increment the exponent by one to account for the integer bit.  */
 
 
  if (!special_exponent)
  if (!special_exponent)
    {
    {
      if (fmt->intbit == floatformat_intbit_no)
      if (fmt->intbit == floatformat_intbit_no)
        dto = ldexp (1.0, exponent);
        dto = ldexp (1.0, exponent);
      else
      else
        exponent++;
        exponent++;
    }
    }
 
 
  while (mant_bits_left > 0)
  while (mant_bits_left > 0)
    {
    {
      mant_bits = min (mant_bits_left, 32);
      mant_bits = min (mant_bits_left, 32);
 
 
      mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);
      mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);
 
 
      dto += ldexp ((double) mant, exponent - mant_bits);
      dto += ldexp ((double) mant, exponent - mant_bits);
      exponent -= mant_bits;
      exponent -= mant_bits;
      mant_off += mant_bits;
      mant_off += mant_bits;
      mant_bits_left -= mant_bits;
      mant_bits_left -= mant_bits;
    }
    }
 
 
  /* Negate it if negative.  */
  /* Negate it if negative.  */
  if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))
  if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))
    dto = -dto;
    dto = -dto;
  *to = dto;
  *to = dto;
}
}


static void put_field (unsigned char *, enum floatformat_byteorders,
static void put_field (unsigned char *, enum floatformat_byteorders,
                       unsigned int,
                       unsigned int,
                       unsigned int, unsigned int, unsigned long);
                       unsigned int, unsigned int, unsigned long);
 
 
/* Set a field which starts at START and is LEN bytes long.  DATA and
/* 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.  */
   TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
static void
static void
put_field (unsigned char *data, enum floatformat_byteorders order,
put_field (unsigned char *data, enum floatformat_byteorders order,
           unsigned int total_len, unsigned int start, unsigned int len,
           unsigned int total_len, unsigned int start, unsigned int len,
           unsigned long stuff_to_put)
           unsigned long stuff_to_put)
{
{
  unsigned int cur_byte;
  unsigned int cur_byte;
  int cur_bitshift;
  int cur_bitshift;
 
 
  /* Caller must byte-swap words before calling this routine.  */
  /* Caller must byte-swap words before calling this routine.  */
  gdb_assert (order == floatformat_little || order == floatformat_big);
  gdb_assert (order == floatformat_little || order == floatformat_big);
 
 
  /* Start at the least significant part of the field.  */
  /* Start at the least significant part of the field.  */
  if (order == floatformat_little)
  if (order == floatformat_little)
    {
    {
      int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
      int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
      cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
      cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
                 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
                 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
      cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
      cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
                     - FLOATFORMAT_CHAR_BIT;
                     - FLOATFORMAT_CHAR_BIT;
    }
    }
  else
  else
    {
    {
      cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
      cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
      cur_bitshift =
      cur_bitshift =
        ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
        ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
    }
    }
  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
    {
    {
      *(data + cur_byte) &=
      *(data + cur_byte) &=
        ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
        ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
          << (-cur_bitshift));
          << (-cur_bitshift));
      *(data + cur_byte) |=
      *(data + cur_byte) |=
        (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
        (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
    }
    }
  cur_bitshift += FLOATFORMAT_CHAR_BIT;
  cur_bitshift += FLOATFORMAT_CHAR_BIT;
  if (order == floatformat_little)
  if (order == floatformat_little)
    ++cur_byte;
    ++cur_byte;
  else
  else
    --cur_byte;
    --cur_byte;
 
 
  /* Move towards the most significant part of the field.  */
  /* Move towards the most significant part of the field.  */
  while (cur_bitshift < len)
  while (cur_bitshift < len)
    {
    {
      if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
      if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
        {
        {
          /* This is the last byte.  */
          /* This is the last byte.  */
          *(data + cur_byte) &=
          *(data + cur_byte) &=
            ~((1 << (len - cur_bitshift)) - 1);
            ~((1 << (len - cur_bitshift)) - 1);
          *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
          *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
        }
        }
      else
      else
        *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
        *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
                              & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
                              & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
      cur_bitshift += FLOATFORMAT_CHAR_BIT;
      cur_bitshift += FLOATFORMAT_CHAR_BIT;
      if (order == floatformat_little)
      if (order == floatformat_little)
        ++cur_byte;
        ++cur_byte;
      else
      else
        --cur_byte;
        --cur_byte;
    }
    }
}
}
 
 
#ifdef HAVE_LONG_DOUBLE
#ifdef HAVE_LONG_DOUBLE
/* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
/* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
   The range of the returned value is >= 0.5 and < 1.0.  This is equivalent to
   The range of the returned value is >= 0.5 and < 1.0.  This is equivalent to
   frexp, but operates on the long double data type.  */
   frexp, but operates on the long double data type.  */
 
 
static long double ldfrexp (long double value, int *eptr);
static long double ldfrexp (long double value, int *eptr);
 
 
static long double
static long double
ldfrexp (long double value, int *eptr)
ldfrexp (long double value, int *eptr)
{
{
  long double tmp;
  long double tmp;
  int exp;
  int exp;
 
 
  /* Unfortunately, there are no portable functions for extracting the exponent
  /* Unfortunately, there are no portable functions for extracting the exponent
     of a long double, so we have to do it iteratively by multiplying or dividing
     of a long double, so we have to do it iteratively by multiplying or dividing
     by two until the fraction is between 0.5 and 1.0.  */
     by two until the fraction is between 0.5 and 1.0.  */
 
 
  if (value < 0.0l)
  if (value < 0.0l)
    value = -value;
    value = -value;
 
 
  tmp = 1.0l;
  tmp = 1.0l;
  exp = 0;
  exp = 0;
 
 
  if (value >= tmp)             /* Value >= 1.0 */
  if (value >= tmp)             /* Value >= 1.0 */
    while (value >= tmp)
    while (value >= tmp)
      {
      {
        tmp *= 2.0l;
        tmp *= 2.0l;
        exp++;
        exp++;
      }
      }
  else if (value != 0.0l)       /* Value < 1.0  and > 0.0 */
  else if (value != 0.0l)       /* Value < 1.0  and > 0.0 */
    {
    {
      while (value < tmp)
      while (value < tmp)
        {
        {
          tmp /= 2.0l;
          tmp /= 2.0l;
          exp--;
          exp--;
        }
        }
      tmp *= 2.0l;
      tmp *= 2.0l;
      exp++;
      exp++;
    }
    }
 
 
  *eptr = exp;
  *eptr = exp;
  return value / tmp;
  return value / tmp;
}
}
#endif /* HAVE_LONG_DOUBLE */
#endif /* HAVE_LONG_DOUBLE */
 
 
 
 
/* The converse: convert the DOUBLEST *FROM to an extended float and
/* The converse: convert the DOUBLEST *FROM to an extended float and
   store where TO points.  Neither FROM nor TO have any alignment
   store where TO points.  Neither FROM nor TO have any alignment
   restrictions.  */
   restrictions.  */
 
 
static void
static void
convert_doublest_to_floatformat (CONST struct floatformat *fmt,
convert_doublest_to_floatformat (CONST struct floatformat *fmt,
                                 const DOUBLEST *from, void *to)
                                 const DOUBLEST *from, void *to)
{
{
  DOUBLEST dfrom;
  DOUBLEST dfrom;
  int exponent;
  int exponent;
  DOUBLEST mant;
  DOUBLEST mant;
  unsigned int mant_bits, mant_off;
  unsigned int mant_bits, mant_off;
  int mant_bits_left;
  int mant_bits_left;
  unsigned char *uto = (unsigned char *) to;
  unsigned char *uto = (unsigned char *) to;
  enum floatformat_byteorders order = fmt->byteorder;
  enum floatformat_byteorders order = fmt->byteorder;
  unsigned char newto[FLOATFORMAT_LARGEST_BYTES];
  unsigned char newto[FLOATFORMAT_LARGEST_BYTES];
 
 
  if (order != floatformat_little)
  if (order != floatformat_little)
    order = floatformat_big;
    order = floatformat_big;
 
 
  if (order != fmt->byteorder)
  if (order != fmt->byteorder)
    uto = newto;
    uto = newto;
 
 
  memcpy (&dfrom, from, sizeof (dfrom));
  memcpy (&dfrom, from, sizeof (dfrom));
  memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
  memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
                    / FLOATFORMAT_CHAR_BIT);
                    / FLOATFORMAT_CHAR_BIT);
 
 
  if (fmt->split_half)
  if (fmt->split_half)
    {
    {
      /* Use static volatile to ensure that any excess precision is
      /* Use static volatile to ensure that any excess precision is
         removed via storing in memory, and so the top half really is
         removed via storing in memory, and so the top half really is
         the result of converting to double.  */
         the result of converting to double.  */
      static volatile double dtop, dbot;
      static volatile double dtop, dbot;
      DOUBLEST dtopnv, dbotnv;
      DOUBLEST dtopnv, dbotnv;
      dtop = (double) dfrom;
      dtop = (double) dfrom;
      /* If the rounded top half is Inf, the bottom must be 0 not NaN
      /* If the rounded top half is Inf, the bottom must be 0 not NaN
         or Inf.  */
         or Inf.  */
      if (dtop + dtop == dtop && dtop != 0.0)
      if (dtop + dtop == dtop && dtop != 0.0)
        dbot = 0.0;
        dbot = 0.0;
      else
      else
        dbot = (double) (dfrom - (DOUBLEST) dtop);
        dbot = (double) (dfrom - (DOUBLEST) dtop);
      dtopnv = dtop;
      dtopnv = dtop;
      dbotnv = dbot;
      dbotnv = dbot;
      floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
      floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
      floatformat_from_doublest (fmt->split_half, &dbotnv,
      floatformat_from_doublest (fmt->split_half, &dbotnv,
                               (uto
                               (uto
                                + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
                                + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
      return;
      return;
    }
    }
 
 
  if (dfrom == 0)
  if (dfrom == 0)
    return;                     /* Result is zero */
    return;                     /* Result is zero */
  if (dfrom != dfrom)           /* Result is NaN */
  if (dfrom != dfrom)           /* Result is NaN */
    {
    {
      /* From is NaN */
      /* From is NaN */
      put_field (uto, order, fmt->totalsize, fmt->exp_start,
      put_field (uto, order, fmt->totalsize, fmt->exp_start,
                 fmt->exp_len, fmt->exp_nan);
                 fmt->exp_len, fmt->exp_nan);
      /* Be sure it's not infinity, but NaN value is irrel */
      /* Be sure it's not infinity, but NaN value is irrel */
      put_field (uto, order, fmt->totalsize, fmt->man_start,
      put_field (uto, order, fmt->totalsize, fmt->man_start,
                 32, 1);
                 32, 1);
      goto finalize_byteorder;
      goto finalize_byteorder;
    }
    }
 
 
  /* If negative, set the sign bit.  */
  /* If negative, set the sign bit.  */
  if (dfrom < 0)
  if (dfrom < 0)
    {
    {
      put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
      put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
      dfrom = -dfrom;
      dfrom = -dfrom;
    }
    }
 
 
  if (dfrom + dfrom == dfrom && dfrom != 0.0)   /* Result is Infinity */
  if (dfrom + dfrom == dfrom && dfrom != 0.0)   /* Result is Infinity */
    {
    {
      /* Infinity exponent is same as NaN's.  */
      /* Infinity exponent is same as NaN's.  */
      put_field (uto, order, fmt->totalsize, fmt->exp_start,
      put_field (uto, order, fmt->totalsize, fmt->exp_start,
                 fmt->exp_len, fmt->exp_nan);
                 fmt->exp_len, fmt->exp_nan);
      /* Infinity mantissa is all zeroes.  */
      /* Infinity mantissa is all zeroes.  */
      put_field (uto, order, fmt->totalsize, fmt->man_start,
      put_field (uto, order, fmt->totalsize, fmt->man_start,
                 fmt->man_len, 0);
                 fmt->man_len, 0);
      goto finalize_byteorder;
      goto finalize_byteorder;
    }
    }
 
 
#ifdef HAVE_LONG_DOUBLE
#ifdef HAVE_LONG_DOUBLE
  mant = ldfrexp (dfrom, &exponent);
  mant = ldfrexp (dfrom, &exponent);
#else
#else
  mant = frexp (dfrom, &exponent);
  mant = frexp (dfrom, &exponent);
#endif
#endif
 
 
  put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
  put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
             exponent + fmt->exp_bias - 1);
             exponent + fmt->exp_bias - 1);
 
 
  mant_bits_left = fmt->man_len;
  mant_bits_left = fmt->man_len;
  mant_off = fmt->man_start;
  mant_off = fmt->man_start;
  while (mant_bits_left > 0)
  while (mant_bits_left > 0)
    {
    {
      unsigned long mant_long;
      unsigned long mant_long;
      mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
      mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
 
 
      mant *= 4294967296.0;
      mant *= 4294967296.0;
      mant_long = ((unsigned long) mant) & 0xffffffffL;
      mant_long = ((unsigned long) mant) & 0xffffffffL;
      mant -= mant_long;
      mant -= mant_long;
 
 
      /* If the integer bit is implicit, then we need to discard it.
      /* 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
         If we are discarding a zero, we should be (but are not) creating
         a denormalized number which means adjusting the exponent
         a denormalized number which means adjusting the exponent
         (I think).  */
         (I think).  */
      if (mant_bits_left == fmt->man_len
      if (mant_bits_left == fmt->man_len
          && fmt->intbit == floatformat_intbit_no)
          && fmt->intbit == floatformat_intbit_no)
        {
        {
          mant_long <<= 1;
          mant_long <<= 1;
          mant_long &= 0xffffffffL;
          mant_long &= 0xffffffffL;
          /* If we are processing the top 32 mantissa bits of a doublest
          /* If we are processing the top 32 mantissa bits of a doublest
             so as to convert to a float value with implied integer bit,
             so as to convert to a float value with implied integer bit,
             we will only be putting 31 of those 32 bits into the
             we will only be putting 31 of those 32 bits into the
             final value due to the discarding of the top bit.  In the
             final value due to the discarding of the top bit.  In the
             case of a small float value where the number of mantissa
             case of a small float value where the number of mantissa
             bits is less than 32, discarding the top bit does not alter
             bits is less than 32, discarding the top bit does not alter
             the number of bits we will be adding to the result.  */
             the number of bits we will be adding to the result.  */
          if (mant_bits == 32)
          if (mant_bits == 32)
            mant_bits -= 1;
            mant_bits -= 1;
        }
        }
 
 
      if (mant_bits < 32)
      if (mant_bits < 32)
        {
        {
          /* The bits we want are in the most significant MANT_BITS bits of
          /* The bits we want are in the most significant MANT_BITS bits of
             mant_long.  Move them to the least significant.  */
             mant_long.  Move them to the least significant.  */
          mant_long >>= 32 - mant_bits;
          mant_long >>= 32 - mant_bits;
        }
        }
 
 
      put_field (uto, order, fmt->totalsize,
      put_field (uto, order, fmt->totalsize,
                 mant_off, mant_bits, mant_long);
                 mant_off, mant_bits, mant_long);
      mant_off += mant_bits;
      mant_off += mant_bits;
      mant_bits_left -= mant_bits;
      mant_bits_left -= mant_bits;
    }
    }
 
 
 finalize_byteorder:
 finalize_byteorder:
  /* Do we need to byte-swap the words in the result?  */
  /* Do we need to byte-swap the words in the result?  */
  if (order != fmt->byteorder)
  if (order != fmt->byteorder)
    floatformat_normalize_byteorder (fmt, newto, to);
    floatformat_normalize_byteorder (fmt, newto, to);
}
}
 
 
/* Check if VAL (which is assumed to be a floating point number whose
/* Check if VAL (which is assumed to be a floating point number whose
   format is described by FMT) is negative.  */
   format is described by FMT) is negative.  */
 
 
int
int
floatformat_is_negative (const struct floatformat *fmt,
floatformat_is_negative (const struct floatformat *fmt,
                         const bfd_byte *uval)
                         const bfd_byte *uval)
{
{
  enum floatformat_byteorders order;
  enum floatformat_byteorders order;
  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
 
 
  gdb_assert (fmt != NULL);
  gdb_assert (fmt != NULL);
  gdb_assert (fmt->totalsize
  gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 
 
  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
 
  if (order != fmt->byteorder)
  if (order != fmt->byteorder)
    uval = newfrom;
    uval = newfrom;
 
 
  return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
  return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
}
}
 
 
/* Check if VAL is "not a number" (NaN) for FMT.  */
/* Check if VAL is "not a number" (NaN) for FMT.  */
 
 
enum float_kind
enum float_kind
floatformat_classify (const struct floatformat *fmt,
floatformat_classify (const struct floatformat *fmt,
                      const bfd_byte *uval)
                      const bfd_byte *uval)
{
{
  long exponent;
  long exponent;
  unsigned long mant;
  unsigned long mant;
  unsigned int mant_bits, mant_off;
  unsigned int mant_bits, mant_off;
  int mant_bits_left;
  int mant_bits_left;
  enum floatformat_byteorders order;
  enum floatformat_byteorders order;
  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
  int mant_zero;
  int mant_zero;
 
 
  gdb_assert (fmt != NULL);
  gdb_assert (fmt != NULL);
  gdb_assert (fmt->totalsize
  gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 
 
  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
 
  if (order != fmt->byteorder)
  if (order != fmt->byteorder)
    uval = newfrom;
    uval = newfrom;
 
 
  exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
  exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
                        fmt->exp_len);
                        fmt->exp_len);
 
 
  mant_bits_left = fmt->man_len;
  mant_bits_left = fmt->man_len;
  mant_off = fmt->man_start;
  mant_off = fmt->man_start;
 
 
  mant_zero = 1;
  mant_zero = 1;
  while (mant_bits_left > 0)
  while (mant_bits_left > 0)
    {
    {
      mant_bits = min (mant_bits_left, 32);
      mant_bits = min (mant_bits_left, 32);
 
 
      mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
      mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
 
 
      /* If there is an explicit integer bit, mask it off.  */
      /* If there is an explicit integer bit, mask it off.  */
      if (mant_off == fmt->man_start
      if (mant_off == fmt->man_start
          && fmt->intbit == floatformat_intbit_yes)
          && fmt->intbit == floatformat_intbit_yes)
        mant &= ~(1 << (mant_bits - 1));
        mant &= ~(1 << (mant_bits - 1));
 
 
      if (mant)
      if (mant)
        {
        {
          mant_zero = 0;
          mant_zero = 0;
          break;
          break;
        }
        }
 
 
      mant_off += mant_bits;
      mant_off += mant_bits;
      mant_bits_left -= mant_bits;
      mant_bits_left -= mant_bits;
    }
    }
 
 
  /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
  /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
     supported.  */
     supported.  */
  if (! fmt->exp_nan)
  if (! fmt->exp_nan)
    {
    {
      if (mant_zero)
      if (mant_zero)
        return float_zero;
        return float_zero;
      else
      else
        return float_normal;
        return float_normal;
    }
    }
 
 
  if (exponent == 0 && !mant_zero)
  if (exponent == 0 && !mant_zero)
    return float_subnormal;
    return float_subnormal;
 
 
  if (exponent == fmt->exp_nan)
  if (exponent == fmt->exp_nan)
    {
    {
      if (mant_zero)
      if (mant_zero)
        return float_infinite;
        return float_infinite;
      else
      else
        return float_nan;
        return float_nan;
    }
    }
 
 
  if (mant_zero)
  if (mant_zero)
    return float_zero;
    return float_zero;
 
 
  return float_normal;
  return float_normal;
}
}
 
 
/* Convert the mantissa of VAL (which is assumed to be a floating
/* Convert the mantissa of VAL (which is assumed to be a floating
   point number whose format is described by FMT) into a hexadecimal
   point number whose format is described by FMT) into a hexadecimal
   and store it in a static string.  Return a pointer to that string.  */
   and store it in a static string.  Return a pointer to that string.  */
 
 
const char *
const char *
floatformat_mantissa (const struct floatformat *fmt,
floatformat_mantissa (const struct floatformat *fmt,
                      const bfd_byte *val)
                      const bfd_byte *val)
{
{
  unsigned char *uval = (unsigned char *) val;
  unsigned char *uval = (unsigned char *) val;
  unsigned long mant;
  unsigned long mant;
  unsigned int mant_bits, mant_off;
  unsigned int mant_bits, mant_off;
  int mant_bits_left;
  int mant_bits_left;
  static char res[50];
  static char res[50];
  char buf[9];
  char buf[9];
  int len;
  int len;
  enum floatformat_byteorders order;
  enum floatformat_byteorders order;
  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
 
 
  gdb_assert (fmt != NULL);
  gdb_assert (fmt != NULL);
  gdb_assert (fmt->totalsize
  gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 
 
  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
 
  if (order != fmt->byteorder)
  if (order != fmt->byteorder)
    uval = newfrom;
    uval = newfrom;
 
 
  if (! fmt->exp_nan)
  if (! fmt->exp_nan)
    return 0;
    return 0;
 
 
  /* Make sure we have enough room to store the mantissa.  */
  /* Make sure we have enough room to store the mantissa.  */
  gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
  gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
 
 
  mant_off = fmt->man_start;
  mant_off = fmt->man_start;
  mant_bits_left = fmt->man_len;
  mant_bits_left = fmt->man_len;
  mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
  mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
 
 
  mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
  mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
 
 
  len = xsnprintf (res, sizeof res, "%lx", mant);
  len = xsnprintf (res, sizeof res, "%lx", mant);
 
 
  mant_off += mant_bits;
  mant_off += mant_bits;
  mant_bits_left -= mant_bits;
  mant_bits_left -= mant_bits;
 
 
  while (mant_bits_left > 0)
  while (mant_bits_left > 0)
    {
    {
      mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
      mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
 
 
      xsnprintf (buf, sizeof buf, "%08lx", mant);
      xsnprintf (buf, sizeof buf, "%08lx", mant);
      gdb_assert (len + strlen (buf) <= sizeof res);
      gdb_assert (len + strlen (buf) <= sizeof res);
      strcat (res, buf);
      strcat (res, buf);
 
 
      mant_off += 32;
      mant_off += 32;
      mant_bits_left -= 32;
      mant_bits_left -= 32;
    }
    }
 
 
  return res;
  return res;
}
}
 
 


/* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
/* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
 
 
   If the host and target formats agree, we just copy the raw data
   If the host and target formats agree, we just copy the raw data
   into the appropriate type of variable and return, letting the host
   into the appropriate type of variable and return, letting the host
   increase precision as necessary.  Otherwise, we call the conversion
   increase precision as necessary.  Otherwise, we call the conversion
   routine and let it do the dirty work.  */
   routine and let it do the dirty work.  */
 
 
static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
static const struct floatformat *host_long_double_format = GDB_HOST_LONG_DOUBLE_FORMAT;
static const struct floatformat *host_long_double_format = GDB_HOST_LONG_DOUBLE_FORMAT;
 
 
void
void
floatformat_to_doublest (const struct floatformat *fmt,
floatformat_to_doublest (const struct floatformat *fmt,
                         const void *in, DOUBLEST *out)
                         const void *in, DOUBLEST *out)
{
{
  gdb_assert (fmt != NULL);
  gdb_assert (fmt != NULL);
  if (fmt == host_float_format)
  if (fmt == host_float_format)
    {
    {
      float val;
      float val;
      memcpy (&val, in, sizeof (val));
      memcpy (&val, in, sizeof (val));
      *out = val;
      *out = val;
    }
    }
  else if (fmt == host_double_format)
  else if (fmt == host_double_format)
    {
    {
      double val;
      double val;
      memcpy (&val, in, sizeof (val));
      memcpy (&val, in, sizeof (val));
      *out = val;
      *out = val;
    }
    }
  else if (fmt == host_long_double_format)
  else if (fmt == host_long_double_format)
    {
    {
      long double val;
      long double val;
      memcpy (&val, in, sizeof (val));
      memcpy (&val, in, sizeof (val));
      *out = val;
      *out = val;
    }
    }
  else
  else
    convert_floatformat_to_doublest (fmt, in, out);
    convert_floatformat_to_doublest (fmt, in, out);
}
}
 
 
void
void
floatformat_from_doublest (const struct floatformat *fmt,
floatformat_from_doublest (const struct floatformat *fmt,
                           const DOUBLEST *in, void *out)
                           const DOUBLEST *in, void *out)
{
{
  gdb_assert (fmt != NULL);
  gdb_assert (fmt != NULL);
  if (fmt == host_float_format)
  if (fmt == host_float_format)
    {
    {
      float val = *in;
      float val = *in;
      memcpy (out, &val, sizeof (val));
      memcpy (out, &val, sizeof (val));
    }
    }
  else if (fmt == host_double_format)
  else if (fmt == host_double_format)
    {
    {
      double val = *in;
      double val = *in;
      memcpy (out, &val, sizeof (val));
      memcpy (out, &val, sizeof (val));
    }
    }
  else if (fmt == host_long_double_format)
  else if (fmt == host_long_double_format)
    {
    {
      long double val = *in;
      long double val = *in;
      memcpy (out, &val, sizeof (val));
      memcpy (out, &val, sizeof (val));
    }
    }
  else
  else
    convert_doublest_to_floatformat (fmt, in, out);
    convert_doublest_to_floatformat (fmt, in, out);
}
}
 
 


/* Return a floating-point format for a floating-point variable of
/* Return a floating-point format for a floating-point variable of
   length LEN.  If no suitable floating-point format is found, an
   length LEN.  If no suitable floating-point format is found, an
   error is thrown.
   error is thrown.
 
 
   We need this functionality since information about the
   We need this functionality since information about the
   floating-point format of a type is not always available to GDB; the
   floating-point format of a type is not always available to GDB; the
   debug information typically only tells us the size of a
   debug information typically only tells us the size of a
   floating-point type.
   floating-point type.
 
 
   FIXME: kettenis/2001-10-28: In many places, particularly in
   FIXME: kettenis/2001-10-28: In many places, particularly in
   target-dependent code, the format of floating-point types is known,
   target-dependent code, the format of floating-point types is known,
   but not passed on by GDB.  This should be fixed.  */
   but not passed on by GDB.  This should be fixed.  */
 
 
static const struct floatformat *
static const struct floatformat *
floatformat_from_length (int len)
floatformat_from_length (int len)
{
{
  const struct floatformat *format;
  const struct floatformat *format;
  if (len * TARGET_CHAR_BIT == gdbarch_float_bit (current_gdbarch))
  if (len * TARGET_CHAR_BIT == gdbarch_float_bit (current_gdbarch))
    format = gdbarch_float_format (current_gdbarch)
    format = gdbarch_float_format (current_gdbarch)
               [gdbarch_byte_order (current_gdbarch)];
               [gdbarch_byte_order (current_gdbarch)];
  else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (current_gdbarch))
  else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (current_gdbarch))
    format = gdbarch_double_format (current_gdbarch)
    format = gdbarch_double_format (current_gdbarch)
               [gdbarch_byte_order (current_gdbarch)];
               [gdbarch_byte_order (current_gdbarch)];
  else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (current_gdbarch))
  else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (current_gdbarch))
    format = gdbarch_long_double_format (current_gdbarch)
    format = gdbarch_long_double_format (current_gdbarch)
               [gdbarch_byte_order (current_gdbarch)];
               [gdbarch_byte_order (current_gdbarch)];
  /* On i386 the 'long double' type takes 96 bits,
  /* On i386 the 'long double' type takes 96 bits,
     while the real number of used bits is only 80,
     while the real number of used bits is only 80,
     both in processor and in memory.
     both in processor and in memory.
     The code below accepts the real bit size.  */
     The code below accepts the real bit size.  */
  else if ((gdbarch_long_double_format (current_gdbarch) != NULL)
  else if ((gdbarch_long_double_format (current_gdbarch) != NULL)
           && (len * TARGET_CHAR_BIT ==
           && (len * TARGET_CHAR_BIT ==
               gdbarch_long_double_format (current_gdbarch)[0]->totalsize))
               gdbarch_long_double_format (current_gdbarch)[0]->totalsize))
    format = gdbarch_long_double_format (current_gdbarch)
    format = gdbarch_long_double_format (current_gdbarch)
               [gdbarch_byte_order (current_gdbarch)];
               [gdbarch_byte_order (current_gdbarch)];
  else
  else
    format = NULL;
    format = NULL;
  if (format == NULL)
  if (format == NULL)
    error (_("Unrecognized %d-bit floating-point type."),
    error (_("Unrecognized %d-bit floating-point type."),
           len * TARGET_CHAR_BIT);
           len * TARGET_CHAR_BIT);
  return format;
  return format;
}
}
 
 
const struct floatformat *
const struct floatformat *
floatformat_from_type (const struct type *type)
floatformat_from_type (const struct type *type)
{
{
  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
  if (TYPE_FLOATFORMAT (type) != NULL)
  if (TYPE_FLOATFORMAT (type) != NULL)
    return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)];
    return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)];
  else
  else
    return floatformat_from_length (TYPE_LENGTH (type));
    return floatformat_from_length (TYPE_LENGTH (type));
}
}
 
 
/* If the host doesn't define NAN, use zero instead.  */
/* If the host doesn't define NAN, use zero instead.  */
#ifndef NAN
#ifndef NAN
#define NAN 0.0
#define NAN 0.0
#endif
#endif
 
 
/* Extract a floating-point number of length LEN from a target-order
/* Extract a floating-point number of length LEN from a target-order
   byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
   byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
 
 
static DOUBLEST
static DOUBLEST
extract_floating_by_length (const void *addr, int len)
extract_floating_by_length (const void *addr, int len)
{
{
  const struct floatformat *fmt = floatformat_from_length (len);
  const struct floatformat *fmt = floatformat_from_length (len);
  DOUBLEST val;
  DOUBLEST val;
 
 
  floatformat_to_doublest (fmt, addr, &val);
  floatformat_to_doublest (fmt, addr, &val);
  return val;
  return val;
}
}
 
 
DOUBLEST
DOUBLEST
deprecated_extract_floating (const void *addr, int len)
deprecated_extract_floating (const void *addr, int len)
{
{
  return extract_floating_by_length (addr, len);
  return extract_floating_by_length (addr, len);
}
}
 
 
/* Store VAL as a floating-point number of length LEN to a
/* Store VAL as a floating-point number of length LEN to a
   target-order byte-stream at ADDR.  */
   target-order byte-stream at ADDR.  */
 
 
static void
static void
store_floating_by_length (void *addr, int len, DOUBLEST val)
store_floating_by_length (void *addr, int len, DOUBLEST val)
{
{
  const struct floatformat *fmt = floatformat_from_length (len);
  const struct floatformat *fmt = floatformat_from_length (len);
 
 
  floatformat_from_doublest (fmt, &val, addr);
  floatformat_from_doublest (fmt, &val, addr);
}
}
 
 
void
void
deprecated_store_floating (void *addr, int len, DOUBLEST val)
deprecated_store_floating (void *addr, int len, DOUBLEST val)
{
{
  store_floating_by_length (addr, len, val);
  store_floating_by_length (addr, len, val);
}
}
 
 
/* Extract a floating-point number of type TYPE from a target-order
/* Extract a floating-point number of type TYPE from a target-order
   byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
   byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
 
 
DOUBLEST
DOUBLEST
extract_typed_floating (const void *addr, const struct type *type)
extract_typed_floating (const void *addr, const struct type *type)
{
{
  DOUBLEST retval;
  DOUBLEST retval;
 
 
  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
 
 
  if (TYPE_FLOATFORMAT (type) == NULL)
  if (TYPE_FLOATFORMAT (type) == NULL)
    /* Not all code remembers to set the FLOATFORMAT (language
    /* Not all code remembers to set the FLOATFORMAT (language
       specific code? stabs?) so handle that here as a special case.  */
       specific code? stabs?) so handle that here as a special case.  */
    return extract_floating_by_length (addr, TYPE_LENGTH (type));
    return extract_floating_by_length (addr, TYPE_LENGTH (type));
 
 
  floatformat_to_doublest
  floatformat_to_doublest
        (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
        (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
                           addr, &retval);
                           addr, &retval);
  return retval;
  return retval;
}
}
 
 
/* Store VAL as a floating-point number of type TYPE to a target-order
/* Store VAL as a floating-point number of type TYPE to a target-order
   byte-stream at ADDR.  */
   byte-stream at ADDR.  */
 
 
void
void
store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
{
{
  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
 
 
  /* FIXME: kettenis/2001-10-28: It is debatable whether we should
  /* FIXME: kettenis/2001-10-28: It is debatable whether we should
     zero out any remaining bytes in the target buffer when TYPE is
     zero out any remaining bytes in the target buffer when TYPE is
     longer than the actual underlying floating-point format.  Perhaps
     longer than the actual underlying floating-point format.  Perhaps
     we should store a fixed bitpattern in those remaining bytes,
     we should store a fixed bitpattern in those remaining bytes,
     instead of zero, or perhaps we shouldn't touch those remaining
     instead of zero, or perhaps we shouldn't touch those remaining
     bytes at all.
     bytes at all.
 
 
     NOTE: cagney/2001-10-28: With the way things currently work, it
     NOTE: cagney/2001-10-28: With the way things currently work, it
     isn't a good idea to leave the end bits undefined.  This is
     isn't a good idea to leave the end bits undefined.  This is
     because GDB writes out the entire sizeof(<floating>) bits of the
     because GDB writes out the entire sizeof(<floating>) bits of the
     floating-point type even though the value might only be stored
     floating-point type even though the value might only be stored
     in, and the target processor may only refer to, the first N <
     in, and the target processor may only refer to, the first N <
     TYPE_LENGTH (type) bits.  If the end of the buffer wasn't
     TYPE_LENGTH (type) bits.  If the end of the buffer wasn't
     initialized, GDB would write undefined data to the target.  An
     initialized, GDB would write undefined data to the target.  An
     errant program, refering to that undefined data, would then
     errant program, refering to that undefined data, would then
     become non-deterministic.
     become non-deterministic.
 
 
     See also the function convert_typed_floating below.  */
     See also the function convert_typed_floating below.  */
  memset (addr, 0, TYPE_LENGTH (type));
  memset (addr, 0, TYPE_LENGTH (type));
 
 
  if (TYPE_FLOATFORMAT (type) == NULL)
  if (TYPE_FLOATFORMAT (type) == NULL)
    /* Not all code remembers to set the FLOATFORMAT (language
    /* Not all code remembers to set the FLOATFORMAT (language
       specific code? stabs?) so handle that here as a special case.  */
       specific code? stabs?) so handle that here as a special case.  */
    store_floating_by_length (addr, TYPE_LENGTH (type), val);
    store_floating_by_length (addr, TYPE_LENGTH (type), val);
  else
  else
    floatformat_from_doublest
    floatformat_from_doublest
        (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
        (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
        &val, addr);
        &val, addr);
}
}
 
 
/* Convert a floating-point number of type FROM_TYPE from a
/* Convert a floating-point number of type FROM_TYPE from a
   target-order byte-stream at FROM to a floating-point number of type
   target-order byte-stream at FROM to a floating-point number of type
   TO_TYPE, and store it to a target-order byte-stream at TO.  */
   TO_TYPE, and store it to a target-order byte-stream at TO.  */
 
 
void
void
convert_typed_floating (const void *from, const struct type *from_type,
convert_typed_floating (const void *from, const struct type *from_type,
                        void *to, const struct type *to_type)
                        void *to, const struct type *to_type)
{
{
  const struct floatformat *from_fmt = floatformat_from_type (from_type);
  const struct floatformat *from_fmt = floatformat_from_type (from_type);
  const struct floatformat *to_fmt = floatformat_from_type (to_type);
  const struct floatformat *to_fmt = floatformat_from_type (to_type);
 
 
  gdb_assert (TYPE_CODE (from_type) == TYPE_CODE_FLT);
  gdb_assert (TYPE_CODE (from_type) == TYPE_CODE_FLT);
  gdb_assert (TYPE_CODE (to_type) == TYPE_CODE_FLT);
  gdb_assert (TYPE_CODE (to_type) == TYPE_CODE_FLT);
 
 
  if (from_fmt == NULL || to_fmt == NULL)
  if (from_fmt == NULL || to_fmt == NULL)
    {
    {
      /* If we don't know the floating-point format of FROM_TYPE or
      /* If we don't know the floating-point format of FROM_TYPE or
         TO_TYPE, there's not much we can do.  We might make the
         TO_TYPE, there's not much we can do.  We might make the
         assumption that if the length of FROM_TYPE and TO_TYPE match,
         assumption that if the length of FROM_TYPE and TO_TYPE match,
         their floating-point format would match too, but that
         their floating-point format would match too, but that
         assumption might be wrong on targets that support
         assumption might be wrong on targets that support
         floating-point types that only differ in endianness for
         floating-point types that only differ in endianness for
         example.  So we warn instead, and zero out the target buffer.  */
         example.  So we warn instead, and zero out the target buffer.  */
      warning (_("Can't convert floating-point number to desired type."));
      warning (_("Can't convert floating-point number to desired type."));
      memset (to, 0, TYPE_LENGTH (to_type));
      memset (to, 0, TYPE_LENGTH (to_type));
    }
    }
  else if (from_fmt == to_fmt)
  else if (from_fmt == to_fmt)
    {
    {
      /* We're in business.  The floating-point format of FROM_TYPE
      /* We're in business.  The floating-point format of FROM_TYPE
         and TO_TYPE match.  However, even though the floating-point
         and TO_TYPE match.  However, even though the floating-point
         format matches, the length of the type might still be
         format matches, the length of the type might still be
         different.  Make sure we don't overrun any buffers.  See
         different.  Make sure we don't overrun any buffers.  See
         comment in store_typed_floating for a discussion about
         comment in store_typed_floating for a discussion about
         zeroing out remaining bytes in the target buffer.  */
         zeroing out remaining bytes in the target buffer.  */
      memset (to, 0, TYPE_LENGTH (to_type));
      memset (to, 0, TYPE_LENGTH (to_type));
      memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type)));
      memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type)));
    }
    }
  else
  else
    {
    {
      /* The floating-point types don't match.  The best we can do
      /* The floating-point types don't match.  The best we can do
         (aport from simulating the target FPU) is converting to the
         (aport from simulating the target FPU) is converting to the
         widest floating-point type supported by the host, and then
         widest floating-point type supported by the host, and then
         again to the desired type.  */
         again to the desired type.  */
      DOUBLEST d;
      DOUBLEST d;
 
 
      floatformat_to_doublest (from_fmt, from, &d);
      floatformat_to_doublest (from_fmt, from, &d);
      floatformat_from_doublest (to_fmt, &d, to);
      floatformat_from_doublest (to_fmt, &d, to);
    }
    }
}
}
 
 
const struct floatformat *floatformat_ieee_single[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_ieee_single[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_ieee_double[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_ieee_double[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_ieee_quad[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_ieee_quad[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_arm_ext[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_arm_ext[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_ia64_spill[BFD_ENDIAN_UNKNOWN];
const struct floatformat *floatformat_ia64_spill[BFD_ENDIAN_UNKNOWN];
 
 
extern void _initialize_doublest (void);
extern void _initialize_doublest (void);
 
 
extern void
extern void
_initialize_doublest (void)
_initialize_doublest (void)
{
{
  floatformat_ieee_single[BFD_ENDIAN_LITTLE] = &floatformat_ieee_single_little;
  floatformat_ieee_single[BFD_ENDIAN_LITTLE] = &floatformat_ieee_single_little;
  floatformat_ieee_single[BFD_ENDIAN_BIG] = &floatformat_ieee_single_big;
  floatformat_ieee_single[BFD_ENDIAN_BIG] = &floatformat_ieee_single_big;
  floatformat_ieee_double[BFD_ENDIAN_LITTLE] = &floatformat_ieee_double_little;
  floatformat_ieee_double[BFD_ENDIAN_LITTLE] = &floatformat_ieee_double_little;
  floatformat_ieee_double[BFD_ENDIAN_BIG] = &floatformat_ieee_double_big;
  floatformat_ieee_double[BFD_ENDIAN_BIG] = &floatformat_ieee_double_big;
  floatformat_arm_ext[BFD_ENDIAN_LITTLE] = &floatformat_arm_ext_littlebyte_bigword;
  floatformat_arm_ext[BFD_ENDIAN_LITTLE] = &floatformat_arm_ext_littlebyte_bigword;
  floatformat_arm_ext[BFD_ENDIAN_BIG] = &floatformat_arm_ext_big;
  floatformat_arm_ext[BFD_ENDIAN_BIG] = &floatformat_arm_ext_big;
  floatformat_ia64_spill[BFD_ENDIAN_LITTLE] = &floatformat_ia64_spill_little;
  floatformat_ia64_spill[BFD_ENDIAN_LITTLE] = &floatformat_ia64_spill_little;
  floatformat_ia64_spill[BFD_ENDIAN_BIG] = &floatformat_ia64_spill_big;
  floatformat_ia64_spill[BFD_ENDIAN_BIG] = &floatformat_ia64_spill_big;
  floatformat_ieee_quad[BFD_ENDIAN_LITTLE] = &floatformat_ia64_quad_little;
  floatformat_ieee_quad[BFD_ENDIAN_LITTLE] = &floatformat_ia64_quad_little;
  floatformat_ieee_quad[BFD_ENDIAN_BIG] = &floatformat_ia64_quad_big;
  floatformat_ieee_quad[BFD_ENDIAN_BIG] = &floatformat_ia64_quad_big;
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.