[deliverable/binutils-gdb.git] / gas / config / atof-ieee.c

/* atof_ieee.c - turn a Flonum into an IEEE floating point number
   Copyright 1987, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001, 2005
   Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS 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, or (at your option)
   any later version.

   GAS 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 GAS; see the file COPYING.  If not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

#include "as.h"

/* Flonums returned here.  */
extern FLONUM_TYPE generic_floating_point_number;

extern const char EXP_CHARS[];
/* Precision in LittleNums.  */
/* Don't count the gap in the m68k extended precision format.  */
#define MAX_PRECISION  5
#define F_PRECISION    2
#define D_PRECISION    4
#define X_PRECISION    5
#define P_PRECISION    5

/* Length in LittleNums of guard bits.  */
#define GUARD          2

#ifndef TC_LARGEST_EXPONENT_IS_NORMAL
#define TC_LARGEST_EXPONENT_IS_NORMAL(PRECISION) 0
#endif

static const unsigned long mask[] =
{
  0x00000000,
  0x00000001,
  0x00000003,
  0x00000007,
  0x0000000f,
  0x0000001f,
  0x0000003f,
  0x0000007f,
  0x000000ff,
  0x000001ff,
  0x000003ff,
  0x000007ff,
  0x00000fff,
  0x00001fff,
  0x00003fff,
  0x00007fff,
  0x0000ffff,
  0x0001ffff,
  0x0003ffff,
  0x0007ffff,
  0x000fffff,
  0x001fffff,
  0x003fffff,
  0x007fffff,
  0x00ffffff,
  0x01ffffff,
  0x03ffffff,
  0x07ffffff,
  0x0fffffff,
  0x1fffffff,
  0x3fffffff,
  0x7fffffff,
  0xffffffff,
};
\f
static int bits_left_in_littlenum;
static int littlenums_left;
static LITTLENUM_TYPE *littlenum_pointer;

static int
next_bits (int number_of_bits)
{
  int return_value;

  if (!littlenums_left)
    return 0;

  if (number_of_bits >= bits_left_in_littlenum)
    {
      return_value = mask[bits_left_in_littlenum] & *littlenum_pointer;
      number_of_bits -= bits_left_in_littlenum;
      return_value <<= number_of_bits;

      if (--littlenums_left)
	{
	  bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
	  --littlenum_pointer;
	  return_value |=
	    (*littlenum_pointer >> bits_left_in_littlenum)
	    & mask[number_of_bits];
	}
    }
  else
    {
      bits_left_in_littlenum -= number_of_bits;
      return_value =
	mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
    }
  return return_value;
}

/* Num had better be less than LITTLENUM_NUMBER_OF_BITS.  */

static void
unget_bits (int num)
{
  if (!littlenums_left)
    {
      ++littlenum_pointer;
      ++littlenums_left;
      bits_left_in_littlenum = num;
    }
  else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS)
    {
      bits_left_in_littlenum =
	num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
      ++littlenum_pointer;
      ++littlenums_left;
    }
  else
    bits_left_in_littlenum += num;
}

static void
make_invalid_floating_point_number (LITTLENUM_TYPE *words)
{
  as_bad (_("cannot create floating-point number"));
  /* Zero the leftmost bit.  */
  words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1;
  words[1] = (LITTLENUM_TYPE) -1;
  words[2] = (LITTLENUM_TYPE) -1;
  words[3] = (LITTLENUM_TYPE) -1;
  words[4] = (LITTLENUM_TYPE) -1;
  words[5] = (LITTLENUM_TYPE) -1;
}
\f
/* Warning: This returns 16-bit LITTLENUMs.  It is up to the caller to
   figure out any alignment problems and to conspire for the
   bytes/word to be emitted in the right order.  Bigendians beware!  */

/* Note that atof-ieee always has X and P precisions enabled.  it is up
   to md_atof to filter them out if the target machine does not support
   them.  */

/* Returns pointer past text consumed.  */

char *
atof_ieee (char *str,			/* Text to convert to binary.  */
	   int what_kind,		/* 'd', 'f', 'g', 'h'.  */
	   LITTLENUM_TYPE *words)	/* Build the binary here.  */
{
  /* Extra bits for zeroed low-order bits.
     The 1st MAX_PRECISION are zeroed, the last contain flonum bits.  */
  static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
  char *return_value;
  /* Number of 16-bit words in the format.  */
  int precision;
  long exponent_bits;
  FLONUM_TYPE save_gen_flonum;

  /* We have to save the generic_floating_point_number because it
     contains storage allocation about the array of LITTLENUMs where
     the value is actually stored.  We will allocate our own array of
     littlenums below, but have to restore the global one on exit.  */
  save_gen_flonum = generic_floating_point_number;

  return_value = str;
  generic_floating_point_number.low = bits + MAX_PRECISION;
  generic_floating_point_number.high = NULL;
  generic_floating_point_number.leader = NULL;
  generic_floating_point_number.exponent = 0;
  generic_floating_point_number.sign = '\0';

  /* Use more LittleNums than seems necessary: the highest flonum may
     have 15 leading 0 bits, so could be useless.  */

  memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);

  switch (what_kind)
    {
    case 'f':
    case 'F':
    case 's':
    case 'S':
      precision = F_PRECISION;
      exponent_bits = 8;
      break;

    case 'd':
    case 'D':
    case 'r':
    case 'R':
      precision = D_PRECISION;
      exponent_bits = 11;
      break;

    case 'x':
    case 'X':
    case 'e':
    case 'E':
      precision = X_PRECISION;
      exponent_bits = 15;
      break;

    case 'p':
    case 'P':

      precision = P_PRECISION;
      exponent_bits = -1;
      break;

    default:
      make_invalid_floating_point_number (words);
      return (NULL);
    }

  generic_floating_point_number.high
    = generic_floating_point_number.low + precision - 1 + GUARD;

  if (atof_generic (&return_value, ".", EXP_CHARS,
		    &generic_floating_point_number))
    {
      make_invalid_floating_point_number (words);
      return NULL;
    }
  gen_to_words (words, precision, exponent_bits);

  /* Restore the generic_floating_point_number's storage alloc (and
     everything else).  */
  generic_floating_point_number = save_gen_flonum;

  return return_value;
}

/* Turn generic_floating_point_number into a real float/double/extended.  */

int
gen_to_words (LITTLENUM_TYPE *words, int precision, long exponent_bits)
{
  int return_value = 0;

  long exponent_1;
  long exponent_2;
  long exponent_3;
  long exponent_4;
  int exponent_skippage;
  LITTLENUM_TYPE word1;
  LITTLENUM_TYPE *lp;
  LITTLENUM_TYPE *words_end;

  words_end = words + precision;
#ifdef TC_M68K
  if (precision == X_PRECISION)
    /* On the m68k the extended precision format has a gap of 16 bits
       between the exponent and the mantissa.  */
    words_end++;
#endif

  if (generic_floating_point_number.low > generic_floating_point_number.leader)
    {
      /* 0.0e0 seen.  */
      if (generic_floating_point_number.sign == '+')
	words[0] = 0x0000;
      else
	words[0] = 0x8000;
      memset (&words[1], '\0',
	      (words_end - words - 1) * sizeof (LITTLENUM_TYPE));
      return return_value;
    }

  /* NaN:  Do the right thing.  */
  if (generic_floating_point_number.sign == 0)
    {
      if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
	as_warn ("NaNs are not supported by this target\n");
      if (precision == F_PRECISION)
	{
	  words[0] = 0x7fff;
	  words[1] = 0xffff;
	}
      else if (precision == X_PRECISION)
	{
#ifdef TC_M68K
	  words[0] = 0x7fff;
	  words[1] = 0;
	  words[2] = 0xffff;
	  words[3] = 0xffff;
	  words[4] = 0xffff;
	  words[5] = 0xffff;
#else /* ! TC_M68K  */
#ifdef TC_I386
	  words[0] = 0xffff;
	  words[1] = 0xc000;
	  words[2] = 0;
	  words[3] = 0;
	  words[4] = 0;
#else /* ! TC_I386  */
	  abort ();
#endif /* ! TC_I386  */
#endif /* ! TC_M68K  */
	}
      else
	{
	  words[0] = 0x7fff;
	  words[1] = 0xffff;
	  words[2] = 0xffff;
	  words[3] = 0xffff;
	}
      return return_value;
    }
  else if (generic_floating_point_number.sign == 'P')
    {
      if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
	as_warn ("Infinities are not supported by this target\n");

      /* +INF:  Do the right thing.  */
      if (precision == F_PRECISION)
	{
	  words[0] = 0x7f80;
	  words[1] = 0;
	}
      else if (precision == X_PRECISION)
	{
#ifdef TC_M68K
	  words[0] = 0x7fff;
	  words[1] = 0;
	  words[2] = 0;
	  words[3] = 0;
	  words[4] = 0;
	  words[5] = 0;
#else /* ! TC_M68K  */
#ifdef TC_I386
	  words[0] = 0x7fff;
	  words[1] = 0x8000;
	  words[2] = 0;
	  words[3] = 0;
	  words[4] = 0;
#else /* ! TC_I386  */
	  abort ();
#endif /* ! TC_I386  */
#endif /* ! TC_M68K  */
	}
      else
	{
	  words[0] = 0x7ff0;
	  words[1] = 0;
	  words[2] = 0;
	  words[3] = 0;
	}
      return return_value;
    }
  else if (generic_floating_point_number.sign == 'N')
    {
      if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
	as_warn ("Infinities are not supported by this target\n");

      /* Negative INF.  */
      if (precision == F_PRECISION)
	{
	  words[0] = 0xff80;
	  words[1] = 0x0;
	}
      else if (precision == X_PRECISION)
	{
#ifdef TC_M68K
	  words[0] = 0xffff;
	  words[1] = 0;
	  words[2] = 0;
	  words[3] = 0;
	  words[4] = 0;
	  words[5] = 0;
#else /* ! TC_M68K  */
#ifdef TC_I386
	  words[0] = 0xffff;
	  words[1] = 0x8000;
	  words[2] = 0;
	  words[3] = 0;
	  words[4] = 0;
#else /* ! TC_I386  */
	  abort ();
#endif /* ! TC_I386  */
#endif /* ! TC_M68K  */
	}
      else
	{
	  words[0] = 0xfff0;
	  words[1] = 0x0;
	  words[2] = 0x0;
	  words[3] = 0x0;
	}
      return return_value;
    }

  /* The floating point formats we support have:
     Bit 15 is sign bit.
     Bits 14:n are excess-whatever exponent.
     Bits n-1:0 (if any) are most significant bits of fraction.
     Bits 15:0 of the next word(s) are the next most significant bits.

     So we need: number of bits of exponent, number of bits of
     mantissa.  */
  bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
  littlenum_pointer = generic_floating_point_number.leader;
  littlenums_left = (1
		     + generic_floating_point_number.leader
		     - generic_floating_point_number.low);

  /* Seek (and forget) 1st significant bit.  */
  for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage);;
  exponent_1 = (generic_floating_point_number.exponent
		+ generic_floating_point_number.leader
		+ 1
		- generic_floating_point_number.low);

  /* Radix LITTLENUM_RADIX, point just higher than
     generic_floating_point_number.leader.  */
  exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;

  /* Radix 2.  */
  exponent_3 = exponent_2 - exponent_skippage;

  /* Forget leading zeros, forget 1st bit.  */
  exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);

  /* Offset exponent.  */
  lp = words;

  /* Word 1.  Sign, exponent and perhaps high bits.  */
  word1 = ((generic_floating_point_number.sign == '+')
	   ? 0
	   : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));

  /* Assume 2's complement integers.  */
  if (exponent_4 <= 0)
    {
      int prec_bits;
      int num_bits;

      unget_bits (1);
      num_bits = -exponent_4;
      prec_bits =
	LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
#ifdef TC_I386
      if (precision == X_PRECISION && exponent_bits == 15)
	{
	  /* On the i386 a denormalized extended precision float is
	     shifted down by one, effectively decreasing the exponent
	     bias by one.  */
	  prec_bits -= 1;
	  num_bits += 1;
	}
#endif

      if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits)
	{
	  /* Bigger than one littlenum.  */
	  num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
	  *lp++ = word1;
	  if (num_bits + exponent_bits + 1
	      > precision * LITTLENUM_NUMBER_OF_BITS)
	    {
	      /* Exponent overflow.  */
	      make_invalid_floating_point_number (words);
	      return return_value;
	    }
#ifdef TC_M68K
	  if (precision == X_PRECISION && exponent_bits == 15)
	    *lp++ = 0;
#endif
	  while (num_bits >= LITTLENUM_NUMBER_OF_BITS)
	    {
	      num_bits -= LITTLENUM_NUMBER_OF_BITS;
	      *lp++ = 0;
	    }
	  if (num_bits)
	    *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits));
	}
      else
	{
	  if (precision == X_PRECISION && exponent_bits == 15)
	    {
	      *lp++ = word1;
#ifdef TC_M68K
	      *lp++ = 0;
#endif
	      *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits);
	    }
	  else
	    {
	      word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1)
				  - (exponent_bits + num_bits));
	      *lp++ = word1;
	    }
	}
      while (lp < words_end)
	*lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);

      /* Round the mantissa up, but don't change the number.  */
      if (next_bits (1))
	{
	  --lp;
	  if (prec_bits >= LITTLENUM_NUMBER_OF_BITS)
	    {
	      int n = 0;
	      int tmp_bits;

	      n = 0;
	      tmp_bits = prec_bits;
	      while (tmp_bits > LITTLENUM_NUMBER_OF_BITS)
		{
		  if (lp[n] != (LITTLENUM_TYPE) - 1)
		    break;
		  --n;
		  tmp_bits -= LITTLENUM_NUMBER_OF_BITS;
		}
	      if (tmp_bits > LITTLENUM_NUMBER_OF_BITS
		  || (lp[n] & mask[tmp_bits]) != mask[tmp_bits]
		  || (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS
				    - exponent_bits - 1)
#ifdef TC_I386
		      /* An extended precision float with only the integer
			 bit set would be invalid.  That must be converted
			 to the smallest normalized number.  */
		      && !(precision == X_PRECISION
			   && prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS
					    - exponent_bits - 2))
#endif
		      ))
		{
		  unsigned long carry;

		  for (carry = 1; carry && (lp >= words); lp--)
		    {
		      carry = *lp + carry;
		      *lp = carry;
		      carry >>= LITTLENUM_NUMBER_OF_BITS;
		    }
		}
	      else
		{
		  /* This is an overflow of the denormal numbers.  We
                     need to forget what we have produced, and instead
                     generate the smallest normalized number.  */
		  lp = words;
		  word1 = ((generic_floating_point_number.sign == '+')
			   ? 0
			   : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
		  word1 |= (1
			    << ((LITTLENUM_NUMBER_OF_BITS - 1)
				- exponent_bits));
		  *lp++ = word1;
#ifdef TC_I386
		  /* Set the integer bit in the extended precision format.
		     This cannot happen on the m68k where the mantissa
		     just overflows into the integer bit above.  */
		  if (precision == X_PRECISION)
		    *lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
#endif
		  while (lp < words_end)
		    *lp++ = 0;
		}
	    }
	  else
	    *lp += 1;
	}

      return return_value;
    }
  else if ((unsigned long) exponent_4 > mask[exponent_bits]
	   || (! TC_LARGEST_EXPONENT_IS_NORMAL (precision)
	       && (unsigned long) exponent_4 == mask[exponent_bits]))
    {
      /* Exponent overflow.  Lose immediately.  */

      /* We leave return_value alone: admit we read the
	 number, but return a floating exception
	 because we can't encode the number.  */
      make_invalid_floating_point_number (words);
      return return_value;
    }
  else
    {
      word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits))
	| next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits);
    }

  *lp++ = word1;

  /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
     middle.  Either way, it is then followed by a 1 bit.  */
  if (exponent_bits == 15 && precision == X_PRECISION)
    {
#ifdef TC_M68K
      *lp++ = 0;
#endif
      *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1)
	       | next_bits (LITTLENUM_NUMBER_OF_BITS - 1));
    }

  /* The rest of the words are just mantissa bits.  */
  while (lp < words_end)
    *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);

  if (next_bits (1))
    {
      unsigned long carry;
      /* Since the NEXT bit is a 1, round UP the mantissa.
	 The cunning design of these hidden-1 floats permits
	 us to let the mantissa overflow into the exponent, and
	 it 'does the right thing'. However, we lose if the
	 highest-order bit of the lowest-order word flips.
	 Is that clear?  */

      /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
	 Please allow at least 1 more bit in carry than is in a LITTLENUM.
	 We need that extra bit to hold a carry during a LITTLENUM carry
	 propagation. Another extra bit (kept 0) will assure us that we
	 don't get a sticky sign bit after shifting right, and that
	 permits us to propagate the carry without any masking of bits.
	 #endif */
      for (carry = 1, lp--; carry; lp--)
	{
	  carry = *lp + carry;
	  *lp = carry;
	  carry >>= LITTLENUM_NUMBER_OF_BITS;
	  if (lp == words)
	    break;
	}
      if (precision == X_PRECISION && exponent_bits == 15)
	{
	  /* Extended precision numbers have an explicit integer bit
	     that we may have to restore.  */
	  if (lp == words)
	    {
#ifdef TC_M68K
	      /* On the m68k there is a gap of 16 bits.  We must
		 explicitly propagate the carry into the exponent.  */
	      words[0] += words[1];
	      words[1] = 0;
	      lp++;
#endif
	      /* Put back the integer bit.  */
	      lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
	    }
	}
      if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
	{
	  /* We leave return_value alone: admit we read the number,
	     but return a floating exception because we can't encode
	     the number.  */
	  *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
	}
    }
  return return_value;
}

#ifdef TEST
char *
print_gen (gen)
     FLONUM_TYPE *gen;
{
  FLONUM_TYPE f;
  LITTLENUM_TYPE arr[10];
  double dv;
  float fv;
  static char sbuf[40];

  if (gen)
    {
      f = generic_floating_point_number;
      generic_floating_point_number = *gen;
    }
  gen_to_words (&arr[0], 4, 11);
  memcpy (&dv, &arr[0], sizeof (double));
  sprintf (sbuf, "%x %x %x %x %.14G   ", arr[0], arr[1], arr[2], arr[3], dv);
  gen_to_words (&arr[0], 2, 8);
  memcpy (&fv, &arr[0], sizeof (float));
  sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv);

  if (gen)
    generic_floating_point_number = f;

  return (sbuf);
}

#endif
Commit	Line	Data
252b5132	1	/* atof_ieee.c - turn a Flonum into an IEEE floating point number
aef6203b	2	Copyright 1987, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001, 2005
252b5132 RH	3	Free Software Foundation, Inc.
	4
	5	This file is part of GAS, the GNU Assembler.
	6
	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
	11
	12	GAS is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GAS; see the file COPYING. If not, write to the Free
	19	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	20	02111-1307, USA. */
	21
	22	#include "as.h"
	23
	24	/* Flonums returned here. */
	25	extern FLONUM_TYPE generic_floating_point_number;
	26
252b5132	27	extern const char EXP_CHARS[];
2d484c7f	28	/* Precision in LittleNums. */
252b5132	29	/* Don't count the gap in the m68k extended precision format. */
ea1562b3 NC	30	#define MAX_PRECISION 5
	31	#define F_PRECISION 2
	32	#define D_PRECISION 4
	33	#define X_PRECISION 5
	34	#define P_PRECISION 5
252b5132	35
2d484c7f	36	/* Length in LittleNums of guard bits. */
ea1562b3	37	#define GUARD 2
252b5132	38
3a18fa4f	39	#ifndef TC_LARGEST_EXPONENT_IS_NORMAL
580a832e	40	#define TC_LARGEST_EXPONENT_IS_NORMAL(PRECISION) 0
e103941e NC	41	#endif
e103941e NC	42
252b5132 RH	43	static const unsigned long mask[] =
	44	{
	45	0x00000000,
	46	0x00000001,
	47	0x00000003,
	48	0x00000007,
	49	0x0000000f,
	50	0x0000001f,
	51	0x0000003f,
	52	0x0000007f,
	53	0x000000ff,
	54	0x000001ff,
	55	0x000003ff,
	56	0x000007ff,
	57	0x00000fff,
	58	0x00001fff,
	59	0x00003fff,
	60	0x00007fff,
	61	0x0000ffff,
	62	0x0001ffff,
	63	0x0003ffff,
	64	0x0007ffff,
	65	0x000fffff,
	66	0x001fffff,
	67	0x003fffff,
	68	0x007fffff,
	69	0x00ffffff,
	70	0x01ffffff,
	71	0x03ffffff,
	72	0x07ffffff,
	73	0x0fffffff,
	74	0x1fffffff,
	75	0x3fffffff,
	76	0x7fffffff,
	77	0xffffffff,
	78	};
	79	\f
252b5132 RH	80	static int bits_left_in_littlenum;
	81	static int littlenums_left;
	82	static LITTLENUM_TYPE *littlenum_pointer;
	83
	84	static int
ea1562b3	85	next_bits (int number_of_bits)
252b5132 RH	86	{
	87	int return_value;
	88
	89	if (!littlenums_left)
ea1562b3 NC	90	return 0;
ea1562b3 NC	91
252b5132 RH	92	if (number_of_bits >= bits_left_in_littlenum)
	93	{
	94	return_value = mask[bits_left_in_littlenum] & *littlenum_pointer;
	95	number_of_bits -= bits_left_in_littlenum;
	96	return_value <<= number_of_bits;
	97
	98	if (--littlenums_left)
	99	{
	100	bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
	101	--littlenum_pointer;
2d484c7f KH	102	return_value \|=
	103	(*littlenum_pointer >> bits_left_in_littlenum)
	104	& mask[number_of_bits];
252b5132 RH	105	}
	106	}
	107	else
	108	{
	109	bits_left_in_littlenum -= number_of_bits;
2d484c7f KH	110	return_value =
2d484c7f KH	111	mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
252b5132	112	}
2d484c7f	113	return return_value;
252b5132 RH	114	}
252b5132 RH	115
2d484c7f KH	116	/* Num had better be less than LITTLENUM_NUMBER_OF_BITS. */
2d484c7f KH	117
252b5132	118	static void
ea1562b3	119	unget_bits (int num)
252b5132 RH	120	{
	121	if (!littlenums_left)
	122	{
	123	++littlenum_pointer;
	124	++littlenums_left;
	125	bits_left_in_littlenum = num;
	126	}
	127	else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS)
	128	{
2d484c7f KH	129	bits_left_in_littlenum =
2d484c7f KH	130	num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
252b5132 RH	131	++littlenum_pointer;
	132	++littlenums_left;
	133	}
	134	else
	135	bits_left_in_littlenum += num;
	136	}
	137
	138	static void
ea1562b3	139	make_invalid_floating_point_number (LITTLENUM_TYPE *words)
252b5132 RH	140	{
252b5132 RH	141	as_bad (_("cannot create floating-point number"));
2d484c7f KH	142	/* Zero the leftmost bit. */
2d484c7f KH	143	words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1;
252b5132 RH	144	words[1] = (LITTLENUM_TYPE) -1;
	145	words[2] = (LITTLENUM_TYPE) -1;
	146	words[3] = (LITTLENUM_TYPE) -1;
	147	words[4] = (LITTLENUM_TYPE) -1;
	148	words[5] = (LITTLENUM_TYPE) -1;
	149	}
	150	\f
2d484c7f KH	151	/* Warning: This returns 16-bit LITTLENUMs. It is up to the caller to
	152	figure out any alignment problems and to conspire for the
	153	bytes/word to be emitted in the right order. Bigendians beware! */
252b5132 RH	154
	155	/* Note that atof-ieee always has X and P precisions enabled. it is up
	156	to md_atof to filter them out if the target machine does not support
	157	them. */
	158
2d484c7f KH	159	/* Returns pointer past text consumed. */
2d484c7f KH	160
252b5132	161	char *
ea1562b3 NC	162	atof_ieee (char str, / Text to convert to binary. */
	163	int what_kind, /* 'd', 'f', 'g', 'h'. */
	164	LITTLENUM_TYPE words) / Build the binary here. */
252b5132	165	{
2d484c7f KH	166	/* Extra bits for zeroed low-order bits.
2d484c7f KH	167	The 1st MAX_PRECISION are zeroed, the last contain flonum bits. */
252b5132 RH	168	static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
252b5132 RH	169	char *return_value;
2d484c7f	170	/* Number of 16-bit words in the format. */
252b5132 RH	171	int precision;
	172	long exponent_bits;
	173	FLONUM_TYPE save_gen_flonum;
	174
	175	/* We have to save the generic_floating_point_number because it
	176	contains storage allocation about the array of LITTLENUMs where
	177	the value is actually stored. We will allocate our own array of
	178	littlenums below, but have to restore the global one on exit. */
	179	save_gen_flonum = generic_floating_point_number;
	180
	181	return_value = str;
	182	generic_floating_point_number.low = bits + MAX_PRECISION;
	183	generic_floating_point_number.high = NULL;
	184	generic_floating_point_number.leader = NULL;
	185	generic_floating_point_number.exponent = 0;
	186	generic_floating_point_number.sign = '\0';
	187
	188	/* Use more LittleNums than seems necessary: the highest flonum may
2d484c7f	189	have 15 leading 0 bits, so could be useless. */
252b5132 RH	190
	191	memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);
	192
	193	switch (what_kind)
	194	{
	195	case 'f':
	196	case 'F':
	197	case 's':
	198	case 'S':
	199	precision = F_PRECISION;
	200	exponent_bits = 8;
	201	break;
	202
	203	case 'd':
	204	case 'D':
	205	case 'r':
	206	case 'R':
	207	precision = D_PRECISION;
	208	exponent_bits = 11;
	209	break;
	210
	211	case 'x':
	212	case 'X':
	213	case 'e':
	214	case 'E':
	215	precision = X_PRECISION;
	216	exponent_bits = 15;
	217	break;
	218
	219	case 'p':
	220	case 'P':
	221
	222	precision = P_PRECISION;
	223	exponent_bits = -1;
	224	break;
	225
	226	default:
	227	make_invalid_floating_point_number (words);
	228	return (NULL);
	229	}
	230
	231	generic_floating_point_number.high
	232	= generic_floating_point_number.low + precision - 1 + GUARD;
	233
	234	if (atof_generic (&return_value, ".", EXP_CHARS,
	235	&generic_floating_point_number))
	236	{
	237	make_invalid_floating_point_number (words);
ea1562b3	238	return NULL;
252b5132 RH	239	}
	240	gen_to_words (words, precision, exponent_bits);
	241
	242	/* Restore the generic_floating_point_number's storage alloc (and
	243	everything else). */
	244	generic_floating_point_number = save_gen_flonum;
	245
	246	return return_value;
	247	}
	248
	249	/* Turn generic_floating_point_number into a real float/double/extended. */
2d484c7f	250
252b5132	251	int
ea1562b3	252	gen_to_words (LITTLENUM_TYPE *words, int precision, long exponent_bits)
252b5132 RH	253	{
	254	int return_value = 0;
	255
	256	long exponent_1;
	257	long exponent_2;
	258	long exponent_3;
	259	long exponent_4;
	260	int exponent_skippage;
	261	LITTLENUM_TYPE word1;
	262	LITTLENUM_TYPE *lp;
	263	LITTLENUM_TYPE *words_end;
	264
	265	words_end = words + precision;
	266	#ifdef TC_M68K
	267	if (precision == X_PRECISION)
	268	/* On the m68k the extended precision format has a gap of 16 bits
	269	between the exponent and the mantissa. */
	270	words_end++;
	271	#endif
	272
	273	if (generic_floating_point_number.low > generic_floating_point_number.leader)
	274	{
2d484c7f	275	/* 0.0e0 seen. */
252b5132 RH	276	if (generic_floating_point_number.sign == '+')
	277	words[0] = 0x0000;
	278	else
	279	words[0] = 0x8000;
	280	memset (&words[1], '\0',
	281	(words_end - words - 1) * sizeof (LITTLENUM_TYPE));
2d484c7f	282	return return_value;
252b5132 RH	283	}
252b5132 RH	284
2d484c7f	285	/* NaN: Do the right thing. */
252b5132 RH	286	if (generic_floating_point_number.sign == 0)
252b5132 RH	287	{
580a832e	288	if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
e103941e	289	as_warn ("NaNs are not supported by this target\n");
252b5132 RH	290	if (precision == F_PRECISION)
	291	{
	292	words[0] = 0x7fff;
	293	words[1] = 0xffff;
	294	}
	295	else if (precision == X_PRECISION)
	296	{
	297	#ifdef TC_M68K
	298	words[0] = 0x7fff;
	299	words[1] = 0;
	300	words[2] = 0xffff;
	301	words[3] = 0xffff;
	302	words[4] = 0xffff;
	303	words[5] = 0xffff;
2d484c7f	304	#else /* ! TC_M68K */
252b5132 RH	305	#ifdef TC_I386
	306	words[0] = 0xffff;
	307	words[1] = 0xc000;
	308	words[2] = 0;
	309	words[3] = 0;
	310	words[4] = 0;
2d484c7f	311	#else /* ! TC_I386 */
252b5132	312	abort ();
2d484c7f KH	313	#endif /* ! TC_I386 */
2d484c7f KH	314	#endif /* ! TC_M68K */
252b5132 RH	315	}
	316	else
	317	{
	318	words[0] = 0x7fff;
	319	words[1] = 0xffff;
	320	words[2] = 0xffff;
	321	words[3] = 0xffff;
	322	}
	323	return return_value;
	324	}
	325	else if (generic_floating_point_number.sign == 'P')
	326	{
580a832e	327	if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
e103941e NC	328	as_warn ("Infinities are not supported by this target\n");
e103941e NC	329
2d484c7f	330	/* +INF: Do the right thing. */
252b5132 RH	331	if (precision == F_PRECISION)
	332	{
	333	words[0] = 0x7f80;
	334	words[1] = 0;
	335	}
	336	else if (precision == X_PRECISION)
	337	{
	338	#ifdef TC_M68K
	339	words[0] = 0x7fff;
	340	words[1] = 0;
	341	words[2] = 0;
	342	words[3] = 0;
	343	words[4] = 0;
	344	words[5] = 0;
2d484c7f	345	#else /* ! TC_M68K */
252b5132 RH	346	#ifdef TC_I386
	347	words[0] = 0x7fff;
	348	words[1] = 0x8000;
	349	words[2] = 0;
	350	words[3] = 0;
	351	words[4] = 0;
2d484c7f	352	#else /* ! TC_I386 */
252b5132	353	abort ();
2d484c7f KH	354	#endif /* ! TC_I386 */
2d484c7f KH	355	#endif /* ! TC_M68K */
252b5132 RH	356	}
	357	else
	358	{
	359	words[0] = 0x7ff0;
	360	words[1] = 0;
	361	words[2] = 0;
	362	words[3] = 0;
	363	}
2d484c7f	364	return return_value;
252b5132 RH	365	}
	366	else if (generic_floating_point_number.sign == 'N')
	367	{
580a832e	368	if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
e103941e NC	369	as_warn ("Infinities are not supported by this target\n");
e103941e NC	370
2d484c7f	371	/* Negative INF. */
252b5132 RH	372	if (precision == F_PRECISION)
	373	{
	374	words[0] = 0xff80;
	375	words[1] = 0x0;
	376	}
	377	else if (precision == X_PRECISION)
	378	{
	379	#ifdef TC_M68K
	380	words[0] = 0xffff;
	381	words[1] = 0;
	382	words[2] = 0;
	383	words[3] = 0;
	384	words[4] = 0;
	385	words[5] = 0;
2d484c7f	386	#else /* ! TC_M68K */
252b5132 RH	387	#ifdef TC_I386
	388	words[0] = 0xffff;
	389	words[1] = 0x8000;
	390	words[2] = 0;
	391	words[3] = 0;
	392	words[4] = 0;
2d484c7f	393	#else /* ! TC_I386 */
252b5132	394	abort ();
2d484c7f KH	395	#endif /* ! TC_I386 */
2d484c7f KH	396	#endif /* ! TC_M68K */
252b5132 RH	397	}
	398	else
	399	{
	400	words[0] = 0xfff0;
	401	words[1] = 0x0;
	402	words[2] = 0x0;
	403	words[3] = 0x0;
	404	}
2d484c7f	405	return return_value;
252b5132	406	}
2d484c7f KH	407
	408	/* The floating point formats we support have:
	409	Bit 15 is sign bit.
	410	Bits 14:n are excess-whatever exponent.
	411	Bits n-1:0 (if any) are most significant bits of fraction.
	412	Bits 15:0 of the next word(s) are the next most significant bits.
	413
	414	So we need: number of bits of exponent, number of bits of
	415	mantissa. */
252b5132 RH	416	bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
	417	littlenum_pointer = generic_floating_point_number.leader;
	418	littlenums_left = (1
	419	+ generic_floating_point_number.leader
	420	- generic_floating_point_number.low);
2d484c7f KH	421
2d484c7f KH	422	/* Seek (and forget) 1st significant bit. */
252b5132 RH	423	for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage);;
	424	exponent_1 = (generic_floating_point_number.exponent
	425	+ generic_floating_point_number.leader
	426	+ 1
	427	- generic_floating_point_number.low);
2d484c7f	428
252b5132	429	/* Radix LITTLENUM_RADIX, point just higher than
2d484c7f	430	generic_floating_point_number.leader. */
252b5132	431	exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
2d484c7f KH	432
2d484c7f KH	433	/* Radix 2. */
252b5132	434	exponent_3 = exponent_2 - exponent_skippage;
2d484c7f KH	435
2d484c7f KH	436	/* Forget leading zeros, forget 1st bit. */
252b5132	437	exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
252b5132	438
2d484c7f	439	/* Offset exponent. */
252b5132 RH	440	lp = words;
252b5132 RH	441
2d484c7f	442	/* Word 1. Sign, exponent and perhaps high bits. */
252b5132 RH	443	word1 = ((generic_floating_point_number.sign == '+')
	444	? 0
	445	: (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
	446
2d484c7f	447	/* Assume 2's complement integers. */
252b5132 RH	448	if (exponent_4 <= 0)
	449	{
	450	int prec_bits;
	451	int num_bits;
	452
	453	unget_bits (1);
	454	num_bits = -exponent_4;
2d484c7f KH	455	prec_bits =
2d484c7f KH	456	LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
252b5132 RH	457	#ifdef TC_I386
	458	if (precision == X_PRECISION && exponent_bits == 15)
	459	{
	460	/* On the i386 a denormalized extended precision float is
	461	shifted down by one, effectively decreasing the exponent
	462	bias by one. */
	463	prec_bits -= 1;
	464	num_bits += 1;
	465	}
	466	#endif
	467
	468	if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits)
	469	{
2d484c7f	470	/* Bigger than one littlenum. */
252b5132 RH	471	num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
252b5132 RH	472	*lp++ = word1;
2d484c7f KH	473	if (num_bits + exponent_bits + 1
2d484c7f KH	474	> precision * LITTLENUM_NUMBER_OF_BITS)
252b5132	475	{
2d484c7f	476	/* Exponent overflow. */
252b5132	477	make_invalid_floating_point_number (words);
2d484c7f	478	return return_value;
252b5132 RH	479	}
	480	#ifdef TC_M68K
	481	if (precision == X_PRECISION && exponent_bits == 15)
	482	*lp++ = 0;
	483	#endif
	484	while (num_bits >= LITTLENUM_NUMBER_OF_BITS)
	485	{
	486	num_bits -= LITTLENUM_NUMBER_OF_BITS;
	487	*lp++ = 0;
	488	}
	489	if (num_bits)
	490	*lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits));
	491	}
	492	else
	493	{
	494	if (precision == X_PRECISION && exponent_bits == 15)
	495	{
	496	*lp++ = word1;
	497	#ifdef TC_M68K
	498	*lp++ = 0;
	499	#endif
	500	*lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits);
	501	}
	502	else
	503	{
2d484c7f KH	504	word1 \|= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1)
2d484c7f KH	505	- (exponent_bits + num_bits));
252b5132 RH	506	*lp++ = word1;
	507	}
	508	}
	509	while (lp < words_end)
	510	*lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
	511
2d484c7f	512	/* Round the mantissa up, but don't change the number. */
252b5132 RH	513	if (next_bits (1))
	514	{
	515	--lp;
19b34177	516	if (prec_bits >= LITTLENUM_NUMBER_OF_BITS)
252b5132 RH	517	{
	518	int n = 0;
	519	int tmp_bits;
	520
	521	n = 0;
	522	tmp_bits = prec_bits;
	523	while (tmp_bits > LITTLENUM_NUMBER_OF_BITS)
	524	{
	525	if (lp[n] != (LITTLENUM_TYPE) - 1)
	526	break;
	527	--n;
	528	tmp_bits -= LITTLENUM_NUMBER_OF_BITS;
	529	}
19b34177 AS	530	if (tmp_bits > LITTLENUM_NUMBER_OF_BITS
	531	\|\| (lp[n] & mask[tmp_bits]) != mask[tmp_bits]
	532	\|\| (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS
	533	- exponent_bits - 1)
	534	#ifdef TC_I386
	535	/* An extended precision float with only the integer
	536	bit set would be invalid. That must be converted
	537	to the smallest normalized number. */
	538	&& !(precision == X_PRECISION
	539	&& prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS
	540	- exponent_bits - 2))
	541	#endif
	542	))
252b5132 RH	543	{
	544	unsigned long carry;
	545
	546	for (carry = 1; carry && (lp >= words); lp--)
	547	{
	548	carry = *lp + carry;
	549	*lp = carry;
	550	carry >>= LITTLENUM_NUMBER_OF_BITS;
	551	}
	552	}
	553	else
	554	{
	555	/* This is an overflow of the denormal numbers. We
	556	need to forget what we have produced, and instead
	557	generate the smallest normalized number. */
	558	lp = words;
	559	word1 = ((generic_floating_point_number.sign == '+')
	560	? 0
	561	: (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
	562	word1 \|= (1
	563	<< ((LITTLENUM_NUMBER_OF_BITS - 1)
	564	- exponent_bits));
	565	*lp++ = word1;
19b34177 AS	566	#ifdef TC_I386
	567	/* Set the integer bit in the extended precision format.
	568	This cannot happen on the m68k where the mantissa
	569	just overflows into the integer bit above. */
	570	if (precision == X_PRECISION)
	571	*lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
	572	#endif
252b5132 RH	573	while (lp < words_end)
	574	*lp++ = 0;
	575	}
	576	}
19b34177	577	else
252b5132 RH	578	*lp += 1;
	579	}
	580
	581	return return_value;
	582	}
e103941e	583	else if ((unsigned long) exponent_4 > mask[exponent_bits]
580a832e	584	\|\| (! TC_LARGEST_EXPONENT_IS_NORMAL (precision)
e103941e	585	&& (unsigned long) exponent_4 == mask[exponent_bits]))
252b5132	586	{
2d484c7f KH	587	/* Exponent overflow. Lose immediately. */
	588
	589	/* We leave return_value alone: admit we read the
	590	number, but return a floating exception
	591	because we can't encode the number. */
252b5132 RH	592	make_invalid_floating_point_number (words);
	593	return return_value;
	594	}
	595	else
	596	{
	597	word1 \|= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits))
	598	\| next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits);
	599	}
	600
	601	*lp++ = word1;
	602
	603	/* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
2d484c7f	604	middle. Either way, it is then followed by a 1 bit. */
252b5132 RH	605	if (exponent_bits == 15 && precision == X_PRECISION)
	606	{
	607	#ifdef TC_M68K
	608	*lp++ = 0;
	609	#endif
	610	*lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1)
	611	\| next_bits (LITTLENUM_NUMBER_OF_BITS - 1));
	612	}
	613
2d484c7f	614	/* The rest of the words are just mantissa bits. */
252b5132 RH	615	while (lp < words_end)
	616	*lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
	617
	618	if (next_bits (1))
	619	{
	620	unsigned long carry;
2d484c7f KH	621	/* Since the NEXT bit is a 1, round UP the mantissa.
	622	The cunning design of these hidden-1 floats permits
	623	us to let the mantissa overflow into the exponent, and
	624	it 'does the right thing'. However, we lose if the
	625	highest-order bit of the lowest-order word flips.
	626	Is that clear? */
252b5132 RH	627
	628	/* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
	629	Please allow at least 1 more bit in carry than is in a LITTLENUM.
	630	We need that extra bit to hold a carry during a LITTLENUM carry
	631	propagation. Another extra bit (kept 0) will assure us that we
	632	don't get a sticky sign bit after shifting right, and that
	633	permits us to propagate the carry without any masking of bits.
	634	#endif */
44877466	635	for (carry = 1, lp--; carry; lp--)
252b5132 RH	636	{
	637	carry = *lp + carry;
	638	*lp = carry;
	639	carry >>= LITTLENUM_NUMBER_OF_BITS;
44877466 ILT	640	if (lp == words)
44877466 ILT	641	break;
252b5132 RH	642	}
	643	if (precision == X_PRECISION && exponent_bits == 15)
	644	{
	645	/* Extended precision numbers have an explicit integer bit
	646	that we may have to restore. */
	647	if (lp == words)
	648	{
	649	#ifdef TC_M68K
	650	/* On the m68k there is a gap of 16 bits. We must
2d484c7f	651	explicitly propagate the carry into the exponent. */
252b5132 RH	652	words[0] += words[1];
	653	words[1] = 0;
	654	lp++;
	655	#endif
2d484c7f	656	/* Put back the integer bit. */
252b5132 RH	657	lp[1] \|= 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
252b5132 RH	658	}
2d484c7f	659	}
252b5132 RH	660	if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
252b5132 RH	661	{
2d484c7f KH	662	/* We leave return_value alone: admit we read the number,
	663	but return a floating exception because we can't encode
	664	the number. */
252b5132	665	*words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
252b5132 RH	666	}
252b5132 RH	667	}
2d484c7f	668	return return_value;
252b5132 RH	669	}
252b5132 RH	670
252b5132 RH	671	#ifdef TEST
	672	char *
	673	print_gen (gen)
	674	FLONUM_TYPE *gen;
	675	{
	676	FLONUM_TYPE f;
	677	LITTLENUM_TYPE arr[10];
	678	double dv;
	679	float fv;
	680	static char sbuf[40];
	681
	682	if (gen)
	683	{
	684	f = generic_floating_point_number;
	685	generic_floating_point_number = *gen;
	686	}
	687	gen_to_words (&arr[0], 4, 11);
	688	memcpy (&dv, &arr[0], sizeof (double));
	689	sprintf (sbuf, "%x %x %x %x %.14G ", arr[0], arr[1], arr[2], arr[3], dv);
	690	gen_to_words (&arr[0], 2, 8);
	691	memcpy (&fv, &arr[0], sizeof (float));
	692	sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv);
	693
	694	if (gen)
2d484c7f	695	generic_floating_point_number = f;
252b5132 RH	696
	697	return (sbuf);
	698	}
	699
	700	#endif