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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [gas/] [config/] [atof-ieee.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* atof_ieee.c - turn a Flonum into an IEEE floating point number
2
   Copyright 1987, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001, 2005,
3
   2007 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 3, 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, 51 Franklin Street - Fifth Floor, Boston, MA
20
   02110-1301, USA.  */
21
 
22
#include "as.h"
23
 
24
/* Flonums returned here.  */
25
extern FLONUM_TYPE generic_floating_point_number;
26
 
27
extern const char EXP_CHARS[];
28
/* Precision in LittleNums.  */
29
/* Don't count the gap in the m68k extended precision format.  */
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
35
 
36
/* Length in LittleNums of guard bits.  */
37
#define GUARD          2
38
 
39
#ifndef TC_LARGEST_EXPONENT_IS_NORMAL
40
#define TC_LARGEST_EXPONENT_IS_NORMAL(PRECISION) 0
41
#endif
42
 
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
 
80
static int bits_left_in_littlenum;
81
static int littlenums_left;
82
static LITTLENUM_TYPE *littlenum_pointer;
83
 
84
static int
85
next_bits (int number_of_bits)
86
{
87
  int return_value;
88
 
89
  if (!littlenums_left)
90
    return 0;
91
 
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;
102
          return_value |=
103
            (*littlenum_pointer >> bits_left_in_littlenum)
104
            & mask[number_of_bits];
105
        }
106
    }
107
  else
108
    {
109
      bits_left_in_littlenum -= number_of_bits;
110
      return_value =
111
        mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
112
    }
113
  return return_value;
114
}
115
 
116
/* Num had better be less than LITTLENUM_NUMBER_OF_BITS.  */
117
 
118
static void
119
unget_bits (int num)
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
    {
129
      bits_left_in_littlenum =
130
        num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
131
      ++littlenum_pointer;
132
      ++littlenums_left;
133
    }
134
  else
135
    bits_left_in_littlenum += num;
136
}
137
 
138
static void
139
make_invalid_floating_point_number (LITTLENUM_TYPE *words)
140
{
141
  as_bad (_("cannot create floating-point number"));
142
  /* Zero the leftmost bit.  */
143
  words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1;
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
 
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!  */
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
 
159
/* Returns pointer past text consumed.  */
160
 
161
char *
162
atof_ieee (char *str,                   /* Text to convert to binary.  */
163
           int what_kind,               /* 'd', 'f', 'x', 'p'.  */
164
           LITTLENUM_TYPE *words)       /* Build the binary here.  */
165
{
166
  /* Extra bits for zeroed low-order bits.
167
     The 1st MAX_PRECISION are zeroed, the last contain flonum bits.  */
168
  static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
169
  char *return_value;
170
  /* Number of 16-bit words in the format.  */
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
189
     have 15 leading 0 bits, so could be useless.  */
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
      precision = P_PRECISION;
222
      exponent_bits = -1;
223
      break;
224
 
225
    default:
226
      make_invalid_floating_point_number (words);
227
      return (NULL);
228
    }
229
 
230
  generic_floating_point_number.high
231
    = generic_floating_point_number.low + precision - 1 + GUARD;
232
 
233
  if (atof_generic (&return_value, ".", EXP_CHARS,
234
                    &generic_floating_point_number))
235
    {
236
      make_invalid_floating_point_number (words);
237
      return NULL;
238
    }
239
  gen_to_words (words, precision, exponent_bits);
240
 
241
  /* Restore the generic_floating_point_number's storage alloc (and
242
     everything else).  */
243
  generic_floating_point_number = save_gen_flonum;
244
 
245
  return return_value;
246
}
247
 
248
/* Turn generic_floating_point_number into a real float/double/extended.  */
249
 
250
int
251
gen_to_words (LITTLENUM_TYPE *words, int precision, long exponent_bits)
252
{
253
  int return_value = 0;
254
 
255
  long exponent_1;
256
  long exponent_2;
257
  long exponent_3;
258
  long exponent_4;
259
  int exponent_skippage;
260
  LITTLENUM_TYPE word1;
261
  LITTLENUM_TYPE *lp;
262
  LITTLENUM_TYPE *words_end;
263
 
264
  words_end = words + precision;
265
#ifdef TC_M68K
266
  if (precision == X_PRECISION)
267
    /* On the m68k the extended precision format has a gap of 16 bits
268
       between the exponent and the mantissa.  */
269
    words_end++;
270
#endif
271
 
272
  if (generic_floating_point_number.low > generic_floating_point_number.leader)
273
    {
274
      /* 0.0e0 seen.  */
275
      if (generic_floating_point_number.sign == '+')
276
        words[0] = 0x0000;
277
      else
278
        words[0] = 0x8000;
279
      memset (&words[1], '\0',
280
              (words_end - words - 1) * sizeof (LITTLENUM_TYPE));
281
      return return_value;
282
    }
283
 
284
  /* NaN:  Do the right thing.  */
285
  if (generic_floating_point_number.sign == 0)
286
    {
287
      if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
288
        as_warn ("NaNs are not supported by this target\n");
289
      if (precision == F_PRECISION)
290
        {
291
          words[0] = 0x7fff;
292
          words[1] = 0xffff;
293
        }
294
      else if (precision == X_PRECISION)
295
        {
296
#ifdef TC_M68K
297
          words[0] = 0x7fff;
298
          words[1] = 0;
299
          words[2] = 0xffff;
300
          words[3] = 0xffff;
301
          words[4] = 0xffff;
302
          words[5] = 0xffff;
303
#else /* ! TC_M68K  */
304
#ifdef TC_I386
305
          words[0] = 0xffff;
306
          words[1] = 0xc000;
307
          words[2] = 0;
308
          words[3] = 0;
309
          words[4] = 0;
310
#else /* ! TC_I386  */
311
          abort ();
312
#endif /* ! TC_I386  */
313
#endif /* ! TC_M68K  */
314
        }
315
      else
316
        {
317
          words[0] = 0x7fff;
318
          words[1] = 0xffff;
319
          words[2] = 0xffff;
320
          words[3] = 0xffff;
321
        }
322
      return return_value;
323
    }
324
  else if (generic_floating_point_number.sign == 'P')
325
    {
326
      if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
327
        as_warn ("Infinities are not supported by this target\n");
328
 
329
      /* +INF:  Do the right thing.  */
330
      if (precision == F_PRECISION)
331
        {
332
          words[0] = 0x7f80;
333
          words[1] = 0;
334
        }
335
      else if (precision == X_PRECISION)
336
        {
337
#ifdef TC_M68K
338
          words[0] = 0x7fff;
339
          words[1] = 0;
340
          words[2] = 0;
341
          words[3] = 0;
342
          words[4] = 0;
343
          words[5] = 0;
344
#else /* ! TC_M68K  */
345
#ifdef TC_I386
346
          words[0] = 0x7fff;
347
          words[1] = 0x8000;
348
          words[2] = 0;
349
          words[3] = 0;
350
          words[4] = 0;
351
#else /* ! TC_I386  */
352
          abort ();
353
#endif /* ! TC_I386  */
354
#endif /* ! TC_M68K  */
355
        }
356
      else
357
        {
358
          words[0] = 0x7ff0;
359
          words[1] = 0;
360
          words[2] = 0;
361
          words[3] = 0;
362
        }
363
      return return_value;
364
    }
365
  else if (generic_floating_point_number.sign == 'N')
366
    {
367
      if (TC_LARGEST_EXPONENT_IS_NORMAL (precision))
368
        as_warn ("Infinities are not supported by this target\n");
369
 
370
      /* Negative INF.  */
371
      if (precision == F_PRECISION)
372
        {
373
          words[0] = 0xff80;
374
          words[1] = 0x0;
375
        }
376
      else if (precision == X_PRECISION)
377
        {
378
#ifdef TC_M68K
379
          words[0] = 0xffff;
380
          words[1] = 0;
381
          words[2] = 0;
382
          words[3] = 0;
383
          words[4] = 0;
384
          words[5] = 0;
385
#else /* ! TC_M68K  */
386
#ifdef TC_I386
387
          words[0] = 0xffff;
388
          words[1] = 0x8000;
389
          words[2] = 0;
390
          words[3] = 0;
391
          words[4] = 0;
392
#else /* ! TC_I386  */
393
          abort ();
394
#endif /* ! TC_I386  */
395
#endif /* ! TC_M68K  */
396
        }
397
      else
398
        {
399
          words[0] = 0xfff0;
400
          words[1] = 0x0;
401
          words[2] = 0x0;
402
          words[3] = 0x0;
403
        }
404
      return return_value;
405
    }
406
 
407
  /* The floating point formats we support have:
408
     Bit 15 is sign bit.
409
     Bits 14:n are excess-whatever exponent.
410
     Bits n-1:0 (if any) are most significant bits of fraction.
411
     Bits 15:0 of the next word(s) are the next most significant bits.
412
 
413
     So we need: number of bits of exponent, number of bits of
414
     mantissa.  */
415
  bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
416
  littlenum_pointer = generic_floating_point_number.leader;
417
  littlenums_left = (1
418
                     + generic_floating_point_number.leader
419
                     - generic_floating_point_number.low);
420
 
421
  /* Seek (and forget) 1st significant bit.  */
422
  for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage);;
423
  exponent_1 = (generic_floating_point_number.exponent
424
                + generic_floating_point_number.leader
425
                + 1
426
                - generic_floating_point_number.low);
427
 
428
  /* Radix LITTLENUM_RADIX, point just higher than
429
     generic_floating_point_number.leader.  */
430
  exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
431
 
432
  /* Radix 2.  */
433
  exponent_3 = exponent_2 - exponent_skippage;
434
 
435
  /* Forget leading zeros, forget 1st bit.  */
436
  exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
437
 
438
  /* Offset exponent.  */
439
  lp = words;
440
 
441
  /* Word 1.  Sign, exponent and perhaps high bits.  */
442
  word1 = ((generic_floating_point_number.sign == '+')
443
           ? 0
444
           : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
445
 
446
  /* Assume 2's complement integers.  */
447
  if (exponent_4 <= 0)
448
    {
449
      int prec_bits;
450
      int num_bits;
451
 
452
      unget_bits (1);
453
      num_bits = -exponent_4;
454
      prec_bits =
455
        LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
456
#ifdef TC_I386
457
      if (precision == X_PRECISION && exponent_bits == 15)
458
        {
459
          /* On the i386 a denormalized extended precision float is
460
             shifted down by one, effectively decreasing the exponent
461
             bias by one.  */
462
          prec_bits -= 1;
463
          num_bits += 1;
464
        }
465
#endif
466
 
467
      if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits)
468
        {
469
          /* Bigger than one littlenum.  */
470
          num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
471
          *lp++ = word1;
472
          if (num_bits + exponent_bits + 1
473
              > precision * LITTLENUM_NUMBER_OF_BITS)
474
            {
475
              /* Exponent overflow.  */
476
              make_invalid_floating_point_number (words);
477
              return return_value;
478
            }
479
#ifdef TC_M68K
480
          if (precision == X_PRECISION && exponent_bits == 15)
481
            *lp++ = 0;
482
#endif
483
          while (num_bits >= LITTLENUM_NUMBER_OF_BITS)
484
            {
485
              num_bits -= LITTLENUM_NUMBER_OF_BITS;
486
              *lp++ = 0;
487
            }
488
          if (num_bits)
489
            *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits));
490
        }
491
      else
492
        {
493
          if (precision == X_PRECISION && exponent_bits == 15)
494
            {
495
              *lp++ = word1;
496
#ifdef TC_M68K
497
              *lp++ = 0;
498
#endif
499
              *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits);
500
            }
501
          else
502
            {
503
              word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1)
504
                                  - (exponent_bits + num_bits));
505
              *lp++ = word1;
506
            }
507
        }
508
      while (lp < words_end)
509
        *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
510
 
511
      /* Round the mantissa up, but don't change the number.  */
512
      if (next_bits (1))
513
        {
514
          --lp;
515
          if (prec_bits >= LITTLENUM_NUMBER_OF_BITS)
516
            {
517
              int n = 0;
518
              int tmp_bits;
519
 
520
              n = 0;
521
              tmp_bits = prec_bits;
522
              while (tmp_bits > LITTLENUM_NUMBER_OF_BITS)
523
                {
524
                  if (lp[n] != (LITTLENUM_TYPE) - 1)
525
                    break;
526
                  --n;
527
                  tmp_bits -= LITTLENUM_NUMBER_OF_BITS;
528
                }
529
              if (tmp_bits > LITTLENUM_NUMBER_OF_BITS
530
                  || (lp[n] & mask[tmp_bits]) != mask[tmp_bits]
531
                  || (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS
532
                                    - exponent_bits - 1)
533
#ifdef TC_I386
534
                      /* An extended precision float with only the integer
535
                         bit set would be invalid.  That must be converted
536
                         to the smallest normalized number.  */
537
                      && !(precision == X_PRECISION
538
                           && prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS
539
                                            - exponent_bits - 2))
540
#endif
541
                      ))
542
                {
543
                  unsigned long carry;
544
 
545
                  for (carry = 1; carry && (lp >= words); lp--)
546
                    {
547
                      carry = *lp + carry;
548
                      *lp = carry;
549
                      carry >>= LITTLENUM_NUMBER_OF_BITS;
550
                    }
551
                }
552
              else
553
                {
554
                  /* This is an overflow of the denormal numbers.  We
555
                     need to forget what we have produced, and instead
556
                     generate the smallest normalized number.  */
557
                  lp = words;
558
                  word1 = ((generic_floating_point_number.sign == '+')
559
                           ? 0
560
                           : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
561
                  word1 |= (1
562
                            << ((LITTLENUM_NUMBER_OF_BITS - 1)
563
                                - exponent_bits));
564
                  *lp++ = word1;
565
#ifdef TC_I386
566
                  /* Set the integer bit in the extended precision format.
567
                     This cannot happen on the m68k where the mantissa
568
                     just overflows into the integer bit above.  */
569
                  if (precision == X_PRECISION)
570
                    *lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
571
#endif
572
                  while (lp < words_end)
573
                    *lp++ = 0;
574
                }
575
            }
576
          else
577
            *lp += 1;
578
        }
579
 
580
      return return_value;
581
    }
582
  else if ((unsigned long) exponent_4 > mask[exponent_bits]
583
           || (! TC_LARGEST_EXPONENT_IS_NORMAL (precision)
584
               && (unsigned long) exponent_4 == mask[exponent_bits]))
585
    {
586
      /* Exponent overflow.  Lose immediately.  */
587
 
588
      /* We leave return_value alone: admit we read the
589
         number, but return a floating exception
590
         because we can't encode the number.  */
591
      make_invalid_floating_point_number (words);
592
      return return_value;
593
    }
594
  else
595
    {
596
      word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits))
597
        | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits);
598
    }
599
 
600
  *lp++ = word1;
601
 
602
  /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
603
     middle.  Either way, it is then followed by a 1 bit.  */
604
  if (exponent_bits == 15 && precision == X_PRECISION)
605
    {
606
#ifdef TC_M68K
607
      *lp++ = 0;
608
#endif
609
      *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1)
610
               | next_bits (LITTLENUM_NUMBER_OF_BITS - 1));
611
    }
612
 
613
  /* The rest of the words are just mantissa bits.  */
614
  while (lp < words_end)
615
    *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
616
 
617
  if (next_bits (1))
618
    {
619
      unsigned long carry;
620
      /* Since the NEXT bit is a 1, round UP the mantissa.
621
         The cunning design of these hidden-1 floats permits
622
         us to let the mantissa overflow into the exponent, and
623
         it 'does the right thing'. However, we lose if the
624
         highest-order bit of the lowest-order word flips.
625
         Is that clear?  */
626
 
627
      /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
628
         Please allow at least 1 more bit in carry than is in a LITTLENUM.
629
         We need that extra bit to hold a carry during a LITTLENUM carry
630
         propagation. Another extra bit (kept 0) will assure us that we
631
         don't get a sticky sign bit after shifting right, and that
632
         permits us to propagate the carry without any masking of bits.
633
         #endif */
634
      for (carry = 1, lp--; carry; lp--)
635
        {
636
          carry = *lp + carry;
637
          *lp = carry;
638
          carry >>= LITTLENUM_NUMBER_OF_BITS;
639
          if (lp == words)
640
            break;
641
        }
642
      if (precision == X_PRECISION && exponent_bits == 15)
643
        {
644
          /* Extended precision numbers have an explicit integer bit
645
             that we may have to restore.  */
646
          if (lp == words)
647
            {
648
#ifdef TC_M68K
649
              /* On the m68k there is a gap of 16 bits.  We must
650
                 explicitly propagate the carry into the exponent.  */
651
              words[0] += words[1];
652
              words[1] = 0;
653
              lp++;
654
#endif
655
              /* Put back the integer bit.  */
656
              lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
657
            }
658
        }
659
      if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
660
        {
661
          /* We leave return_value alone: admit we read the number,
662
             but return a floating exception because we can't encode
663
             the number.  */
664
          *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
665
        }
666
    }
667
  return return_value;
668
}
669
 
670
#ifdef TEST
671
char *
672
print_gen (gen)
673
     FLONUM_TYPE *gen;
674
{
675
  FLONUM_TYPE f;
676
  LITTLENUM_TYPE arr[10];
677
  double dv;
678
  float fv;
679
  static char sbuf[40];
680
 
681
  if (gen)
682
    {
683
      f = generic_floating_point_number;
684
      generic_floating_point_number = *gen;
685
    }
686
  gen_to_words (&arr[0], 4, 11);
687
  memcpy (&dv, &arr[0], sizeof (double));
688
  sprintf (sbuf, "%x %x %x %x %.14G   ", arr[0], arr[1], arr[2], arr[3], dv);
689
  gen_to_words (&arr[0], 2, 8);
690
  memcpy (&fv, &arr[0], sizeof (float));
691
  sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv);
692
 
693
  if (gen)
694
    generic_floating_point_number = f;
695
 
696
  return (sbuf);
697
}
698
#endif
699
 
700
extern const char FLT_CHARS[];
701
#define MAX_LITTLENUMS 6
702
 
703
/* This is a utility function called from various tc-*.c files.  It
704
   is here in order to reduce code duplication.
705
 
706
   Turn a string at input_line_pointer into a floating point constant
707
   of type TYPE (a character found in the FLT_CHARS macro), and store
708
   it as LITTLENUMS in the bytes buffer LITP.  The number of chars
709
   emitted is stored in *SIZEP.  BIG_WORDIAN is TRUE if the littlenums
710
   should be emitted most significant littlenum first.
711
 
712
   An error message is returned, or a NULL pointer if everything went OK.  */
713
 
714
char *
715
ieee_md_atof (int type,
716
              char *litP,
717
              int *sizeP,
718
              bfd_boolean big_wordian)
719
{
720
  LITTLENUM_TYPE words[MAX_LITTLENUMS];
721
  LITTLENUM_TYPE *wordP;
722
  char *t;
723
  int prec = 0;
724
 
725
  if (strchr (FLT_CHARS, type) != NULL)
726
    {
727
      switch (type)
728
        {
729
        case 'f':
730
        case 'F':
731
        case 's':
732
        case 'S':
733
          prec = F_PRECISION;
734
          break;
735
 
736
        case 'd':
737
        case 'D':
738
        case 'r':
739
        case 'R':
740
          prec = D_PRECISION;
741
          break;
742
 
743
        case 't':
744
        case 'T':
745
          prec = X_PRECISION;
746
          type = 'x';           /* This is what atof_ieee() understands.  */
747
          break;
748
 
749
        case 'x':
750
        case 'X':
751
        case 'p':
752
        case 'P':
753
#ifdef TC_M68K
754
          /* Note: on the m68k there is a gap of 16 bits (one littlenum)
755
             between the exponent and mantissa.  Hence the precision is
756
             6 and not 5.  */
757
          prec = P_PRECISION + 1;
758
#else
759
          prec = P_PRECISION;
760
#endif
761
          break;
762
 
763
        default:
764
          break;
765
        }
766
    }
767
  /* The 'f' and 'd' types are always recognised, even if the target has
768
     not put them into the FLT_CHARS macro.  This is because the 'f' type
769
     can come from the .dc.s, .dcb.s, .float or .single pseudo-ops and the
770
     'd' type from the .dc.d, .dbc.d or .double pseudo-ops.
771
 
772
     The 'x' type is not implicitly recongised however, even though it can
773
     be generated by the .dc.x and .dbc.x pseudo-ops because not all targets
774
     can support floating point values that big.  ie the target has to
775
     explicitly allow them by putting them into FLT_CHARS.  */
776
  else if (type == 'f')
777
    prec = F_PRECISION;
778
  else if (type == 'd')
779
    prec = D_PRECISION;
780
 
781
  if (prec == 0)
782
    {
783
      *sizeP = 0;
784
      return _("Unrecognized or unsupported floating point constant");
785
    }
786
 
787
  assert (prec <= MAX_LITTLENUMS);
788
 
789
  t = atof_ieee (input_line_pointer, type, words);
790
  if (t)
791
    input_line_pointer = t;
792
 
793
  *sizeP = prec * sizeof (LITTLENUM_TYPE);
794
 
795
  if (big_wordian)
796
    {
797
      for (wordP = words; prec --;)
798
        {
799
          md_number_to_chars (litP, (valueT) (* wordP ++), sizeof (LITTLENUM_TYPE));
800
          litP += sizeof (LITTLENUM_TYPE);
801
        }
802
    }
803
  else
804
    {
805
      for (wordP = words + prec; prec --;)
806
        {
807
          md_number_to_chars (litP, (valueT) (* -- wordP), sizeof (LITTLENUM_TYPE));
808
          litP += sizeof (LITTLENUM_TYPE);
809
        }
810
    }
811
 
812
  return NULL;
813
}

powered by: WebSVN 2.1.0

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