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