1	/* real.cc - software floating point emulation.
2	Copyright (C) 1993-2023 Free Software Foundation, Inc.
3	Contributed by Stephen L. Moshier (moshier@world.std.com).
4	Re-written by Richard Henderson <rth@redhat.com>
5
6	This file is part of GCC.
7
8	GCC is free software; you can redistribute it and/or modify it under
9	the terms of the GNU General Public License as published by the Free
10	Software Foundation; either version 3, or (at your option) any later
11	version.
12
13	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14	WARRANTY; without even the implied warranty of MERCHANTABILITY or
15	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16	for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with GCC; see the file COPYING3. If not see
20	<http://www.gnu.org/licenses/>. */
21
22	#include "config.h"
23	#include "system.h"
24	#include "coretypes.h"
25	#include "tm.h"
26	#include "rtl.h"
27	#include "tree.h"
28	#include "realmpfr.h"
29	#include "dfp.h"
30
31	/* The floating point model used internally is not exactly IEEE 754
32	compliant, and close to the description in the ISO C99 standard,
33	section 5.2.4.2.2 Characteristics of floating types.
34
35	Specifically
36
37	x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
38
39	where
40	s = sign (+- 1)
41	b = base or radix, here always 2
42	e = exponent
43	p = precision (the number of base-b digits in the significand)
44	f_k = the digits of the significand.
45
46	We differ from typical IEEE 754 encodings in that the entire
47	significand is fractional. Normalized significands are in the
48	range [0.5, 1.0).
49
50	A requirement of the model is that P be larger than the largest
51	supported target floating-point type by at least 2 bits. This gives
52	us proper rounding when we truncate to the target type. In addition,
53	E must be large enough to hold the smallest supported denormal number
54	in a normalized form.
55
56	Both of these requirements are easily satisfied. The largest target
57	significand is 113 bits; we store at least 160. The smallest
58	denormal number fits in 17 exponent bits; we store 26. */
59
60
61	/* Used to classify two numbers simultaneously. */
62	#define CLASS2(A, B) ((A) << 2 | (B))
63
64	#if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
65	#error "Some constant folding done by hand to avoid shift count warnings"
66	#endif
67
68	static void get_zero (REAL_VALUE_TYPE *, int);
69	static void get_canonical_qnan (REAL_VALUE_TYPE *, int);
70	static void get_canonical_snan (REAL_VALUE_TYPE *, int);
71	static void get_inf (REAL_VALUE_TYPE *, int);
72	static bool sticky_rshift_significand (REAL_VALUE_TYPE *,
73	const REAL_VALUE_TYPE *, unsigned int);
74	static void rshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
75	unsigned int);
76	static void lshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
77	unsigned int);
78	static void lshift_significand_1 (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
79	static bool add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *,
80	const REAL_VALUE_TYPE *);
81	static bool sub_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
82	const REAL_VALUE_TYPE *, int);
83	static void neg_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
84	static int cmp_significands (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
85	static int cmp_significand_0 (const REAL_VALUE_TYPE *);
86	static void set_significand_bit (REAL_VALUE_TYPE *, unsigned int);
87	static void clear_significand_bit (REAL_VALUE_TYPE *, unsigned int);
88	static bool test_significand_bit (REAL_VALUE_TYPE *, unsigned int);
89	static void clear_significand_below (REAL_VALUE_TYPE *, unsigned int);
90	static bool div_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
91	const REAL_VALUE_TYPE *);
92	static void normalize (REAL_VALUE_TYPE *);
93
94	static bool do_add (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
95	const REAL_VALUE_TYPE *, int);
96	static bool do_multiply (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
97	const REAL_VALUE_TYPE *);
98	static bool do_divide (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
99	const REAL_VALUE_TYPE *);
100	static int do_compare (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
101	static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
102
103	static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *);
104	static void decimal_from_integer (REAL_VALUE_TYPE *);
105	static void decimal_integer_string (char *, const REAL_VALUE_TYPE *,
106	size_t);
107
108	static const REAL_VALUE_TYPE * ten_to_ptwo (int);
109	static const REAL_VALUE_TYPE * ten_to_mptwo (int);
110	static const REAL_VALUE_TYPE * real_digit (int);
111	static void times_pten (REAL_VALUE_TYPE *, int);
112
113	static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *);
114
115	/* Determine whether a floating-point value X is a denormal. R is
116	expected to be in denormal form, so this function is only
117	meaningful after a call to round_for_format. */
118
119	static inline bool
120	real_isdenormal (const REAL_VALUE_TYPE *r)
121	{
122	return r->cl == rvc_normal && (r->sig[SIGSZ-1] & SIG_MSB) == 0;
123	}
124
125	/* Initialize R with a positive zero. */
126
127	static inline void
128	get_zero (REAL_VALUE_TYPE *r, int sign)
129	{
130	memset (s: r, c: 0, n: sizeof (*r));
131	r->sign = sign;
132	}
133
134	/* Initialize R with the canonical quiet NaN. */
135
136	static inline void
137	get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
138	{
139	memset (s: r, c: 0, n: sizeof (*r));
140	r->cl = rvc_nan;
141	r->sign = sign;
142	r->canonical = 1;
143	}
144
145	static inline void
146	get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
147	{
148	memset (s: r, c: 0, n: sizeof (*r));
149	r->cl = rvc_nan;
150	r->sign = sign;
151	r->signalling = 1;
152	r->canonical = 1;
153	}
154
155	static inline void
156	get_inf (REAL_VALUE_TYPE *r, int sign)
157	{
158	memset (s: r, c: 0, n: sizeof (*r));
159	r->cl = rvc_inf;
160	r->sign = sign;
161	}
162
163
164	/* Right-shift the significand of A by N bits; put the result in the
165	significand of R. If any one bits are shifted out, return true. */
166
167	static bool
168	sticky_rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
169	unsigned int n)
170	{
171	unsigned long sticky = 0;
172	unsigned int i, ofs = 0;
173
174	if (n >= HOST_BITS_PER_LONG)
175	{
176	for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i)
177	sticky |= a->sig[i];
178	n &= HOST_BITS_PER_LONG - 1;
179	}
180
181	if (n != 0)
182	{
183	sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1);
184	for (i = 0; i < SIGSZ; ++i)
185	{
186	r->sig[i]
187	= (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
188	| ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
189	<< (HOST_BITS_PER_LONG - n)));
190	}
191	}
192	else
193	{
194	for (i = 0; ofs + i < SIGSZ; ++i)
195	r->sig[i] = a->sig[ofs + i];
196	for (; i < SIGSZ; ++i)
197	r->sig[i] = 0;
198	}
199
200	return sticky != 0;
201	}
202
203	/* Right-shift the significand of A by N bits; put the result in the
204	significand of R. */
205
206	static void
207	rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
208	unsigned int n)
209	{
210	unsigned int i, ofs = n / HOST_BITS_PER_LONG;
211
212	n &= HOST_BITS_PER_LONG - 1;
213	if (n != 0)
214	{
215	for (i = 0; i < SIGSZ; ++i)
216	{
217	r->sig[i]
218	= (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
219	| ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
220	<< (HOST_BITS_PER_LONG - n)));
221	}
222	}
223	else
224	{
225	for (i = 0; ofs + i < SIGSZ; ++i)
226	r->sig[i] = a->sig[ofs + i];
227	for (; i < SIGSZ; ++i)
228	r->sig[i] = 0;
229	}
230	}
231
232	/* Left-shift the significand of A by N bits; put the result in the
233	significand of R. */
234
235	static void
236	lshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
237	unsigned int n)
238	{
239	unsigned int i, ofs = n / HOST_BITS_PER_LONG;
240
241	n &= HOST_BITS_PER_LONG - 1;
242	if (n == 0)
243	{
244	for (i = 0; ofs + i < SIGSZ; ++i)
245	r->sig[SIGSZ-1-i] = a->sig[SIGSZ-1-i-ofs];
246	for (; i < SIGSZ; ++i)
247	r->sig[SIGSZ-1-i] = 0;
248	}
249	else
250	for (i = 0; i < SIGSZ; ++i)
251	{
252	r->sig[SIGSZ-1-i]
253	= (((ofs + i >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs]) << n)
254	| ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs-1])
255	>> (HOST_BITS_PER_LONG - n)));
256	}
257	}
258
259	/* Likewise, but N is specialized to 1. */
260
261	static inline void
262	lshift_significand_1 (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
263	{
264	unsigned int i;
265
266	for (i = SIGSZ - 1; i > 0; --i)
267	r->sig[i] = (a->sig[i] << 1) | (a->sig[i-1] >> (HOST_BITS_PER_LONG - 1));
268	r->sig[0] = a->sig[0] << 1;
269	}
270
271	/* Add the significands of A and B, placing the result in R. Return
272	true if there was carry out of the most significant word. */
273
274	static inline bool
275	add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
276	const REAL_VALUE_TYPE *b)
277	{
278	bool carry = false;
279	int i;
280
281	for (i = 0; i < SIGSZ; ++i)
282	{
283	unsigned long ai = a->sig[i];
284	unsigned long ri = ai + b->sig[i];
285
286	if (carry)
287	{
288	carry = ri < ai;
289	carry |= ++ri == 0;
290	}
291	else
292	carry = ri < ai;
293
294	r->sig[i] = ri;
295	}
296
297	return carry;
298	}
299
300	/* Subtract the significands of A and B, placing the result in R. CARRY is
301	true if there's a borrow incoming to the least significant word.
302	Return true if there was borrow out of the most significant word. */
303
304	static inline bool
305	sub_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
306	const REAL_VALUE_TYPE *b, int carry)
307	{
308	int i;
309
310	for (i = 0; i < SIGSZ; ++i)
311	{
312	unsigned long ai = a->sig[i];
313	unsigned long ri = ai - b->sig[i];
314
315	if (carry)
316	{
317	carry = ri > ai;
318	carry |= ~--ri == 0;
319	}
320	else
321	carry = ri > ai;
322
323	r->sig[i] = ri;
324	}
325
326	return carry;
327	}
328
329	/* Negate the significand A, placing the result in R. */
330
331	static inline void
332	neg_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
333	{
334	bool carry = true;
335	int i;
336
337	for (i = 0; i < SIGSZ; ++i)
338	{
339	unsigned long ri, ai = a->sig[i];
340
341	if (carry)
342	{
343	if (ai)
344	{
345	ri = -ai;
346	carry = false;
347	}
348	else
349	ri = ai;
350	}
351	else
352	ri = ~ai;
353
354	r->sig[i] = ri;
355	}
356	}
357
358	/* Compare significands. Return tri-state vs zero. */
359
360	static inline int
361	cmp_significands (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
362	{
363	int i;
364
365	for (i = SIGSZ - 1; i >= 0; --i)
366	{
367	unsigned long ai = a->sig[i];
368	unsigned long bi = b->sig[i];
369
370	if (ai > bi)
371	return 1;
372	if (ai < bi)
373	return -1;
374	}
375
376	return 0;
377	}
378
379	/* Return true if A is nonzero. */
380
381	static inline int
382	cmp_significand_0 (const REAL_VALUE_TYPE *a)
383	{
384	int i;
385
386	for (i = SIGSZ - 1; i >= 0; --i)
387	if (a->sig[i])
388	return 1;
389
390	return 0;
391	}
392
393	/* Set bit N of the significand of R. */
394
395	static inline void
396	set_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
397	{
398	r->sig[n / HOST_BITS_PER_LONG]
399	|= (unsigned long)1 << (n % HOST_BITS_PER_LONG);
400	}
401
402	/* Clear bit N of the significand of R. */
403
404	static inline void
405	clear_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
406	{
407	r->sig[n / HOST_BITS_PER_LONG]
408	&= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG));
409	}
410
411	/* Test bit N of the significand of R. */
412
413	static inline bool
414	test_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
415	{
416	/* ??? Compiler bug here if we return this expression directly.
417	The conversion to bool strips the "&1" and we wind up testing
418	e.g. 2 != 0 -> true. Seen in gcc version 3.2 20020520. */
419	int t = (r->sig[n / HOST_BITS_PER_LONG] >> (n % HOST_BITS_PER_LONG)) & 1;
420	return t;
421	}
422
423	/* Clear bits 0..N-1 of the significand of R. */
424
425	static void
426	clear_significand_below (REAL_VALUE_TYPE *r, unsigned int n)
427	{
428	int i, w = n / HOST_BITS_PER_LONG;
429
430	for (i = 0; i < w; ++i)
431	r->sig[i] = 0;
432
433	/* We are actually passing N == SIGNIFICAND_BITS which would result
434	in an out-of-bound access below. */
435	if (n % HOST_BITS_PER_LONG != 0)
436	r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1);
437	}
438
439	/* Divide the significands of A and B, placing the result in R. Return
440	true if the division was inexact. */
441
442	static inline bool
443	div_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
444	const REAL_VALUE_TYPE *b)
445	{
446	REAL_VALUE_TYPE u;
447	int i, bit = SIGNIFICAND_BITS - 1;
448	unsigned long msb, inexact;
449
450	u = *a;
451	memset (s: r->sig, c: 0, n: sizeof (r->sig));
452
453	msb = 0;
454	goto start;
455	do
456	{
457	msb = u.sig[SIGSZ-1] & SIG_MSB;
458	lshift_significand_1 (r: &u, a: &u);
459	start:
460	if (msb || cmp_significands (a: &u, b) >= 0)
461	{
462	sub_significands (r: &u, a: &u, b, carry: 0);
463	set_significand_bit (r, n: bit);
464	}
465	}
466	while (--bit >= 0);
467
468	for (i = 0, inexact = 0; i < SIGSZ; i++)
469	inexact |= u.sig[i];
470
471	return inexact != 0;
472	}
473
474	/* Adjust the exponent and significand of R such that the most
475	significant bit is set. We underflow to zero and overflow to
476	infinity here, without denormals. (The intermediate representation
477	exponent is large enough to handle target denormals normalized.) */
478
479	static void
480	normalize (REAL_VALUE_TYPE *r)
481	{
482	int shift = 0, exp;
483	int i, j;
484
485	if (r->decimal)
486	return;
487
488	/* Find the first word that is nonzero. */
489	for (i = SIGSZ - 1; i >= 0; i--)
490	if (r->sig[i] == 0)
491	shift += HOST_BITS_PER_LONG;
492	else
493	break;
494
495	/* Zero significand flushes to zero. */
496	if (i < 0)
497	{
498	r->cl = rvc_zero;
499	SET_REAL_EXP (r, 0);
500	return;
501	}
502
503	/* Find the first bit that is nonzero. */
504	for (j = 0; ; j++)
505	if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j)))
506	break;
507	shift += j;
508
509	if (shift > 0)
510	{
511	exp = REAL_EXP (r) - shift;
512	if (exp > MAX_EXP)
513	get_inf (r, sign: r->sign);
514	else if (exp < -MAX_EXP)
515	get_zero (r, sign: r->sign);
516	else
517	{
518	SET_REAL_EXP (r, exp);
519	lshift_significand (r, a: r, n: shift);
520	}
521	}
522	}
523
524	/* Calculate R = A + (SUBTRACT_P ? -B : B). Return true if the
525	result may be inexact due to a loss of precision. */
526
527	static bool
528	do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
529	const REAL_VALUE_TYPE *b, int subtract_p)
530	{
531	int dexp, sign, exp;
532	REAL_VALUE_TYPE t;
533	bool inexact = false;
534
535	/* Determine if we need to add or subtract. */
536	sign = a->sign;
537	subtract_p = (sign ^ b->sign) ^ subtract_p;
538
539	switch (CLASS2 (a->cl, b->cl))
540	{
541	case CLASS2 (rvc_zero, rvc_zero):
542	/* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
543	get_zero (r, sign: sign & !subtract_p);
544	return false;
545
546	case CLASS2 (rvc_zero, rvc_normal):
547	case CLASS2 (rvc_zero, rvc_inf):
548	case CLASS2 (rvc_zero, rvc_nan):
549	/* 0 + ANY = ANY. */
550	case CLASS2 (rvc_normal, rvc_nan):
551	case CLASS2 (rvc_inf, rvc_nan):
552	case CLASS2 (rvc_nan, rvc_nan):
553	/* ANY + NaN = NaN. */
554	case CLASS2 (rvc_normal, rvc_inf):
555	/* R + Inf = Inf. */
556	*r = *b;
557	/* Make resulting NaN value to be qNaN. The caller has the
558	responsibility to avoid the operation if flag_signaling_nans
559	is on. */
560	r->signalling = 0;
561	r->sign = sign ^ subtract_p;
562	return false;
563
564	case CLASS2 (rvc_normal, rvc_zero):
565	case CLASS2 (rvc_inf, rvc_zero):
566	case CLASS2 (rvc_nan, rvc_zero):
567	/* ANY + 0 = ANY. */
568	case CLASS2 (rvc_nan, rvc_normal):
569	case CLASS2 (rvc_nan, rvc_inf):
570	/* NaN + ANY = NaN. */
571	case CLASS2 (rvc_inf, rvc_normal):
572	/* Inf + R = Inf. */
573	*r = *a;
574	/* Make resulting NaN value to be qNaN. The caller has the
575	responsibility to avoid the operation if flag_signaling_nans
576	is on. */
577	r->signalling = 0;
578	return false;
579
580	case CLASS2 (rvc_inf, rvc_inf):
581	if (subtract_p)
582	/* Inf - Inf = NaN. */
583	get_canonical_qnan (r, sign: 0);
584	else
585	/* Inf + Inf = Inf. */
586	*r = *a;
587	return false;
588
589	case CLASS2 (rvc_normal, rvc_normal):
590	break;
591
592	default:
593	gcc_unreachable ();
594	}
595
596	/* Swap the arguments such that A has the larger exponent. */
597	dexp = REAL_EXP (a) - REAL_EXP (b);
598	if (dexp < 0)
599	{
600	const REAL_VALUE_TYPE *t;
601	t = a, a = b, b = t;
602	dexp = -dexp;
603	sign ^= subtract_p;
604	}
605	exp = REAL_EXP (a);
606
607	/* If the exponents are not identical, we need to shift the
608	significand of B down. */
609	if (dexp > 0)
610	{
611	/* If the exponents are too far apart, the significands
612	do not overlap, which makes the subtraction a noop. */
613	if (dexp >= SIGNIFICAND_BITS)
614	{
615	*r = *a;
616	r->sign = sign;
617	return true;
618	}
619
620	inexact |= sticky_rshift_significand (r: &t, a: b, n: dexp);
621	b = &t;
622	}
623
624	if (subtract_p)
625	{
626	if (sub_significands (r, a, b, carry: inexact))
627	{
628	/* We got a borrow out of the subtraction. That means that
629	A and B had the same exponent, and B had the larger
630	significand. We need to swap the sign and negate the
631	significand. */
632	sign ^= 1;
633	neg_significand (r, a: r);
634	}
635	}
636	else
637	{
638	if (add_significands (r, a, b))
639	{
640	/* We got carry out of the addition. This means we need to
641	shift the significand back down one bit and increase the
642	exponent. */
643	inexact |= sticky_rshift_significand (r, a: r, n: 1);
644	r->sig[SIGSZ-1] |= SIG_MSB;
645	if (++exp > MAX_EXP)
646	{
647	get_inf (r, sign);
648	return true;
649	}
650	}
651	}
652
653	r->cl = rvc_normal;
654	r->sign = sign;
655	SET_REAL_EXP (r, exp);
656	/* Zero out the remaining fields. */
657	r->signalling = 0;
658	r->canonical = 0;
659	r->decimal = 0;
660
661	/* Re-normalize the result. */
662	normalize (r);
663
664	/* Special case: if the subtraction results in zero, the result
665	is positive. */
666	if (r->cl == rvc_zero)
667	r->sign = 0;
668	else
669	r->sig[0] |= inexact;
670
671	return inexact;
672	}
673
674	/* Calculate R = A * B. Return true if the result may be inexact. */
675
676	static bool
677	do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
678	const REAL_VALUE_TYPE *b)
679	{
680	REAL_VALUE_TYPE u, t, *rr;
681	unsigned int i, j, k;
682	int sign = a->sign ^ b->sign;
683	bool inexact = false;
684
685	switch (CLASS2 (a->cl, b->cl))
686	{
687	case CLASS2 (rvc_zero, rvc_zero):
688	case CLASS2 (rvc_zero, rvc_normal):
689	case CLASS2 (rvc_normal, rvc_zero):
690	/* +-0 * ANY = 0 with appropriate sign. */
691	get_zero (r, sign);
692	return false;
693
694	case CLASS2 (rvc_zero, rvc_nan):
695	case CLASS2 (rvc_normal, rvc_nan):
696	case CLASS2 (rvc_inf, rvc_nan):
697	case CLASS2 (rvc_nan, rvc_nan):
698	/* ANY * NaN = NaN. */
699	*r = *b;
700	/* Make resulting NaN value to be qNaN. The caller has the
701	responsibility to avoid the operation if flag_signaling_nans
702	is on. */
703	r->signalling = 0;
704	r->sign = sign;
705	return false;
706
707	case CLASS2 (rvc_nan, rvc_zero):
708	case CLASS2 (rvc_nan, rvc_normal):
709	case CLASS2 (rvc_nan, rvc_inf):
710	/* NaN * ANY = NaN. */
711	*r = *a;
712	/* Make resulting NaN value to be qNaN. The caller has the
713	responsibility to avoid the operation if flag_signaling_nans
714	is on. */
715	r->signalling = 0;
716	r->sign = sign;
717	return false;
718
719	case CLASS2 (rvc_zero, rvc_inf):
720	case CLASS2 (rvc_inf, rvc_zero):
721	/* 0 * Inf = NaN */
722	get_canonical_qnan (r, sign);
723	return false;
724
725	case CLASS2 (rvc_inf, rvc_inf):
726	case CLASS2 (rvc_normal, rvc_inf):
727	case CLASS2 (rvc_inf, rvc_normal):
728	/* Inf * Inf = Inf, R * Inf = Inf */
729	get_inf (r, sign);
730	return false;
731
732	case CLASS2 (rvc_normal, rvc_normal):
733	break;
734
735	default:
736	gcc_unreachable ();
737	}
738
739	if (r == a || r == b)
740	rr = &t;
741	else
742	rr = r;
743	get_zero (r: rr, sign: 0);
744
745	/* Collect all the partial products. Since we don't have sure access
746	to a widening multiply, we split each long into two half-words.
747
748	Consider the long-hand form of a four half-word multiplication:
749
750	A B C D
751	* E F G H
752	--------------
753	DE DF DG DH
754	CE CF CG CH
755	BE BF BG BH
756	AE AF AG AH
757
758	We construct partial products of the widened half-word products
759	that are known to not overlap, e.g. DF+DH. Each such partial
760	product is given its proper exponent, which allows us to sum them
761	and obtain the finished product. */
762
763	for (i = 0; i < SIGSZ * 2; ++i)
764	{
765	unsigned long ai = a->sig[i / 2];
766	if (i & 1)
767	ai >>= HOST_BITS_PER_LONG / 2;
768	else
769	ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
770
771	if (ai == 0)
772	continue;
773
774	for (j = 0; j < 2; ++j)
775	{
776	int exp = (REAL_EXP (a) - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
777	+ (REAL_EXP (b) - (1-j)*(HOST_BITS_PER_LONG/2)));
778
779	if (exp > MAX_EXP)
780	{
781	get_inf (r, sign);
782	return true;
783	}
784	if (exp < -MAX_EXP)
785	{
786	/* Would underflow to zero, which we shouldn't bother adding. */
787	inexact = true;
788	continue;
789	}
790
791	memset (s: &u, c: 0, n: sizeof (u));
792	u.cl = rvc_normal;
793	SET_REAL_EXP (&u, exp);
794
795	for (k = j; k < SIGSZ * 2; k += 2)
796	{
797	unsigned long bi = b->sig[k / 2];
798	if (k & 1)
799	bi >>= HOST_BITS_PER_LONG / 2;
800	else
801	bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
802
803	u.sig[k / 2] = ai * bi;
804	}
805
806	normalize (r: &u);
807	inexact |= do_add (r: rr, a: rr, b: &u, subtract_p: 0);
808	}
809	}
810
811	rr->sign = sign;
812	if (rr != r)
813	*r = t;
814
815	return inexact;
816	}
817
818	/* Calculate R = A / B. Return true if the result may be inexact. */
819
820	static bool
821	do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
822	const REAL_VALUE_TYPE *b)
823	{
824	int exp, sign = a->sign ^ b->sign;
825	REAL_VALUE_TYPE t, *rr;
826	bool inexact;
827
828	switch (CLASS2 (a->cl, b->cl))
829	{
830	case CLASS2 (rvc_zero, rvc_zero):
831	/* 0 / 0 = NaN. */
832	case CLASS2 (rvc_inf, rvc_inf):
833	/* Inf / Inf = NaN. */
834	get_canonical_qnan (r, sign);
835	return false;
836
837	case CLASS2 (rvc_zero, rvc_normal):
838	case CLASS2 (rvc_zero, rvc_inf):
839	/* 0 / ANY = 0. */
840	case CLASS2 (rvc_normal, rvc_inf):
841	/* R / Inf = 0. */
842	get_zero (r, sign);
843	return false;
844
845	case CLASS2 (rvc_normal, rvc_zero):
846	/* R / 0 = Inf. */
847	case CLASS2 (rvc_inf, rvc_zero):
848	/* Inf / 0 = Inf. */
849	get_inf (r, sign);
850	return false;
851
852	case CLASS2 (rvc_zero, rvc_nan):
853	case CLASS2 (rvc_normal, rvc_nan):
854	case CLASS2 (rvc_inf, rvc_nan):
855	case CLASS2 (rvc_nan, rvc_nan):
856	/* ANY / NaN = NaN. */
857	*r = *b;
858	/* Make resulting NaN value to be qNaN. The caller has the
859	responsibility to avoid the operation if flag_signaling_nans
860	is on. */
861	r->signalling = 0;
862	r->sign = sign;
863	return false;
864
865	case CLASS2 (rvc_nan, rvc_zero):
866	case CLASS2 (rvc_nan, rvc_normal):
867	case CLASS2 (rvc_nan, rvc_inf):
868	/* NaN / ANY = NaN. */
869	*r = *a;
870	/* Make resulting NaN value to be qNaN. The caller has the
871	responsibility to avoid the operation if flag_signaling_nans
872	is on. */
873	r->signalling = 0;
874	r->sign = sign;
875	return false;
876
877	case CLASS2 (rvc_inf, rvc_normal):
878	/* Inf / R = Inf. */
879	get_inf (r, sign);
880	return false;
881
882	case CLASS2 (rvc_normal, rvc_normal):
883	break;
884
885	default:
886	gcc_unreachable ();
887	}
888
889	if (r == a || r == b)
890	rr = &t;
891	else
892	rr = r;
893
894	/* Make sure all fields in the result are initialized. */
895	get_zero (r: rr, sign: 0);
896	rr->cl = rvc_normal;
897	rr->sign = sign;
898
899	exp = REAL_EXP (a) - REAL_EXP (b) + 1;
900	if (exp > MAX_EXP)
901	{
902	get_inf (r, sign);
903	return true;
904	}
905	if (exp < -MAX_EXP)
906	{
907	get_zero (r, sign);
908	return true;
909	}
910	SET_REAL_EXP (rr, exp);
911
912	inexact = div_significands (r: rr, a, b);
913
914	/* Re-normalize the result. */
915	normalize (r: rr);
916	rr->sig[0] |= inexact;
917
918	if (rr != r)
919	*r = t;
920
921	return inexact;
922	}
923
924	/* Return a tri-state comparison of A vs B. Return NAN_RESULT if
925	one of the two operands is a NaN. */
926
927	static int
928	do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
929	int nan_result)
930	{
931	int ret;
932
933	switch (CLASS2 (a->cl, b->cl))
934	{
935	case CLASS2 (rvc_zero, rvc_zero):
936	/* Sign of zero doesn't matter for compares. */
937	return 0;
938
939	case CLASS2 (rvc_normal, rvc_zero):
940	/* Decimal float zero is special and uses rvc_normal, not rvc_zero. */
941	if (a->decimal)
942	return decimal_do_compare (a, b, nan_result);
943	/* Fall through. */
944	case CLASS2 (rvc_inf, rvc_zero):
945	case CLASS2 (rvc_inf, rvc_normal):
946	return (a->sign ? -1 : 1);
947
948	case CLASS2 (rvc_inf, rvc_inf):
949	return -a->sign - -b->sign;
950
951	case CLASS2 (rvc_zero, rvc_normal):
952	/* Decimal float zero is special and uses rvc_normal, not rvc_zero. */
953	if (b->decimal)
954	return decimal_do_compare (a, b, nan_result);
955	/* Fall through. */
956	case CLASS2 (rvc_zero, rvc_inf):
957	case CLASS2 (rvc_normal, rvc_inf):
958	return (b->sign ? 1 : -1);
959
960	case CLASS2 (rvc_zero, rvc_nan):
961	case CLASS2 (rvc_normal, rvc_nan):
962	case CLASS2 (rvc_inf, rvc_nan):
963	case CLASS2 (rvc_nan, rvc_nan):
964	case CLASS2 (rvc_nan, rvc_zero):
965	case CLASS2 (rvc_nan, rvc_normal):
966	case CLASS2 (rvc_nan, rvc_inf):
967	return nan_result;
968
969	case CLASS2 (rvc_normal, rvc_normal):
970	break;
971
972	default:
973	gcc_unreachable ();
974	}
975
976	if (a->decimal || b->decimal)
977	return decimal_do_compare (a, b, nan_result);
978
979	if (a->sign != b->sign)
980	return -a->sign - -b->sign;
981
982	if (REAL_EXP (a) > REAL_EXP (b))
983	ret = 1;
984	else if (REAL_EXP (a) < REAL_EXP (b))
985	ret = -1;
986	else
987	ret = cmp_significands (a, b);
988
989	return (a->sign ? -ret : ret);
990	}
991
992	/* Return A truncated to an integral value toward zero. */
993
994	static void
995	do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
996	{
997	*r = *a;
998
999	switch (r->cl)
1000	{
1001	case rvc_zero:
1002	case rvc_inf:
1003	case rvc_nan:
1004	/* Make resulting NaN value to be qNaN. The caller has the
1005	responsibility to avoid the operation if flag_signaling_nans
1006	is on. */
1007	r->signalling = 0;
1008	break;
1009
1010	case rvc_normal:
1011	if (r->decimal)
1012	{
1013	decimal_do_fix_trunc (r, a);
1014	return;
1015	}
1016	if (REAL_EXP (r) <= 0)
1017	get_zero (r, sign: r->sign);
1018	else if (REAL_EXP (r) < SIGNIFICAND_BITS)
1019	clear_significand_below (r, SIGNIFICAND_BITS - REAL_EXP (r));
1020	break;
1021
1022	default:
1023	gcc_unreachable ();
1024	}
1025	}
1026
1027	/* Perform the binary or unary operation described by CODE.
1028	For a unary operation, leave OP1 NULL. This function returns
1029	true if the result may be inexact due to loss of precision. */
1030
1031	bool
1032	real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
1033	const REAL_VALUE_TYPE *op1)
1034	{
1035	enum tree_code code = (enum tree_code) icode;
1036
1037	if (op0->decimal || (op1 && op1->decimal))
1038	return decimal_real_arithmetic (r, code, op0, op1);
1039
1040	switch (code)
1041	{
1042	case PLUS_EXPR:
1043	/* Clear any padding areas in *r if it isn't equal to one of the
1044	operands so that we can later do bitwise comparisons later on. */
1045	if (r != op0 && r != op1)
1046	memset (s: r, c: '\0', n: sizeof (*r));
1047	return do_add (r, a: op0, b: op1, subtract_p: 0);
1048
1049	case MINUS_EXPR:
1050	if (r != op0 && r != op1)
1051	memset (s: r, c: '\0', n: sizeof (*r));
1052	return do_add (r, a: op0, b: op1, subtract_p: 1);
1053
1054	case MULT_EXPR:
1055	if (r != op0 && r != op1)
1056	memset (s: r, c: '\0', n: sizeof (*r));
1057	return do_multiply (r, a: op0, b: op1);
1058
1059	case RDIV_EXPR:
1060	if (r != op0 && r != op1)
1061	memset (s: r, c: '\0', n: sizeof (*r));
1062	return do_divide (r, a: op0, b: op1);
1063
1064	case MIN_EXPR:
1065	if (op1->cl == rvc_nan)
1066	{
1067	*r = *op1;
1068	/* Make resulting NaN value to be qNaN. The caller has the
1069	responsibility to avoid the operation if flag_signaling_nans
1070	is on. */
1071	r->signalling = 0;
1072	}
1073	else if (do_compare (a: op0, b: op1, nan_result: -1) < 0)
1074	*r = *op0;
1075	else
1076	*r = *op1;
1077	break;
1078
1079	case MAX_EXPR:
1080	if (op1->cl == rvc_nan)
1081	{
1082	*r = *op1;
1083	/* Make resulting NaN value to be qNaN. The caller has the
1084	responsibility to avoid the operation if flag_signaling_nans
1085	is on. */
1086	r->signalling = 0;
1087	}
1088	else if (do_compare (a: op0, b: op1, nan_result: 1) < 0)
1089	*r = *op1;
1090	else
1091	*r = *op0;
1092	break;
1093
1094	case NEGATE_EXPR:
1095	*r = *op0;
1096	r->sign ^= 1;
1097	break;
1098
1099	case ABS_EXPR:
1100	*r = *op0;
1101	r->sign = 0;
1102	break;
1103
1104	case FIX_TRUNC_EXPR:
1105	do_fix_trunc (r, a: op0);
1106	break;
1107
1108	default:
1109	gcc_unreachable ();
1110	}
1111	return false;
1112	}
1113
1114	REAL_VALUE_TYPE
1115	real_value_negate (const REAL_VALUE_TYPE *op0)
1116	{
1117	REAL_VALUE_TYPE r;
1118	real_arithmetic (r: &r, icode: NEGATE_EXPR, op0, NULL);
1119	return r;
1120	}
1121
1122	REAL_VALUE_TYPE
1123	real_value_abs (const REAL_VALUE_TYPE *op0)
1124	{
1125	REAL_VALUE_TYPE r;
1126	real_arithmetic (r: &r, icode: ABS_EXPR, op0, NULL);
1127	return r;
1128	}
1129
1130	/* Return whether OP0 == OP1. */
1131
1132	bool
1133	real_equal (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
1134	{
1135	return do_compare (a: op0, b: op1, nan_result: -1) == 0;
1136	}
1137
1138	/* Return whether OP0 < OP1. */
1139
1140	bool
1141	real_less (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
1142	{
1143	return do_compare (a: op0, b: op1, nan_result: 1) < 0;
1144	}
1145
1146	bool
1147	real_compare (int icode, const REAL_VALUE_TYPE *op0,
1148	const REAL_VALUE_TYPE *op1)
1149	{
1150	enum tree_code code = (enum tree_code) icode;
1151
1152	switch (code)
1153	{
1154	case LT_EXPR:
1155	return real_less (op0, op1);
1156	case LE_EXPR:
1157	return do_compare (a: op0, b: op1, nan_result: 1) <= 0;
1158	case GT_EXPR:
1159	return do_compare (a: op0, b: op1, nan_result: -1) > 0;
1160	case GE_EXPR:
1161	return do_compare (a: op0, b: op1, nan_result: -1) >= 0;
1162	case EQ_EXPR:
1163	return real_equal (op0, op1);
1164	case NE_EXPR:
1165	return do_compare (a: op0, b: op1, nan_result: -1) != 0;
1166	case UNORDERED_EXPR:
1167	return op0->cl == rvc_nan || op1->cl == rvc_nan;
1168	case ORDERED_EXPR:
1169	return op0->cl != rvc_nan && op1->cl != rvc_nan;
1170	case UNLT_EXPR:
1171	return do_compare (a: op0, b: op1, nan_result: -1) < 0;
1172	case UNLE_EXPR:
1173	return do_compare (a: op0, b: op1, nan_result: -1) <= 0;
1174	case UNGT_EXPR:
1175	return do_compare (a: op0, b: op1, nan_result: 1) > 0;
1176	case UNGE_EXPR:
1177	return do_compare (a: op0, b: op1, nan_result: 1) >= 0;
1178	case UNEQ_EXPR:
1179	return do_compare (a: op0, b: op1, nan_result: 0) == 0;
1180	case LTGT_EXPR:
1181	return do_compare (a: op0, b: op1, nan_result: 0) != 0;
1182
1183	default:
1184	gcc_unreachable ();
1185	}
1186	}
1187
1188	/* Return floor log2(R). */
1189
1190	int
1191	real_exponent (const REAL_VALUE_TYPE *r)
1192	{
1193	switch (r->cl)
1194	{
1195	case rvc_zero:
1196	return 0;
1197	case rvc_inf:
1198	case rvc_nan:
1199	return (unsigned int)-1 >> 1;
1200	case rvc_normal:
1201	return REAL_EXP (r);
1202	default:
1203	gcc_unreachable ();
1204	}
1205	}
1206
1207	/* R = OP0 * 2**EXP. */
1208
1209	void
1210	real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
1211	{
1212	*r = *op0;
1213	switch (r->cl)
1214	{
1215	case rvc_zero:
1216	case rvc_inf:
1217	case rvc_nan:
1218	/* Make resulting NaN value to be qNaN. The caller has the
1219	responsibility to avoid the operation if flag_signaling_nans
1220	is on. */
1221	r->signalling = 0;
1222	break;
1223
1224	case rvc_normal:
1225	exp += REAL_EXP (op0);
1226	if (exp > MAX_EXP)
1227	get_inf (r, sign: r->sign);
1228	else if (exp < -MAX_EXP)
1229	get_zero (r, sign: r->sign);
1230	else
1231	SET_REAL_EXP (r, exp);
1232	break;
1233
1234	default:
1235	gcc_unreachable ();
1236	}
1237	}
1238
1239	/* Determine whether a floating-point value X is infinite. */
1240
1241	bool
1242	real_isinf (const REAL_VALUE_TYPE *r)
1243	{
1244	return (r->cl == rvc_inf);
1245	}
1246
1247	/* Determine whether a floating-point value X is infinite with SIGN. */
1248
1249	bool
1250	real_isinf (const REAL_VALUE_TYPE *r, bool sign)
1251	{
1252	return real_isinf (r) && r->sign == sign;
1253	}
1254
1255	/* Determine whether a floating-point value X is a NaN. */
1256
1257	bool
1258	real_isnan (const REAL_VALUE_TYPE *r)
1259	{
1260	return (r->cl == rvc_nan);
1261	}
1262
1263	/* Determine whether a floating-point value X is a signaling NaN. */
1264	bool real_issignaling_nan (const REAL_VALUE_TYPE *r)
1265	{
1266	return real_isnan (r) && r->signalling;
1267	}
1268
1269	/* Determine whether a floating-point value X is finite. */
1270
1271	bool
1272	real_isfinite (const REAL_VALUE_TYPE *r)
1273	{
1274	return (r->cl != rvc_nan) && (r->cl != rvc_inf);
1275	}
1276
1277	/* Determine whether a floating-point value X is negative. */
1278
1279	bool
1280	real_isneg (const REAL_VALUE_TYPE *r)
1281	{
1282	return r->sign;
1283	}
1284
1285	/* Determine whether a floating-point value X is plus or minus zero. */
1286
1287	bool
1288	real_iszero (const REAL_VALUE_TYPE *r)
1289	{
1290	return r->cl == rvc_zero;
1291	}
1292
1293	/* Determine whether a floating-point value X is zero with SIGN. */
1294
1295	bool
1296	real_iszero (const REAL_VALUE_TYPE *r, bool sign)
1297	{
1298	return real_iszero (r) && r->sign == sign;
1299	}
1300
1301	/* Determine whether a floating-point value X is minus zero. */
1302
1303	bool
1304	real_isnegzero (const REAL_VALUE_TYPE *r)
1305	{
1306	return r->sign && r->cl == rvc_zero;
1307	}
1308
1309	/* Compare two floating-point objects for bitwise identity. */
1310
1311	bool
1312	real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
1313	{
1314	int i;
1315
1316	if (a->cl != b->cl)
1317	return false;
1318	if (a->sign != b->sign)
1319	return false;
1320
1321	switch (a->cl)
1322	{
1323	case rvc_zero:
1324	case rvc_inf:
1325	return true;
1326
1327	case rvc_normal:
1328	if (a->decimal != b->decimal)
1329	return false;
1330	if (REAL_EXP (a) != REAL_EXP (b))
1331	return false;
1332	break;
1333
1334	case rvc_nan:
1335	if (a->signalling != b->signalling)
1336	return false;
1337	/* The significand is ignored for canonical NaNs. */
1338	if (a->canonical || b->canonical)
1339	return a->canonical == b->canonical;
1340	break;
1341
1342	default:
1343	gcc_unreachable ();
1344	}
1345
1346	for (i = 0; i < SIGSZ; ++i)
1347	if (a->sig[i] != b->sig[i])
1348	return false;
1349
1350	return true;
1351	}
1352
1353	/* Try to change R into its exact multiplicative inverse in format FMT.
1354	Return true if successful. */
1355
1356	bool
1357	exact_real_inverse (format_helper fmt, REAL_VALUE_TYPE *r)
1358	{
1359	const REAL_VALUE_TYPE *one = real_digit (1);
1360	REAL_VALUE_TYPE u;
1361	int i;
1362
1363	if (r->cl != rvc_normal)
1364	return false;
1365
1366	/* Check for a power of two: all significand bits zero except the MSB. */
1367	for (i = 0; i < SIGSZ-1; ++i)
1368	if (r->sig[i] != 0)
1369	return false;
1370	if (r->sig[SIGSZ-1] != SIG_MSB)
1371	return false;
1372
1373	/* Find the inverse and truncate to the required format. */
1374	do_divide (r: &u, a: one, b: r);
1375	real_convert (&u, fmt, &u);
1376
1377	/* The rounding may have overflowed. */
1378	if (u.cl != rvc_normal)
1379	return false;
1380	for (i = 0; i < SIGSZ-1; ++i)
1381	if (u.sig[i] != 0)
1382	return false;
1383	if (u.sig[SIGSZ-1] != SIG_MSB)
1384	return false;
1385
1386	*r = u;
1387	return true;
1388	}
1389
1390	/* Return true if arithmetic on values in IMODE that were promoted
1391	from values in TMODE is equivalent to direct arithmetic on values
1392	in TMODE. */
1393
1394	bool
1395	real_can_shorten_arithmetic (machine_mode imode, machine_mode tmode)
1396	{
1397	const struct real_format *tfmt, *ifmt;
1398	tfmt = REAL_MODE_FORMAT (tmode);
1399	ifmt = REAL_MODE_FORMAT (imode);
1400	/* These conditions are conservative rather than trying to catch the
1401	exact boundary conditions; the main case to allow is IEEE float
1402	and double. */
1403	return (ifmt->b == tfmt->b
1404	&& ifmt->p > 2 * tfmt->p
1405	&& ifmt->emin < 2 * tfmt->emin - tfmt->p - 2
1406	&& ifmt->emin < tfmt->emin - tfmt->emax - tfmt->p - 2
1407	&& ifmt->emax > 2 * tfmt->emax + 2
1408	&& ifmt->emax > tfmt->emax - tfmt->emin + tfmt->p + 2
1409	&& ifmt->round_towards_zero == tfmt->round_towards_zero
1410	&& (ifmt->has_sign_dependent_rounding
1411	== tfmt->has_sign_dependent_rounding)
1412	&& ifmt->has_nans >= tfmt->has_nans
1413	&& ifmt->has_inf >= tfmt->has_inf
1414	&& ifmt->has_signed_zero >= tfmt->has_signed_zero
1415	&& !MODE_COMPOSITE_P (tmode)
1416	&& !MODE_COMPOSITE_P (imode));
1417	}
1418
1419	/* Render R as an integer. */
1420
1421	HOST_WIDE_INT
1422	real_to_integer (const REAL_VALUE_TYPE *r)
1423	{
1424	unsigned HOST_WIDE_INT i;
1425
1426	switch (r->cl)
1427	{
1428	case rvc_zero:
1429	underflow:
1430	return 0;
1431
1432	case rvc_inf:
1433	case rvc_nan:
1434	overflow:
1435	i = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1);
1436	if (!r->sign)
1437	i--;
1438	return i;
1439
1440	case rvc_normal:
1441	if (r->decimal)
1442	return decimal_real_to_integer (r);
1443
1444	if (REAL_EXP (r) <= 0)
1445	goto underflow;
1446	/* Only force overflow for unsigned overflow. Signed overflow is
1447	undefined, so it doesn't matter what we return, and some callers
1448	expect to be able to use this routine for both signed and
1449	unsigned conversions. */
1450	if (REAL_EXP (r) > HOST_BITS_PER_WIDE_INT)
1451	goto overflow;
1452
1453	if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1454	i = r->sig[SIGSZ-1];
1455	else
1456	{
1457	gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
1458	i = r->sig[SIGSZ-1];
1459	i = i << (HOST_BITS_PER_LONG - 1) << 1;
1460	i |= r->sig[SIGSZ-2];
1461	}
1462
1463	i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
1464
1465	if (r->sign)
1466	i = -i;
1467	return i;
1468
1469	default:
1470	gcc_unreachable ();
1471	}
1472	}
1473
1474	/* Likewise, but producing a wide-int of PRECISION. If the value cannot
1475	be represented in precision, *FAIL is set to TRUE. */
1476
1477	wide_int
1478	real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision)
1479	{
1480	HOST_WIDE_INT valb[WIDE_INT_MAX_INL_ELTS], *val;
1481	int exp;
1482	int words, w;
1483	wide_int result;
1484
1485	switch (r->cl)
1486	{
1487	case rvc_zero:
1488	underflow:
1489	return wi::zero (precision);
1490
1491	case rvc_inf:
1492	case rvc_nan:
1493	overflow:
1494	*fail = true;
1495
1496	if (r->sign)
1497	return wi::set_bit_in_zero (bit: precision - 1, precision);
1498	else
1499	return ~wi::set_bit_in_zero (bit: precision - 1, precision);
1500
1501	case rvc_normal:
1502	if (r->decimal)
1503	return decimal_real_to_integer (r, fail, precision);
1504
1505	exp = REAL_EXP (r);
1506	if (exp <= 0)
1507	goto underflow;
1508	/* Only force overflow for unsigned overflow. Signed overflow is
1509	undefined, so it doesn't matter what we return, and some callers
1510	expect to be able to use this routine for both signed and
1511	unsigned conversions. */
1512	if (exp > precision)
1513	goto overflow;
1514
1515	/* Put the significand into a wide_int that has precision W, which
1516	is the smallest HWI-multiple that has at least PRECISION bits.
1517	This ensures that the top bit of the significand is in the
1518	top bit of the wide_int. */
1519	words = ((precision + HOST_BITS_PER_WIDE_INT - 1)
1520	/ HOST_BITS_PER_WIDE_INT);
1521	val = valb;
1522	if (UNLIKELY (words > WIDE_INT_MAX_INL_ELTS))
1523	val = XALLOCAVEC (HOST_WIDE_INT, words);
1524	w = words * HOST_BITS_PER_WIDE_INT;
1525
1526	#if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
1527	for (int i = 0; i < words; i++)
1528	{
1529	int j = SIGSZ - words + i;
1530	val[i] = (j < 0) ? 0 : r->sig[j];
1531	}
1532	#else
1533	gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
1534	for (int i = 0; i < words; i++)
1535	{
1536	int j = SIGSZ - (words * 2) + (i * 2);
1537	if (j < 0)
1538	val[i] = 0;
1539	else
1540	val[i] = r->sig[j];
1541	j += 1;
1542	if (j >= 0)
1543	val[i] |= (unsigned HOST_WIDE_INT) r->sig[j] << HOST_BITS_PER_LONG;
1544	}
1545	#endif
1546	/* Shift the value into place and truncate to the desired precision. */
1547	result = wide_int::from_array (val, len: words, precision: w);
1548	result = wi::lrshift (x: result, y: w - exp);
1549	result = wide_int::from (x: result, precision, sgn: UNSIGNED);
1550
1551	if (r->sign)
1552	return -result;
1553	else
1554	return result;
1555
1556	default:
1557	gcc_unreachable ();
1558	}
1559	}
1560
1561	/* A subroutine of real_to_decimal. Compute the quotient and remainder
1562	of NUM / DEN. Return the quotient and place the remainder in NUM.
1563	It is expected that NUM / DEN are close enough that the quotient is
1564	small. */
1565
1566	static unsigned long
1567	rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
1568	{
1569	unsigned long q, msb;
1570	int expn = REAL_EXP (num), expd = REAL_EXP (den);
1571
1572	if (expn < expd)
1573	return 0;
1574
1575	q = msb = 0;
1576	goto start;
1577	do
1578	{
1579	msb = num->sig[SIGSZ-1] & SIG_MSB;
1580	q <<= 1;
1581	lshift_significand_1 (r: num, a: num);
1582	start:
1583	if (msb || cmp_significands (a: num, b: den) >= 0)
1584	{
1585	sub_significands (r: num, a: num, b: den, carry: 0);
1586	q |= 1;
1587	}
1588	}
1589	while (--expn >= expd);
1590
1591	SET_REAL_EXP (num, expd);
1592	normalize (r: num);
1593
1594	return q;
1595	}
1596
1597	/* Render R as a decimal floating point constant. Emit DIGITS significant
1598	digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the
1599	maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing
1600	zeros. If MODE is VOIDmode, round to nearest value. Otherwise, round
1601	to a string that, when parsed back in mode MODE, yields the same value. */
1602
1603	#define M_LOG10_2 0.30102999566398119521
1604
1605	void
1606	real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig,
1607	size_t buf_size, size_t digits,
1608	int crop_trailing_zeros, machine_mode mode)
1609	{
1610	const struct real_format *fmt = NULL;
1611	const REAL_VALUE_TYPE *one, *ten;
1612	REAL_VALUE_TYPE r, pten, u, v;
1613	int dec_exp, cmp_one, digit;
1614	size_t max_digits;
1615	char *p, *first, *last;
1616	bool sign;
1617	bool round_up;
1618
1619	if (mode != VOIDmode)
1620	{
1621	fmt = REAL_MODE_FORMAT (mode);
1622	gcc_assert (fmt);
1623	}
1624
1625	r = *r_orig;
1626	switch (r.cl)
1627	{
1628	case rvc_zero:
1629	strcpy (dest: str, src: (r.sign ? "-0.0" : "0.0"));
1630	return;
1631	case rvc_normal:
1632	break;
1633	case rvc_inf:
1634	strcpy (dest: str, src: (r.sign ? "-Inf" : "+Inf"));
1635	return;
1636	case rvc_nan:
1637	/* ??? Print the significand as well, if not canonical? */
1638	sprintf (s: str, format: "%c%cNaN", (r_orig->sign ? '-' : '+'),
1639	(r_orig->signalling ? 'S' : 'Q'));
1640	return;
1641	default:
1642	gcc_unreachable ();
1643	}
1644
1645	if (r.decimal)
1646	{
1647	decimal_real_to_decimal (str, &r, buf_size, digits, crop_trailing_zeros);
1648	return;
1649	}
1650
1651	/* Bound the number of digits printed by the size of the representation. */
1652	max_digits = SIGNIFICAND_BITS * M_LOG10_2;
1653	if (digits == 0 || digits > max_digits)
1654	digits = max_digits;
1655
1656	/* Estimate the decimal exponent, and compute the length of the string it
1657	will print as. Be conservative and add one to account for possible
1658	overflow or rounding error. */
1659	dec_exp = REAL_EXP (&r) * M_LOG10_2;
1660	for (max_digits = 1; dec_exp ; max_digits++)
1661	dec_exp /= 10;
1662
1663	/* Bound the number of digits printed by the size of the output buffer. */
1664	max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
1665	gcc_assert (max_digits <= buf_size);
1666	if (digits > max_digits)
1667	digits = max_digits;
1668
1669	one = real_digit (1);
1670	ten = ten_to_ptwo (0);
1671
1672	sign = r.sign;
1673	r.sign = 0;
1674
1675	dec_exp = 0;
1676	pten = *one;
1677
1678	cmp_one = do_compare (a: &r, b: one, nan_result: 0);
1679	if (cmp_one > 0)
1680	{
1681	int m;
1682
1683	/* Number is greater than one. Convert significand to an integer
1684	and strip trailing decimal zeros. */
1685
1686	u = r;
1687	SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1);
1688
1689	/* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS. */
1690	m = floor_log2 (x: max_digits);
1691
1692	/* Iterate over the bits of the possible powers of 10 that might
1693	be present in U and eliminate them. That is, if we find that
1694	10**2**M divides U evenly, keep the division and increase
1695	DEC_EXP by 2**M. */
1696	do
1697	{
1698	REAL_VALUE_TYPE t;
1699
1700	do_divide (r: &t, a: &u, b: ten_to_ptwo (m));
1701	do_fix_trunc (r: &v, a: &t);
1702	if (cmp_significands (a: &v, b: &t) == 0)
1703	{
1704	u = t;
1705	dec_exp += 1 << m;
1706	}
1707	}
1708	while (--m >= 0);
1709
1710	/* Revert the scaling to integer that we performed earlier. */
1711	SET_REAL_EXP (&u, REAL_EXP (&u) + REAL_EXP (&r)
1712	- (SIGNIFICAND_BITS - 1));
1713	r = u;
1714
1715	/* Find power of 10. Do this by dividing out 10**2**M when
1716	this is larger than the current remainder. Fill PTEN with
1717	the power of 10 that we compute. */
1718	if (REAL_EXP (&r) > 0)
1719	{
1720	m = floor_log2 (x: (int)(REAL_EXP (&r) * M_LOG10_2)) + 1;
1721	do
1722	{
1723	const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1724	if (do_compare (a: &u, b: ptentwo, nan_result: 0) >= 0)
1725	{
1726	do_divide (r: &u, a: &u, b: ptentwo);
1727	do_multiply (r: &pten, a: &pten, b: ptentwo);
1728	dec_exp += 1 << m;
1729	}
1730	}
1731	while (--m >= 0);
1732	}
1733	else
1734	/* We managed to divide off enough tens in the above reduction
1735	loop that we've now got a negative exponent. Fall into the
1736	less-than-one code to compute the proper value for PTEN. */
1737	cmp_one = -1;
1738	}
1739	if (cmp_one < 0)
1740	{
1741	int m;
1742
1743	/* Number is less than one. Pad significand with leading
1744	decimal zeros. */
1745
1746	v = r;
1747	while (1)
1748	{
1749	/* Stop if we'd shift bits off the bottom. */
1750	if (v.sig[0] & 7)
1751	break;
1752
1753	do_multiply (r: &u, a: &v, b: ten);
1754
1755	/* Stop if we're now >= 1 or zero. */
1756	if (REAL_EXP (&u) > 0 || u.cl == rvc_zero)
1757	break;
1758
1759	v = u;
1760	dec_exp -= 1;
1761	}
1762	r = v;
1763
1764	/* Find power of 10. Do this by multiplying in P=10**2**M when
1765	the current remainder is smaller than 1/P. Fill PTEN with the
1766	power of 10 that we compute. */
1767	m = floor_log2 (x: (int)(-REAL_EXP (&r) * M_LOG10_2)) + 1;
1768	do
1769	{
1770	const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
1771	const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
1772
1773	if (do_compare (a: &v, b: ptenmtwo, nan_result: 0) <= 0)
1774	{
1775	do_multiply (r: &v, a: &v, b: ptentwo);
1776	do_multiply (r: &pten, a: &pten, b: ptentwo);
1777	dec_exp -= 1 << m;
1778	}
1779	}
1780	while (--m >= 0);
1781
1782	/* Invert the positive power of 10 that we've collected so far. */
1783	do_divide (r: &pten, a: one, b: &pten);
1784	}
1785
1786	p = str;
1787	if (sign)
1788	*p++ = '-';
1789	first = p++;
1790
1791	/* At this point, PTEN should contain the nearest power of 10 smaller
1792	than R, such that this division produces the first digit.
1793
1794	Using a divide-step primitive that returns the complete integral
1795	remainder avoids the rounding error that would be produced if
1796	we were to use do_divide here and then simply multiply by 10 for
1797	each subsequent digit. */
1798
1799	digit = rtd_divmod (num: &r, den: &pten);
1800
1801	/* Be prepared for error in that division via underflow ... */
1802	if (digit == 0 && cmp_significand_0 (a: &r))
1803	{
1804	/* Multiply by 10 and try again. */
1805	do_multiply (r: &r, a: &r, b: ten);
1806	digit = rtd_divmod (num: &r, den: &pten);
1807	dec_exp -= 1;
1808	gcc_assert (digit != 0);
1809	}
1810
1811	/* ... or overflow. */
1812	if (digit == 10)
1813	{
1814	*p++ = '1';
1815	if (--digits > 0)
1816	*p++ = '0';
1817	dec_exp += 1;
1818	}
1819	else
1820	{
1821	gcc_assert (digit <= 10);
1822	*p++ = digit + '0';
1823	}
1824
1825	/* Generate subsequent digits. */
1826	while (--digits > 0)
1827	{
1828	do_multiply (r: &r, a: &r, b: ten);
1829	digit = rtd_divmod (num: &r, den: &pten);
1830	*p++ = digit + '0';
1831	}
1832	last = p;
1833
1834	/* Generate one more digit with which to do rounding. */
1835	do_multiply (r: &r, a: &r, b: ten);
1836	digit = rtd_divmod (num: &r, den: &pten);
1837
1838	/* Round the result. */
1839	if (fmt && fmt->round_towards_zero)
1840	{
1841	/* If the format uses round towards zero when parsing the string
1842	back in, we need to always round away from zero here. */
1843	if (cmp_significand_0 (a: &r))
1844	digit++;
1845	round_up = digit > 0;
1846	}
1847	else
1848	{
1849	if (digit == 5)
1850	{
1851	/* Round to nearest. If R is nonzero there are additional
1852	nonzero digits to be extracted. */
1853	if (cmp_significand_0 (a: &r))
1854	digit++;
1855	/* Round to even. */
1856	else if ((p[-1] - '0') & 1)
1857	digit++;
1858	}
1859
1860	round_up = digit > 5;
1861	}
1862
1863	if (round_up)
1864	{
1865	while (p > first)
1866	{
1867	digit = *--p;
1868	if (digit == '9')
1869	*p = '0';
1870	else
1871	{
1872	*p = digit + 1;
1873	break;
1874	}
1875	}
1876
1877	/* Carry out of the first digit. This means we had all 9's and
1878	now have all 0's. "Prepend" a 1 by overwriting the first 0. */
1879	if (p == first)
1880	{
1881	first[1] = '1';
1882	dec_exp++;
1883	}
1884	}
1885
1886	/* Insert the decimal point. */
1887	first[0] = first[1];
1888	first[1] = '.';
1889
1890	/* If requested, drop trailing zeros. Never crop past "1.0". */
1891	if (crop_trailing_zeros)
1892	while (last > first + 3 && last[-1] == '0')
1893	last--;
1894
1895	/* Append the exponent. */
1896	sprintf (s: last, format: "e%+d", dec_exp);
1897
1898	/* Verify that we can read the original value back in. */
1899	if (flag_checking && mode != VOIDmode)
1900	{
1901	real_from_string (&r, str);
1902	real_convert (&r, mode, &r);
1903	gcc_assert (real_identical (&r, r_orig));
1904	}
1905	}
1906
1907	/* Likewise, except always uses round-to-nearest. */
1908
1909	void
1910	real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
1911	size_t digits, int crop_trailing_zeros)
1912	{
1913	real_to_decimal_for_mode (str, r_orig, buf_size,
1914	digits, crop_trailing_zeros, VOIDmode);
1915	}
1916
1917	DEBUG_FUNCTION void
1918	debug (const REAL_VALUE_TYPE &r)
1919	{
1920	char s[60];
1921	real_to_hexadecimal (s, &r, sizeof (s), 0, 1);
1922	fprintf (stderr, format: "%s\n", s);
1923	}
1924
1925	/* Render R as a hexadecimal floating point constant. Emit DIGITS
1926	significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0,
1927	choose the maximum for the representation. If CROP_TRAILING_ZEROS,
1928	strip trailing zeros. */
1929
1930	void
1931	real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
1932	size_t digits, int crop_trailing_zeros)
1933	{
1934	int i, j, exp = REAL_EXP (r);
1935	char *p, *first;
1936	char exp_buf[16];
1937	size_t max_digits;
1938
1939	switch (r->cl)
1940	{
1941	case rvc_zero:
1942	exp = 0;
1943	break;
1944	case rvc_normal:
1945	break;
1946	case rvc_inf:
1947	strcpy (dest: str, src: (r->sign ? "-Inf" : "+Inf"));
1948	return;
1949	case rvc_nan:
1950	/* ??? Print the significand as well, if not canonical? */
1951	sprintf (s: str, format: "%c%cNaN", (r->sign ? '-' : '+'),
1952	(r->signalling ? 'S' : 'Q'));
1953	return;
1954	default:
1955	gcc_unreachable ();
1956	}
1957
1958	if (r->decimal)
1959	{
1960	/* Hexadecimal format for decimal floats is not interesting. */
1961	strcpy (dest: str, src: "N/A");
1962	return;
1963	}
1964
1965	if (digits == 0)
1966	digits = SIGNIFICAND_BITS / 4;
1967
1968	/* Bound the number of digits printed by the size of the output buffer. */
1969
1970	sprintf (s: exp_buf, format: "p%+d", exp);
1971	max_digits = buf_size - strlen (s: exp_buf) - r->sign - 4 - 1;
1972	gcc_assert (max_digits <= buf_size);
1973	if (digits > max_digits)
1974	digits = max_digits;
1975
1976	p = str;
1977	if (r->sign)
1978	*p++ = '-';
1979	*p++ = '0';
1980	*p++ = 'x';
1981	*p++ = '0';
1982	*p++ = '.';
1983	first = p;
1984
1985	for (i = SIGSZ - 1; i >= 0; --i)
1986	for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
1987	{
1988	*p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
1989	if (--digits == 0)
1990	goto out;
1991	}
1992
1993	out:
1994	if (crop_trailing_zeros)
1995	while (p > first + 1 && p[-1] == '0')
1996	p--;
1997
1998	sprintf (s: p, format: "p%+d", exp);
1999	}
2000
2001	/* Initialize R from a decimal or hexadecimal string. The string is
2002	assumed to have been syntax checked already. Return -1 if the
2003	value underflows, +1 if overflows, and 0 otherwise. */
2004
2005	int
2006	real_from_string (REAL_VALUE_TYPE *r, const char *str)
2007	{
2008	int exp = 0;
2009	bool sign = false;
2010
2011	get_zero (r, sign: 0);
2012
2013	if (*str == '-')
2014	{
2015	sign = true;
2016	str++;
2017	}
2018	else if (*str == '+')
2019	str++;
2020
2021	if (startswith (str, prefix: "QNaN"))
2022	{
2023	get_canonical_qnan (r, sign);
2024	return 0;
2025	}
2026	else if (startswith (str, prefix: "SNaN"))
2027	{
2028	get_canonical_snan (r, sign);
2029	return 0;
2030	}
2031	else if (startswith (str, prefix: "Inf"))
2032	{
2033	get_inf (r, sign);
2034	return 0;
2035	}
2036
2037	if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
2038	{
2039	/* Hexadecimal floating point. */
2040	int pos = SIGNIFICAND_BITS - 4, d;
2041
2042	str += 2;
2043
2044	while (*str == '0')
2045	str++;
2046	while (1)
2047	{
2048	d = hex_value (*str);
2049	if (d == _hex_bad)
2050	break;
2051	if (pos >= 0)
2052	{
2053	r->sig[pos / HOST_BITS_PER_LONG]
2054	|= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
2055	pos -= 4;
2056	}
2057	else if (d)
2058	/* Ensure correct rounding by setting last bit if there is
2059	a subsequent nonzero digit. */
2060	r->sig[0] |= 1;
2061	exp += 4;
2062	str++;
2063	}
2064	if (*str == '.')
2065	{
2066	str++;
2067	if (pos == SIGNIFICAND_BITS - 4)
2068	{
2069	while (*str == '0')
2070	str++, exp -= 4;
2071	}
2072	while (1)
2073	{
2074	d = hex_value (*str);
2075	if (d == _hex_bad)
2076	break;
2077	if (pos >= 0)
2078	{
2079	r->sig[pos / HOST_BITS_PER_LONG]
2080	|= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
2081	pos -= 4;
2082	}
2083	else if (d)
2084	/* Ensure correct rounding by setting last bit if there is
2085	a subsequent nonzero digit. */
2086	r->sig[0] |= 1;
2087	str++;
2088	}
2089	}
2090
2091	/* If the mantissa is zero, ignore the exponent. */
2092	if (!cmp_significand_0 (a: r))
2093	goto is_a_zero;
2094
2095	if (*str == 'p' || *str == 'P')
2096	{
2097	bool exp_neg = false;
2098
2099	str++;
2100	if (*str == '-')
2101	{
2102	exp_neg = true;
2103	str++;
2104	}
2105	else if (*str == '+')
2106	str++;
2107
2108	d = 0;
2109	while (ISDIGIT (*str))
2110	{
2111	d *= 10;
2112	d += *str - '0';
2113	if (d > MAX_EXP)
2114	{
2115	/* Overflowed the exponent. */
2116	if (exp_neg)
2117	goto underflow;
2118	else
2119	goto overflow;
2120	}
2121	str++;
2122	}
2123	if (exp_neg)
2124	d = -d;
2125
2126	exp += d;
2127	}
2128
2129	r->cl = rvc_normal;
2130	SET_REAL_EXP (r, exp);
2131
2132	normalize (r);
2133	}
2134	else
2135	{
2136	/* Decimal floating point. */
2137	const char *cstr = str;
2138	bool inexact;
2139
2140	while (*cstr == '0')
2141	cstr++;
2142	if (*cstr == '.')
2143	{
2144	cstr++;
2145	while (*cstr == '0')
2146	cstr++;
2147	}
2148
2149	/* If the mantissa is zero, ignore the exponent. */
2150	if (!ISDIGIT (*cstr))
2151	goto is_a_zero;
2152
2153	/* Nonzero value, possibly overflowing or underflowing. */
2154	auto_mpfr m (SIGNIFICAND_BITS);
2155	inexact = mpfr_strtofr (m, str, NULL, 10, MPFR_RNDZ);
2156	/* The result should never be a NaN, and because the rounding is
2157	toward zero should never be an infinity. */
2158	gcc_assert (!mpfr_nan_p (m) && !mpfr_inf_p (m));
2159	if (mpfr_zero_p (m) || mpfr_get_exp (m) < -MAX_EXP + 4)
2160	goto underflow;
2161	else if (mpfr_get_exp (m) > MAX_EXP - 4)
2162	goto overflow;
2163	else
2164	{
2165	real_from_mpfr (r, m, NULL_TREE, MPFR_RNDZ);
2166	/* 1 to 3 bits may have been shifted off (with a sticky bit)
2167	because the hex digits used in real_from_mpfr did not
2168	start with a digit 8 to f, but the exponent bounds above
2169	should have avoided underflow or overflow. */
2170	gcc_assert (r->cl == rvc_normal);
2171	/* Set a sticky bit if mpfr_strtofr was inexact. */
2172	r->sig[0] |= inexact;
2173	}
2174	}
2175
2176	r->sign = sign;
2177	return 0;
2178
2179	is_a_zero:
2180	get_zero (r, sign);
2181	return 0;
2182
2183	underflow:
2184	get_zero (r, sign);
2185	return -1;
2186
2187	overflow:
2188	get_inf (r, sign);
2189	return 1;
2190	}
2191
2192	/* Legacy. Similar, but return the result directly. */
2193
2194	REAL_VALUE_TYPE
2195	real_from_string2 (const char *s, format_helper fmt)
2196	{
2197	REAL_VALUE_TYPE r;
2198
2199	real_from_string (r: &r, str: s);
2200	if (fmt)
2201	real_convert (&r, fmt, &r);
2202
2203	return r;
2204	}
2205
2206	/* Initialize R from string S and desired format FMT. */
2207
2208	void
2209	real_from_string3 (REAL_VALUE_TYPE *r, const char *s, format_helper fmt)
2210	{
2211	if (fmt.decimal_p ())
2212	decimal_real_from_string (r, s);
2213	else
2214	real_from_string (r, str: s);
2215
2216	if (fmt)
2217	real_convert (r, fmt, r);
2218	}
2219
2220	/* Initialize R from the wide_int VAL_IN. Round it to format FMT if
2221	FMT is nonnull. */
2222
2223	void
2224	real_from_integer (REAL_VALUE_TYPE *r, format_helper fmt,
2225	const wide_int_ref &val_in, signop sgn)
2226	{
2227	if (val_in == 0)
2228	get_zero (r, sign: 0);
2229	else
2230	{
2231	unsigned int len = val_in.get_precision ();
2232	int i, j, e = 0;
2233	int maxbitlen = MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT;
2234	const unsigned int realmax = (SIGNIFICAND_BITS / HOST_BITS_PER_WIDE_INT
2235	* HOST_BITS_PER_WIDE_INT);
2236
2237	memset (s: r, c: 0, n: sizeof (*r));
2238	r->cl = rvc_normal;
2239	r->sign = wi::neg_p (x: val_in, sgn);
2240
2241	/* We have to ensure we can negate the largest negative number. */
2242	wide_int val = wide_int::from (x: val_in, precision: maxbitlen, sgn);
2243
2244	if (r->sign)
2245	val = -val;
2246
2247	/* Ensure a multiple of HOST_BITS_PER_WIDE_INT, ceiling, as elt
2248	won't work with precisions that are not a multiple of
2249	HOST_BITS_PER_WIDE_INT. */
2250	len += HOST_BITS_PER_WIDE_INT - 1;
2251
2252	/* Ensure we can represent the largest negative number. */
2253	len += 1;
2254
2255	len = len/HOST_BITS_PER_WIDE_INT * HOST_BITS_PER_WIDE_INT;
2256
2257	/* Cap the size to the size allowed by real.h. */
2258	if (len > realmax)
2259	{
2260	HOST_WIDE_INT cnt_l_z;
2261	cnt_l_z = wi::clz (val);
2262
2263	if (maxbitlen - cnt_l_z > realmax)
2264	{
2265	e = maxbitlen - cnt_l_z - realmax;
2266
2267	/* This value is too large, we must shift it right to
2268	preserve all the bits we can, and then bump the
2269	exponent up by that amount. */
2270	val = wi::lrshift (x: val, y: e);
2271	}
2272	len = realmax;
2273	}
2274
2275	/* Clear out top bits so elt will work with precisions that aren't
2276	a multiple of HOST_BITS_PER_WIDE_INT. */
2277	val = wide_int::from (x: val, precision: len, sgn);
2278	len = len / HOST_BITS_PER_WIDE_INT;
2279
2280	SET_REAL_EXP (r, len * HOST_BITS_PER_WIDE_INT + e);
2281
2282	j = SIGSZ - 1;
2283	if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
2284	for (i = len - 1; i >= 0; i--)
2285	{
2286	r->sig[j--] = val.elt (i);
2287	if (j < 0)
2288	break;
2289	}
2290	else
2291	{
2292	gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
2293	for (i = len - 1; i >= 0; i--)
2294	{
2295	HOST_WIDE_INT e = val.elt (i);
2296	r->sig[j--] = e >> (HOST_BITS_PER_LONG - 1) >> 1;
2297	if (j < 0)
2298	break;
2299	r->sig[j--] = e;
2300	if (j < 0)
2301	break;
2302	}
2303	}
2304
2305	normalize (r);
2306	}
2307
2308	if (fmt.decimal_p ())
2309	decimal_from_integer (r);
2310	if (fmt)
2311	real_convert (r, fmt, r);
2312	}
2313
2314	/* Render R, an integral value, as a floating point constant with no
2315	specified exponent. */
2316
2317	static void
2318	decimal_integer_string (char *str, const REAL_VALUE_TYPE *r_orig,
2319	size_t buf_size)
2320	{
2321	int dec_exp, digit, digits;
2322	REAL_VALUE_TYPE r, pten;
2323	char *p;
2324	bool sign;
2325
2326	r = *r_orig;
2327
2328	if (r.cl == rvc_zero)
2329	{
2330	strcpy (dest: str, src: "0.");
2331	return;
2332	}
2333
2334	sign = r.sign;
2335	r.sign = 0;
2336
2337	dec_exp = REAL_EXP (&r) * M_LOG10_2;
2338	digits = dec_exp + 1;
2339	gcc_assert ((digits + 2) < (int)buf_size);
2340
2341	pten = *real_digit (1);
2342	times_pten (&pten, dec_exp);
2343
2344	p = str;
2345	if (sign)
2346	*p++ = '-';
2347
2348	digit = rtd_divmod (num: &r, den: &pten);
2349	gcc_assert (digit >= 0 && digit <= 9);
2350	*p++ = digit + '0';
2351	while (--digits > 0)
2352	{
2353	times_pten (&r, 1);
2354	digit = rtd_divmod (num: &r, den: &pten);
2355	*p++ = digit + '0';
2356	}
2357	*p++ = '.';
2358	*p++ = '\0';
2359	}
2360
2361	/* Convert a real with an integral value to decimal float. */
2362
2363	static void
2364	decimal_from_integer (REAL_VALUE_TYPE *r)
2365	{
2366	char str[256];
2367
2368	decimal_integer_string (str, r_orig: r, buf_size: sizeof (str) - 1);
2369	decimal_real_from_string (r, str);
2370	}
2371
2372	/* Returns 10**2**N. */
2373
2374	static const REAL_VALUE_TYPE *
2375	ten_to_ptwo (int n)
2376	{
2377	static REAL_VALUE_TYPE tens[EXP_BITS];
2378
2379	gcc_assert (n >= 0);
2380	gcc_assert (n < EXP_BITS);
2381
2382	if (tens[n].cl == rvc_zero)
2383	{
2384	if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
2385	{
2386	HOST_WIDE_INT t = 10;
2387	int i;
2388
2389	for (i = 0; i < n; ++i)
2390	t *= t;
2391
2392	real_from_integer (r: &tens[n], VOIDmode, val_in: t, sgn: UNSIGNED);
2393	}
2394	else
2395	{
2396	const REAL_VALUE_TYPE *t = ten_to_ptwo (n: n - 1);
2397	do_multiply (r: &tens[n], a: t, b: t);
2398	}
2399	}
2400
2401	return &tens[n];
2402	}
2403
2404	/* Returns 10**(-2**N). */
2405
2406	static const REAL_VALUE_TYPE *
2407	ten_to_mptwo (int n)
2408	{
2409	static REAL_VALUE_TYPE tens[EXP_BITS];
2410
2411	gcc_assert (n >= 0);
2412	gcc_assert (n < EXP_BITS);
2413
2414	if (tens[n].cl == rvc_zero)
2415	do_divide (r: &tens[n], a: real_digit (1), b: ten_to_ptwo (n));
2416
2417	return &tens[n];
2418	}
2419
2420	/* Returns N. */
2421
2422	static const REAL_VALUE_TYPE *
2423	real_digit (int n)
2424	{
2425	static REAL_VALUE_TYPE num[10];
2426
2427	gcc_assert (n >= 0);
2428	gcc_assert (n <= 9);
2429
2430	if (n > 0 && num[n].cl == rvc_zero)
2431	real_from_integer (r: &num[n], VOIDmode, val_in: n, sgn: UNSIGNED);
2432
2433	return &num[n];
2434	}
2435
2436	/* Multiply R by 10**EXP. */
2437
2438	static void
2439	times_pten (REAL_VALUE_TYPE *r, int exp)
2440	{
2441	REAL_VALUE_TYPE pten, *rr;
2442	bool negative = (exp < 0);
2443	int i;
2444
2445	if (negative)
2446	{
2447	exp = -exp;
2448	pten = *real_digit (n: 1);
2449	rr = &pten;
2450	}
2451	else
2452	rr = r;
2453
2454	for (i = 0; exp > 0; ++i, exp >>= 1)
2455	if (exp & 1)
2456	do_multiply (r: rr, a: rr, b: ten_to_ptwo (n: i));
2457
2458	if (negative)
2459	do_divide (r, a: r, b: &pten);
2460	}
2461
2462	/* Returns the special REAL_VALUE_TYPE corresponding to 'e'. */
2463
2464	const REAL_VALUE_TYPE *
2465	dconst_e_ptr (void)
2466	{
2467	static REAL_VALUE_TYPE value;
2468
2469	/* Initialize mathematical constants for constant folding builtins.
2470	These constants need to be given to at least 160 bits precision. */
2471	if (value.cl == rvc_zero)
2472	{
2473	auto_mpfr m (SIGNIFICAND_BITS);
2474	mpfr_set_ui (m, 1, MPFR_RNDN);
2475	mpfr_exp (m, m, MPFR_RNDN);
2476	real_from_mpfr (&value, m, NULL_TREE, MPFR_RNDN);
2477
2478	}
2479	return &value;
2480	}
2481
2482	/* Returns the special REAL_VALUE_TYPE corresponding to 'pi'. */
2483
2484	const REAL_VALUE_TYPE *
2485	dconst_pi_ptr (void)
2486	{
2487	static REAL_VALUE_TYPE value;
2488
2489	/* Initialize mathematical constants for constant folding builtins.
2490	These constants need to be given to at least 160 bits precision. */
2491	if (value.cl == rvc_zero)
2492	{
2493	auto_mpfr m (SIGNIFICAND_BITS);
2494	mpfr_set_si (m, -1, MPFR_RNDN);
2495	mpfr_acos (m, m, MPFR_RNDN);
2496	real_from_mpfr (&value, m, NULL_TREE, MPFR_RNDN);
2497
2498	}
2499	return &value;
2500	}
2501
2502	/* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n. */
2503
2504	#define CACHED_FRACTION(NAME, N) \
2505	const REAL_VALUE_TYPE * \
2506	NAME (void) \
2507	{ \
2508	static REAL_VALUE_TYPE value; \
2509	\
2510	/* Initialize mathematical constants for constant folding builtins. \
2511	These constants need to be given to at least 160 bits \
2512	precision. */ \
2513	if (value.cl == rvc_zero) \
2514	real_arithmetic (&value, RDIV_EXPR, &dconst1, real_digit (N)); \
2515	return &value; \
2516	}
2517
2518	CACHED_FRACTION (dconst_third_ptr, 3)
2519	CACHED_FRACTION (dconst_quarter_ptr, 4)
2520	CACHED_FRACTION (dconst_sixth_ptr, 6)
2521	CACHED_FRACTION (dconst_ninth_ptr, 9)
2522
2523	/* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */
2524
2525	const REAL_VALUE_TYPE *
2526	dconst_sqrt2_ptr (void)
2527	{
2528	static REAL_VALUE_TYPE value;
2529
2530	/* Initialize mathematical constants for constant folding builtins.
2531	These constants need to be given to at least 160 bits precision. */
2532	if (value.cl == rvc_zero)
2533	{
2534	auto_mpfr m (SIGNIFICAND_BITS);
2535	mpfr_sqrt_ui (m, 2, MPFR_RNDN);
2536	real_from_mpfr (&value, m, NULL_TREE, MPFR_RNDN);
2537	}
2538	return &value;
2539	}
2540
2541	/* Fills R with Inf with SIGN. */
2542
2543	void
2544	real_inf (REAL_VALUE_TYPE *r, bool sign)
2545	{
2546	get_inf (r, sign);
2547	}
2548
2549	/* Fills R with a NaN whose significand is described by STR. If QUIET,
2550	we force a QNaN, else we force an SNaN. The string, if not empty,
2551	is parsed as a number and placed in the significand. Return true
2552	if the string was successfully parsed. */
2553
2554	bool
2555	real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
2556	format_helper fmt)
2557	{
2558	if (*str == 0)
2559	{
2560	if (quiet)
2561	get_canonical_qnan (r, sign: 0);
2562	else
2563	get_canonical_snan (r, sign: 0);
2564	}
2565	else
2566	{
2567	int base = 10, d;
2568
2569	memset (s: r, c: 0, n: sizeof (*r));
2570	r->cl = rvc_nan;
2571
2572	/* Parse akin to strtol into the significand of R. */
2573
2574	while (ISSPACE (*str))
2575	str++;
2576	if (*str == '-')
2577	str++;
2578	else if (*str == '+')
2579	str++;
2580	if (*str == '0')
2581	{
2582	str++;
2583	if (*str == 'x' || *str == 'X')
2584	{
2585	base = 16;
2586	str++;
2587	}
2588	else
2589	base = 8;
2590	}
2591
2592	while ((d = hex_value (*str)) < base)
2593	{
2594	REAL_VALUE_TYPE u;
2595
2596	switch (base)
2597	{
2598	case 8:
2599	lshift_significand (r, a: r, n: 3);
2600	break;
2601	case 16:
2602	lshift_significand (r, a: r, n: 4);
2603	break;
2604	case 10:
2605	lshift_significand_1 (r: &u, a: r);
2606	lshift_significand (r, a: r, n: 3);
2607	add_significands (r, a: r, b: &u);
2608	break;
2609	default:
2610	gcc_unreachable ();
2611	}
2612
2613	get_zero (r: &u, sign: 0);
2614	u.sig[0] = d;
2615	add_significands (r, a: r, b: &u);
2616
2617	str++;
2618	}
2619
2620	/* Must have consumed the entire string for success. */
2621	if (*str != 0)
2622	return false;
2623
2624	/* Shift the significand into place such that the bits
2625	are in the most significant bits for the format. */
2626	lshift_significand (r, a: r, SIGNIFICAND_BITS - fmt->pnan);
2627
2628	/* Our MSB is always unset for NaNs. */
2629	r->sig[SIGSZ-1] &= ~SIG_MSB;
2630
2631	/* Force quiet or signaling NaN. */
2632	r->signalling = !quiet;
2633	}
2634
2635	return true;
2636	}
2637
2638	/* Fills R with the largest finite value representable in mode MODE.
2639	If SIGN is nonzero, R is set to the most negative finite value. */
2640
2641	void
2642	real_maxval (REAL_VALUE_TYPE *r, int sign, machine_mode mode)
2643	{
2644	const struct real_format *fmt;
2645	int np2;
2646
2647	fmt = REAL_MODE_FORMAT (mode);
2648	gcc_assert (fmt);
2649	memset (s: r, c: 0, n: sizeof (*r));
2650
2651	if (fmt->b == 10)
2652	decimal_real_maxval (r, sign, mode);
2653	else
2654	{
2655	r->cl = rvc_normal;
2656	r->sign = sign;
2657	SET_REAL_EXP (r, fmt->emax);
2658
2659	np2 = SIGNIFICAND_BITS - fmt->p;
2660	memset (s: r->sig, c: -1, SIGSZ * sizeof (unsigned long));
2661	clear_significand_below (r, n: np2);
2662
2663	if (fmt->pnan < fmt->p)
2664	/* This is an IBM extended double format made up of two IEEE
2665	doubles. The value of the long double is the sum of the
2666	values of the two parts. The most significant part is
2667	required to be the value of the long double rounded to the
2668	nearest double. Rounding means we need a slightly smaller
2669	value for LDBL_MAX. */
2670	clear_significand_bit (r, SIGNIFICAND_BITS - fmt->pnan - 1);
2671	}
2672	}
2673
2674	/* Fills R with 2**N. */
2675
2676	void
2677	real_2expN (REAL_VALUE_TYPE *r, int n, format_helper fmt)
2678	{
2679	memset (s: r, c: 0, n: sizeof (*r));
2680
2681	n++;
2682	if (n > MAX_EXP)
2683	r->cl = rvc_inf;
2684	else if (n < -MAX_EXP)
2685	;
2686	else
2687	{
2688	r->cl = rvc_normal;
2689	SET_REAL_EXP (r, n);
2690	r->sig[SIGSZ-1] = SIG_MSB;
2691	}
2692	if (fmt.decimal_p ())
2693	decimal_real_convert (r, fmt, r);
2694	}
2695
2696
2697	static void
2698	round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
2699	{
2700	int p2, np2, i, w;
2701	int emin2m1, emax2;
2702	bool round_up = false;
2703
2704	if (r->decimal)
2705	{
2706	if (fmt->b == 10)
2707	{
2708	decimal_round_for_format (fmt, r);
2709	return;
2710	}
2711	/* FIXME. We can come here via fp_easy_constant
2712	(e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
2713	investigated whether this convert needs to be here, or
2714	something else is missing. */
2715	decimal_real_convert (r, REAL_MODE_FORMAT (DFmode), r);
2716	}
2717
2718	p2 = fmt->p;
2719	emin2m1 = fmt->emin - 1;
2720	emax2 = fmt->emax;
2721
2722	np2 = SIGNIFICAND_BITS - p2;
2723	switch (r->cl)
2724	{
2725	underflow:
2726	get_zero (r, sign: r->sign);
2727	/* FALLTHRU */
2728	case rvc_zero:
2729	if (!fmt->has_signed_zero)
2730	r->sign = 0;
2731	return;
2732
2733	overflow:
2734	get_inf (r, sign: r->sign);
2735	case rvc_inf:
2736	return;
2737
2738	case rvc_nan:
2739	clear_significand_below (r, n: np2);
2740	return;
2741
2742	case rvc_normal:
2743	break;
2744
2745	default:
2746	gcc_unreachable ();
2747	}
2748
2749	/* Check the range of the exponent. If we're out of range,
2750	either underflow or overflow. */
2751	if (REAL_EXP (r) > emax2)
2752	goto overflow;
2753	else if (REAL_EXP (r) <= emin2m1)
2754	{
2755	int diff;
2756
2757	if (!fmt->has_denorm)
2758	{
2759	/* Don't underflow completely until we've had a chance to round. */
2760	if (REAL_EXP (r) < emin2m1)
2761	goto underflow;
2762	}
2763	else
2764	{
2765	diff = emin2m1 - REAL_EXP (r) + 1;
2766	if (diff > p2)
2767	goto underflow;
2768
2769	/* De-normalize the significand. */
2770	r->sig[0] |= sticky_rshift_significand (r, a: r, n: diff);
2771	SET_REAL_EXP (r, REAL_EXP (r) + diff);
2772	}
2773	}
2774
2775	if (!fmt->round_towards_zero)
2776	{
2777	/* There are P2 true significand bits, followed by one guard bit,
2778	followed by one sticky bit, followed by stuff. Fold nonzero
2779	stuff into the sticky bit. */
2780	unsigned long sticky;
2781	bool guard, lsb;
2782
2783	sticky = 0;
2784	for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
2785	sticky |= r->sig[i];
2786	sticky |= r->sig[w]
2787	& (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
2788
2789	guard = test_significand_bit (r, n: np2 - 1);
2790	lsb = test_significand_bit (r, n: np2);
2791
2792	/* Round to even. */
2793	round_up = guard && (sticky || lsb);
2794	}
2795
2796	if (round_up)
2797	{
2798	REAL_VALUE_TYPE u;
2799	get_zero (r: &u, sign: 0);
2800	set_significand_bit (r: &u, n: np2);
2801
2802	if (add_significands (r, a: r, b: &u))
2803	{
2804	/* Overflow. Means the significand had been all ones, and
2805	is now all zeros. Need to increase the exponent, and
2806	possibly re-normalize it. */
2807	SET_REAL_EXP (r, REAL_EXP (r) + 1);
2808	if (REAL_EXP (r) > emax2)
2809	goto overflow;
2810	r->sig[SIGSZ-1] = SIG_MSB;
2811	}
2812	}
2813
2814	/* Catch underflow that we deferred until after rounding. */
2815	if (REAL_EXP (r) <= emin2m1)
2816	goto underflow;
2817
2818	/* Clear out trailing garbage. */
2819	clear_significand_below (r, n: np2);
2820	}
2821
2822	/* Extend or truncate to a new format. */
2823
2824	void
2825	real_convert (REAL_VALUE_TYPE *r, format_helper fmt,
2826	const REAL_VALUE_TYPE *a)
2827	{
2828	*r = *a;
2829
2830	if (a->decimal || fmt->b == 10)
2831	decimal_real_convert (r, fmt, a);
2832
2833	round_for_format (fmt, r);
2834
2835	/* Make resulting NaN value to be qNaN. The caller has the
2836	responsibility to avoid the operation if flag_signaling_nans
2837	is on. */
2838	if (r->cl == rvc_nan)
2839	r->signalling = 0;
2840
2841	/* round_for_format de-normalizes denormals. Undo just that part. */
2842	if (r->cl == rvc_normal)
2843	normalize (r);
2844	}
2845
2846	/* Legacy. Likewise, except return the struct directly. */
2847
2848	REAL_VALUE_TYPE
2849	real_value_truncate (format_helper fmt, REAL_VALUE_TYPE a)
2850	{
2851	REAL_VALUE_TYPE r;
2852	real_convert (r: &r, fmt, a: &a);
2853	return r;
2854	}
2855
2856	/* Return true if truncating to FMT is exact. */
2857
2858	bool
2859	exact_real_truncate (format_helper fmt, const REAL_VALUE_TYPE *a)
2860	{
2861	REAL_VALUE_TYPE t;
2862	int emin2m1;
2863
2864	/* Don't allow conversion to denormals. */
2865	emin2m1 = fmt->emin - 1;
2866	if (REAL_EXP (a) <= emin2m1)
2867	return false;
2868
2869	/* After conversion to the new format, the value must be identical. */
2870	real_convert (r: &t, fmt, a);
2871	return real_identical (a: &t, b: a);
2872	}
2873
2874	/* Write R to the given target format. Place the words of the result
2875	in target word order in BUF. There are always 32 bits in each
2876	long, no matter the size of the host long.
2877
2878	Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
2879
2880	long
2881	real_to_target (long *buf, const REAL_VALUE_TYPE *r_orig,
2882	format_helper fmt)
2883	{
2884	REAL_VALUE_TYPE r;
2885	long buf1;
2886
2887	r = *r_orig;
2888	round_for_format (fmt, r: &r);
2889
2890	if (!buf)
2891	buf = &buf1;
2892	(*fmt->encode) (fmt, buf, &r);
2893
2894	return *buf;
2895	}
2896
2897	/* Read R from the given target format. Read the words of the result
2898	in target word order in BUF. There are always 32 bits in each
2899	long, no matter the size of the host long. */
2900
2901	void
2902	real_from_target (REAL_VALUE_TYPE *r, const long *buf, format_helper fmt)
2903	{
2904	(*fmt->decode) (fmt, r, buf);
2905	}
2906
2907	/* Return the number of bits of the largest binary value that the
2908	significand of FMT will hold. */
2909	/* ??? Legacy. Should get access to real_format directly. */
2910
2911	int
2912	significand_size (format_helper fmt)
2913	{
2914	if (fmt == NULL)
2915	return 0;
2916
2917	if (fmt->b == 10)
2918	{
2919	/* Return the size in bits of the largest binary value that can be
2920	held by the decimal coefficient for this format. This is one more
2921	than the number of bits required to hold the largest coefficient
2922	of this format. */
2923	double log2_10 = 3.3219281;
2924	return fmt->p * log2_10;
2925	}
2926	return fmt->p;
2927	}
2928
2929	/* Return a hash value for the given real value. */
2930	/* ??? The "unsigned int" return value is intended to be hashval_t,
2931	but I didn't want to pull hashtab.h into real.h. */
2932
2933	unsigned int
2934	real_hash (const REAL_VALUE_TYPE *r)
2935	{
2936	unsigned int h;
2937	size_t i;
2938
2939	h = r->cl | (r->sign << 2);
2940	switch (r->cl)
2941	{
2942	case rvc_zero:
2943	case rvc_inf:
2944	return h;
2945
2946	case rvc_normal:
2947	h |= (unsigned int)REAL_EXP (r) << 3;
2948	break;
2949
2950	case rvc_nan:
2951	if (r->signalling)
2952	h ^= (unsigned int)-1;
2953	if (r->canonical)
2954	return h;
2955	break;
2956
2957	default:
2958	gcc_unreachable ();
2959	}
2960
2961	if (sizeof (unsigned long) > sizeof (unsigned int))
2962	for (i = 0; i < SIGSZ; ++i)
2963	{
2964	unsigned long s = r->sig[i];
2965	h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
2966	}
2967	else
2968	for (i = 0; i < SIGSZ; ++i)
2969	h ^= r->sig[i];
2970
2971	return h;
2972	}
2973
2974	/* IEEE single-precision format. */
2975
2976	static void encode_ieee_single (const struct real_format *fmt,
2977	long *, const REAL_VALUE_TYPE *);
2978	static void decode_ieee_single (const struct real_format *,
2979	REAL_VALUE_TYPE *, const long *);
2980
2981	static void
2982	encode_ieee_single (const struct real_format *fmt, long *buf,
2983	const REAL_VALUE_TYPE *r)
2984	{
2985	unsigned long image, sig, exp;
2986	unsigned long sign = r->sign;
2987
2988	image = sign << 31;
2989	sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
2990
2991	switch (r->cl)
2992	{
2993	case rvc_zero:
2994	break;
2995
2996	case rvc_inf:
2997	if (fmt->has_inf)
2998	image |= 255 << 23;
2999	else
3000	image |= 0x7fffffff;
3001	break;
3002
3003	case rvc_nan:
3004	if (fmt->has_nans)
3005	{
3006	if (r->canonical)
3007	sig = (fmt->canonical_nan_lsbs_set ? (1 << 22) - 1 : 0);
3008	if (r->signalling == fmt->qnan_msb_set)
3009	sig &= ~(1 << 22);
3010	else
3011	sig |= 1 << 22;
3012	if (sig == 0)
3013	sig = 1 << 21;
3014
3015	image |= 255 << 23;
3016	image |= sig;
3017	}
3018	else
3019	image |= 0x7fffffff;
3020	break;
3021
3022	case rvc_normal:
3023	/* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3024	whereas the intermediate representation is 0.F x 2**exp.
3025	Which means we're off by one. */
3026	if (real_isdenormal (r))
3027	exp = 0;
3028	else
3029	exp = REAL_EXP (r) + 127 - 1;
3030	image |= exp << 23;
3031	image |= sig;
3032	break;
3033
3034	default:
3035	gcc_unreachable ();
3036	}
3037
3038	buf[0] = image;
3039	}
3040
3041	static void
3042	decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3043	const long *buf)
3044	{
3045	unsigned long image = buf[0] & 0xffffffff;
3046	bool sign = (image >> 31) & 1;
3047	int exp = (image >> 23) & 0xff;
3048
3049	memset (s: r, c: 0, n: sizeof (*r));
3050	image <<= HOST_BITS_PER_LONG - 24;
3051	image &= ~SIG_MSB;
3052
3053	if (exp == 0)
3054	{
3055	if (image && fmt->has_denorm)
3056	{
3057	r->cl = rvc_normal;
3058	r->sign = sign;
3059	SET_REAL_EXP (r, -126);
3060	r->sig[SIGSZ-1] = image << 1;
3061	normalize (r);
3062	}
3063	else if (fmt->has_signed_zero)
3064	r->sign = sign;
3065	}
3066	else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
3067	{
3068	if (image)
3069	{
3070	r->cl = rvc_nan;
3071	r->sign = sign;
3072	r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
3073	^ fmt->qnan_msb_set);
3074	r->sig[SIGSZ-1] = image;
3075	}
3076	else
3077	{
3078	r->cl = rvc_inf;
3079	r->sign = sign;
3080	}
3081	}
3082	else
3083	{
3084	r->cl = rvc_normal;
3085	r->sign = sign;
3086	SET_REAL_EXP (r, exp - 127 + 1);
3087	r->sig[SIGSZ-1] = image | SIG_MSB;
3088	}
3089	}
3090
3091	const struct real_format ieee_single_format =
3092	{
3093	.encode: encode_ieee_single,
3094	.decode: decode_ieee_single,
3095	.b: 2,
3096	.p: 24,
3097	.pnan: 24,
3098	.emin: -125,
3099	.emax: 128,
3100	.signbit_ro: 31,
3101	.signbit_rw: 31,
3102	.ieee_bits: 32,
3103	.round_towards_zero: false,
3104	.has_sign_dependent_rounding: true,
3105	.has_nans: true,
3106	.has_inf: true,
3107	.has_denorm: true,
3108	.has_signed_zero: true,
3109	.qnan_msb_set: true,
3110	.canonical_nan_lsbs_set: false,
3111	.name: "ieee_single"
3112	};
3113
3114	const struct real_format mips_single_format =
3115	{
3116	.encode: encode_ieee_single,
3117	.decode: decode_ieee_single,
3118	.b: 2,
3119	.p: 24,
3120	.pnan: 24,
3121	.emin: -125,
3122	.emax: 128,
3123	.signbit_ro: 31,
3124	.signbit_rw: 31,
3125	.ieee_bits: 32,
3126	.round_towards_zero: false,
3127	.has_sign_dependent_rounding: true,
3128	.has_nans: true,
3129	.has_inf: true,
3130	.has_denorm: true,
3131	.has_signed_zero: true,
3132	.qnan_msb_set: false,
3133	.canonical_nan_lsbs_set: true,
3134	.name: "mips_single"
3135	};
3136
3137	const struct real_format motorola_single_format =
3138	{
3139	.encode: encode_ieee_single,
3140	.decode: decode_ieee_single,
3141	.b: 2,
3142	.p: 24,
3143	.pnan: 24,
3144	.emin: -125,
3145	.emax: 128,
3146	.signbit_ro: 31,
3147	.signbit_rw: 31,
3148	.ieee_bits: 32,
3149	.round_towards_zero: false,
3150	.has_sign_dependent_rounding: true,
3151	.has_nans: true,
3152	.has_inf: true,
3153	.has_denorm: true,
3154	.has_signed_zero: true,
3155	.qnan_msb_set: true,
3156	.canonical_nan_lsbs_set: true,
3157	.name: "motorola_single"
3158	};
3159
3160	/* SPU Single Precision (Extended-Range Mode) format is the same as IEEE
3161	single precision with the following differences:
3162	- Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT
3163	are generated.
3164	- NaNs are not supported.
3165	- The range of non-zero numbers in binary is
3166	(001)[1.]000...000 to (255)[1.]111...111.
3167	- Denormals can be represented, but are treated as +0.0 when
3168	used as an operand and are never generated as a result.
3169	- -0.0 can be represented, but a zero result is always +0.0.
3170	- the only supported rounding mode is trunction (towards zero). */
3171	const struct real_format spu_single_format =
3172	{
3173	.encode: encode_ieee_single,
3174	.decode: decode_ieee_single,
3175	.b: 2,
3176	.p: 24,
3177	.pnan: 24,
3178	.emin: -125,
3179	.emax: 129,
3180	.signbit_ro: 31,
3181	.signbit_rw: 31,
3182	.ieee_bits: 0,
3183	.round_towards_zero: true,
3184	.has_sign_dependent_rounding: false,
3185	.has_nans: false,
3186	.has_inf: false,
3187	.has_denorm: true,
3188	.has_signed_zero: true,
3189	.qnan_msb_set: false,
3190	.canonical_nan_lsbs_set: false,
3191	.name: "spu_single"
3192	};
3193
3194	/* IEEE double-precision format. */
3195
3196	static void encode_ieee_double (const struct real_format *fmt,
3197	long *, const REAL_VALUE_TYPE *);
3198	static void decode_ieee_double (const struct real_format *,
3199	REAL_VALUE_TYPE *, const long *);
3200
3201	static void
3202	encode_ieee_double (const struct real_format *fmt, long *buf,
3203	const REAL_VALUE_TYPE *r)
3204	{
3205	unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
3206	unsigned long sign = r->sign;
3207
3208	image_hi = sign << 31;
3209	image_lo = 0;
3210
3211	if (HOST_BITS_PER_LONG == 64)
3212	{
3213	sig_hi = r->sig[SIGSZ-1];
3214	sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
3215	sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
3216	}
3217	else
3218	{
3219	sig_hi = r->sig[SIGSZ-1];
3220	sig_lo = r->sig[SIGSZ-2];
3221	sig_lo = (sig_hi << 21) | (sig_lo >> 11);
3222	sig_hi = (sig_hi >> 11) & 0xfffff;
3223	}
3224
3225	switch (r->cl)
3226	{
3227	case rvc_zero:
3228	break;
3229
3230	case rvc_inf:
3231	if (fmt->has_inf)
3232	image_hi |= 2047 << 20;
3233	else
3234	{
3235	image_hi |= 0x7fffffff;
3236	image_lo = 0xffffffff;
3237	}
3238	break;
3239
3240	case rvc_nan:
3241	if (fmt->has_nans)
3242	{
3243	if (r->canonical)
3244	{
3245	if (fmt->canonical_nan_lsbs_set)
3246	{
3247	sig_hi = (1 << 19) - 1;
3248	sig_lo = 0xffffffff;
3249	}
3250	else
3251	{
3252	sig_hi = 0;
3253	sig_lo = 0;
3254	}
3255	}
3256	if (r->signalling == fmt->qnan_msb_set)
3257	sig_hi &= ~(1 << 19);
3258	else
3259	sig_hi |= 1 << 19;
3260	if (sig_hi == 0 && sig_lo == 0)
3261	sig_hi = 1 << 18;
3262
3263	image_hi |= 2047 << 20;
3264	image_hi |= sig_hi;
3265	image_lo = sig_lo;
3266	}
3267	else
3268	{
3269	image_hi |= 0x7fffffff;
3270	image_lo = 0xffffffff;
3271	}
3272	break;
3273
3274	case rvc_normal:
3275	/* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3276	whereas the intermediate representation is 0.F x 2**exp.
3277	Which means we're off by one. */
3278	if (real_isdenormal (r))
3279	exp = 0;
3280	else
3281	exp = REAL_EXP (r) + 1023 - 1;
3282	image_hi |= exp << 20;
3283	image_hi |= sig_hi;
3284	image_lo = sig_lo;
3285	break;
3286
3287	default:
3288	gcc_unreachable ();
3289	}
3290
3291	if (FLOAT_WORDS_BIG_ENDIAN)
3292	buf[0] = image_hi, buf[1] = image_lo;
3293	else
3294	buf[0] = image_lo, buf[1] = image_hi;
3295	}
3296
3297	static void
3298	decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3299	const long *buf)
3300	{
3301	unsigned long image_hi, image_lo;
3302	bool sign;
3303	int exp;
3304
3305	if (FLOAT_WORDS_BIG_ENDIAN)
3306	image_hi = buf[0], image_lo = buf[1];
3307	else
3308	image_lo = buf[0], image_hi = buf[1];
3309	image_lo &= 0xffffffff;
3310	image_hi &= 0xffffffff;
3311
3312	sign = (image_hi >> 31) & 1;
3313	exp = (image_hi >> 20) & 0x7ff;
3314
3315	memset (s: r, c: 0, n: sizeof (*r));
3316
3317	image_hi <<= 32 - 21;
3318	image_hi |= image_lo >> 21;
3319	image_hi &= 0x7fffffff;
3320	image_lo <<= 32 - 21;
3321
3322	if (exp == 0)
3323	{
3324	if ((image_hi || image_lo) && fmt->has_denorm)
3325	{
3326	r->cl = rvc_normal;
3327	r->sign = sign;
3328	SET_REAL_EXP (r, -1022);
3329	if (HOST_BITS_PER_LONG == 32)
3330	{
3331	image_hi = (image_hi << 1) | (image_lo >> 31);
3332	image_lo <<= 1;
3333	r->sig[SIGSZ-1] = image_hi;
3334	r->sig[SIGSZ-2] = image_lo;
3335	}
3336	else
3337	{
3338	image_hi = (image_hi << 31 << 2) | (image_lo << 1);
3339	r->sig[SIGSZ-1] = image_hi;
3340	}
3341	normalize (r);
3342	}
3343	else if (fmt->has_signed_zero)
3344	r->sign = sign;
3345	}
3346	else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
3347	{
3348	if (image_hi || image_lo)
3349	{
3350	r->cl = rvc_nan;
3351	r->sign = sign;
3352	r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3353	if (HOST_BITS_PER_LONG == 32)
3354	{
3355	r->sig[SIGSZ-1] = image_hi;
3356	r->sig[SIGSZ-2] = image_lo;
3357	}
3358	else
3359	r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
3360	}
3361	else
3362	{
3363	r->cl = rvc_inf;
3364	r->sign = sign;
3365	}
3366	}
3367	else
3368	{
3369	r->cl = rvc_normal;
3370	r->sign = sign;
3371	SET_REAL_EXP (r, exp - 1023 + 1);
3372	if (HOST_BITS_PER_LONG == 32)
3373	{
3374	r->sig[SIGSZ-1] = image_hi | SIG_MSB;
3375	r->sig[SIGSZ-2] = image_lo;
3376	}
3377	else
3378	r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
3379	}
3380	}
3381
3382	const struct real_format ieee_double_format =
3383	{
3384	.encode: encode_ieee_double,
3385	.decode: decode_ieee_double,
3386	.b: 2,
3387	.p: 53,
3388	.pnan: 53,
3389	.emin: -1021,
3390	.emax: 1024,
3391	.signbit_ro: 63,
3392	.signbit_rw: 63,
3393	.ieee_bits: 64,
3394	.round_towards_zero: false,
3395	.has_sign_dependent_rounding: true,
3396	.has_nans: true,
3397	.has_inf: true,
3398	.has_denorm: true,
3399	.has_signed_zero: true,
3400	.qnan_msb_set: true,
3401	.canonical_nan_lsbs_set: false,
3402	.name: "ieee_double"
3403	};
3404
3405	const struct real_format mips_double_format =
3406	{
3407	.encode: encode_ieee_double,
3408	.decode: decode_ieee_double,
3409	.b: 2,
3410	.p: 53,
3411	.pnan: 53,
3412	.emin: -1021,
3413	.emax: 1024,
3414	.signbit_ro: 63,
3415	.signbit_rw: 63,
3416	.ieee_bits: 64,
3417	.round_towards_zero: false,
3418	.has_sign_dependent_rounding: true,
3419	.has_nans: true,
3420	.has_inf: true,
3421	.has_denorm: true,
3422	.has_signed_zero: true,
3423	.qnan_msb_set: false,
3424	.canonical_nan_lsbs_set: true,
3425	.name: "mips_double"
3426	};
3427
3428	const struct real_format motorola_double_format =
3429	{
3430	.encode: encode_ieee_double,
3431	.decode: decode_ieee_double,
3432	.b: 2,
3433	.p: 53,
3434	.pnan: 53,
3435	.emin: -1021,
3436	.emax: 1024,
3437	.signbit_ro: 63,
3438	.signbit_rw: 63,
3439	.ieee_bits: 64,
3440	.round_towards_zero: false,
3441	.has_sign_dependent_rounding: true,
3442	.has_nans: true,
3443	.has_inf: true,
3444	.has_denorm: true,
3445	.has_signed_zero: true,
3446	.qnan_msb_set: true,
3447	.canonical_nan_lsbs_set: true,
3448	.name: "motorola_double"
3449	};
3450
3451	/* IEEE extended real format. This comes in three flavors: Intel's as
3452	a 12 byte image, Intel's as a 16 byte image, and Motorola's. Intel
3453	12- and 16-byte images may be big- or little endian; Motorola's is
3454	always big endian. */
3455
3456	/* Helper subroutine which converts from the internal format to the
3457	12-byte little-endian Intel format. Functions below adjust this
3458	for the other possible formats. */
3459	static void
3460	encode_ieee_extended (const struct real_format *fmt, long *buf,
3461	const REAL_VALUE_TYPE *r)
3462	{
3463	unsigned long image_hi, sig_hi, sig_lo;
3464
3465	image_hi = r->sign << 15;
3466	sig_hi = sig_lo = 0;
3467
3468	switch (r->cl)
3469	{
3470	case rvc_zero:
3471	break;
3472
3473	case rvc_inf:
3474	if (fmt->has_inf)
3475	{
3476	image_hi |= 32767;
3477
3478	/* Intel requires the explicit integer bit to be set, otherwise
3479	it considers the value a "pseudo-infinity". Motorola docs
3480	say it doesn't care. */
3481	sig_hi = 0x80000000;
3482	}
3483	else
3484	{
3485	image_hi |= 32767;
3486	sig_lo = sig_hi = 0xffffffff;
3487	}
3488	break;
3489
3490	case rvc_nan:
3491	if (fmt->has_nans)
3492	{
3493	image_hi |= 32767;
3494	if (r->canonical)
3495	{
3496	if (fmt->canonical_nan_lsbs_set)
3497	{
3498	sig_hi = (1 << 30) - 1;
3499	sig_lo = 0xffffffff;
3500	}
3501	}
3502	else if (HOST_BITS_PER_LONG == 32)
3503	{
3504	sig_hi = r->sig[SIGSZ-1];
3505	sig_lo = r->sig[SIGSZ-2];
3506	}
3507	else
3508	{
3509	sig_lo = r->sig[SIGSZ-1];
3510	sig_hi = sig_lo >> 31 >> 1;
3511	sig_lo &= 0xffffffff;
3512	}
3513	if (r->signalling == fmt->qnan_msb_set)
3514	sig_hi &= ~(1 << 30);
3515	else
3516	sig_hi |= 1 << 30;
3517	if ((sig_hi & 0x7fffffff) == 0 && sig_lo == 0)
3518	sig_hi = 1 << 29;
3519
3520	/* Intel requires the explicit integer bit to be set, otherwise
3521	it considers the value a "pseudo-nan". Motorola docs say it
3522	doesn't care. */
3523	sig_hi |= 0x80000000;
3524	}
3525	else
3526	{
3527	image_hi |= 32767;
3528	sig_lo = sig_hi = 0xffffffff;
3529	}
3530	break;
3531
3532	case rvc_normal:
3533	{
3534	int exp = REAL_EXP (r);
3535
3536	/* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
3537	whereas the intermediate representation is 0.F x 2**exp.
3538	Which means we're off by one.
3539
3540	Except for Motorola, which consider exp=0 and explicit
3541	integer bit set to continue to be normalized. In theory
3542	this discrepancy has been taken care of by the difference
3543	in fmt->emin in round_for_format. */
3544
3545	if (real_isdenormal (r))
3546	exp = 0;
3547	else
3548	{
3549	exp += 16383 - 1;
3550	gcc_assert (exp >= 0);
3551	}
3552	image_hi |= exp;
3553
3554	if (HOST_BITS_PER_LONG == 32)
3555	{
3556	sig_hi = r->sig[SIGSZ-1];
3557	sig_lo = r->sig[SIGSZ-2];
3558	}
3559	else
3560	{
3561	sig_lo = r->sig[SIGSZ-1];
3562	sig_hi = sig_lo >> 31 >> 1;
3563	sig_lo &= 0xffffffff;
3564	}
3565	}
3566	break;
3567
3568	default:
3569	gcc_unreachable ();
3570	}
3571
3572	buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
3573	}
3574
3575	/* Convert from the internal format to the 12-byte Motorola format
3576	for an IEEE extended real. */
3577	static void
3578	encode_ieee_extended_motorola (const struct real_format *fmt, long *buf,
3579	const REAL_VALUE_TYPE *r)
3580	{
3581	long intermed[3];
3582	encode_ieee_extended (fmt, buf: intermed, r);
3583
3584	if (r->cl == rvc_inf)
3585	/* For infinity clear the explicit integer bit again, so that the
3586	format matches the canonical infinity generated by the FPU. */
3587	intermed[1] = 0;
3588
3589	/* Motorola chips are assumed always to be big-endian. Also, the
3590	padding in a Motorola extended real goes between the exponent and
3591	the mantissa. At this point the mantissa is entirely within
3592	elements 0 and 1 of intermed, and the exponent entirely within
3593	element 2, so all we have to do is swap the order around, and
3594	shift element 2 left 16 bits. */
3595	buf[0] = intermed[2] << 16;
3596	buf[1] = intermed[1];
3597	buf[2] = intermed[0];
3598	}
3599
3600	/* Convert from the internal format to the 12-byte Intel format for
3601	an IEEE extended real. */
3602	static void
3603	encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf,
3604	const REAL_VALUE_TYPE *r)
3605	{
3606	if (FLOAT_WORDS_BIG_ENDIAN)
3607	{
3608	/* All the padding in an Intel-format extended real goes at the high
3609	end, which in this case is after the mantissa, not the exponent.
3610	Therefore we must shift everything down 16 bits. */
3611	long intermed[3];
3612	encode_ieee_extended (fmt, buf: intermed, r);
3613	buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16));
3614	buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16));
3615	buf[2] = (intermed[0] << 16);
3616	}
3617	else
3618	/* encode_ieee_extended produces what we want directly. */
3619	encode_ieee_extended (fmt, buf, r);
3620	}
3621
3622	/* Convert from the internal format to the 16-byte Intel format for
3623	an IEEE extended real. */
3624	static void
3625	encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf,
3626	const REAL_VALUE_TYPE *r)
3627	{
3628	/* All the padding in an Intel-format extended real goes at the high end. */
3629	encode_ieee_extended_intel_96 (fmt, buf, r);
3630	buf[3] = 0;
3631	}
3632
3633	/* As above, we have a helper function which converts from 12-byte
3634	little-endian Intel format to internal format. Functions below
3635	adjust for the other possible formats. */
3636	static void
3637	decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3638	const long *buf)
3639	{
3640	unsigned long image_hi, sig_hi, sig_lo;
3641	bool sign;
3642	int exp;
3643
3644	sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
3645	sig_lo &= 0xffffffff;
3646	sig_hi &= 0xffffffff;
3647	image_hi &= 0xffffffff;
3648
3649	sign = (image_hi >> 15) & 1;
3650	exp = image_hi & 0x7fff;
3651
3652	memset (s: r, c: 0, n: sizeof (*r));
3653
3654	if (exp == 0)
3655	{
3656	if ((sig_hi || sig_lo) && fmt->has_denorm)
3657	{
3658	r->cl = rvc_normal;
3659	r->sign = sign;
3660
3661	/* When the IEEE format contains a hidden bit, we know that
3662	it's zero at this point, and so shift up the significand
3663	and decrease the exponent to match. In this case, Motorola
3664	defines the explicit integer bit to be valid, so we don't
3665	know whether the msb is set or not. */
3666	SET_REAL_EXP (r, fmt->emin);
3667	if (HOST_BITS_PER_LONG == 32)
3668	{
3669	r->sig[SIGSZ-1] = sig_hi;
3670	r->sig[SIGSZ-2] = sig_lo;
3671	}
3672	else
3673	r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3674
3675	normalize (r);
3676	}
3677	else if (fmt->has_signed_zero)
3678	r->sign = sign;
3679	}
3680	else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
3681	{
3682	/* See above re "pseudo-infinities" and "pseudo-nans".
3683	Short summary is that the MSB will likely always be
3684	set, and that we don't care about it. */
3685	sig_hi &= 0x7fffffff;
3686
3687	if (sig_hi || sig_lo)
3688	{
3689	r->cl = rvc_nan;
3690	r->sign = sign;
3691	r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
3692	if (HOST_BITS_PER_LONG == 32)
3693	{
3694	r->sig[SIGSZ-1] = sig_hi;
3695	r->sig[SIGSZ-2] = sig_lo;
3696	}
3697	else
3698	r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3699	}
3700	else
3701	{
3702	r->cl = rvc_inf;
3703	r->sign = sign;
3704	}
3705	}
3706	else
3707	{
3708	r->cl = rvc_normal;
3709	r->sign = sign;
3710	SET_REAL_EXP (r, exp - 16383 + 1);
3711	if (HOST_BITS_PER_LONG == 32)
3712	{
3713	r->sig[SIGSZ-1] = sig_hi;
3714	r->sig[SIGSZ-2] = sig_lo;
3715	}
3716	else
3717	r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
3718	}
3719	}
3720
3721	/* Convert from the internal format to the 12-byte Motorola format
3722	for an IEEE extended real. */
3723	static void
3724	decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3725	const long *buf)
3726	{
3727	long intermed[3];
3728
3729	/* Motorola chips are assumed always to be big-endian. Also, the
3730	padding in a Motorola extended real goes between the exponent and
3731	the mantissa; remove it. */
3732	intermed[0] = buf[2];
3733	intermed[1] = buf[1];
3734	intermed[2] = (unsigned long)buf[0] >> 16;
3735
3736	decode_ieee_extended (fmt, r, buf: intermed);
3737	}
3738
3739	/* Convert from the internal format to the 12-byte Intel format for
3740	an IEEE extended real. */
3741	static void
3742	decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3743	const long *buf)
3744	{
3745	if (FLOAT_WORDS_BIG_ENDIAN)
3746	{
3747	/* All the padding in an Intel-format extended real goes at the high
3748	end, which in this case is after the mantissa, not the exponent.
3749	Therefore we must shift everything up 16 bits. */
3750	long intermed[3];
3751
3752	intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16));
3753	intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16));
3754	intermed[2] = ((unsigned long)buf[0] >> 16);
3755
3756	decode_ieee_extended (fmt, r, buf: intermed);
3757	}
3758	else
3759	/* decode_ieee_extended produces what we want directly. */
3760	decode_ieee_extended (fmt, r, buf);
3761	}
3762
3763	/* Convert from the internal format to the 16-byte Intel format for
3764	an IEEE extended real. */
3765	static void
3766	decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
3767	const long *buf)
3768	{
3769	/* All the padding in an Intel-format extended real goes at the high end. */
3770	decode_ieee_extended_intel_96 (fmt, r, buf);
3771	}
3772
3773	const struct real_format ieee_extended_motorola_format =
3774	{
3775	.encode: encode_ieee_extended_motorola,
3776	.decode: decode_ieee_extended_motorola,
3777	.b: 2,
3778	.p: 64,
3779	.pnan: 64,
3780	.emin: -16382,
3781	.emax: 16384,
3782	.signbit_ro: 95,
3783	.signbit_rw: 95,
3784	.ieee_bits: 0,
3785	.round_towards_zero: false,
3786	.has_sign_dependent_rounding: true,
3787	.has_nans: true,
3788	.has_inf: true,
3789	.has_denorm: true,
3790	.has_signed_zero: true,
3791	.qnan_msb_set: true,
3792	.canonical_nan_lsbs_set: true,
3793	.name: "ieee_extended_motorola"
3794	};
3795
3796	const struct real_format ieee_extended_intel_96_format =
3797	{
3798	.encode: encode_ieee_extended_intel_96,
3799	.decode: decode_ieee_extended_intel_96,
3800	.b: 2,
3801	.p: 64,
3802	.pnan: 64,
3803	.emin: -16381,
3804	.emax: 16384,
3805	.signbit_ro: 79,
3806	.signbit_rw: 79,
3807	.ieee_bits: 65,
3808	.round_towards_zero: false,
3809	.has_sign_dependent_rounding: true,
3810	.has_nans: true,
3811	.has_inf: true,
3812	.has_denorm: true,
3813	.has_signed_zero: true,
3814	.qnan_msb_set: true,
3815	.canonical_nan_lsbs_set: false,
3816	.name: "ieee_extended_intel_96"
3817	};
3818
3819	const struct real_format ieee_extended_intel_128_format =
3820	{
3821	.encode: encode_ieee_extended_intel_128,
3822	.decode: decode_ieee_extended_intel_128,
3823	.b: 2,
3824	.p: 64,
3825	.pnan: 64,
3826	.emin: -16381,
3827	.emax: 16384,
3828	.signbit_ro: 79,
3829	.signbit_rw: 79,
3830	.ieee_bits: 65,
3831	.round_towards_zero: false,
3832	.has_sign_dependent_rounding: true,
3833	.has_nans: true,
3834	.has_inf: true,
3835	.has_denorm: true,
3836	.has_signed_zero: true,
3837	.qnan_msb_set: true,
3838	.canonical_nan_lsbs_set: false,
3839	.name: "ieee_extended_intel_128"
3840	};
3841
3842	/* The following caters to i386 systems that set the rounding precision
3843	to 53 bits instead of 64, e.g. FreeBSD. */
3844	const struct real_format ieee_extended_intel_96_round_53_format =
3845	{
3846	.encode: encode_ieee_extended_intel_96,
3847	.decode: decode_ieee_extended_intel_96,
3848	.b: 2,
3849	.p: 53,
3850	.pnan: 53,
3851	.emin: -16381,
3852	.emax: 16384,
3853	.signbit_ro: 79,
3854	.signbit_rw: 79,
3855	.ieee_bits: 33,
3856	.round_towards_zero: false,
3857	.has_sign_dependent_rounding: true,
3858	.has_nans: true,
3859	.has_inf: true,
3860	.has_denorm: true,
3861	.has_signed_zero: true,
3862	.qnan_msb_set: true,
3863	.canonical_nan_lsbs_set: false,
3864	.name: "ieee_extended_intel_96_round_53"
3865	};
3866
3867	/* IBM 128-bit extended precision format: a pair of IEEE double precision
3868	numbers whose sum is equal to the extended precision value. The number
3869	with greater magnitude is first. This format has the same magnitude
3870	range as an IEEE double precision value, but effectively 106 bits of
3871	significand precision. Infinity and NaN are represented by their IEEE
3872	double precision value stored in the first number, the second number is
3873	+0.0 or -0.0 for Infinity and don't-care for NaN. */
3874
3875	static void encode_ibm_extended (const struct real_format *fmt,
3876	long *, const REAL_VALUE_TYPE *);
3877	static void decode_ibm_extended (const struct real_format *,
3878	REAL_VALUE_TYPE *, const long *);
3879
3880	static void
3881	encode_ibm_extended (const struct real_format *fmt, long *buf,
3882	const REAL_VALUE_TYPE *r)
3883	{
3884	REAL_VALUE_TYPE u, normr, v;
3885	const struct real_format *base_fmt;
3886
3887	base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3888
3889	/* Renormalize R before doing any arithmetic on it. */
3890	normr = *r;
3891	if (normr.cl == rvc_normal)
3892	normalize (r: &normr);
3893
3894	/* u = IEEE double precision portion of significand. */
3895	u = normr;
3896	round_for_format (fmt: base_fmt, r: &u);
3897	encode_ieee_double (fmt: base_fmt, buf: &buf[0], r: &u);
3898
3899	if (u.cl == rvc_normal)
3900	{
3901	do_add (r: &v, a: &normr, b: &u, subtract_p: 1);
3902	/* Call round_for_format since we might need to denormalize. */
3903	round_for_format (fmt: base_fmt, r: &v);
3904	encode_ieee_double (fmt: base_fmt, buf: &buf[2], r: &v);
3905	}
3906	else
3907	{
3908	/* Inf, NaN, 0 are all representable as doubles, so the
3909	least-significant part can be 0.0. */
3910	buf[2] = 0;
3911	buf[3] = 0;
3912	}
3913	}
3914
3915	static void
3916	decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_TYPE *r,
3917	const long *buf)
3918	{
3919	REAL_VALUE_TYPE u, v;
3920	const struct real_format *base_fmt;
3921
3922	base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
3923	decode_ieee_double (fmt: base_fmt, r: &u, buf: &buf[0]);
3924
3925	if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
3926	{
3927	decode_ieee_double (fmt: base_fmt, r: &v, buf: &buf[2]);
3928	do_add (r, a: &u, b: &v, subtract_p: 0);
3929	}
3930	else
3931	*r = u;
3932	}
3933
3934	const struct real_format ibm_extended_format =
3935	{
3936	.encode: encode_ibm_extended,
3937	.decode: decode_ibm_extended,
3938	.b: 2,
3939	.p: 53 + 53,
3940	.pnan: 53,
3941	.emin: -1021 + 53,
3942	.emax: 1024,
3943	.signbit_ro: 127,
3944	.signbit_rw: -1,
3945	.ieee_bits: 0,
3946	.round_towards_zero: false,
3947	.has_sign_dependent_rounding: true,
3948	.has_nans: true,
3949	.has_inf: true,
3950	.has_denorm: true,
3951	.has_signed_zero: true,
3952	.qnan_msb_set: true,
3953	.canonical_nan_lsbs_set: false,
3954	.name: "ibm_extended"
3955	};
3956
3957	const struct real_format mips_extended_format =
3958	{
3959	.encode: encode_ibm_extended,
3960	.decode: decode_ibm_extended,
3961	.b: 2,
3962	.p: 53 + 53,
3963	.pnan: 53,
3964	.emin: -1021 + 53,
3965	.emax: 1024,
3966	.signbit_ro: 127,
3967	.signbit_rw: -1,
3968	.ieee_bits: 0,
3969	.round_towards_zero: false,
3970	.has_sign_dependent_rounding: true,
3971	.has_nans: true,
3972	.has_inf: true,
3973	.has_denorm: true,
3974	.has_signed_zero: true,
3975	.qnan_msb_set: false,
3976	.canonical_nan_lsbs_set: true,
3977	.name: "mips_extended"
3978	};
3979
3980
3981	/* IEEE quad precision format. */
3982
3983	static void encode_ieee_quad (const struct real_format *fmt,
3984	long *, const REAL_VALUE_TYPE *);
3985	static void decode_ieee_quad (const struct real_format *,
3986	REAL_VALUE_TYPE *, const long *);
3987
3988	static void
3989	encode_ieee_quad (const struct real_format *fmt, long *buf,
3990	const REAL_VALUE_TYPE *r)
3991	{
3992	unsigned long image3, image2, image1, image0, exp;
3993	unsigned long sign = r->sign;
3994	REAL_VALUE_TYPE u;
3995
3996	image3 = sign << 31;
3997	image2 = 0;
3998	image1 = 0;
3999	image0 = 0;
4000
4001	rshift_significand (r: &u, a: r, SIGNIFICAND_BITS - 113);
4002
4003	switch (r->cl)
4004	{
4005	case rvc_zero:
4006	break;
4007
4008	case rvc_inf:
4009	if (fmt->has_inf)
4010	image3 |= 32767 << 16;
4011	else
4012	{
4013	image3 |= 0x7fffffff;
4014	image2 = 0xffffffff;
4015	image1 = 0xffffffff;
4016	image0 = 0xffffffff;
4017	}
4018	break;
4019
4020	case rvc_nan:
4021	if (fmt->has_nans)
4022	{
4023	image3 |= 32767 << 16;
4024
4025	if (r->canonical)
4026	{
4027	if (fmt->canonical_nan_lsbs_set)
4028	{
4029	image3 |= 0x7fff;
4030	image2 = image1 = image0 = 0xffffffff;
4031	}
4032	}
4033	else if (HOST_BITS_PER_LONG == 32)
4034	{
4035	image0 = u.sig[0];
4036	image1 = u.sig[1];
4037	image2 = u.sig[2];
4038	image3 |= u.sig[3] & 0xffff;
4039	}
4040	else
4041	{
4042	image0 = u.sig[0];
4043	image1 = image0 >> 31 >> 1;
4044	image2 = u.sig[1];
4045	image3 |= (image2 >> 31 >> 1) & 0xffff;
4046	image0 &= 0xffffffff;
4047	image2 &= 0xffffffff;
4048	}
4049	if (r->signalling == fmt->qnan_msb_set)
4050	image3 &= ~0x8000;
4051	else
4052	image3 |= 0x8000;
4053	if (((image3 & 0xffff) | image2 | image1 | image0) == 0)
4054	image3 |= 0x4000;
4055	}
4056	else
4057	{
4058	image3 |= 0x7fffffff;
4059	image2 = 0xffffffff;
4060	image1 = 0xffffffff;
4061	image0 = 0xffffffff;
4062	}
4063	break;
4064
4065	case rvc_normal:
4066	/* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
4067	whereas the intermediate representation is 0.F x 2**exp.
4068	Which means we're off by one. */
4069	if (real_isdenormal (r))
4070	exp = 0;
4071	else
4072	exp = REAL_EXP (r) + 16383 - 1;
4073	image3 |= exp << 16;
4074
4075	if (HOST_BITS_PER_LONG == 32)
4076	{
4077	image0 = u.sig[0];
4078	image1 = u.sig[1];
4079	image2 = u.sig[2];
4080	image3 |= u.sig[3] & 0xffff;
4081	}
4082	else
4083	{
4084	image0 = u.sig[0];
4085	image1 = image0 >> 31 >> 1;
4086	image2 = u.sig[1];
4087	image3 |= (image2 >> 31 >> 1) & 0xffff;
4088	image0 &= 0xffffffff;
4089	image2 &= 0xffffffff;
4090	}
4091	break;
4092
4093	default:
4094	gcc_unreachable ();
4095	}
4096
4097	if (FLOAT_WORDS_BIG_ENDIAN)
4098	{
4099	buf[0] = image3;
4100	buf[1] = image2;
4101	buf[2] = image1;
4102	buf[3] = image0;
4103	}
4104	else
4105	{
4106	buf[0] = image0;
4107	buf[1] = image1;
4108	buf[2] = image2;
4109	buf[3] = image3;
4110	}
4111	}
4112
4113	static void
4114	decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
4115	const long *buf)
4116	{
4117	unsigned long image3, image2, image1, image0;
4118	bool sign;
4119	int exp;
4120
4121	if (FLOAT_WORDS_BIG_ENDIAN)
4122	{
4123	image3 = buf[0];
4124	image2 = buf[1];
4125	image1 = buf[2];
4126	image0 = buf[3];
4127	}
4128	else
4129	{
4130	image0 = buf[0];
4131	image1 = buf[1];
4132	image2 = buf[2];
4133	image3 = buf[3];
4134	}
4135	image0 &= 0xffffffff;
4136	image1 &= 0xffffffff;
4137	image2 &= 0xffffffff;
4138
4139	sign = (image3 >> 31) & 1;
4140	exp = (image3 >> 16) & 0x7fff;
4141	image3 &= 0xffff;
4142
4143	memset (s: r, c: 0, n: sizeof (*r));
4144
4145	if (exp == 0)
4146	{
4147	if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
4148	{
4149	r->cl = rvc_normal;
4150	r->sign = sign;
4151
4152	SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
4153	if (HOST_BITS_PER_LONG == 32)
4154	{
4155	r->sig[0] = image0;
4156	r->sig[1] = image1;
4157	r->sig[2] = image2;
4158	r->sig[3] = image3;
4159	}
4160	else
4161	{
4162	r->sig[0] = (image1 << 31 << 1) | image0;
4163	r->sig[1] = (image3 << 31 << 1) | image2;
4164	}
4165
4166	normalize (r);
4167	}
4168	else if (fmt->has_signed_zero)
4169	r->sign = sign;
4170	}
4171	else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
4172	{
4173	if (image3 | image2 | image1 | image0)
4174	{
4175	r->cl = rvc_nan;
4176	r->sign = sign;
4177	r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
4178
4179	if (HOST_BITS_PER_LONG == 32)
4180	{
4181	r->sig[0] = image0;
4182	r->sig[1] = image1;
4183	r->sig[2] = image2;
4184	r->sig[3] = image3;
4185	}
4186	else
4187	{
4188	r->sig[0] = (image1 << 31 << 1) | image0;
4189	r->sig[1] = (image3 << 31 << 1) | image2;
4190	}
4191	lshift_significand (r, a: r, SIGNIFICAND_BITS - 113);
4192	}
4193	else
4194	{
4195	r->cl = rvc_inf;
4196	r->sign = sign;
4197	}
4198	}
4199	else
4200	{
4201	r->cl = rvc_normal;
4202	r->sign = sign;
4203	SET_REAL_EXP (r, exp - 16383 + 1);
4204
4205	if (HOST_BITS_PER_LONG == 32)
4206	{
4207	r->sig[0] = image0;
4208	r->sig[1] = image1;
4209	r->sig[2] = image2;
4210	r->sig[3] = image3;
4211	}
4212	else
4213	{
4214	r->sig[0] = (image1 << 31 << 1) | image0;
4215	r->sig[1] = (image3 << 31 << 1) | image2;
4216	}
4217	lshift_significand (r, a: r, SIGNIFICAND_BITS - 113);
4218	r->sig[SIGSZ-1] |= SIG_MSB;
4219	}
4220	}
4221
4222	const struct real_format ieee_quad_format =
4223	{
4224	.encode: encode_ieee_quad,
4225	.decode: decode_ieee_quad,
4226	.b: 2,
4227	.p: 113,
4228	.pnan: 113,
4229	.emin: -16381,
4230	.emax: 16384,
4231	.signbit_ro: 127,
4232	.signbit_rw: 127,
4233	.ieee_bits: 128,
4234	.round_towards_zero: false,
4235	.has_sign_dependent_rounding: true,
4236	.has_nans: true,
4237	.has_inf: true,
4238	.has_denorm: true,
4239	.has_signed_zero: true,
4240	.qnan_msb_set: true,
4241	.canonical_nan_lsbs_set: false,
4242	.name: "ieee_quad"
4243	};
4244
4245	const struct real_format mips_quad_format =
4246	{
4247	.encode: encode_ieee_quad,
4248	.decode: decode_ieee_quad,
4249	.b: 2,
4250	.p: 113,
4251	.pnan: 113,
4252	.emin: -16381,
4253	.emax: 16384,
4254	.signbit_ro: 127,
4255	.signbit_rw: 127,
4256	.ieee_bits: 128,
4257	.round_towards_zero: false,
4258	.has_sign_dependent_rounding: true,
4259	.has_nans: true,
4260	.has_inf: true,
4261	.has_denorm: true,
4262	.has_signed_zero: true,
4263	.qnan_msb_set: false,
4264	.canonical_nan_lsbs_set: true,
4265	.name: "mips_quad"
4266	};
4267
4268	/* Descriptions of VAX floating point formats can be found beginning at
4269
4270	http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
4271
4272	The thing to remember is that they're almost IEEE, except for word
4273	order, exponent bias, and the lack of infinities, nans, and denormals.
4274
4275	We don't implement the H_floating format here, simply because neither
4276	the VAX or Alpha ports use it. */
4277
4278	static void encode_vax_f (const struct real_format *fmt,
4279	long *, const REAL_VALUE_TYPE *);
4280	static void decode_vax_f (const struct real_format *,
4281	REAL_VALUE_TYPE *, const long *);
4282	static void encode_vax_d (const struct real_format *fmt,
4283	long *, const REAL_VALUE_TYPE *);
4284	static void decode_vax_d (const struct real_format *,
4285	REAL_VALUE_TYPE *, const long *);
4286	static void encode_vax_g (const struct real_format *fmt,
4287	long *, const REAL_VALUE_TYPE *);
4288	static void decode_vax_g (const struct real_format *,
4289	REAL_VALUE_TYPE *, const long *);
4290
4291	static void
4292	encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4293	const REAL_VALUE_TYPE *r)
4294	{
4295	unsigned long sign, exp, sig, image;
4296
4297	sign = r->sign << 15;
4298
4299	switch (r->cl)
4300	{
4301	case rvc_zero:
4302	image = 0;
4303	break;
4304
4305	case rvc_inf:
4306	case rvc_nan:
4307	image = 0xffff7fff | sign;
4308	break;
4309
4310	case rvc_normal:
4311	sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
4312	exp = REAL_EXP (r) + 128;
4313
4314	image = (sig << 16) & 0xffff0000;
4315	image |= sign;
4316	image |= exp << 7;
4317	image |= sig >> 16;
4318	break;
4319
4320	default:
4321	gcc_unreachable ();
4322	}
4323
4324	buf[0] = image;
4325	}
4326
4327	static void
4328	decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
4329	REAL_VALUE_TYPE *r, const long *buf)
4330	{
4331	unsigned long image = buf[0] & 0xffffffff;
4332	int exp = (image >> 7) & 0xff;
4333
4334	memset (s: r, c: 0, n: sizeof (*r));
4335
4336	if (exp != 0)
4337	{
4338	r->cl = rvc_normal;
4339	r->sign = (image >> 15) & 1;
4340	SET_REAL_EXP (r, exp - 128);
4341
4342	image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
4343	r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
4344	}
4345	}
4346
4347	static void
4348	encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4349	const REAL_VALUE_TYPE *r)
4350	{
4351	unsigned long image0, image1, sign = r->sign << 15;
4352
4353	switch (r->cl)
4354	{
4355	case rvc_zero:
4356	image0 = image1 = 0;
4357	break;
4358
4359	case rvc_inf:
4360	case rvc_nan:
4361	image0 = 0xffff7fff | sign;
4362	image1 = 0xffffffff;
4363	break;
4364
4365	case rvc_normal:
4366	/* Extract the significand into straight hi:lo. */
4367	if (HOST_BITS_PER_LONG == 64)
4368	{
4369	image0 = r->sig[SIGSZ-1];
4370	image1 = (image0 >> (64 - 56)) & 0xffffffff;
4371	image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
4372	}
4373	else
4374	{
4375	image0 = r->sig[SIGSZ-1];
4376	image1 = r->sig[SIGSZ-2];
4377	image1 = (image0 << 24) | (image1 >> 8);
4378	image0 = (image0 >> 8) & 0xffffff;
4379	}
4380
4381	/* Rearrange the half-words of the significand to match the
4382	external format. */
4383	image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
4384	image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
4385
4386	/* Add the sign and exponent. */
4387	image0 |= sign;
4388	image0 |= (REAL_EXP (r) + 128) << 7;
4389	break;
4390
4391	default:
4392	gcc_unreachable ();
4393	}
4394
4395	if (FLOAT_WORDS_BIG_ENDIAN)
4396	buf[0] = image1, buf[1] = image0;
4397	else
4398	buf[0] = image0, buf[1] = image1;
4399	}
4400
4401	static void
4402	decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
4403	REAL_VALUE_TYPE *r, const long *buf)
4404	{
4405	unsigned long image0, image1;
4406	int exp;
4407
4408	if (FLOAT_WORDS_BIG_ENDIAN)
4409	image1 = buf[0], image0 = buf[1];
4410	else
4411	image0 = buf[0], image1 = buf[1];
4412	image0 &= 0xffffffff;
4413	image1 &= 0xffffffff;
4414
4415	exp = (image0 >> 7) & 0xff;
4416
4417	memset (s: r, c: 0, n: sizeof (*r));
4418
4419	if (exp != 0)
4420	{
4421	r->cl = rvc_normal;
4422	r->sign = (image0 >> 15) & 1;
4423	SET_REAL_EXP (r, exp - 128);
4424
4425	/* Rearrange the half-words of the external format into
4426	proper ascending order. */
4427	image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
4428	image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
4429
4430	if (HOST_BITS_PER_LONG == 64)
4431	{
4432	image0 = (image0 << 31 << 1) | image1;
4433	image0 <<= 64 - 56;
4434	image0 |= SIG_MSB;
4435	r->sig[SIGSZ-1] = image0;
4436	}
4437	else
4438	{
4439	r->sig[SIGSZ-1] = image0;
4440	r->sig[SIGSZ-2] = image1;
4441	lshift_significand (r, a: r, n: 2*HOST_BITS_PER_LONG - 56);
4442	r->sig[SIGSZ-1] |= SIG_MSB;
4443	}
4444	}
4445	}
4446
4447	static void
4448	encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
4449	const REAL_VALUE_TYPE *r)
4450	{
4451	unsigned long image0, image1, sign = r->sign << 15;
4452
4453	switch (r->cl)
4454	{
4455	case rvc_zero:
4456	image0 = image1 = 0;
4457	break;
4458
4459	case rvc_inf:
4460	case rvc_nan:
4461	image0 = 0xffff7fff | sign;
4462	image1 = 0xffffffff;
4463	break;
4464
4465	case rvc_normal:
4466	/* Extract the significand into straight hi:lo. */
4467	if (HOST_BITS_PER_LONG == 64)
4468	{
4469	image0 = r->sig[SIGSZ-1];
4470	image1 = (image0 >> (64 - 53)) & 0xffffffff;
4471	image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
4472	}
4473	else
4474	{
4475	image0 = r->sig[SIGSZ-1];
4476	image1 = r->sig[SIGSZ-2];
4477	image1 = (image0 << 21) | (image1 >> 11);
4478	image0 = (image0 >> 11) & 0xfffff;
4479	}
4480
4481	/* Rearrange the half-words of the significand to match the
4482	external format. */
4483	image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
4484	image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
4485
4486	/* Add the sign and exponent. */
4487	image0 |= sign;
4488	image0 |= (REAL_EXP (r) + 1024) << 4;
4489	break;
4490
4491	default:
4492	gcc_unreachable ();
4493	}
4494
4495	if (FLOAT_WORDS_BIG_ENDIAN)
4496	buf[0] = image1, buf[1] = image0;
4497	else
4498	buf[0] = image0, buf[1] = image1;
4499	}
4500
4501	static void
4502	decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
4503	REAL_VALUE_TYPE *r, const long *buf)
4504	{
4505	unsigned long image0, image1;
4506	int exp;
4507
4508	if (FLOAT_WORDS_BIG_ENDIAN)
4509	image1 = buf[0], image0 = buf[1];
4510	else
4511	image0 = buf[0], image1 = buf[1];
4512	image0 &= 0xffffffff;
4513	image1 &= 0xffffffff;
4514
4515	exp = (image0 >> 4) & 0x7ff;
4516
4517	memset (s: r, c: 0, n: sizeof (*r));
4518
4519	if (exp != 0)
4520	{
4521	r->cl = rvc_normal;
4522	r->sign = (image0 >> 15) & 1;
4523	SET_REAL_EXP (r, exp - 1024);
4524
4525	/* Rearrange the half-words of the external format into
4526	proper ascending order. */
4527	image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
4528	image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
4529
4530	if (HOST_BITS_PER_LONG == 64)
4531	{
4532	image0 = (image0 << 31 << 1) | image1;
4533	image0 <<= 64 - 53;
4534	image0 |= SIG_MSB;
4535	r->sig[SIGSZ-1] = image0;
4536	}
4537	else
4538	{
4539	r->sig[SIGSZ-1] = image0;
4540	r->sig[SIGSZ-2] = image1;
4541	lshift_significand (r, a: r, n: 64 - 53);
4542	r->sig[SIGSZ-1] |= SIG_MSB;
4543	}
4544	}
4545	}
4546
4547	const struct real_format vax_f_format =
4548	{
4549	.encode: encode_vax_f,
4550	.decode: decode_vax_f,
4551	.b: 2,
4552	.p: 24,
4553	.pnan: 24,
4554	.emin: -127,
4555	.emax: 127,
4556	.signbit_ro: 15,
4557	.signbit_rw: 15,
4558	.ieee_bits: 0,
4559	.round_towards_zero: false,
4560	.has_sign_dependent_rounding: false,
4561	.has_nans: false,
4562	.has_inf: false,
4563	.has_denorm: false,
4564	.has_signed_zero: false,
4565	.qnan_msb_set: false,
4566	.canonical_nan_lsbs_set: false,
4567	.name: "vax_f"
4568	};
4569
4570	const struct real_format vax_d_format =
4571	{
4572	.encode: encode_vax_d,
4573	.decode: decode_vax_d,
4574	.b: 2,
4575	.p: 56,
4576	.pnan: 56,
4577	.emin: -127,
4578	.emax: 127,
4579	.signbit_ro: 15,
4580	.signbit_rw: 15,
4581	.ieee_bits: 0,
4582	.round_towards_zero: false,
4583	.has_sign_dependent_rounding: false,
4584	.has_nans: false,
4585	.has_inf: false,
4586	.has_denorm: false,
4587	.has_signed_zero: false,
4588	.qnan_msb_set: false,
4589	.canonical_nan_lsbs_set: false,
4590	.name: "vax_d"
4591	};
4592
4593	const struct real_format vax_g_format =
4594	{
4595	.encode: encode_vax_g,
4596	.decode: decode_vax_g,
4597	.b: 2,
4598	.p: 53,
4599	.pnan: 53,
4600	.emin: -1023,
4601	.emax: 1023,
4602	.signbit_ro: 15,
4603	.signbit_rw: 15,
4604	.ieee_bits: 0,
4605	.round_towards_zero: false,
4606	.has_sign_dependent_rounding: false,
4607	.has_nans: false,
4608	.has_inf: false,
4609	.has_denorm: false,
4610	.has_signed_zero: false,
4611	.qnan_msb_set: false,
4612	.canonical_nan_lsbs_set: false,
4613	.name: "vax_g"
4614	};
4615
4616	/* Encode real R into a single precision DFP value in BUF. */
4617	static void
4618	encode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4619	long *buf ATTRIBUTE_UNUSED,
4620	const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4621	{
4622	encode_decimal32 (fmt, buf, r);
4623	}
4624
4625	/* Decode a single precision DFP value in BUF into a real R. */
4626	static void
4627	decode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
4628	REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4629	const long *buf ATTRIBUTE_UNUSED)
4630	{
4631	decode_decimal32 (fmt, r, buf);
4632	}
4633
4634	/* Encode real R into a double precision DFP value in BUF. */
4635	static void
4636	encode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4637	long *buf ATTRIBUTE_UNUSED,
4638	const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4639	{
4640	encode_decimal64 (fmt, buf, r);
4641	}
4642
4643	/* Decode a double precision DFP value in BUF into a real R. */
4644	static void
4645	decode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
4646	REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4647	const long *buf ATTRIBUTE_UNUSED)
4648	{
4649	decode_decimal64 (fmt, r, buf);
4650	}
4651
4652	/* Encode real R into a quad precision DFP value in BUF. */
4653	static void
4654	encode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
4655	long *buf ATTRIBUTE_UNUSED,
4656	const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
4657	{
4658	encode_decimal128 (fmt, buf, r);
4659	}
4660
4661	/* Decode a quad precision DFP value in BUF into a real R. */
4662	static void
4663	decode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
4664	REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
4665	const long *buf ATTRIBUTE_UNUSED)
4666	{
4667	decode_decimal128 (fmt, r, buf);
4668	}
4669
4670	/* Single precision decimal floating point (IEEE 754). */
4671	const struct real_format decimal_single_format =
4672	{
4673	.encode: encode_decimal_single,
4674	.decode: decode_decimal_single,
4675	.b: 10,
4676	.p: 7,
4677	.pnan: 7,
4678	.emin: -94,
4679	.emax: 97,
4680	.signbit_ro: 31,
4681	.signbit_rw: 31,
4682	.ieee_bits: 32,
4683	.round_towards_zero: false,
4684	.has_sign_dependent_rounding: true,
4685	.has_nans: true,
4686	.has_inf: true,
4687	.has_denorm: true,
4688	.has_signed_zero: true,
4689	.qnan_msb_set: true,
4690	.canonical_nan_lsbs_set: false,
4691	.name: "decimal_single"
4692	};
4693
4694	/* Double precision decimal floating point (IEEE 754). */
4695	const struct real_format decimal_double_format =
4696	{
4697	.encode: encode_decimal_double,
4698	.decode: decode_decimal_double,
4699	.b: 10,
4700	.p: 16,
4701	.pnan: 16,
4702	.emin: -382,
4703	.emax: 385,
4704	.signbit_ro: 63,
4705	.signbit_rw: 63,
4706	.ieee_bits: 64,
4707	.round_towards_zero: false,
4708	.has_sign_dependent_rounding: true,
4709	.has_nans: true,
4710	.has_inf: true,
4711	.has_denorm: true,
4712	.has_signed_zero: true,
4713	.qnan_msb_set: true,
4714	.canonical_nan_lsbs_set: false,
4715	.name: "decimal_double"
4716	};
4717
4718	/* Quad precision decimal floating point (IEEE 754). */
4719	const struct real_format decimal_quad_format =
4720	{
4721	.encode: encode_decimal_quad,
4722	.decode: decode_decimal_quad,
4723	.b: 10,
4724	.p: 34,
4725	.pnan: 34,
4726	.emin: -6142,
4727	.emax: 6145,
4728	.signbit_ro: 127,
4729	.signbit_rw: 127,
4730	.ieee_bits: 128,
4731	.round_towards_zero: false,
4732	.has_sign_dependent_rounding: true,
4733	.has_nans: true,
4734	.has_inf: true,
4735	.has_denorm: true,
4736	.has_signed_zero: true,
4737	.qnan_msb_set: true,
4738	.canonical_nan_lsbs_set: false,
4739	.name: "decimal_quad"
4740	};
4741
4742	/* Encode half-precision floats. This routine is used both for the IEEE
4743	ARM alternative encodings. */
4744	static void
4745	encode_ieee_half (const struct real_format *fmt, long *buf,
4746	const REAL_VALUE_TYPE *r)
4747	{
4748	unsigned long image, sig, exp;
4749	unsigned long sign = r->sign;
4750
4751	image = sign << 15;
4752	sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 11)) & 0x3ff;
4753
4754	switch (r->cl)
4755	{
4756	case rvc_zero:
4757	break;
4758
4759	case rvc_inf:
4760	if (fmt->has_inf)
4761	image |= 31 << 10;
4762	else
4763	image |= 0x7fff;
4764	break;
4765
4766	case rvc_nan:
4767	if (fmt->has_nans)
4768	{
4769	if (r->canonical)
4770	sig = (fmt->canonical_nan_lsbs_set ? (1 << 9) - 1 : 0);
4771	if (r->signalling == fmt->qnan_msb_set)
4772	sig &= ~(1 << 9);
4773	else
4774	sig |= 1 << 9;
4775	if (sig == 0)
4776	sig = 1 << 8;
4777
4778	image |= 31 << 10;
4779	image |= sig;
4780	}
4781	else
4782	image |= 0x3ff;
4783	break;
4784
4785	case rvc_normal:
4786	/* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
4787	whereas the intermediate representation is 0.F x 2**exp.
4788	Which means we're off by one. */
4789	if (real_isdenormal (r))
4790	exp = 0;
4791	else
4792	exp = REAL_EXP (r) + 15 - 1;
4793	image |= exp << 10;
4794	image |= sig;
4795	break;
4796
4797	default:
4798	gcc_unreachable ();
4799	}
4800
4801	buf[0] = image;
4802	}
4803
4804	/* Decode half-precision floats. This routine is used both for the IEEE
4805	ARM alternative encodings. */
4806	static void
4807	decode_ieee_half (const struct real_format *fmt, REAL_VALUE_TYPE *r,
4808	const long *buf)
4809	{
4810	unsigned long image = buf[0] & 0xffff;
4811	bool sign = (image >> 15) & 1;
4812	int exp = (image >> 10) & 0x1f;
4813
4814	memset (s: r, c: 0, n: sizeof (*r));
4815	image <<= HOST_BITS_PER_LONG - 11;
4816	image &= ~SIG_MSB;
4817
4818	if (exp == 0)
4819	{
4820	if (image && fmt->has_denorm)
4821	{
4822	r->cl = rvc_normal;
4823	r->sign = sign;
4824	SET_REAL_EXP (r, -14);
4825	r->sig[SIGSZ-1] = image << 1;
4826	normalize (r);
4827	}
4828	else if (fmt->has_signed_zero)
4829	r->sign = sign;
4830	}
4831	else if (exp == 31 && (fmt->has_nans || fmt->has_inf))
4832	{
4833	if (image)
4834	{
4835	r->cl = rvc_nan;
4836	r->sign = sign;
4837	r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
4838	^ fmt->qnan_msb_set);
4839	r->sig[SIGSZ-1] = image;
4840	}
4841	else
4842	{
4843	r->cl = rvc_inf;
4844	r->sign = sign;
4845	}
4846	}
4847	else
4848	{
4849	r->cl = rvc_normal;
4850	r->sign = sign;
4851	SET_REAL_EXP (r, exp - 15 + 1);
4852	r->sig[SIGSZ-1] = image | SIG_MSB;
4853	}
4854	}
4855
4856	/* Encode arm_bfloat types. */
4857	static void
4858	encode_arm_bfloat_half (const struct real_format *fmt, long *buf,
4859	const REAL_VALUE_TYPE *r)
4860	{
4861	unsigned long image, sig, exp;
4862	unsigned long sign = r->sign;
4863
4864	image = sign << 15;
4865	sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 8)) & 0x7f;
4866
4867	switch (r->cl)
4868	{
4869	case rvc_zero:
4870	break;
4871
4872	case rvc_inf:
4873	if (fmt->has_inf)
4874	image |= 255 << 7;
4875	else
4876	image |= 0x7fff;
4877	break;
4878
4879	case rvc_nan:
4880	if (fmt->has_nans)
4881	{
4882	if (r->canonical)
4883	sig = (fmt->canonical_nan_lsbs_set ? (1 << 6) - 1 : 0);
4884	if (r->signalling == fmt->qnan_msb_set)
4885	sig &= ~(1 << 6);
4886	else
4887	sig |= 1 << 6;
4888	if (sig == 0)
4889	sig = 1 << 5;
4890
4891	image |= 255 << 7;
4892	image |= sig;
4893	}
4894	else
4895	image |= 0x7fff;
4896	break;
4897
4898	case rvc_normal:
4899	if (real_isdenormal (r))
4900	exp = 0;
4901	else
4902	exp = REAL_EXP (r) + 127 - 1;
4903	image |= exp << 7;
4904	image |= sig;
4905	break;
4906
4907	default:
4908	gcc_unreachable ();
4909	}
4910
4911	buf[0] = image;
4912	}
4913
4914	/* Decode arm_bfloat types. */
4915	static void
4916	decode_arm_bfloat_half (const struct real_format *fmt, REAL_VALUE_TYPE *r,
4917	const long *buf)
4918	{
4919	unsigned long image = buf[0] & 0xffff;
4920	bool sign = (image >> 15) & 1;
4921	int exp = (image >> 7) & 0xff;
4922
4923	memset (s: r, c: 0, n: sizeof (*r));
4924	image <<= HOST_BITS_PER_LONG - 8;
4925	image &= ~SIG_MSB;
4926
4927	if (exp == 0)
4928	{
4929	if (image && fmt->has_denorm)
4930	{
4931	r->cl = rvc_normal;
4932	r->sign = sign;
4933	SET_REAL_EXP (r, -126);
4934	r->sig[SIGSZ-1] = image << 1;
4935	normalize (r);
4936	}
4937	else if (fmt->has_signed_zero)
4938	r->sign = sign;
4939	}
4940	else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
4941	{
4942	if (image)
4943	{
4944	r->cl = rvc_nan;
4945	r->sign = sign;
4946	r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
4947	^ fmt->qnan_msb_set);
4948	r->sig[SIGSZ-1] = image;
4949	}
4950	else
4951	{
4952	r->cl = rvc_inf;
4953	r->sign = sign;
4954	}
4955	}
4956	else
4957	{
4958	r->cl = rvc_normal;
4959	r->sign = sign;
4960	SET_REAL_EXP (r, exp - 127 + 1);
4961	r->sig[SIGSZ-1] = image | SIG_MSB;
4962	}
4963	}
4964
4965	/* Half-precision format, as specified in IEEE 754R. */
4966	const struct real_format ieee_half_format =
4967	{
4968	.encode: encode_ieee_half,
4969	.decode: decode_ieee_half,
4970	.b: 2,
4971	.p: 11,
4972	.pnan: 11,
4973	.emin: -13,
4974	.emax: 16,
4975	.signbit_ro: 15,
4976	.signbit_rw: 15,
4977	.ieee_bits: 16,
4978	.round_towards_zero: false,
4979	.has_sign_dependent_rounding: true,
4980	.has_nans: true,
4981	.has_inf: true,
4982	.has_denorm: true,
4983	.has_signed_zero: true,
4984	.qnan_msb_set: true,
4985	.canonical_nan_lsbs_set: false,
4986	.name: "ieee_half"
4987	};
4988
4989	/* ARM's alternative half-precision format, similar to IEEE but with
4990	no reserved exponent value for NaNs and infinities; rather, it just
4991	extends the range of exponents by one. */
4992	const struct real_format arm_half_format =
4993	{
4994	.encode: encode_ieee_half,
4995	.decode: decode_ieee_half,
4996	.b: 2,
4997	.p: 11,
4998	.pnan: 11,
4999	.emin: -13,
5000	.emax: 17,
5001	.signbit_ro: 15,
5002	.signbit_rw: 15,
5003	.ieee_bits: 0,
5004	.round_towards_zero: false,
5005	.has_sign_dependent_rounding: true,
5006	.has_nans: false,
5007	.has_inf: false,
5008	.has_denorm: true,
5009	.has_signed_zero: true,
5010	.qnan_msb_set: false,
5011	.canonical_nan_lsbs_set: false,
5012	.name: "arm_half"
5013	};
5014
5015	/* ARM Bfloat half-precision format. This format resembles a truncated
5016	(16-bit) version of the 32-bit IEEE 754 single-precision floating-point
5017	format. */
5018	const struct real_format arm_bfloat_half_format =
5019	{
5020	.encode: encode_arm_bfloat_half,
5021	.decode: decode_arm_bfloat_half,
5022	.b: 2,
5023	.p: 8,
5024	.pnan: 8,
5025	.emin: -125,
5026	.emax: 128,
5027	.signbit_ro: 15,
5028	.signbit_rw: 15,
5029	.ieee_bits: 0,
5030	.round_towards_zero: false,
5031	.has_sign_dependent_rounding: true,
5032	.has_nans: true,
5033	.has_inf: true,
5034	.has_denorm: true,
5035	.has_signed_zero: true,
5036	.qnan_msb_set: true,
5037	.canonical_nan_lsbs_set: false,
5038	.name: "arm_bfloat_half"
5039	};
5040
5041
5042	/* A synthetic "format" for internal arithmetic. It's the size of the
5043	internal significand minus the two bits needed for proper rounding.
5044	The encode and decode routines exist only to satisfy our paranoia
5045	harness. */
5046
5047	static void encode_internal (const struct real_format *fmt,
5048	long *, const REAL_VALUE_TYPE *);
5049	static void decode_internal (const struct real_format *,
5050	REAL_VALUE_TYPE *, const long *);
5051
5052	static void
5053	encode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
5054	const REAL_VALUE_TYPE *r)
5055	{
5056	memcpy (dest: buf, src: r, n: sizeof (*r));
5057	}
5058
5059	static void
5060	decode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED,
5061	REAL_VALUE_TYPE *r, const long *buf)
5062	{
5063	memcpy (dest: r, src: buf, n: sizeof (*r));
5064	}
5065
5066	const struct real_format real_internal_format =
5067	{
5068	.encode: encode_internal,
5069	.decode: decode_internal,
5070	.b: 2,
5071	SIGNIFICAND_BITS - 2,
5072	SIGNIFICAND_BITS - 2,
5073	.emin: -MAX_EXP,
5074	MAX_EXP,
5075	.signbit_ro: -1,
5076	.signbit_rw: -1,
5077	.ieee_bits: 0,
5078	.round_towards_zero: false,
5079	.has_sign_dependent_rounding: false,
5080	.has_nans: true,
5081	.has_inf: true,
5082	.has_denorm: false,
5083	.has_signed_zero: true,
5084	.qnan_msb_set: true,
5085	.canonical_nan_lsbs_set: false,
5086	.name: "real_internal"
5087	};
5088
5089	/* Calculate X raised to the integer exponent N in format FMT and store
5090	the result in R. Return true if the result may be inexact due to
5091	loss of precision. The algorithm is the classic "left-to-right binary
5092	method" described in section 4.6.3 of Donald Knuth's "Seminumerical
5093	Algorithms", "The Art of Computer Programming", Volume 2. */
5094
5095	bool
5096	real_powi (REAL_VALUE_TYPE *r, format_helper fmt,
5097	const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
5098	{
5099	unsigned HOST_WIDE_INT bit;
5100	REAL_VALUE_TYPE t;
5101	bool inexact = false;
5102	bool init = false;
5103	bool neg;
5104	int i;
5105
5106	if (n == 0)
5107	{
5108	*r = dconst1;
5109	return false;
5110	}
5111	else if (n < 0)
5112	{
5113	/* Don't worry about overflow, from now on n is unsigned. */
5114	neg = true;
5115	n = -n;
5116	}
5117	else
5118	neg = false;
5119
5120	t = *x;
5121	bit = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1);
5122	for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
5123	{
5124	if (init)
5125	{
5126	inexact |= do_multiply (r: &t, a: &t, b: &t);
5127	if (n & bit)
5128	inexact |= do_multiply (r: &t, a: &t, b: x);
5129	}
5130	else if (n & bit)
5131	init = true;
5132	bit >>= 1;
5133	}
5134
5135	if (neg)
5136	inexact |= do_divide (r: &t, a: &dconst1, b: &t);
5137
5138	real_convert (r, fmt, a: &t);
5139	return inexact;
5140	}
5141
5142	/* Round X to the nearest integer not larger in absolute value, i.e.
5143	towards zero, placing the result in R in format FMT. */
5144
5145	void
5146	real_trunc (REAL_VALUE_TYPE *r, format_helper fmt,
5147	const REAL_VALUE_TYPE *x)
5148	{
5149	do_fix_trunc (r, a: x);
5150	if (fmt)
5151	real_convert (r, fmt, a: r);
5152	}
5153
5154	/* Round X to the largest integer not greater in value, i.e. round
5155	down, placing the result in R in format FMT. */
5156
5157	void
5158	real_floor (REAL_VALUE_TYPE *r, format_helper fmt,
5159	const REAL_VALUE_TYPE *x)
5160	{
5161	REAL_VALUE_TYPE t;
5162
5163	do_fix_trunc (r: &t, a: x);
5164	if (! real_identical (a: &t, b: x) && x->sign)
5165	do_add (r: &t, a: &t, b: &dconstm1, subtract_p: 0);
5166	if (fmt)
5167	real_convert (r, fmt, a: &t);
5168	else
5169	*r = t;
5170	}
5171
5172	/* Round X to the smallest integer not less then argument, i.e. round
5173	up, placing the result in R in format FMT. */
5174
5175	void
5176	real_ceil (REAL_VALUE_TYPE *r, format_helper fmt,
5177	const REAL_VALUE_TYPE *x)
5178	{
5179	REAL_VALUE_TYPE t;
5180
5181	do_fix_trunc (r: &t, a: x);
5182	if (! real_identical (a: &t, b: x) && ! x->sign)
5183	do_add (r: &t, a: &t, b: &dconst1, subtract_p: 0);
5184	if (fmt)
5185	real_convert (r, fmt, a: &t);
5186	else
5187	*r = t;
5188	}
5189
5190	/* Round X to the nearest integer, but round halfway cases away from
5191	zero. */
5192
5193	void
5194	real_round (REAL_VALUE_TYPE *r, format_helper fmt,
5195	const REAL_VALUE_TYPE *x)
5196	{
5197	do_add (r, a: x, b: &dconsthalf, subtract_p: x->sign);
5198	do_fix_trunc (r, a: r);
5199	if (fmt)
5200	real_convert (r, fmt, a: r);
5201	}
5202
5203	/* Return true (including 0) if integer part of R is even, else return
5204	false. The function is not valid for rvc_inf and rvc_nan classes. */
5205
5206	static bool
5207	is_even (REAL_VALUE_TYPE *r)
5208	{
5209	gcc_assert (r->cl != rvc_inf);
5210	gcc_assert (r->cl != rvc_nan);
5211
5212	if (r->cl == rvc_zero)
5213	return true;
5214
5215	/* For (-1,1), number is even. */
5216	if (REAL_EXP (r) <= 0)
5217	return true;
5218
5219	/* Check lowest bit, if not set, return true. */
5220	else if (REAL_EXP (r) <= SIGNIFICAND_BITS)
5221	{
5222	unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r);
5223	int w = n / HOST_BITS_PER_LONG;
5224
5225	unsigned long num = ((unsigned long)1 << (n % HOST_BITS_PER_LONG));
5226
5227	if ((r->sig[w] & num) == 0)
5228	return true;
5229	}
5230	else
5231	return true;
5232
5233	return false;
5234	}
5235
5236	/* Return true if R is halfway between two integers, else return
5237	false. */
5238
5239	static bool
5240	is_halfway_below (const REAL_VALUE_TYPE *r)
5241	{
5242	if (r->cl != rvc_normal)
5243	return false;
5244
5245	/* For numbers (-0.5,0) and (0,0.5). */
5246	if (REAL_EXP (r) < 0)
5247	return false;
5248
5249	else if (REAL_EXP (r) < SIGNIFICAND_BITS)
5250	{
5251	unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r) - 1;
5252	int w = n / HOST_BITS_PER_LONG;
5253
5254	for (int i = 0; i < w; ++i)
5255	if (r->sig[i] != 0)
5256	return false;
5257
5258	unsigned long num = 1UL << (n % HOST_BITS_PER_LONG);
5259
5260	if ((r->sig[w] & num) != 0 && (r->sig[w] & (num - 1)) == 0)
5261	return true;
5262	}
5263	return false;
5264	}
5265
5266	/* Round X to nearest integer, rounding halfway cases towards even. */
5267
5268	void
5269	real_roundeven (REAL_VALUE_TYPE *r, format_helper fmt,
5270	const REAL_VALUE_TYPE *x)
5271	{
5272	if (is_halfway_below (r: x))
5273	{
5274	/* Special case as -0.5 rounds to -0.0 and
5275	similarly +0.5 rounds to +0.0. */
5276	if (REAL_EXP (x) == 0)
5277	{
5278	*r = *x;
5279	clear_significand_below (r, SIGNIFICAND_BITS);
5280	}
5281	else
5282	{
5283	do_add (r, a: x, b: &dconsthalf, subtract_p: x->sign);
5284	if (!is_even (r))
5285	do_add (r, a: r, b: &dconstm1, subtract_p: x->sign);
5286	}
5287	if (fmt)
5288	real_convert (r, fmt, a: r);
5289	}
5290	else
5291	real_round (r, fmt, x);
5292	}
5293
5294	/* Set the sign of R to the sign of X. */
5295
5296	void
5297	real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x)
5298	{
5299	r->sign = x->sign;
5300	}
5301
5302	/* Check whether the real constant value given is an integer.
5303	Returns false for signaling NaN. */
5304
5305	bool
5306	real_isinteger (const REAL_VALUE_TYPE *c, format_helper fmt)
5307	{
5308	REAL_VALUE_TYPE cint;
5309
5310	real_trunc (r: &cint, fmt, x: c);
5311	return real_identical (a: c, b: &cint);
5312	}
5313
5314	/* Check whether C is an integer that fits in a HOST_WIDE_INT,
5315	storing it in *INT_OUT if so. */
5316
5317	bool
5318	real_isinteger (const REAL_VALUE_TYPE *c, HOST_WIDE_INT *int_out)
5319	{
5320	REAL_VALUE_TYPE cint;
5321
5322	HOST_WIDE_INT n = real_to_integer (r: c);
5323	real_from_integer (r: &cint, VOIDmode, val_in: n, sgn: SIGNED);
5324	if (real_identical (a: c, b: &cint))
5325	{
5326	*int_out = n;
5327	return true;
5328	}
5329	return false;
5330	}
5331
5332	/* Calculate nextafter (X, Y) or nexttoward (X, Y). Return true if
5333	underflow or overflow needs to be raised. */
5334
5335	bool
5336	real_nextafter (REAL_VALUE_TYPE *r, format_helper fmt,
5337	const REAL_VALUE_TYPE *x, const REAL_VALUE_TYPE *y)
5338	{
5339	int cmp = do_compare (a: x, b: y, nan_result: 2);
5340	/* If either operand is NaN, return qNaN. */
5341	if (cmp == 2)
5342	{
5343	get_canonical_qnan (r, sign: 0);
5344	return false;
5345	}
5346	/* If x == y, return y cast to target type. */
5347	if (cmp == 0)
5348	{
5349	real_convert (r, fmt, a: y);
5350	return false;
5351	}
5352
5353	if (x->cl == rvc_zero)
5354	{
5355	get_zero (r, sign: y->sign);
5356	r->cl = rvc_normal;
5357	SET_REAL_EXP (r, fmt->emin - fmt->p + 1);
5358	r->sig[SIGSZ - 1] = SIG_MSB;
5359	return false;
5360	}
5361
5362	int np2 = SIGNIFICAND_BITS - fmt->p;
5363	/* For denormals adjust np2 correspondingly. */
5364	if (x->cl == rvc_normal && REAL_EXP (x) < fmt->emin)
5365	np2 += fmt->emin - REAL_EXP (x);
5366
5367	REAL_VALUE_TYPE u;
5368	get_zero (r, sign: x->sign);
5369	get_zero (r: &u, sign: 0);
5370	set_significand_bit (r: &u, n: np2);
5371	r->cl = rvc_normal;
5372	SET_REAL_EXP (r, REAL_EXP (x));
5373
5374	if (x->cl == rvc_inf)
5375	{
5376	bool borrow = sub_significands (r, a: r, b: &u, carry: 0);
5377	gcc_assert (borrow);
5378	SET_REAL_EXP (r, fmt->emax);
5379	}
5380	else if (cmp == (x->sign ? 1 : -1))
5381	{
5382	if (add_significands (r, a: x, b: &u))
5383	{
5384	/* Overflow. Means the significand had been all ones, and
5385	is now all zeros. Need to increase the exponent, and
5386	possibly re-normalize it. */
5387	SET_REAL_EXP (r, REAL_EXP (r) + 1);
5388	if (REAL_EXP (r) > fmt->emax)
5389	{
5390	get_inf (r, sign: x->sign);
5391	return true;
5392	}
5393	r->sig[SIGSZ - 1] = SIG_MSB;
5394	}
5395	}
5396	else
5397	{
5398	if (REAL_EXP (x) > fmt->emin && x->sig[SIGSZ - 1] == SIG_MSB)
5399	{
5400	int i;
5401	for (i = SIGSZ - 2; i >= 0; i--)
5402	if (x->sig[i])
5403	break;
5404	if (i < 0)
5405	{
5406	/* When mantissa is 1.0, we need to subtract only
5407	half of u: nextafter (1.0, 0.0) is 1.0 - __DBL_EPSILON__ / 2
5408	rather than 1.0 - __DBL_EPSILON__. */
5409	clear_significand_bit (r: &u, n: np2);
5410	np2--;
5411	set_significand_bit (r: &u, n: np2);
5412	}
5413	}
5414	sub_significands (r, a: x, b: &u, carry: 0);
5415	}
5416
5417	/* Clear out trailing garbage. */
5418	clear_significand_below (r, n: np2);
5419	normalize (r);
5420	if (REAL_EXP (r) <= fmt->emin - fmt->p)
5421	{
5422	get_zero (r, sign: x->sign);
5423	return true;
5424	}
5425	return r->cl == rvc_zero || REAL_EXP (r) < fmt->emin;
5426	}
5427
5428	/* Write into BUF the maximum representable finite floating-point
5429	number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
5430	float string. LEN is the size of BUF, and the buffer must be large
5431	enough to contain the resulting string. If NORM_MAX, instead write
5432	the maximum representable finite normalized floating-point number,
5433	defined to be such that all choices of digits for that exponent are
5434	representable in the format (this only makes a difference for IBM
5435	long double). */
5436
5437	void
5438	get_max_float (const struct real_format *fmt, char *buf, size_t len,
5439	bool norm_max)
5440	{
5441	int i, n;
5442	char *p;
5443	bool is_ibm_extended = fmt->pnan < fmt->p;
5444
5445	strcpy (dest: buf, src: "0x0.");
5446	n = fmt->p;
5447	for (i = 0, p = buf + 4; i + 3 < n; i += 4)
5448	*p++ = 'f';
5449	if (i < n)
5450	*p++ = "08ce"[n - i];
5451	sprintf (s: p, format: "p%d",
5452	(is_ibm_extended && norm_max) ? fmt->emax - 1 : fmt->emax);
5453	if (is_ibm_extended && !norm_max)
5454	{
5455	/* This is an IBM extended double format made up of two IEEE
5456	doubles. The value of the long double is the sum of the
5457	values of the two parts. The most significant part is
5458	required to be the value of the long double rounded to the
5459	nearest double. Rounding means we need a slightly smaller
5460	value for LDBL_MAX. */
5461	buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
5462	}
5463
5464	gcc_assert (strlen (buf) < len);
5465	}
5466
5467	/* True if all values of integral type can be represented
5468	by this floating-point type exactly. */
5469
5470	bool format_helper::can_represent_integral_type_p (tree type) const
5471	{
5472	gcc_assert (! decimal_p () && INTEGRAL_TYPE_P (type));
5473
5474	/* INT?_MIN is power-of-two so it takes
5475	only one mantissa bit. */
5476	bool signed_p = TYPE_SIGN (type) == SIGNED;
5477	return TYPE_PRECISION (type) - signed_p <= significand_size (fmt: *this);
5478	}
5479
5480	/* True if mode M has a NaN representation and
5481	the treatment of NaN operands is important. */
5482
5483	bool
5484	HONOR_NANS (machine_mode m)
5485	{
5486	return MODE_HAS_NANS (m) && !flag_finite_math_only;
5487	}
5488
5489	bool
5490	HONOR_NANS (const_tree t)
5491	{
5492	return HONOR_NANS (m: element_mode (t));
5493	}
5494
5495	bool
5496	HONOR_NANS (const_rtx x)
5497	{
5498	return HONOR_NANS (GET_MODE (x));
5499	}
5500
5501	/* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */
5502
5503	bool
5504	HONOR_SNANS (machine_mode m)
5505	{
5506	return flag_signaling_nans && HONOR_NANS (m);
5507	}
5508
5509	bool
5510	HONOR_SNANS (const_tree t)
5511	{
5512	return HONOR_SNANS (m: element_mode (t));
5513	}
5514
5515	bool
5516	HONOR_SNANS (const_rtx x)
5517	{
5518	return HONOR_SNANS (GET_MODE (x));
5519	}
5520
5521	/* As for HONOR_NANS, but true if the mode can represent infinity and
5522	the treatment of infinite values is important. */
5523
5524	bool
5525	HONOR_INFINITIES (machine_mode m)
5526	{
5527	return MODE_HAS_INFINITIES (m) && !flag_finite_math_only;
5528	}
5529
5530	bool
5531	HONOR_INFINITIES (const_tree t)
5532	{
5533	return HONOR_INFINITIES (m: element_mode (t));
5534	}
5535
5536	bool
5537	HONOR_INFINITIES (const_rtx x)
5538	{
5539	return HONOR_INFINITIES (GET_MODE (x));
5540	}
5541
5542	/* Like HONOR_NANS, but true if the given mode distinguishes between
5543	positive and negative zero, and the sign of zero is important. */
5544
5545	bool
5546	HONOR_SIGNED_ZEROS (machine_mode m)
5547	{
5548	return MODE_HAS_SIGNED_ZEROS (m) && flag_signed_zeros;
5549	}
5550
5551	bool
5552	HONOR_SIGNED_ZEROS (const_tree t)
5553	{
5554	return HONOR_SIGNED_ZEROS (m: element_mode (t));
5555	}
5556
5557	bool
5558	HONOR_SIGNED_ZEROS (const_rtx x)
5559	{
5560	return HONOR_SIGNED_ZEROS (GET_MODE (x));
5561	}
5562
5563	/* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
5564	and the rounding mode is important. */
5565
5566	bool
5567	HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode m)
5568	{
5569	return MODE_HAS_SIGN_DEPENDENT_ROUNDING (m) && flag_rounding_math;
5570	}
5571
5572	bool
5573	HONOR_SIGN_DEPENDENT_ROUNDING (const_tree t)
5574	{
5575	return HONOR_SIGN_DEPENDENT_ROUNDING (m: element_mode (t));
5576	}
5577
5578	bool
5579	HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx x)
5580	{
5581	return HONOR_SIGN_DEPENDENT_ROUNDING (GET_MODE (x));
5582	}
5583
5584	/* Fills r with the largest value such that 1 + r*r won't overflow.
5585	This is used in both sin (atan (x)) and cos (atan(x)) optimizations. */
5586
5587	void
5588	build_sinatan_real (REAL_VALUE_TYPE * r, tree type)
5589	{
5590	REAL_VALUE_TYPE maxval;
5591	mpfr_t mpfr_const1, mpfr_c, mpfr_maxval;
5592	machine_mode mode = TYPE_MODE (type);
5593	const struct real_format * fmt = REAL_MODE_FORMAT (mode);
5594
5595	real_maxval (r: &maxval, sign: 0, mode);
5596
5597	mpfr_inits (mpfr_const1, mpfr_c, mpfr_maxval, NULL);
5598
5599	mpfr_from_real (mpfr_const1, &dconst1, MPFR_RNDN);
5600	mpfr_from_real (mpfr_maxval, &maxval, MPFR_RNDN);
5601
5602	mpfr_sub (mpfr_c, mpfr_maxval, mpfr_const1, MPFR_RNDN);
5603	mpfr_sqrt (mpfr_c, mpfr_c, MPFR_RNDZ);
5604
5605	real_from_mpfr (r, mpfr_c, fmt, MPFR_RNDZ);
5606
5607	mpfr_clears (mpfr_const1, mpfr_c, mpfr_maxval, NULL);
5608	}
5609