WebSVN – Kolibri OS – Blame – /contrib/toolchain/gcc/5x/libgcc/libgcc2.c

Rev	Author	Line No.	Line
6515	serge	1	/* More subroutines needed by GCC output code on some machines. */
		2	/* Compile this one with gcc. */
		3	/* Copyright (C) 1989-2015 Free Software Foundation, Inc.
		4
		5	This file is part of GCC.
		6
		7	GCC is free software; you can redistribute it and/or modify it under
		8	the terms of the GNU General Public License as published by the Free
		9	Software Foundation; either version 3, or (at your option) any later
		10	version.
		11
		12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
		13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
		14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
		15	for more details.
		16
		17	Under Section 7 of GPL version 3, you are granted additional
		18	permissions described in the GCC Runtime Library Exception, version
		19	3.1, as published by the Free Software Foundation.
		20
		21	You should have received a copy of the GNU General Public License and
		22	a copy of the GCC Runtime Library Exception along with this program;
		23	see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
		24	. */
		25
		26	#include "tconfig.h"
		27	#include "tsystem.h"
		28	#include "coretypes.h"
		29	#include "tm.h"
		30	#include "libgcc_tm.h"
		31
		32	#ifdef HAVE_GAS_HIDDEN
		33	#define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
		34	#else
		35	#define ATTRIBUTE_HIDDEN
		36	#endif
		37
		38	/* Work out the largest "word" size that we can deal with on this target. */
		39	#if MIN_UNITS_PER_WORD > 4
		40	# define LIBGCC2_MAX_UNITS_PER_WORD 8
		41	#elif (MIN_UNITS_PER_WORD > 2 \
		42	\|\| (MIN_UNITS_PER_WORD > 1 && __SIZEOF_LONG_LONG__ > 4))
		43	# define LIBGCC2_MAX_UNITS_PER_WORD 4
		44	#else
		45	# define LIBGCC2_MAX_UNITS_PER_WORD MIN_UNITS_PER_WORD
		46	#endif
		47
		48	/* Work out what word size we are using for this compilation.
		49	The value can be set on the command line. */
		50	#ifndef LIBGCC2_UNITS_PER_WORD
		51	#define LIBGCC2_UNITS_PER_WORD LIBGCC2_MAX_UNITS_PER_WORD
		52	#endif
		53
		54	#if LIBGCC2_UNITS_PER_WORD <= LIBGCC2_MAX_UNITS_PER_WORD
		55
		56	#include "libgcc2.h"
		57
		58	#ifdef DECLARE_LIBRARY_RENAMES
		59	DECLARE_LIBRARY_RENAMES
		60	#endif
		61
		62	#if defined (L_negdi2)
		63	DWtype
		64	__negdi2 (DWtype u)
		65	{
		66	const DWunion uu = {.ll = u};
		67	const DWunion w = { {.low = -uu.s.low,
		68	.high = -uu.s.high - ((UWtype) -uu.s.low > 0) } };
		69
		70	return w.ll;
		71	}
		72	#endif
		73
		74	#ifdef L_addvsi3
		75	Wtype
		76	__addvSI3 (Wtype a, Wtype b)
		77	{
		78	const Wtype w = (UWtype) a + (UWtype) b;
		79
		80	if (b >= 0 ? w < a : w > a)
		81	abort ();
		82
		83	return w;
		84	}
		85	#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
		86	SItype
		87	__addvsi3 (SItype a, SItype b)
		88	{
		89	const SItype w = (USItype) a + (USItype) b;
		90
		91	if (b >= 0 ? w < a : w > a)
		92	abort ();
		93
		94	return w;
		95	}
		96	#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
		97	#endif
		98
		99	#ifdef L_addvdi3
		100	DWtype
		101	__addvDI3 (DWtype a, DWtype b)
		102	{
		103	const DWtype w = (UDWtype) a + (UDWtype) b;
		104
		105	if (b >= 0 ? w < a : w > a)
		106	abort ();
		107
		108	return w;
		109	}
		110	#endif
		111
		112	#ifdef L_subvsi3
		113	Wtype
		114	__subvSI3 (Wtype a, Wtype b)
		115	{
		116	const Wtype w = (UWtype) a - (UWtype) b;
		117
		118	if (b >= 0 ? w > a : w < a)
		119	abort ();
		120
		121	return w;
		122	}
		123	#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
		124	SItype
		125	__subvsi3 (SItype a, SItype b)
		126	{
		127	const SItype w = (USItype) a - (USItype) b;
		128
		129	if (b >= 0 ? w > a : w < a)
		130	abort ();
		131
		132	return w;
		133	}
		134	#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
		135	#endif
		136
		137	#ifdef L_subvdi3
		138	DWtype
		139	__subvDI3 (DWtype a, DWtype b)
		140	{
		141	const DWtype w = (UDWtype) a - (UDWtype) b;
		142
		143	if (b >= 0 ? w > a : w < a)
		144	abort ();
		145
		146	return w;
		147	}
		148	#endif
		149
		150	#ifdef L_mulvsi3
		151	Wtype
		152	__mulvSI3 (Wtype a, Wtype b)
		153	{
		154	const DWtype w = (DWtype) a * (DWtype) b;
		155
		156	if ((Wtype) (w >> W_TYPE_SIZE) != (Wtype) w >> (W_TYPE_SIZE - 1))
		157	abort ();
		158
		159	return w;
		160	}
		161	#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
		162	#undef WORD_SIZE
		163	#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
		164	SItype
		165	__mulvsi3 (SItype a, SItype b)
		166	{
		167	const DItype w = (DItype) a * (DItype) b;
		168
		169	if ((SItype) (w >> WORD_SIZE) != (SItype) w >> (WORD_SIZE-1))
		170	abort ();
		171
		172	return w;
		173	}
		174	#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
		175	#endif
		176
		177	#ifdef L_negvsi2
		178	Wtype
		179	__negvSI2 (Wtype a)
		180	{
		181	const Wtype w = -(UWtype) a;
		182
		183	if (a >= 0 ? w > 0 : w < 0)
		184	abort ();
		185
		186	return w;
		187	}
		188	#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
		189	SItype
		190	__negvsi2 (SItype a)
		191	{
		192	const SItype w = -(USItype) a;
		193
		194	if (a >= 0 ? w > 0 : w < 0)
		195	abort ();
		196
		197	return w;
		198	}
		199	#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
		200	#endif
		201
		202	#ifdef L_negvdi2
		203	DWtype
		204	__negvDI2 (DWtype a)
		205	{
		206	const DWtype w = -(UDWtype) a;
		207
		208	if (a >= 0 ? w > 0 : w < 0)
		209	abort ();
		210
		211	return w;
		212	}
		213	#endif
		214
		215	#ifdef L_absvsi2
		216	Wtype
		217	__absvSI2 (Wtype a)
		218	{
		219	Wtype w = a;
		220
		221	if (a < 0)
		222	#ifdef L_negvsi2
		223	w = __negvSI2 (a);
		224	#else
		225	w = -(UWtype) a;
		226
		227	if (w < 0)
		228	abort ();
		229	#endif
		230
		231	return w;
		232	}
		233	#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
		234	SItype
		235	__absvsi2 (SItype a)
		236	{
		237	SItype w = a;
		238
		239	if (a < 0)
		240	#ifdef L_negvsi2
		241	w = __negvsi2 (a);
		242	#else
		243	w = -(USItype) a;
		244
		245	if (w < 0)
		246	abort ();
		247	#endif
		248
		249	return w;
		250	}
		251	#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
		252	#endif
		253
		254	#ifdef L_absvdi2
		255	DWtype
		256	__absvDI2 (DWtype a)
		257	{
		258	DWtype w = a;
		259
		260	if (a < 0)
		261	#ifdef L_negvdi2
		262	w = __negvDI2 (a);
		263	#else
		264	w = -(UDWtype) a;
		265
		266	if (w < 0)
		267	abort ();
		268	#endif
		269
		270	return w;
		271	}
		272	#endif
		273
		274	#ifdef L_mulvdi3
		275	DWtype
		276	__mulvDI3 (DWtype u, DWtype v)
		277	{
		278	/* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
		279	but the checked multiplication needs only two. */
		280	const DWunion uu = {.ll = u};
		281	const DWunion vv = {.ll = v};
		282
		283	if (__builtin_expect (uu.s.high == uu.s.low >> (W_TYPE_SIZE - 1), 1))
		284	{
		285	/* u fits in a single Wtype. */
		286	if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
		287	{
		288	/* v fits in a single Wtype as well. */
		289	/* A single multiplication. No overflow risk. */
		290	return (DWtype) uu.s.low * (DWtype) vv.s.low;
		291	}
		292	else
		293	{
		294	/* Two multiplications. */
		295	DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
		296	* (UDWtype) (UWtype) vv.s.low};
		297	DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.low
		298	* (UDWtype) (UWtype) vv.s.high};
		299
		300	if (vv.s.high < 0)
		301	w1.s.high -= uu.s.low;
		302	if (uu.s.low < 0)
		303	w1.ll -= vv.ll;
		304	w1.ll += (UWtype) w0.s.high;
		305	if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
		306	{
		307	w0.s.high = w1.s.low;
		308	return w0.ll;
		309	}
		310	}
		311	}
		312	else
		313	{
		314	if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
		315	{
		316	/* v fits into a single Wtype. */
		317	/* Two multiplications. */
		318	DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
		319	* (UDWtype) (UWtype) vv.s.low};
		320	DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.high
		321	* (UDWtype) (UWtype) vv.s.low};
		322
		323	if (uu.s.high < 0)
		324	w1.s.high -= vv.s.low;
		325	if (vv.s.low < 0)
		326	w1.ll -= uu.ll;
		327	w1.ll += (UWtype) w0.s.high;
		328	if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
		329	{
		330	w0.s.high = w1.s.low;
		331	return w0.ll;
		332	}
		333	}
		334	else
		335	{
		336	/* A few sign checks and a single multiplication. */
		337	if (uu.s.high >= 0)
		338	{
		339	if (vv.s.high >= 0)
		340	{
		341	if (uu.s.high == 0 && vv.s.high == 0)
		342	{
		343	const DWtype w = (UDWtype) (UWtype) uu.s.low
		344	* (UDWtype) (UWtype) vv.s.low;
		345	if (__builtin_expect (w >= 0, 1))
		346	return w;
		347	}
		348	}
		349	else
		350	{
		351	if (uu.s.high == 0 && vv.s.high == (Wtype) -1)
		352	{
		353	DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
		354	* (UDWtype) (UWtype) vv.s.low};
		355
		356	ww.s.high -= uu.s.low;
		357	if (__builtin_expect (ww.s.high < 0, 1))
		358	return ww.ll;
		359	}
		360	}
		361	}
		362	else
		363	{
		364	if (vv.s.high >= 0)
		365	{
		366	if (uu.s.high == (Wtype) -1 && vv.s.high == 0)
		367	{
		368	DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
		369	* (UDWtype) (UWtype) vv.s.low};
		370
		371	ww.s.high -= vv.s.low;
		372	if (__builtin_expect (ww.s.high < 0, 1))
		373	return ww.ll;
		374	}
		375	}
		376	else
		377	{
		378	if (uu.s.high == (Wtype) -1 && vv.s.high == (Wtype) - 1)
		379	{
		380	DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
		381	* (UDWtype) (UWtype) vv.s.low};
		382
		383	ww.s.high -= uu.s.low;
		384	ww.s.high -= vv.s.low;
		385	if (__builtin_expect (ww.s.high >= 0, 1))
		386	return ww.ll;
		387	}
		388	}
		389	}
		390	}
		391	}
		392
		393	/* Overflow. */
		394	abort ();
		395	}
		396	#endif
		397
		398
		399	/* Unless shift functions are defined with full ANSI prototypes,
		400	parameter b will be promoted to int if shift_count_type is smaller than an int. */
		401	#ifdef L_lshrdi3
		402	DWtype
		403	__lshrdi3 (DWtype u, shift_count_type b)
		404	{
		405	if (b == 0)
		406	return u;
		407
		408	const DWunion uu = {.ll = u};
		409	const shift_count_type bm = W_TYPE_SIZE - b;
		410	DWunion w;
		411
		412	if (bm <= 0)
		413	{
		414	w.s.high = 0;
		415	w.s.low = (UWtype) uu.s.high >> -bm;
		416	}
		417	else
		418	{
		419	const UWtype carries = (UWtype) uu.s.high << bm;
		420
		421	w.s.high = (UWtype) uu.s.high >> b;
		422	w.s.low = ((UWtype) uu.s.low >> b) \| carries;
		423	}
		424
		425	return w.ll;
		426	}
		427	#endif
		428
		429	#ifdef L_ashldi3
		430	DWtype
		431	__ashldi3 (DWtype u, shift_count_type b)
		432	{
		433	if (b == 0)
		434	return u;
		435
		436	const DWunion uu = {.ll = u};
		437	const shift_count_type bm = W_TYPE_SIZE - b;
		438	DWunion w;
		439
		440	if (bm <= 0)
		441	{
		442	w.s.low = 0;
		443	w.s.high = (UWtype) uu.s.low << -bm;
		444	}
		445	else
		446	{
		447	const UWtype carries = (UWtype) uu.s.low >> bm;
		448
		449	w.s.low = (UWtype) uu.s.low << b;
		450	w.s.high = ((UWtype) uu.s.high << b) \| carries;
		451	}
		452
		453	return w.ll;
		454	}
		455	#endif
		456
		457	#ifdef L_ashrdi3
		458	DWtype
		459	__ashrdi3 (DWtype u, shift_count_type b)
		460	{
		461	if (b == 0)
		462	return u;
		463
		464	const DWunion uu = {.ll = u};
		465	const shift_count_type bm = W_TYPE_SIZE - b;
		466	DWunion w;
		467
		468	if (bm <= 0)
		469	{
		470	/* w.s.high = 1..1 or 0..0 */
		471	w.s.high = uu.s.high >> (W_TYPE_SIZE - 1);
		472	w.s.low = uu.s.high >> -bm;
		473	}
		474	else
		475	{
		476	const UWtype carries = (UWtype) uu.s.high << bm;
		477
		478	w.s.high = uu.s.high >> b;
		479	w.s.low = ((UWtype) uu.s.low >> b) \| carries;
		480	}
		481
		482	return w.ll;
		483	}
		484	#endif
		485
		486	#ifdef L_bswapsi2
		487	SItype
		488	__bswapsi2 (SItype u)
		489	{
		490	return ((((u) & 0xff000000) >> 24)
		491	\| (((u) & 0x00ff0000) >> 8)
		492	\| (((u) & 0x0000ff00) << 8)
		493	\| (((u) & 0x000000ff) << 24));
		494	}
		495	#endif
		496	#ifdef L_bswapdi2
		497	DItype
		498	__bswapdi2 (DItype u)
		499	{
		500	return ((((u) & 0xff00000000000000ull) >> 56)
		501	\| (((u) & 0x00ff000000000000ull) >> 40)
		502	\| (((u) & 0x0000ff0000000000ull) >> 24)
		503	\| (((u) & 0x000000ff00000000ull) >> 8)
		504	\| (((u) & 0x00000000ff000000ull) << 8)
		505	\| (((u) & 0x0000000000ff0000ull) << 24)
		506	\| (((u) & 0x000000000000ff00ull) << 40)
		507	\| (((u) & 0x00000000000000ffull) << 56));
		508	}
		509	#endif
		510	#ifdef L_ffssi2
		511	#undef int
		512	int
		513	__ffsSI2 (UWtype u)
		514	{
		515	UWtype count;
		516
		517	if (u == 0)
		518	return 0;
		519
		520	count_trailing_zeros (count, u);
		521	return count + 1;
		522	}
		523	#endif
		524
		525	#ifdef L_ffsdi2
		526	#undef int
		527	int
		528	__ffsDI2 (DWtype u)
		529	{
		530	const DWunion uu = {.ll = u};
		531	UWtype word, count, add;
		532
		533	if (uu.s.low != 0)
		534	word = uu.s.low, add = 0;
		535	else if (uu.s.high != 0)
		536	word = uu.s.high, add = W_TYPE_SIZE;
		537	else
		538	return 0;
		539
		540	count_trailing_zeros (count, word);
		541	return count + add + 1;
		542	}
		543	#endif
		544
		545	#ifdef L_muldi3
		546	DWtype
		547	__muldi3 (DWtype u, DWtype v)
		548	{
		549	const DWunion uu = {.ll = u};
		550	const DWunion vv = {.ll = v};
		551	DWunion w = {.ll = __umulsidi3 (uu.s.low, vv.s.low)};
		552
		553	w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
		554	+ (UWtype) uu.s.high * (UWtype) vv.s.low);
		555
		556	return w.ll;
		557	}
		558	#endif
		559
		560	#if (defined (L_udivdi3) \|\| defined (L_divdi3) \|\| \
		561	defined (L_umoddi3) \|\| defined (L_moddi3))
		562	#if defined (sdiv_qrnnd)
		563	#define L_udiv_w_sdiv
		564	#endif
		565	#endif
		566
		567	#ifdef L_udiv_w_sdiv
		568	#if defined (sdiv_qrnnd)
		569	#if (defined (L_udivdi3) \|\| defined (L_divdi3) \|\| \
		570	defined (L_umoddi3) \|\| defined (L_moddi3))
		571	static inline __attribute__ ((__always_inline__))
		572	#endif
		573	UWtype
		574	__udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
		575	{
		576	UWtype q, r;
		577	UWtype c0, c1, b1;
		578
		579	if ((Wtype) d >= 0)
		580	{
		581	if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
		582	{
		583	/* Dividend, divisor, and quotient are nonnegative. */
		584	sdiv_qrnnd (q, r, a1, a0, d);
		585	}
		586	else
		587	{
		588	/* Compute c12^32 + c0 = a12^32 + a0 - 2^31d. /
		589	sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
		590	/* Divide (c12^32 + c0) by d. /
		591	sdiv_qrnnd (q, r, c1, c0, d);
		592	/* Add 2^31 to quotient. */
		593	q += (UWtype) 1 << (W_TYPE_SIZE - 1);
		594	}
		595	}
		596	else
		597	{
		598	b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
		599	c1 = a1 >> 1; /* A/2 */
		600	c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
		601
		602	if (a1 < b1) /* A < 2^32b1, so A/2 < 2^31b1 */
		603	{
		604	sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
		605
		606	r = 2r + (a0 & 1); / Remainder from A/(2b1) /
		607	if ((d & 1) != 0)
		608	{
		609	if (r >= q)
		610	r = r - q;
		611	else if (q - r <= d)
		612	{
		613	r = r - q + d;
		614	q--;
		615	}
		616	else
		617	{
		618	r = r - q + 2*d;
		619	q -= 2;
		620	}
		621	}
		622	}
		623	else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
		624	{
		625	c1 = (b1 - 1) - c1;
		626	c0 = ~c0; /* logical NOT */
		627
		628	sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
		629
		630	q = ~q; /* (A/2)/b1 */
		631	r = (b1 - 1) - r;
		632
		633	r = 2r + (a0 & 1); / A/(2b1) /
		634
		635	if ((d & 1) != 0)
		636	{
		637	if (r >= q)
		638	r = r - q;
		639	else if (q - r <= d)
		640	{
		641	r = r - q + d;
		642	q--;
		643	}
		644	else
		645	{
		646	r = r - q + 2*d;
		647	q -= 2;
		648	}
		649	}
		650	}
		651	else /* Implies c1 = b1 */
		652	{ /* Hence a1 = d - 1 = 2b1 - 1 /
		653	if (a0 >= -d)
		654	{
		655	q = -1;
		656	r = a0 + d;
		657	}
		658	else
		659	{
		660	q = -2;
		661	r = a0 + 2*d;
		662	}
		663	}
		664	}
		665
		666	*rp = r;
		667	return q;
		668	}
		669	#else
		670	/* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
		671	UWtype
		672	__udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
		673	UWtype a1 __attribute__ ((__unused__)),
		674	UWtype a0 __attribute__ ((__unused__)),
		675	UWtype d __attribute__ ((__unused__)))
		676	{
		677	return 0;
		678	}
		679	#endif
		680	#endif
		681
		682	#if (defined (L_udivdi3) \|\| defined (L_divdi3) \|\| \
		683	defined (L_umoddi3) \|\| defined (L_moddi3))
		684	#define L_udivmoddi4
		685	#endif
		686
		687	#ifdef L_clz
		688	const UQItype __clz_tab[256] =
		689	{
		690	0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
		691	6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
		692	7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
		693	7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
		694	8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		695	8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		696	8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		697	8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
		698	};
		699	#endif
		700
		701	#ifdef L_clzsi2
		702	#undef int
		703	int
		704	__clzSI2 (UWtype x)
		705	{
		706	Wtype ret;
		707
		708	count_leading_zeros (ret, x);
		709
		710	return ret;
		711	}
		712	#endif
		713
		714	#ifdef L_clzdi2
		715	#undef int
		716	int
		717	__clzDI2 (UDWtype x)
		718	{
		719	const DWunion uu = {.ll = x};
		720	UWtype word;
		721	Wtype ret, add;
		722
		723	if (uu.s.high)
		724	word = uu.s.high, add = 0;
		725	else
		726	word = uu.s.low, add = W_TYPE_SIZE;
		727
		728	count_leading_zeros (ret, word);
		729	return ret + add;
		730	}
		731	#endif
		732
		733	#ifdef L_ctzsi2
		734	#undef int
		735	int
		736	__ctzSI2 (UWtype x)
		737	{
		738	Wtype ret;
		739
		740	count_trailing_zeros (ret, x);
		741
		742	return ret;
		743	}
		744	#endif
		745
		746	#ifdef L_ctzdi2
		747	#undef int
		748	int
		749	__ctzDI2 (UDWtype x)
		750	{
		751	const DWunion uu = {.ll = x};
		752	UWtype word;
		753	Wtype ret, add;
		754
		755	if (uu.s.low)
		756	word = uu.s.low, add = 0;
		757	else
		758	word = uu.s.high, add = W_TYPE_SIZE;
		759
		760	count_trailing_zeros (ret, word);
		761	return ret + add;
		762	}
		763	#endif
		764
		765	#ifdef L_clrsbsi2
		766	#undef int
		767	int
		768	__clrsbSI2 (Wtype x)
		769	{
		770	Wtype ret;
		771
		772	if (x < 0)
		773	x = ~x;
		774	if (x == 0)
		775	return W_TYPE_SIZE - 1;
		776	count_leading_zeros (ret, x);
		777	return ret - 1;
		778	}
		779	#endif
		780
		781	#ifdef L_clrsbdi2
		782	#undef int
		783	int
		784	__clrsbDI2 (DWtype x)
		785	{
		786	const DWunion uu = {.ll = x};
		787	UWtype word;
		788	Wtype ret, add;
		789
		790	if (uu.s.high == 0)
		791	word = uu.s.low, add = W_TYPE_SIZE;
		792	else if (uu.s.high == -1)
		793	word = ~uu.s.low, add = W_TYPE_SIZE;
		794	else if (uu.s.high >= 0)
		795	word = uu.s.high, add = 0;
		796	else
		797	word = ~uu.s.high, add = 0;
		798
		799	if (word == 0)
		800	ret = W_TYPE_SIZE;
		801	else
		802	count_leading_zeros (ret, word);
		803
		804	return ret + add - 1;
		805	}
		806	#endif
		807
		808	#ifdef L_popcount_tab
		809	const UQItype __popcount_tab[256] =
		810	{
		811	0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
		812	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
		813	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
		814	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
		815	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
		816	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
		817	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
		818	3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
		819	};
		820	#endif
		821
		822	#if defined(L_popcountsi2) \|\| defined(L_popcountdi2)
		823	#define POPCOUNTCST2(x) (((UWtype) x << BITS_PER_UNIT) \| x)
		824	#define POPCOUNTCST4(x) (((UWtype) x << (2 * BITS_PER_UNIT)) \| x)
		825	#define POPCOUNTCST8(x) (((UWtype) x << (4 * BITS_PER_UNIT)) \| x)
		826	#if W_TYPE_SIZE == BITS_PER_UNIT
		827	#define POPCOUNTCST(x) x
		828	#elif W_TYPE_SIZE == 2 * BITS_PER_UNIT
		829	#define POPCOUNTCST(x) POPCOUNTCST2 (x)
		830	#elif W_TYPE_SIZE == 4 * BITS_PER_UNIT
		831	#define POPCOUNTCST(x) POPCOUNTCST4 (POPCOUNTCST2 (x))
		832	#elif W_TYPE_SIZE == 8 * BITS_PER_UNIT
		833	#define POPCOUNTCST(x) POPCOUNTCST8 (POPCOUNTCST4 (POPCOUNTCST2 (x)))
		834	#endif
		835	#endif
		836
		837	#ifdef L_popcountsi2
		838	#undef int
		839	int
		840	__popcountSI2 (UWtype x)
		841	{
		842	/* Force table lookup on targets like AVR and RL78 which only
		843	pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
		844	have 1, and other small word targets. */
		845	#if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && BITS_PER_UNIT == 8
		846	x = x - ((x >> 1) & POPCOUNTCST (0x55));
		847	x = (x & POPCOUNTCST (0x33)) + ((x >> 2) & POPCOUNTCST (0x33));
		848	x = (x + (x >> 4)) & POPCOUNTCST (0x0F);
		849	return (x * POPCOUNTCST (0x01)) >> (W_TYPE_SIZE - BITS_PER_UNIT);
		850	#else
		851	int i, ret = 0;
		852
		853	for (i = 0; i < W_TYPE_SIZE; i += 8)
		854	ret += __popcount_tab[(x >> i) & 0xff];
		855
		856	return ret;
		857	#endif
		858	}
		859	#endif
		860
		861	#ifdef L_popcountdi2
		862	#undef int
		863	int
		864	__popcountDI2 (UDWtype x)
		865	{
		866	/* Force table lookup on targets like AVR and RL78 which only
		867	pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
		868	have 1, and other small word targets. */
		869	#if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && BITS_PER_UNIT == 8
		870	const DWunion uu = {.ll = x};
		871	UWtype x1 = uu.s.low, x2 = uu.s.high;
		872	x1 = x1 - ((x1 >> 1) & POPCOUNTCST (0x55));
		873	x2 = x2 - ((x2 >> 1) & POPCOUNTCST (0x55));
		874	x1 = (x1 & POPCOUNTCST (0x33)) + ((x1 >> 2) & POPCOUNTCST (0x33));
		875	x2 = (x2 & POPCOUNTCST (0x33)) + ((x2 >> 2) & POPCOUNTCST (0x33));
		876	x1 = (x1 + (x1 >> 4)) & POPCOUNTCST (0x0F);
		877	x2 = (x2 + (x2 >> 4)) & POPCOUNTCST (0x0F);
		878	x1 += x2;
		879	return (x1 * POPCOUNTCST (0x01)) >> (W_TYPE_SIZE - BITS_PER_UNIT);
		880	#else
		881	int i, ret = 0;
		882
		883	for (i = 0; i < 2*W_TYPE_SIZE; i += 8)
		884	ret += __popcount_tab[(x >> i) & 0xff];
		885
		886	return ret;
		887	#endif
		888	}
		889	#endif
		890
		891	#ifdef L_paritysi2
		892	#undef int
		893	int
		894	__paritySI2 (UWtype x)
		895	{
		896	#if W_TYPE_SIZE > 64
		897	# error "fill out the table"
		898	#endif
		899	#if W_TYPE_SIZE > 32
		900	x ^= x >> 32;
		901	#endif
		902	#if W_TYPE_SIZE > 16
		903	x ^= x >> 16;
		904	#endif
		905	x ^= x >> 8;
		906	x ^= x >> 4;
		907	x &= 0xf;
		908	return (0x6996 >> x) & 1;
		909	}
		910	#endif
		911
		912	#ifdef L_paritydi2
		913	#undef int
		914	int
		915	__parityDI2 (UDWtype x)
		916	{
		917	const DWunion uu = {.ll = x};
		918	UWtype nx = uu.s.low ^ uu.s.high;
		919
		920	#if W_TYPE_SIZE > 64
		921	# error "fill out the table"
		922	#endif
		923	#if W_TYPE_SIZE > 32
		924	nx ^= nx >> 32;
		925	#endif
		926	#if W_TYPE_SIZE > 16
		927	nx ^= nx >> 16;
		928	#endif
		929	nx ^= nx >> 8;
		930	nx ^= nx >> 4;
		931	nx &= 0xf;
		932	return (0x6996 >> nx) & 1;
		933	}
		934	#endif
		935
		936	#ifdef L_udivmoddi4
		937	#ifdef TARGET_HAS_NO_HW_DIVIDE
		938
		939	#if (defined (L_udivdi3) \|\| defined (L_divdi3) \|\| \
		940	defined (L_umoddi3) \|\| defined (L_moddi3))
		941	static inline __attribute__ ((__always_inline__))
		942	#endif
		943	UDWtype
		944	__udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
		945	{
		946	UDWtype q = 0, r = n, y = d;
		947	UWtype lz1, lz2, i, k;
		948
		949	/* Implements align divisor shift dividend method. This algorithm
		950	aligns the divisor under the dividend and then perform number of
		951	test-subtract iterations which shift the dividend left. Number of
		952	iterations is k + 1 where k is the number of bit positions the
		953	divisor must be shifted left to align it under the dividend.
		954	quotient bits can be saved in the rightmost positions of the dividend
		955	as it shifts left on each test-subtract iteration. */
		956
		957	if (y <= r)
		958	{
		959	lz1 = __builtin_clzll (d);
		960	lz2 = __builtin_clzll (n);
		961
		962	k = lz1 - lz2;
		963	y = (y << k);
		964
		965	/* Dividend can exceed 2 ^ (width − 1) − 1 but still be less than the
		966	aligned divisor. Normal iteration can drops the high order bit
		967	of the dividend. Therefore, first test-subtract iteration is a
		968	special case, saving its quotient bit in a separate location and
		969	not shifting the dividend. */
		970	if (r >= y)
		971	{
		972	r = r - y;
		973	q = (1ULL << k);
		974	}
		975
		976	if (k > 0)
		977	{
		978	y = y >> 1;
		979
		980	/* k additional iterations where k regular test subtract shift
		981	dividend iterations are done. */
		982	i = k;
		983	do
		984	{
		985	if (r >= y)
		986	r = ((r - y) << 1) + 1;
		987	else
		988	r = (r << 1);
		989	i = i - 1;
		990	} while (i != 0);
		991
		992	/* First quotient bit is combined with the quotient bits resulting
		993	from the k regular iterations. */
		994	q = q + r;
		995	r = r >> k;
		996	q = q - (r << k);
		997	}
		998	}
		999
		1000	if (rp)
		1001	*rp = r;
		1002	return q;
		1003	}
		1004	#else
		1005
		1006	#if (defined (L_udivdi3) \|\| defined (L_divdi3) \|\| \
		1007	defined (L_umoddi3) \|\| defined (L_moddi3))
		1008	static inline __attribute__ ((__always_inline__))
		1009	#endif
		1010	UDWtype
		1011	__udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
		1012	{
		1013	const DWunion nn = {.ll = n};
		1014	const DWunion dd = {.ll = d};
		1015	DWunion rr;
		1016	UWtype d0, d1, n0, n1, n2;
		1017	UWtype q0, q1;
		1018	UWtype b, bm;
		1019
		1020	d0 = dd.s.low;
		1021	d1 = dd.s.high;
		1022	n0 = nn.s.low;
		1023	n1 = nn.s.high;
		1024
		1025	#if !UDIV_NEEDS_NORMALIZATION
		1026	if (d1 == 0)
		1027	{
		1028	if (d0 > n1)
		1029	{
		1030	/* 0q = nn / 0D */
		1031
		1032	udiv_qrnnd (q0, n0, n1, n0, d0);
		1033	q1 = 0;
		1034
		1035	/* Remainder in n0. */
		1036	}
		1037	else
		1038	{
		1039	/* qq = NN / 0d */
		1040
		1041	if (d0 == 0)
		1042	d0 = 1 / d0; /* Divide intentionally by zero. */
		1043
		1044	udiv_qrnnd (q1, n1, 0, n1, d0);
		1045	udiv_qrnnd (q0, n0, n1, n0, d0);
		1046
		1047	/* Remainder in n0. */
		1048	}
		1049
		1050	if (rp != 0)
		1051	{
		1052	rr.s.low = n0;
		1053	rr.s.high = 0;
		1054	*rp = rr.ll;
		1055	}
		1056	}
		1057
		1058	#else /* UDIV_NEEDS_NORMALIZATION */
		1059
		1060	if (d1 == 0)
		1061	{
		1062	if (d0 > n1)
		1063	{
		1064	/* 0q = nn / 0D */
		1065
		1066	count_leading_zeros (bm, d0);
		1067
		1068	if (bm != 0)
		1069	{
		1070	/* Normalize, i.e. make the most significant bit of the
		1071	denominator set. */
		1072
		1073	d0 = d0 << bm;
		1074	n1 = (n1 << bm) \| (n0 >> (W_TYPE_SIZE - bm));
		1075	n0 = n0 << bm;
		1076	}
		1077
		1078	udiv_qrnnd (q0, n0, n1, n0, d0);
		1079	q1 = 0;
		1080
		1081	/* Remainder in n0 >> bm. */
		1082	}
		1083	else
		1084	{
		1085	/* qq = NN / 0d */
		1086
		1087	if (d0 == 0)
		1088	d0 = 1 / d0; /* Divide intentionally by zero. */
		1089
		1090	count_leading_zeros (bm, d0);
		1091
		1092	if (bm == 0)
		1093	{
		1094	/* From (n1 >= d0) /\ (the most significant bit of d0 is set),
		1095	conclude (the most significant bit of n1 is set) /\ (the
		1096	leading quotient digit q1 = 1).
		1097
		1098	This special case is necessary, not an optimization.
		1099	(Shifts counts of W_TYPE_SIZE are undefined.) */
		1100
		1101	n1 -= d0;
		1102	q1 = 1;
		1103	}
		1104	else
		1105	{
		1106	/* Normalize. */
		1107
		1108	b = W_TYPE_SIZE - bm;
		1109
		1110	d0 = d0 << bm;
		1111	n2 = n1 >> b;
		1112	n1 = (n1 << bm) \| (n0 >> b);
		1113	n0 = n0 << bm;
		1114
		1115	udiv_qrnnd (q1, n1, n2, n1, d0);
		1116	}
		1117
		1118	/* n1 != d0... */
		1119
		1120	udiv_qrnnd (q0, n0, n1, n0, d0);
		1121
		1122	/* Remainder in n0 >> bm. */
		1123	}
		1124
		1125	if (rp != 0)
		1126	{
		1127	rr.s.low = n0 >> bm;
		1128	rr.s.high = 0;
		1129	*rp = rr.ll;
		1130	}
		1131	}
		1132	#endif /* UDIV_NEEDS_NORMALIZATION */
		1133
		1134	else
		1135	{
		1136	if (d1 > n1)
		1137	{
		1138	/* 00 = nn / DD */
		1139
		1140	q0 = 0;
		1141	q1 = 0;
		1142
		1143	/* Remainder in n1n0. */
		1144	if (rp != 0)
		1145	{
		1146	rr.s.low = n0;
		1147	rr.s.high = n1;
		1148	*rp = rr.ll;
		1149	}
		1150	}
		1151	else
		1152	{
		1153	/* 0q = NN / dd */
		1154
		1155	count_leading_zeros (bm, d1);
		1156	if (bm == 0)
		1157	{
		1158	/* From (n1 >= d1) /\ (the most significant bit of d1 is set),
		1159	conclude (the most significant bit of n1 is set) /\ (the
		1160	quotient digit q0 = 0 or 1).
		1161
		1162	This special case is necessary, not an optimization. */
		1163
		1164	/* The condition on the next line takes advantage of that
		1165	n1 >= d1 (true due to program flow). */
		1166	if (n1 > d1 \|\| n0 >= d0)
		1167	{
		1168	q0 = 1;
		1169	sub_ddmmss (n1, n0, n1, n0, d1, d0);
		1170	}
		1171	else
		1172	q0 = 0;
		1173
		1174	q1 = 0;
		1175
		1176	if (rp != 0)
		1177	{
		1178	rr.s.low = n0;
		1179	rr.s.high = n1;
		1180	*rp = rr.ll;
		1181	}
		1182	}
		1183	else
		1184	{
		1185	UWtype m1, m0;
		1186	/* Normalize. */
		1187
		1188	b = W_TYPE_SIZE - bm;
		1189
		1190	d1 = (d1 << bm) \| (d0 >> b);
		1191	d0 = d0 << bm;
		1192	n2 = n1 >> b;
		1193	n1 = (n1 << bm) \| (n0 >> b);
		1194	n0 = n0 << bm;
		1195
		1196	udiv_qrnnd (q0, n1, n2, n1, d1);
		1197	umul_ppmm (m1, m0, q0, d0);
		1198
		1199	if (m1 > n1 \|\| (m1 == n1 && m0 > n0))
		1200	{
		1201	q0--;
		1202	sub_ddmmss (m1, m0, m1, m0, d1, d0);
		1203	}
		1204
		1205	q1 = 0;
		1206
		1207	/* Remainder in (n1n0 - m1m0) >> bm. */
		1208	if (rp != 0)
		1209	{
		1210	sub_ddmmss (n1, n0, n1, n0, m1, m0);
		1211	rr.s.low = (n1 << b) \| (n0 >> bm);
		1212	rr.s.high = n1 >> bm;
		1213	*rp = rr.ll;
		1214	}
		1215	}
		1216	}
		1217	}
		1218
		1219	const DWunion ww = {{.low = q0, .high = q1}};
		1220	return ww.ll;
		1221	}
		1222	#endif
		1223	#endif
		1224
		1225	#ifdef L_divdi3
		1226	DWtype
		1227	__divdi3 (DWtype u, DWtype v)
		1228	{
		1229	Wtype c = 0;
		1230	DWunion uu = {.ll = u};
		1231	DWunion vv = {.ll = v};
		1232	DWtype w;
		1233
		1234	if (uu.s.high < 0)
		1235	c = ~c,
		1236	uu.ll = -uu.ll;
		1237	if (vv.s.high < 0)
		1238	c = ~c,
		1239	vv.ll = -vv.ll;
		1240
		1241	w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
		1242	if (c)
		1243	w = -w;
		1244
		1245	return w;
		1246	}
		1247	#endif
		1248
		1249	#ifdef L_moddi3
		1250	DWtype
		1251	__moddi3 (DWtype u, DWtype v)
		1252	{
		1253	Wtype c = 0;
		1254	DWunion uu = {.ll = u};
		1255	DWunion vv = {.ll = v};
		1256	DWtype w;
		1257
		1258	if (uu.s.high < 0)
		1259	c = ~c,
		1260	uu.ll = -uu.ll;
		1261	if (vv.s.high < 0)
		1262	vv.ll = -vv.ll;
		1263
		1264	(void) __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&w);
		1265	if (c)
		1266	w = -w;
		1267
		1268	return w;
		1269	}
		1270	#endif
		1271
		1272	#ifdef L_umoddi3
		1273	UDWtype
		1274	__umoddi3 (UDWtype u, UDWtype v)
		1275	{
		1276	UDWtype w;
		1277
		1278	(void) __udivmoddi4 (u, v, &w);
		1279
		1280	return w;
		1281	}
		1282	#endif
		1283
		1284	#ifdef L_udivdi3
		1285	UDWtype
		1286	__udivdi3 (UDWtype n, UDWtype d)
		1287	{
		1288	return __udivmoddi4 (n, d, (UDWtype *) 0);
		1289	}
		1290	#endif
		1291
		1292	#ifdef L_cmpdi2
		1293	cmp_return_type
		1294	__cmpdi2 (DWtype a, DWtype b)
		1295	{
		1296	const DWunion au = {.ll = a};
		1297	const DWunion bu = {.ll = b};
		1298
		1299	if (au.s.high < bu.s.high)
		1300	return 0;
		1301	else if (au.s.high > bu.s.high)
		1302	return 2;
		1303	if ((UWtype) au.s.low < (UWtype) bu.s.low)
		1304	return 0;
		1305	else if ((UWtype) au.s.low > (UWtype) bu.s.low)
		1306	return 2;
		1307	return 1;
		1308	}
		1309	#endif
		1310
		1311	#ifdef L_ucmpdi2
		1312	cmp_return_type
		1313	__ucmpdi2 (DWtype a, DWtype b)
		1314	{
		1315	const DWunion au = {.ll = a};
		1316	const DWunion bu = {.ll = b};
		1317
		1318	if ((UWtype) au.s.high < (UWtype) bu.s.high)
		1319	return 0;
		1320	else if ((UWtype) au.s.high > (UWtype) bu.s.high)
		1321	return 2;
		1322	if ((UWtype) au.s.low < (UWtype) bu.s.low)
		1323	return 0;
		1324	else if ((UWtype) au.s.low > (UWtype) bu.s.low)
		1325	return 2;
		1326	return 1;
		1327	}
		1328	#endif
		1329
		1330	#if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
		1331	UDWtype
		1332	__fixunstfDI (TFtype a)
		1333	{
		1334	if (a < 0)
		1335	return 0;
		1336
		1337	/* Compute high word of result, as a flonum. */
		1338	const TFtype b = (a / Wtype_MAXp1_F);
		1339	/* Convert that to fixed (but not to DWtype!),
		1340	and shift it into the high word. */
		1341	UDWtype v = (UWtype) b;
		1342	v <<= W_TYPE_SIZE;
		1343	/* Remove high part from the TFtype, leaving the low part as flonum. */
		1344	a -= (TFtype)v;
		1345	/* Convert that to fixed (but not to DWtype!) and add it in.
		1346	Sometimes A comes out negative. This is significant, since
		1347	A has more bits than a long int does. */
		1348	if (a < 0)
		1349	v -= (UWtype) (- a);
		1350	else
		1351	v += (UWtype) a;
		1352	return v;
		1353	}
		1354	#endif
		1355
		1356	#if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
		1357	DWtype
		1358	__fixtfdi (TFtype a)
		1359	{
		1360	if (a < 0)
		1361	return - __fixunstfDI (-a);
		1362	return __fixunstfDI (a);
		1363	}
		1364	#endif
		1365
		1366	#if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
		1367	UDWtype
		1368	__fixunsxfDI (XFtype a)
		1369	{
		1370	if (a < 0)
		1371	return 0;
		1372
		1373	/* Compute high word of result, as a flonum. */
		1374	const XFtype b = (a / Wtype_MAXp1_F);
		1375	/* Convert that to fixed (but not to DWtype!),
		1376	and shift it into the high word. */
		1377	UDWtype v = (UWtype) b;
		1378	v <<= W_TYPE_SIZE;
		1379	/* Remove high part from the XFtype, leaving the low part as flonum. */
		1380	a -= (XFtype)v;
		1381	/* Convert that to fixed (but not to DWtype!) and add it in.
		1382	Sometimes A comes out negative. This is significant, since
		1383	A has more bits than a long int does. */
		1384	if (a < 0)
		1385	v -= (UWtype) (- a);
		1386	else
		1387	v += (UWtype) a;
		1388	return v;
		1389	}
		1390	#endif
		1391
		1392	#if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
		1393	DWtype
		1394	__fixxfdi (XFtype a)
		1395	{
		1396	if (a < 0)
		1397	return - __fixunsxfDI (-a);
		1398	return __fixunsxfDI (a);
		1399	}
		1400	#endif
		1401
		1402	#if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
		1403	UDWtype
		1404	__fixunsdfDI (DFtype a)
		1405	{
		1406	/* Get high part of result. The division here will just moves the radix
		1407	point and will not cause any rounding. Then the conversion to integral
		1408	type chops result as desired. */
		1409	const UWtype hi = a / Wtype_MAXp1_F;
		1410
		1411	/* Get low part of result. Convert `hi' to floating type and scale it back,
		1412	then subtract this from the number being converted. This leaves the low
		1413	part. Convert that to integral type. */
		1414	const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F;
		1415
		1416	/* Assemble result from the two parts. */
		1417	return ((UDWtype) hi << W_TYPE_SIZE) \| lo;
		1418	}
		1419	#endif
		1420
		1421	#if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
		1422	DWtype
		1423	__fixdfdi (DFtype a)
		1424	{
		1425	if (a < 0)
		1426	return - __fixunsdfDI (-a);
		1427	return __fixunsdfDI (a);
		1428	}
		1429	#endif
		1430
		1431	#if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
		1432	UDWtype
		1433	__fixunssfDI (SFtype a)
		1434	{
		1435	#if LIBGCC2_HAS_DF_MODE
		1436	/* Convert the SFtype to a DFtype, because that is surely not going
		1437	to lose any bits. Some day someone else can write a faster version
		1438	that avoids converting to DFtype, and verify it really works right. */
		1439	const DFtype dfa = a;
		1440
		1441	/* Get high part of result. The division here will just moves the radix
		1442	point and will not cause any rounding. Then the conversion to integral
		1443	type chops result as desired. */
		1444	const UWtype hi = dfa / Wtype_MAXp1_F;
		1445
		1446	/* Get low part of result. Convert `hi' to floating type and scale it back,
		1447	then subtract this from the number being converted. This leaves the low
		1448	part. Convert that to integral type. */
		1449	const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F;
		1450
		1451	/* Assemble result from the two parts. */
		1452	return ((UDWtype) hi << W_TYPE_SIZE) \| lo;
		1453	#elif FLT_MANT_DIG < W_TYPE_SIZE
		1454	if (a < 1)
		1455	return 0;
		1456	if (a < Wtype_MAXp1_F)
		1457	return (UWtype)a;
		1458	if (a < Wtype_MAXp1_F * Wtype_MAXp1_F)
		1459	{
		1460	/* Since we know that there are fewer significant bits in the SFmode
		1461	quantity than in a word, we know that we can convert out all the
		1462	significant bits in one step, and thus avoid losing bits. */
		1463
		1464	/* ??? This following loop essentially performs frexpf. If we could
		1465	use the real libm function, or poke at the actual bits of the fp
		1466	format, it would be significantly faster. */
		1467
		1468	UWtype shift = 0, counter;
		1469	SFtype msb;
		1470
		1471	a /= Wtype_MAXp1_F;
		1472	for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1)
		1473	{
		1474	SFtype counterf = (UWtype)1 << counter;
		1475	if (a >= counterf)
		1476	{
		1477	shift \|= counter;
		1478	a /= counterf;
		1479	}
		1480	}
		1481
		1482	/* Rescale into the range of one word, extract the bits of that
		1483	one word, and shift the result into position. */
		1484	a *= Wtype_MAXp1_F;
		1485	counter = a;
		1486	return (DWtype)counter << shift;
		1487	}
		1488	return -1;
		1489	#else
		1490	# error
		1491	#endif
		1492	}
		1493	#endif
		1494
		1495	#if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
		1496	DWtype
		1497	__fixsfdi (SFtype a)
		1498	{
		1499	if (a < 0)
		1500	return - __fixunssfDI (-a);
		1501	return __fixunssfDI (a);
		1502	}
		1503	#endif
		1504
		1505	#if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
		1506	XFtype
		1507	__floatdixf (DWtype u)
		1508	{
		1509	#if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
		1510	# error
		1511	#endif
		1512	XFtype d = (Wtype) (u >> W_TYPE_SIZE);
		1513	d *= Wtype_MAXp1_F;
		1514	d += (UWtype)u;
		1515	return d;
		1516	}
		1517	#endif
		1518
		1519	#if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
		1520	XFtype
		1521	__floatundixf (UDWtype u)
		1522	{
		1523	#if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
		1524	# error
		1525	#endif
		1526	XFtype d = (UWtype) (u >> W_TYPE_SIZE);
		1527	d *= Wtype_MAXp1_F;
		1528	d += (UWtype)u;
		1529	return d;
		1530	}
		1531	#endif
		1532
		1533	#if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
		1534	TFtype
		1535	__floatditf (DWtype u)
		1536	{
		1537	#if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
		1538	# error
		1539	#endif
		1540	TFtype d = (Wtype) (u >> W_TYPE_SIZE);
		1541	d *= Wtype_MAXp1_F;
		1542	d += (UWtype)u;
		1543	return d;
		1544	}
		1545	#endif
		1546
		1547	#if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
		1548	TFtype
		1549	__floatunditf (UDWtype u)
		1550	{
		1551	#if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
		1552	# error
		1553	#endif
		1554	TFtype d = (UWtype) (u >> W_TYPE_SIZE);
		1555	d *= Wtype_MAXp1_F;
		1556	d += (UWtype)u;
		1557	return d;
		1558	}
		1559	#endif
		1560
		1561	#if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \
		1562	\|\| (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
		1563	#define DI_SIZE (W_TYPE_SIZE * 2)
		1564	#define F_MODE_OK(SIZE) \
		1565	(SIZE < DI_SIZE \
		1566	&& SIZE > (DI_SIZE - SIZE + FSSIZE) \
		1567	&& !AVOID_FP_TYPE_CONVERSION(SIZE))
		1568	#if defined(L_floatdisf)
		1569	#define FUNC __floatdisf
		1570	#define FSTYPE SFtype
		1571	#define FSSIZE __LIBGCC_SF_MANT_DIG__
		1572	#else
		1573	#define FUNC __floatdidf
		1574	#define FSTYPE DFtype
		1575	#define FSSIZE __LIBGCC_DF_MANT_DIG__
		1576	#endif
		1577
		1578	FSTYPE
		1579	FUNC (DWtype u)
		1580	{
		1581	#if FSSIZE >= W_TYPE_SIZE
		1582	/* When the word size is small, we never get any rounding error. */
		1583	FSTYPE f = (Wtype) (u >> W_TYPE_SIZE);
		1584	f *= Wtype_MAXp1_F;
		1585	f += (UWtype)u;
		1586	return f;
		1587	#elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__)) \
		1588	\|\| (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__)) \
		1589	\|\| (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
		1590
		1591	#if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
		1592	# define FSIZE __LIBGCC_DF_MANT_DIG__
		1593	# define FTYPE DFtype
		1594	#elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
		1595	# define FSIZE __LIBGCC_XF_MANT_DIG__
		1596	# define FTYPE XFtype
		1597	#elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
		1598	# define FSIZE __LIBGCC_TF_MANT_DIG__
		1599	# define FTYPE TFtype
		1600	#else
		1601	# error
		1602	#endif
		1603
		1604	#define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
		1605
		1606	/* Protect against double-rounding error.
		1607	Represent any low-order bits, that might be truncated by a bit that
		1608	won't be lost. The bit can go in anywhere below the rounding position
		1609	of the FSTYPE. A fixed mask and bit position handles all usual
		1610	configurations. */
		1611	if (! (- ((DWtype) 1 << FSIZE) < u
		1612	&& u < ((DWtype) 1 << FSIZE)))
		1613	{
		1614	if ((UDWtype) u & (REP_BIT - 1))
		1615	{
		1616	u &= ~ (REP_BIT - 1);
		1617	u \|= REP_BIT;
		1618	}
		1619	}
		1620
		1621	/* Do the calculation in a wider type so that we don't lose any of
		1622	the precision of the high word while multiplying it. */
		1623	FTYPE f = (Wtype) (u >> W_TYPE_SIZE);
		1624	f *= Wtype_MAXp1_F;
		1625	f += (UWtype)u;
		1626	return (FSTYPE) f;
		1627	#else
		1628	#if FSSIZE >= W_TYPE_SIZE - 2
		1629	# error
		1630	#endif
		1631	/* Finally, the word size is larger than the number of bits in the
		1632	required FSTYPE, and we've got no suitable wider type. The only
		1633	way to avoid double rounding is to special case the
		1634	extraction. */
		1635
		1636	/* If there are no high bits set, fall back to one conversion. */
		1637	if ((Wtype)u == u)
		1638	return (FSTYPE)(Wtype)u;
		1639
		1640	/* Otherwise, find the power of two. */
		1641	Wtype hi = u >> W_TYPE_SIZE;
		1642	if (hi < 0)
		1643	hi = -(UWtype) hi;
		1644
		1645	UWtype count, shift;
		1646	count_leading_zeros (count, hi);
		1647
		1648	/* No leading bits means u == minimum. */
		1649	if (count == 0)
		1650	return -(Wtype_MAXp1_F * (Wtype_MAXp1_F / 2));
		1651
		1652	shift = 1 + W_TYPE_SIZE - count;
		1653
		1654	/* Shift down the most significant bits. */
		1655	hi = u >> shift;
		1656
		1657	/* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
		1658	if ((UWtype)u << (W_TYPE_SIZE - shift))
		1659	hi \|= 1;
		1660
		1661	/* Convert the one word of data, and rescale. */
		1662	FSTYPE f = hi, e;
		1663	if (shift == W_TYPE_SIZE)
		1664	e = Wtype_MAXp1_F;
		1665	/* The following two cases could be merged if we knew that the target
		1666	supported a native unsigned->float conversion. More often, we only
		1667	have a signed conversion, and have to add extra fixup code. */
		1668	else if (shift == W_TYPE_SIZE - 1)
		1669	e = Wtype_MAXp1_F / 2;
		1670	else
		1671	e = (Wtype)1 << shift;
		1672	return f * e;
		1673	#endif
		1674	}
		1675	#endif
		1676
		1677	#if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \
		1678	\|\| (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
		1679	#define DI_SIZE (W_TYPE_SIZE * 2)
		1680	#define F_MODE_OK(SIZE) \
		1681	(SIZE < DI_SIZE \
		1682	&& SIZE > (DI_SIZE - SIZE + FSSIZE) \
		1683	&& !AVOID_FP_TYPE_CONVERSION(SIZE))
		1684	#if defined(L_floatundisf)
		1685	#define FUNC __floatundisf
		1686	#define FSTYPE SFtype
		1687	#define FSSIZE __LIBGCC_SF_MANT_DIG__
		1688	#else
		1689	#define FUNC __floatundidf
		1690	#define FSTYPE DFtype
		1691	#define FSSIZE __LIBGCC_DF_MANT_DIG__
		1692	#endif
		1693
		1694	FSTYPE
		1695	FUNC (UDWtype u)
		1696	{
		1697	#if FSSIZE >= W_TYPE_SIZE
		1698	/* When the word size is small, we never get any rounding error. */
		1699	FSTYPE f = (UWtype) (u >> W_TYPE_SIZE);
		1700	f *= Wtype_MAXp1_F;
		1701	f += (UWtype)u;
		1702	return f;
		1703	#elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__)) \
		1704	\|\| (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__)) \
		1705	\|\| (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
		1706
		1707	#if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
		1708	# define FSIZE __LIBGCC_DF_MANT_DIG__
		1709	# define FTYPE DFtype
		1710	#elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
		1711	# define FSIZE __LIBGCC_XF_MANT_DIG__
		1712	# define FTYPE XFtype
		1713	#elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
		1714	# define FSIZE __LIBGCC_TF_MANT_DIG__
		1715	# define FTYPE TFtype
		1716	#else
		1717	# error
		1718	#endif
		1719
		1720	#define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
		1721
		1722	/* Protect against double-rounding error.
		1723	Represent any low-order bits, that might be truncated by a bit that
		1724	won't be lost. The bit can go in anywhere below the rounding position
		1725	of the FSTYPE. A fixed mask and bit position handles all usual
		1726	configurations. */
		1727	if (u >= ((UDWtype) 1 << FSIZE))
		1728	{
		1729	if ((UDWtype) u & (REP_BIT - 1))
		1730	{
		1731	u &= ~ (REP_BIT - 1);
		1732	u \|= REP_BIT;
		1733	}
		1734	}
		1735
		1736	/* Do the calculation in a wider type so that we don't lose any of
		1737	the precision of the high word while multiplying it. */
		1738	FTYPE f = (UWtype) (u >> W_TYPE_SIZE);
		1739	f *= Wtype_MAXp1_F;
		1740	f += (UWtype)u;
		1741	return (FSTYPE) f;
		1742	#else
		1743	#if FSSIZE == W_TYPE_SIZE - 1
		1744	# error
		1745	#endif
		1746	/* Finally, the word size is larger than the number of bits in the
		1747	required FSTYPE, and we've got no suitable wider type. The only
		1748	way to avoid double rounding is to special case the
		1749	extraction. */
		1750
		1751	/* If there are no high bits set, fall back to one conversion. */
		1752	if ((UWtype)u == u)
		1753	return (FSTYPE)(UWtype)u;
		1754
		1755	/* Otherwise, find the power of two. */
		1756	UWtype hi = u >> W_TYPE_SIZE;
		1757
		1758	UWtype count, shift;
		1759	count_leading_zeros (count, hi);
		1760
		1761	shift = W_TYPE_SIZE - count;
		1762
		1763	/* Shift down the most significant bits. */
		1764	hi = u >> shift;
		1765
		1766	/* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
		1767	if ((UWtype)u << (W_TYPE_SIZE - shift))
		1768	hi \|= 1;
		1769
		1770	/* Convert the one word of data, and rescale. */
		1771	FSTYPE f = hi, e;
		1772	if (shift == W_TYPE_SIZE)
		1773	e = Wtype_MAXp1_F;
		1774	/* The following two cases could be merged if we knew that the target
		1775	supported a native unsigned->float conversion. More often, we only
		1776	have a signed conversion, and have to add extra fixup code. */
		1777	else if (shift == W_TYPE_SIZE - 1)
		1778	e = Wtype_MAXp1_F / 2;
		1779	else
		1780	e = (Wtype)1 << shift;
		1781	return f * e;
		1782	#endif
		1783	}
		1784	#endif
		1785
		1786	#if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
		1787	UWtype
		1788	__fixunsxfSI (XFtype a)
		1789	{
		1790	if (a >= - (DFtype) Wtype_MIN)
		1791	return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
		1792	return (Wtype) a;
		1793	}
		1794	#endif
		1795
		1796	#if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
		1797	UWtype
		1798	__fixunsdfSI (DFtype a)
		1799	{
		1800	if (a >= - (DFtype) Wtype_MIN)
		1801	return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
		1802	return (Wtype) a;
		1803	}
		1804	#endif
		1805
		1806	#if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
		1807	UWtype
		1808	__fixunssfSI (SFtype a)
		1809	{
		1810	if (a >= - (SFtype) Wtype_MIN)
		1811	return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
		1812	return (Wtype) a;
		1813	}
		1814	#endif
		1815
		1816	/* Integer power helper used from __builtin_powi for non-constant
		1817	exponents. */
		1818
		1819	#if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
		1820	\|\| (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
		1821	\|\| (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
		1822	\|\| (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
		1823	# if defined(L_powisf2)
		1824	# define TYPE SFtype
		1825	# define NAME __powisf2
		1826	# elif defined(L_powidf2)
		1827	# define TYPE DFtype
		1828	# define NAME __powidf2
		1829	# elif defined(L_powixf2)
		1830	# define TYPE XFtype
		1831	# define NAME __powixf2
		1832	# elif defined(L_powitf2)
		1833	# define TYPE TFtype
		1834	# define NAME __powitf2
		1835	# endif
		1836
		1837	#undef int
		1838	#undef unsigned
		1839	TYPE
		1840	NAME (TYPE x, int m)
		1841	{
		1842	unsigned int n = m < 0 ? -m : m;
		1843	TYPE y = n % 2 ? x : 1;
		1844	while (n >>= 1)
		1845	{
		1846	x = x * x;
		1847	if (n % 2)
		1848	y = y * x;
		1849	}
		1850	return m < 0 ? 1/y : y;
		1851	}
		1852
		1853	#endif
		1854
		1855	#if ((defined(L_mulsc3) \|\| defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
		1856	\|\| ((defined(L_muldc3) \|\| defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
		1857	\|\| ((defined(L_mulxc3) \|\| defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
		1858	\|\| ((defined(L_multc3) \|\| defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
		1859
		1860	#undef float
		1861	#undef double
		1862	#undef long
		1863
		1864	#if defined(L_mulsc3) \|\| defined(L_divsc3)
		1865	# define MTYPE SFtype
		1866	# define CTYPE SCtype
		1867	# define MODE sc
		1868	# define CEXT __LIBGCC_SF_FUNC_EXT__
		1869	# define NOTRUNC __LIBGCC_SF_EXCESS_PRECISION__
		1870	#elif defined(L_muldc3) \|\| defined(L_divdc3)
		1871	# define MTYPE DFtype
		1872	# define CTYPE DCtype
		1873	# define MODE dc
		1874	# define CEXT __LIBGCC_DF_FUNC_EXT__
		1875	# define NOTRUNC __LIBGCC_DF_EXCESS_PRECISION__
		1876	#elif defined(L_mulxc3) \|\| defined(L_divxc3)
		1877	# define MTYPE XFtype
		1878	# define CTYPE XCtype
		1879	# define MODE xc
		1880	# define CEXT __LIBGCC_XF_FUNC_EXT__
		1881	# define NOTRUNC __LIBGCC_XF_EXCESS_PRECISION__
		1882	#elif defined(L_multc3) \|\| defined(L_divtc3)
		1883	# define MTYPE TFtype
		1884	# define CTYPE TCtype
		1885	# define MODE tc
		1886	# define CEXT __LIBGCC_TF_FUNC_EXT__
		1887	# define NOTRUNC __LIBGCC_TF_EXCESS_PRECISION__
		1888	#else
		1889	# error
		1890	#endif
		1891
		1892	#define CONCAT3(A,B,C) _CONCAT3(A,B,C)
		1893	#define _CONCAT3(A,B,C) A##B##C
		1894
		1895	#define CONCAT2(A,B) _CONCAT2(A,B)
		1896	#define _CONCAT2(A,B) A##B
		1897
		1898	/* All of these would be present in a full C99 implementation of
		1899	and . Our problem is that only a few systems have such full
		1900	implementations. Further, libgcc_s.so isn't currently linked against
		1901	libm.so, and even for systems that do provide full C99, the extra overhead
		1902	of all programs using libgcc having to link against libm. So avoid it. */
		1903
		1904	#define isnan(x) __builtin_expect ((x) != (x), 0)
		1905	#define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1)
		1906	#define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0)
		1907
		1908	#define INFINITY CONCAT2(__builtin_huge_val, CEXT) ()
		1909	#define I 1i
		1910
		1911	/* Helpers to make the following code slightly less gross. */
		1912	#define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
		1913	#define FABS CONCAT2(__builtin_fabs, CEXT)
		1914
		1915	/* Verify that MTYPE matches up with CEXT. */
		1916	extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1];
		1917
		1918	/* Ensure that we've lost any extra precision. */
		1919	#if NOTRUNC
		1920	# define TRUNC(x)
		1921	#else
		1922	# define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
		1923	#endif
		1924
		1925	#if defined(L_mulsc3) \|\| defined(L_muldc3) \
		1926	\|\| defined(L_mulxc3) \|\| defined(L_multc3)
		1927
		1928	CTYPE
		1929	CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
		1930	{
		1931	MTYPE ac, bd, ad, bc, x, y;
		1932	CTYPE res;
		1933
		1934	ac = a * c;
		1935	bd = b * d;
		1936	ad = a * d;
		1937	bc = b * c;
		1938
		1939	TRUNC (ac);
		1940	TRUNC (bd);
		1941	TRUNC (ad);
		1942	TRUNC (bc);
		1943
		1944	x = ac - bd;
		1945	y = ad + bc;
		1946
		1947	if (isnan (x) && isnan (y))
		1948	{
		1949	/* Recover infinities that computed as NaN + iNaN. */
		1950	_Bool recalc = 0;
		1951	if (isinf (a) \|\| isinf (b))
		1952	{
		1953	/* z is infinite. "Box" the infinity and change NaNs in
		1954	the other factor to 0. */
		1955	a = COPYSIGN (isinf (a) ? 1 : 0, a);
		1956	b = COPYSIGN (isinf (b) ? 1 : 0, b);
		1957	if (isnan (c)) c = COPYSIGN (0, c);
		1958	if (isnan (d)) d = COPYSIGN (0, d);
		1959	recalc = 1;
		1960	}
		1961	if (isinf (c) \|\| isinf (d))
		1962	{
		1963	/* w is infinite. "Box" the infinity and change NaNs in
		1964	the other factor to 0. */
		1965	c = COPYSIGN (isinf (c) ? 1 : 0, c);
		1966	d = COPYSIGN (isinf (d) ? 1 : 0, d);
		1967	if (isnan (a)) a = COPYSIGN (0, a);
		1968	if (isnan (b)) b = COPYSIGN (0, b);
		1969	recalc = 1;
		1970	}
		1971	if (!recalc
		1972	&& (isinf (ac) \|\| isinf (bd)
		1973	\|\| isinf (ad) \|\| isinf (bc)))
		1974	{
		1975	/* Recover infinities from overflow by changing NaNs to 0. */
		1976	if (isnan (a)) a = COPYSIGN (0, a);
		1977	if (isnan (b)) b = COPYSIGN (0, b);
		1978	if (isnan (c)) c = COPYSIGN (0, c);
		1979	if (isnan (d)) d = COPYSIGN (0, d);
		1980	recalc = 1;
		1981	}
		1982	if (recalc)
		1983	{
		1984	x = INFINITY * (a * c - b * d);
		1985	y = INFINITY * (a * d + b * c);
		1986	}
		1987	}
		1988
		1989	__real__ res = x;
		1990	__imag__ res = y;
		1991	return res;
		1992	}
		1993	#endif /* complex multiply */
		1994
		1995	#if defined(L_divsc3) \|\| defined(L_divdc3) \
		1996	\|\| defined(L_divxc3) \|\| defined(L_divtc3)
		1997
		1998	CTYPE
		1999	CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
		2000	{
		2001	MTYPE denom, ratio, x, y;
		2002	CTYPE res;
		2003
		2004	/* ??? We can get better behavior from logarithmic scaling instead of
		2005	the division. But that would mean starting to link libgcc against
		2006	libm. We could implement something akin to ldexp/frexp as gcc builtins
		2007	fairly easily... */
		2008	if (FABS (c) < FABS (d))
		2009	{
		2010	ratio = c / d;
		2011	denom = (c * ratio) + d;
		2012	x = ((a * ratio) + b) / denom;
		2013	y = ((b * ratio) - a) / denom;
		2014	}
		2015	else
		2016	{
		2017	ratio = d / c;
		2018	denom = (d * ratio) + c;
		2019	x = ((b * ratio) + a) / denom;
		2020	y = (b - (a * ratio)) / denom;
		2021	}
		2022
		2023	/* Recover infinities and zeros that computed as NaN+iNaN; the only cases
		2024	are nonzero/zero, infinite/finite, and finite/infinite. */
		2025	if (isnan (x) && isnan (y))
		2026	{
		2027	if (c == 0.0 && d == 0.0 && (!isnan (a) \|\| !isnan (b)))
		2028	{
		2029	x = COPYSIGN (INFINITY, c) * a;
		2030	y = COPYSIGN (INFINITY, c) * b;
		2031	}
		2032	else if ((isinf (a) \|\| isinf (b)) && isfinite (c) && isfinite (d))
		2033	{
		2034	a = COPYSIGN (isinf (a) ? 1 : 0, a);
		2035	b = COPYSIGN (isinf (b) ? 1 : 0, b);
		2036	x = INFINITY * (a * c + b * d);
		2037	y = INFINITY * (b * c - a * d);
		2038	}
		2039	else if ((isinf (c) \|\| isinf (d)) && isfinite (a) && isfinite (b))
		2040	{
		2041	c = COPYSIGN (isinf (c) ? 1 : 0, c);
		2042	d = COPYSIGN (isinf (d) ? 1 : 0, d);
		2043	x = 0.0 * (a * c + b * d);
		2044	y = 0.0 * (b * c - a * d);
		2045	}
		2046	}
		2047
		2048	__real__ res = x;
		2049	__imag__ res = y;
		2050	return res;
		2051	}
		2052	#endif /* complex divide */
		2053
		2054	#endif /* all complex float routines */
		2055
		2056	/* From here on down, the routines use normal data types. */
		2057
		2058	#define SItype bogus_type
		2059	#define USItype bogus_type
		2060	#define DItype bogus_type
		2061	#define UDItype bogus_type
		2062	#define SFtype bogus_type
		2063	#define DFtype bogus_type
		2064	#undef Wtype
		2065	#undef UWtype
		2066	#undef HWtype
		2067	#undef UHWtype
		2068	#undef DWtype
		2069	#undef UDWtype
		2070
		2071	#undef char
		2072	#undef short
		2073	#undef int
		2074	#undef long
		2075	#undef unsigned
		2076	#undef float
		2077	#undef double
		2078
		2079	#ifdef L__gcc_bcmp
		2080
		2081	/* Like bcmp except the sign is meaningful.
		2082	Result is negative if S1 is less than S2,
		2083	positive if S1 is greater, 0 if S1 and S2 are equal. */
		2084
		2085	int
		2086	__gcc_bcmp (const unsigned char s1, const unsigned char s2, size_t size)
		2087	{
		2088	while (size > 0)
		2089	{
		2090	const unsigned char c1 = s1++, c2 = s2++;
		2091	if (c1 != c2)
		2092	return c1 - c2;
		2093	size--;
		2094	}
		2095	return 0;
		2096	}
		2097
		2098	#endif
		2099
		2100	/* __eprintf used to be used by GCC's private version of .
		2101	We no longer provide that header, but this routine remains in libgcc.a
		2102	for binary backward compatibility. Note that it is not included in
		2103	the shared version of libgcc. */
		2104	#ifdef L_eprintf
		2105	#ifndef inhibit_libc
		2106
		2107	#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
		2108	#include
		2109
		2110	void
		2111	__eprintf (const char string, const char expression,
		2112	unsigned int line, const char *filename)
		2113	{
		2114	fprintf (stderr, string, expression, line, filename);
		2115	fflush (stderr);
		2116	abort ();
		2117	}
		2118
		2119	#endif
		2120	#endif
		2121
		2122
		2123	#ifdef L_clear_cache
		2124	/* Clear part of an instruction cache. */
		2125
		2126	void
		2127	__clear_cache (char *beg __attribute__((__unused__)),
		2128	char *end __attribute__((__unused__)))
		2129	{
		2130	#ifdef CLEAR_INSN_CACHE
		2131	CLEAR_INSN_CACHE (beg, end);
		2132	#endif /* CLEAR_INSN_CACHE */
		2133	}
		2134
		2135	#endif /* L_clear_cache */
		2136
		2137	#ifdef L_trampoline
		2138
		2139	/* Jump to a trampoline, loading the static chain address. */
		2140
		2141	#if defined(WINNT) && ! defined(__CYGWIN__)
		2142	#include
		2143	int getpagesize (void);
		2144	int mprotect (char *,int, int);
		2145
		2146	int
		2147	getpagesize (void)
		2148	{
		2149	#ifdef _ALPHA_
		2150	return 8192;
		2151	#else
		2152	return 4096;
		2153	#endif
		2154	}
		2155
		2156	int
		2157	mprotect (char *addr, int len, int prot)
		2158	{
		2159	DWORD np, op;
		2160
		2161	if (prot == 7)
		2162	np = 0x40;
		2163	else if (prot == 5)
		2164	np = 0x20;
		2165	else if (prot == 4)
		2166	np = 0x10;
		2167	else if (prot == 3)
		2168	np = 0x04;
		2169	else if (prot == 1)
		2170	np = 0x02;
		2171	else if (prot == 0)
		2172	np = 0x01;
		2173	else
		2174	return -1;
		2175
		2176	if (VirtualProtect (addr, len, np, &op))
		2177	return 0;
		2178	else
		2179	return -1;
		2180	}
		2181
		2182	#endif /* WINNT && ! __CYGWIN__ */
		2183
		2184	#ifdef TRANSFER_FROM_TRAMPOLINE
		2185	TRANSFER_FROM_TRAMPOLINE
		2186	#endif
		2187	#endif /* L_trampoline */
		2188
		2189	#ifndef __CYGWIN__
		2190	#ifdef L__main
		2191
		2192	#include "gbl-ctors.h"
		2193
		2194	/* Some systems use __main in a way incompatible with its use in gcc, in these
		2195	cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
		2196	give the same symbol without quotes for an alternative entry point. You
		2197	must define both, or neither. */
		2198	#ifndef NAME__MAIN
		2199	#define NAME__MAIN "__main"
		2200	#define SYMBOL__MAIN __main
		2201	#endif
		2202
		2203	#if defined (__LIBGCC_INIT_SECTION_ASM_OP__) \
		2204	\|\| defined (__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__)
		2205	#undef HAS_INIT_SECTION
		2206	#define HAS_INIT_SECTION
		2207	#endif
		2208
		2209	#if !defined (HAS_INIT_SECTION) \|\| !defined (OBJECT_FORMAT_ELF)
		2210
		2211	/* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
		2212	code to run constructors. In that case, we need to handle EH here, too.
		2213	But MINGW32 is special because it handles CRTSTUFF and EH on its own. */
		2214
		2215	#ifdef __MINGW32__
		2216	#undef __LIBGCC_EH_FRAME_SECTION_NAME__
		2217	#endif
		2218
		2219	#ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
		2220	#include "unwind-dw2-fde.h"
		2221	extern unsigned char __EH_FRAME_BEGIN__[];
		2222	#endif
		2223
		2224	/* Run all the global destructors on exit from the program. */
		2225
		2226	void
		2227	__do_global_dtors (void)
		2228	{
		2229	#ifdef DO_GLOBAL_DTORS_BODY
		2230	DO_GLOBAL_DTORS_BODY;
		2231	#else
		2232	static func_ptr *p = __DTOR_LIST__ + 1;
		2233	while (*p)
		2234	{
		2235	p++;
		2236	(*(p-1)) ();
		2237	}
		2238	#endif
		2239	#if defined (__LIBGCC_EH_FRAME_SECTION_NAME__) && !defined (HAS_INIT_SECTION)
		2240	{
		2241	static int completed = 0;
		2242	if (! completed)
		2243	{
		2244	completed = 1;
		2245	__deregister_frame_info (__EH_FRAME_BEGIN__);
		2246	}
		2247	}
		2248	#endif
		2249	}
		2250	#endif
		2251
		2252	#ifndef HAS_INIT_SECTION
		2253	/* Run all the global constructors on entry to the program. */
		2254
		2255	void
		2256	__do_global_ctors (void)
		2257	{
		2258	#ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
		2259	{
		2260	static struct object object;
		2261	__register_frame_info (__EH_FRAME_BEGIN__, &object);
		2262	}
		2263	#endif
		2264	DO_GLOBAL_CTORS_BODY;
		2265	atexit (__do_global_dtors);
		2266	}
		2267	#endif /* no HAS_INIT_SECTION */
		2268
		2269	#if !defined (HAS_INIT_SECTION) \|\| defined (INVOKE__main)
		2270	/* Subroutine called automatically by `main'.
		2271	Compiling a global function named `main'
		2272	produces an automatic call to this function at the beginning.
		2273
		2274	For many systems, this routine calls __do_global_ctors.
		2275	For systems which support a .init section we use the .init section
		2276	to run __do_global_ctors, so we need not do anything here. */
		2277
		2278	extern void SYMBOL__MAIN (void);
		2279	void
		2280	SYMBOL__MAIN (void)
		2281	{
		2282	/* Support recursive calls to `main': run initializers just once. */
		2283	static int initialized;
		2284	if (! initialized)
		2285	{
		2286	initialized = 1;
		2287	__do_global_ctors ();
		2288	}
		2289	}
		2290	#endif /* no HAS_INIT_SECTION or INVOKE__main */
		2291
		2292	#endif /* L__main */
		2293	#endif /* __CYGWIN__ */
		2294
		2295	#ifdef L_ctors
		2296
		2297	#include "gbl-ctors.h"
		2298
		2299	/* Provide default definitions for the lists of constructors and
		2300	destructors, so that we don't get linker errors. These symbols are
		2301	intentionally bss symbols, so that gld and/or collect will provide
		2302	the right values. */
		2303
		2304	/* We declare the lists here with two elements each,
		2305	so that they are valid empty lists if no other definition is loaded.
		2306
		2307	If we are using the old "set" extensions to have the gnu linker
		2308	collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
		2309	must be in the bss/common section.
		2310
		2311	Long term no port should use those extensions. But many still do. */
		2312	#if !defined(__LIBGCC_INIT_SECTION_ASM_OP__) \
		2313	&& !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
		2314	#if defined (TARGET_ASM_CONSTRUCTOR) \|\| defined (USE_COLLECT2)
		2315	func_ptr __CTOR_LIST__[2] = {0, 0};
		2316	func_ptr __DTOR_LIST__[2] = {0, 0};
		2317	#else
		2318	func_ptr __CTOR_LIST__[2];
		2319	func_ptr __DTOR_LIST__[2];
		2320	#endif
		2321	#endif /* no __LIBGCC_INIT_SECTION_ASM_OP__ and not CTOR_LISTS_DEFINED_EXTERNALLY */
		2322	#endif /* L_ctors */
		2323	#endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/gcc/5x/libgcc/libgcc2.c – Rev 6515