1/* More subroutines needed by GCC output code on some machines. */ 2/* Compile this one with gcc. */ 3/* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, |
4 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. |
5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 --- 8 unchanged lines hidden (view full) --- 21 22GCC is distributed in the hope that it will be useful, but WITHOUT ANY 23WARRANTY; without even the implied warranty of MERCHANTABILITY or 24FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 25for more details. 26 27You should have received a copy of the GNU General Public License 28along with GCC; see the file COPYING. If not, write to the Free |
29Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 3002110-1301, USA. */ |
31 |
32#include "tconfig.h" 33#include "tsystem.h" 34#include "coretypes.h" 35#include "tm.h" 36 |
37#ifdef HAVE_GAS_HIDDEN 38#define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden"))) 39#else 40#define ATTRIBUTE_HIDDEN 41#endif 42 |
43#ifndef MIN_UNITS_PER_WORD 44#define MIN_UNITS_PER_WORD UNITS_PER_WORD 45#endif 46 47/* Work out the largest "word" size that we can deal with on this target. */ 48#if MIN_UNITS_PER_WORD > 4 49# define LIBGCC2_MAX_UNITS_PER_WORD 8 50#elif (MIN_UNITS_PER_WORD > 2 \ 51 || (MIN_UNITS_PER_WORD > 1 && LONG_LONG_TYPE_SIZE > 32)) 52# define LIBGCC2_MAX_UNITS_PER_WORD 4 53#else 54# define LIBGCC2_MAX_UNITS_PER_WORD MIN_UNITS_PER_WORD 55#endif 56 57/* Work out what word size we are using for this compilation. 58 The value can be set on the command line. */ 59#ifndef LIBGCC2_UNITS_PER_WORD 60#define LIBGCC2_UNITS_PER_WORD LIBGCC2_MAX_UNITS_PER_WORD 61#endif 62 63#if LIBGCC2_UNITS_PER_WORD <= LIBGCC2_MAX_UNITS_PER_WORD 64 |
65#include "libgcc2.h" 66 67#ifdef DECLARE_LIBRARY_RENAMES 68 DECLARE_LIBRARY_RENAMES 69#endif 70 71#if defined (L_negdi2) 72DWtype --- 79 unchanged lines hidden (view full) --- 152 if (b >= 0 ? w > a : w < a) 153 abort (); 154 155 return w; 156} 157#endif 158 159#ifdef L_mulvsi3 |
160Wtype 161__mulvSI3 (Wtype a, Wtype b) 162{ 163 const DWtype w = (DWtype) a * (DWtype) b; 164 |
165 if ((Wtype) (w >> W_TYPE_SIZE) != (Wtype) w >> (W_TYPE_SIZE - 1)) |
166 abort (); 167 168 return w; 169} 170#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC 171#undef WORD_SIZE 172#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT) 173SItype --- 102 unchanged lines hidden (view full) --- 276 abort (); 277#endif 278 279 return w; 280} 281#endif 282 283#ifdef L_mulvdi3 |
284DWtype 285__mulvDI3 (DWtype u, DWtype v) 286{ 287 /* The unchecked multiplication needs 3 Wtype x Wtype multiplications, 288 but the checked multiplication needs only two. */ 289 const DWunion uu = {.ll = u}; 290 const DWunion vv = {.ll = v}; 291 |
292 if (__builtin_expect (uu.s.high == uu.s.low >> (W_TYPE_SIZE - 1), 1)) |
293 { 294 /* u fits in a single Wtype. */ |
295 if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1)) |
296 { 297 /* v fits in a single Wtype as well. */ 298 /* A single multiplication. No overflow risk. */ 299 return (DWtype) uu.s.low * (DWtype) vv.s.low; 300 } 301 else 302 { 303 /* Two multiplications. */ 304 DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low 305 * (UDWtype) (UWtype) vv.s.low}; 306 DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.low 307 * (UDWtype) (UWtype) vv.s.high}; 308 309 if (vv.s.high < 0) 310 w1.s.high -= uu.s.low; 311 if (uu.s.low < 0) 312 w1.ll -= vv.ll; 313 w1.ll += (UWtype) w0.s.high; |
314 if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1)) |
315 { 316 w0.s.high = w1.s.low; 317 return w0.ll; 318 } 319 } 320 } 321 else 322 { |
323 if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1)) |
324 { 325 /* v fits into a single Wtype. */ 326 /* Two multiplications. */ 327 DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low 328 * (UDWtype) (UWtype) vv.s.low}; 329 DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.high 330 * (UDWtype) (UWtype) vv.s.low}; 331 332 if (uu.s.high < 0) 333 w1.s.high -= vv.s.low; 334 if (vv.s.low < 0) 335 w1.ll -= uu.ll; 336 w1.ll += (UWtype) w0.s.high; |
337 if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1)) |
338 { 339 w0.s.high = w1.s.low; 340 return w0.ll; 341 } 342 } 343 else 344 { 345 /* A few sign checks and a single multiplication. */ --- 143 unchanged lines hidden (view full) --- 489 } 490 491 return w.ll; 492} 493#endif 494 495#ifdef L_ffssi2 496#undef int |
497int 498__ffsSI2 (UWtype u) 499{ 500 UWtype count; 501 502 if (u == 0) 503 return 0; 504 505 count_trailing_zeros (count, u); 506 return count + 1; 507} 508#endif 509 510#ifdef L_ffsdi2 511#undef int |
512int 513__ffsDI2 (DWtype u) 514{ 515 const DWunion uu = {.ll = u}; 516 UWtype word, count, add; 517 518 if (uu.s.low != 0) 519 word = uu.s.low, add = 0; --- 40 unchanged lines hidden (view full) --- 560{ 561 UWtype q, r; 562 UWtype c0, c1, b1; 563 564 if ((Wtype) d >= 0) 565 { 566 if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1))) 567 { |
568 /* Dividend, divisor, and quotient are nonnegative. */ |
569 sdiv_qrnnd (q, r, a1, a0, d); 570 } 571 else 572 { |
573 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */ |
574 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1)); |
575 /* Divide (c1*2^32 + c0) by d. */ |
576 sdiv_qrnnd (q, r, c1, c0, d); |
577 /* Add 2^31 to quotient. */ |
578 q += (UWtype) 1 << (W_TYPE_SIZE - 1); 579 } 580 } 581 else 582 { 583 b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */ 584 c1 = a1 >> 1; /* A/2 */ 585 c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1); --- 79 unchanged lines hidden (view full) --- 665#endif 666 667#if (defined (L_udivdi3) || defined (L_divdi3) || \ 668 defined (L_umoddi3) || defined (L_moddi3)) 669#define L_udivmoddi4 670#endif 671 672#ifdef L_clz |
673const UQItype __clz_tab[256] = |
674{ 675 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, 676 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, 677 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, 678 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, 679 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, 680 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, 681 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, |
682 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 |
683}; 684#endif 685 686#ifdef L_clzsi2 687#undef int |
688int 689__clzSI2 (UWtype x) 690{ 691 Wtype ret; 692 693 count_leading_zeros (ret, x); 694 695 return ret; 696} 697#endif 698 699#ifdef L_clzdi2 700#undef int |
701int 702__clzDI2 (UDWtype x) 703{ 704 const DWunion uu = {.ll = x}; 705 UWtype word; 706 Wtype ret, add; 707 708 if (uu.s.high) 709 word = uu.s.high, add = 0; 710 else 711 word = uu.s.low, add = W_TYPE_SIZE; 712 713 count_leading_zeros (ret, word); 714 return ret + add; 715} 716#endif 717 718#ifdef L_ctzsi2 719#undef int |
720int 721__ctzSI2 (UWtype x) 722{ 723 Wtype ret; 724 725 count_trailing_zeros (ret, x); 726 727 return ret; 728} 729#endif 730 731#ifdef L_ctzdi2 732#undef int |
733int 734__ctzDI2 (UDWtype x) 735{ 736 const DWunion uu = {.ll = x}; 737 UWtype word; 738 Wtype ret, add; 739 740 if (uu.s.low) 741 word = uu.s.low, add = 0; 742 else 743 word = uu.s.high, add = W_TYPE_SIZE; 744 745 count_trailing_zeros (ret, word); 746 return ret + add; 747} 748#endif 749 |
750#ifdef L_popcount_tab |
751const UQItype __popcount_tab[256] = |
752{ 753 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, 754 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, 755 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, 756 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, 757 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, 758 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, 759 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, |
760 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 |
761}; 762#endif 763 764#ifdef L_popcountsi2 765#undef int |
766int 767__popcountSI2 (UWtype x) 768{ |
769 int i, ret = 0; |
770 771 for (i = 0; i < W_TYPE_SIZE; i += 8) 772 ret += __popcount_tab[(x >> i) & 0xff]; 773 774 return ret; 775} 776#endif 777 778#ifdef L_popcountdi2 779#undef int |
780int 781__popcountDI2 (UDWtype x) 782{ |
783 int i, ret = 0; |
784 785 for (i = 0; i < 2*W_TYPE_SIZE; i += 8) 786 ret += __popcount_tab[(x >> i) & 0xff]; 787 788 return ret; 789} 790#endif 791 792#ifdef L_paritysi2 793#undef int |
794int 795__paritySI2 (UWtype x) 796{ 797#if W_TYPE_SIZE > 64 798# error "fill out the table" 799#endif 800#if W_TYPE_SIZE > 32 801 x ^= x >> 32; --- 5 unchanged lines hidden (view full) --- 807 x ^= x >> 4; 808 x &= 0xf; 809 return (0x6996 >> x) & 1; 810} 811#endif 812 813#ifdef L_paritydi2 814#undef int |
815int 816__parityDI2 (UDWtype x) 817{ 818 const DWunion uu = {.ll = x}; 819 UWtype nx = uu.s.low ^ uu.s.high; 820 821#if W_TYPE_SIZE > 64 822# error "fill out the table" --- 265 unchanged lines hidden (view full) --- 1088 DWtype w; 1089 1090 if (uu.s.high < 0) 1091 c = ~c, 1092 uu.ll = -uu.ll; 1093 if (vv.s.high < 0) 1094 vv.ll = -vv.ll; 1095 |
1096 (void) __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&w); |
1097 if (c) 1098 w = -w; 1099 1100 return w; 1101} 1102#endif 1103 1104#ifdef L_umoddi3 --- 49 unchanged lines hidden (view full) --- 1154 if ((UWtype) au.s.low < (UWtype) bu.s.low) 1155 return 0; 1156 else if ((UWtype) au.s.low > (UWtype) bu.s.low) 1157 return 2; 1158 return 1; 1159} 1160#endif 1161 |
1162#if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE |
1163DWtype 1164__fixunstfDI (TFtype a) 1165{ 1166 if (a < 0) 1167 return 0; 1168 1169 /* Compute high word of result, as a flonum. */ |
1170 const TFtype b = (a / Wtype_MAXp1_F); |
1171 /* Convert that to fixed (but not to DWtype!), 1172 and shift it into the high word. */ 1173 UDWtype v = (UWtype) b; |
1174 v <<= W_TYPE_SIZE; |
1175 /* Remove high part from the TFtype, leaving the low part as flonum. */ 1176 a -= (TFtype)v; 1177 /* Convert that to fixed (but not to DWtype!) and add it in. 1178 Sometimes A comes out negative. This is significant, since 1179 A has more bits than a long int does. */ 1180 if (a < 0) 1181 v -= (UWtype) (- a); 1182 else 1183 v += (UWtype) a; 1184 return v; 1185} 1186#endif 1187 |
1188#if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE |
1189DWtype 1190__fixtfdi (TFtype a) 1191{ 1192 if (a < 0) 1193 return - __fixunstfDI (-a); 1194 return __fixunstfDI (a); 1195} 1196#endif 1197 |
1198#if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE |
1199DWtype 1200__fixunsxfDI (XFtype a) 1201{ 1202 if (a < 0) 1203 return 0; 1204 1205 /* Compute high word of result, as a flonum. */ |
1206 const XFtype b = (a / Wtype_MAXp1_F); |
1207 /* Convert that to fixed (but not to DWtype!), 1208 and shift it into the high word. */ 1209 UDWtype v = (UWtype) b; |
1210 v <<= W_TYPE_SIZE; |
1211 /* Remove high part from the XFtype, leaving the low part as flonum. */ 1212 a -= (XFtype)v; 1213 /* Convert that to fixed (but not to DWtype!) and add it in. 1214 Sometimes A comes out negative. This is significant, since 1215 A has more bits than a long int does. */ 1216 if (a < 0) 1217 v -= (UWtype) (- a); 1218 else 1219 v += (UWtype) a; 1220 return v; 1221} 1222#endif 1223 |
1224#if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE |
1225DWtype 1226__fixxfdi (XFtype a) 1227{ 1228 if (a < 0) 1229 return - __fixunsxfDI (-a); 1230 return __fixunsxfDI (a); 1231} 1232#endif 1233 |
1234#if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE |
1235DWtype 1236__fixunsdfDI (DFtype a) 1237{ 1238 /* Get high part of result. The division here will just moves the radix 1239 point and will not cause any rounding. Then the conversion to integral 1240 type chops result as desired. */ |
1241 const UWtype hi = a / Wtype_MAXp1_F; |
1242 1243 /* Get low part of result. Convert `hi' to floating type and scale it back, 1244 then subtract this from the number being converted. This leaves the low 1245 part. Convert that to integral type. */ |
1246 const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F; |
1247 1248 /* Assemble result from the two parts. */ |
1249 return ((UDWtype) hi << W_TYPE_SIZE) | lo; |
1250} 1251#endif 1252 |
1253#if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE |
1254DWtype 1255__fixdfdi (DFtype a) 1256{ 1257 if (a < 0) 1258 return - __fixunsdfDI (-a); 1259 return __fixunsdfDI (a); 1260} 1261#endif 1262 |
1263#if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE |
1264DWtype |
1265__fixunssfDI (SFtype a) |
1266{ |
1267#if LIBGCC2_HAS_DF_MODE |
1268 /* Convert the SFtype to a DFtype, because that is surely not going 1269 to lose any bits. Some day someone else can write a faster version 1270 that avoids converting to DFtype, and verify it really works right. */ |
1271 const DFtype dfa = a; |
1272 1273 /* Get high part of result. The division here will just moves the radix 1274 point and will not cause any rounding. Then the conversion to integral 1275 type chops result as desired. */ |
1276 const UWtype hi = dfa / Wtype_MAXp1_F; |
1277 1278 /* Get low part of result. Convert `hi' to floating type and scale it back, 1279 then subtract this from the number being converted. This leaves the low 1280 part. Convert that to integral type. */ |
1281 const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F; |
1282 1283 /* Assemble result from the two parts. */ |
1284 return ((UDWtype) hi << W_TYPE_SIZE) | lo; 1285#elif FLT_MANT_DIG < W_TYPE_SIZE 1286 if (a < 1) 1287 return 0; 1288 if (a < Wtype_MAXp1_F) 1289 return (UWtype)a; 1290 if (a < Wtype_MAXp1_F * Wtype_MAXp1_F) 1291 { 1292 /* Since we know that there are fewer significant bits in the SFmode 1293 quantity than in a word, we know that we can convert out all the 1294 significant bits in one step, and thus avoid losing bits. */ 1295 1296 /* ??? This following loop essentially performs frexpf. If we could 1297 use the real libm function, or poke at the actual bits of the fp 1298 format, it would be significantly faster. */ 1299 1300 UWtype shift = 0, counter; 1301 SFtype msb; 1302 1303 a /= Wtype_MAXp1_F; 1304 for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1) 1305 { 1306 SFtype counterf = (UWtype)1 << counter; 1307 if (a >= counterf) 1308 { 1309 shift |= counter; 1310 a /= counterf; 1311 } 1312 } 1313 1314 /* Rescale into the range of one word, extract the bits of that 1315 one word, and shift the result into position. */ 1316 a *= Wtype_MAXp1_F; 1317 counter = a; 1318 return (DWtype)counter << shift; 1319 } 1320 return -1; 1321#else 1322# error 1323#endif |
1324} 1325#endif 1326 |
1327#if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE |
1328DWtype 1329__fixsfdi (SFtype a) 1330{ 1331 if (a < 0) 1332 return - __fixunssfDI (-a); 1333 return __fixunssfDI (a); 1334} 1335#endif 1336 |
1337#if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE |
1338XFtype 1339__floatdixf (DWtype u) 1340{ |
1341#if W_TYPE_SIZE > XF_SIZE 1342# error 1343#endif 1344 XFtype d = (Wtype) (u >> W_TYPE_SIZE); 1345 d *= Wtype_MAXp1_F; 1346 d += (UWtype)u; 1347 return d; 1348} 1349#endif |
1350 |
1351#if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE 1352XFtype 1353__floatundixf (UDWtype u) 1354{ 1355#if W_TYPE_SIZE > XF_SIZE 1356# error 1357#endif 1358 XFtype d = (UWtype) (u >> W_TYPE_SIZE); 1359 d *= Wtype_MAXp1_F; 1360 d += (UWtype)u; |
1361 return d; 1362} 1363#endif 1364 |
1365#if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE |
1366TFtype 1367__floatditf (DWtype u) 1368{ |
1369#if W_TYPE_SIZE > TF_SIZE 1370# error 1371#endif 1372 TFtype d = (Wtype) (u >> W_TYPE_SIZE); 1373 d *= Wtype_MAXp1_F; 1374 d += (UWtype)u; 1375 return d; 1376} 1377#endif |
1378 |
1379#if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE 1380TFtype 1381__floatunditf (UDWtype u) 1382{ 1383#if W_TYPE_SIZE > TF_SIZE 1384# error 1385#endif 1386 TFtype d = (UWtype) (u >> W_TYPE_SIZE); 1387 d *= Wtype_MAXp1_F; 1388 d += (UWtype)u; |
1389 return d; 1390} 1391#endif 1392 |
1393#if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \ 1394 || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE) 1395#define DI_SIZE (W_TYPE_SIZE * 2) 1396#define F_MODE_OK(SIZE) \ 1397 (SIZE < DI_SIZE \ 1398 && SIZE > (DI_SIZE - SIZE + FSSIZE) \ 1399 /* Don't use IBM Extended Double TFmode for TI->SF calculations. \ 1400 The conversion from long double to float suffers from double \ 1401 rounding, because we convert via double. In any case, the \ 1402 fallback code is faster. */ \ 1403 && !IS_IBM_EXTENDED (SIZE)) 1404#if defined(L_floatdisf) 1405#define FUNC __floatdisf 1406#define FSTYPE SFtype 1407#define FSSIZE SF_SIZE 1408#else 1409#define FUNC __floatdidf 1410#define FSTYPE DFtype 1411#define FSSIZE DF_SIZE 1412#endif |
1413 |
1414FSTYPE 1415FUNC (DWtype u) |
1416{ |
1417#if FSSIZE >= W_TYPE_SIZE 1418 /* When the word size is small, we never get any rounding error. */ 1419 FSTYPE f = (Wtype) (u >> W_TYPE_SIZE); 1420 f *= Wtype_MAXp1_F; 1421 f += (UWtype)u; 1422 return f; 1423#elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \ 1424 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \ 1425 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE)) |
1426 |
1427#if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) 1428# define FSIZE DF_SIZE 1429# define FTYPE DFtype 1430#elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) 1431# define FSIZE XF_SIZE 1432# define FTYPE XFtype 1433#elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE)) 1434# define FSIZE TF_SIZE 1435# define FTYPE TFtype 1436#else 1437# error |
1438#endif 1439 |
1440#define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE)) |
1441 |
1442 /* Protect against double-rounding error. 1443 Represent any low-order bits, that might be truncated by a bit that 1444 won't be lost. The bit can go in anywhere below the rounding position 1445 of the FSTYPE. A fixed mask and bit position handles all usual 1446 configurations. */ 1447 if (! (- ((DWtype) 1 << FSIZE) < u 1448 && u < ((DWtype) 1 << FSIZE))) 1449 { 1450 if ((UDWtype) u & (REP_BIT - 1)) 1451 { 1452 u &= ~ (REP_BIT - 1); 1453 u |= REP_BIT; 1454 } 1455 } |
1456 |
1457 /* Do the calculation in a wider type so that we don't lose any of 1458 the precision of the high word while multiplying it. */ 1459 FTYPE f = (Wtype) (u >> W_TYPE_SIZE); 1460 f *= Wtype_MAXp1_F; 1461 f += (UWtype)u; 1462 return (FSTYPE) f; 1463#else 1464#if FSSIZE >= W_TYPE_SIZE - 2 1465# error 1466#endif 1467 /* Finally, the word size is larger than the number of bits in the 1468 required FSTYPE, and we've got no suitable wider type. The only 1469 way to avoid double rounding is to special case the 1470 extraction. */ 1471 1472 /* If there are no high bits set, fall back to one conversion. */ 1473 if ((Wtype)u == u) 1474 return (FSTYPE)(Wtype)u; 1475 1476 /* Otherwise, find the power of two. */ 1477 Wtype hi = u >> W_TYPE_SIZE; 1478 if (hi < 0) 1479 hi = -hi; 1480 1481 UWtype count, shift; 1482 count_leading_zeros (count, hi); 1483 1484 /* No leading bits means u == minimum. */ 1485 if (count == 0) 1486 return -(Wtype_MAXp1_F * (Wtype_MAXp1_F / 2)); 1487 1488 shift = 1 + W_TYPE_SIZE - count; 1489 1490 /* Shift down the most significant bits. */ 1491 hi = u >> shift; 1492 1493 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */ 1494 if (u & (((DWtype)1 << shift) - 1)) 1495 hi |= 1; 1496 1497 /* Convert the one word of data, and rescale. */ 1498 FSTYPE f = hi; 1499 f *= (UDWtype)1 << shift; 1500 return f; 1501#endif 1502} 1503#endif 1504 1505#if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \ 1506 || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE) 1507#define DI_SIZE (W_TYPE_SIZE * 2) 1508#define F_MODE_OK(SIZE) \ 1509 (SIZE < DI_SIZE \ 1510 && SIZE > (DI_SIZE - SIZE + FSSIZE) \ 1511 /* Don't use IBM Extended Double TFmode for TI->SF calculations. \ 1512 The conversion from long double to float suffers from double \ 1513 rounding, because we convert via double. In any case, the \ 1514 fallback code is faster. */ \ 1515 && !IS_IBM_EXTENDED (SIZE)) 1516#if defined(L_floatundisf) 1517#define FUNC __floatundisf 1518#define FSTYPE SFtype 1519#define FSSIZE SF_SIZE 1520#else 1521#define FUNC __floatundidf 1522#define FSTYPE DFtype 1523#define FSSIZE DF_SIZE 1524#endif 1525 1526FSTYPE 1527FUNC (UDWtype u) |
1528{ |
1529#if FSSIZE >= W_TYPE_SIZE 1530 /* When the word size is small, we never get any rounding error. */ 1531 FSTYPE f = (UWtype) (u >> W_TYPE_SIZE); 1532 f *= Wtype_MAXp1_F; 1533 f += (UWtype)u; 1534 return f; 1535#elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \ 1536 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \ 1537 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE)) 1538 1539#if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) 1540# define FSIZE DF_SIZE 1541# define FTYPE DFtype 1542#elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) 1543# define FSIZE XF_SIZE 1544# define FTYPE XFtype 1545#elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE)) 1546# define FSIZE TF_SIZE 1547# define FTYPE TFtype 1548#else 1549# error 1550#endif 1551 1552#define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE)) 1553 |
1554 /* Protect against double-rounding error. |
1555 Represent any low-order bits, that might be truncated by a bit that 1556 won't be lost. The bit can go in anywhere below the rounding position 1557 of the FSTYPE. A fixed mask and bit position handles all usual 1558 configurations. */ 1559 if (u >= ((UDWtype) 1 << FSIZE)) |
1560 { |
1561 if ((UDWtype) u & (REP_BIT - 1)) |
1562 { |
1563 u &= ~ (REP_BIT - 1); 1564 u |= REP_BIT; |
1565 } 1566 } |
1567 |
1568 /* Do the calculation in a wider type so that we don't lose any of 1569 the precision of the high word while multiplying it. */ 1570 FTYPE f = (UWtype) (u >> W_TYPE_SIZE); 1571 f *= Wtype_MAXp1_F; 1572 f += (UWtype)u; 1573 return (FSTYPE) f; 1574#else 1575#if FSSIZE == W_TYPE_SIZE - 1 1576# error 1577#endif 1578 /* Finally, the word size is larger than the number of bits in the 1579 required FSTYPE, and we've got no suitable wider type. The only 1580 way to avoid double rounding is to special case the 1581 extraction. */ 1582 1583 /* If there are no high bits set, fall back to one conversion. */ 1584 if ((UWtype)u == u) 1585 return (FSTYPE)(UWtype)u; 1586 1587 /* Otherwise, find the power of two. */ 1588 UWtype hi = u >> W_TYPE_SIZE; 1589 1590 UWtype count, shift; 1591 count_leading_zeros (count, hi); 1592 1593 shift = W_TYPE_SIZE - count; 1594 1595 /* Shift down the most significant bits. */ 1596 hi = u >> shift; 1597 1598 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */ 1599 if (u & (((UDWtype)1 << shift) - 1)) 1600 hi |= 1; 1601 1602 /* Convert the one word of data, and rescale. */ 1603 FSTYPE f = hi; 1604 f *= (UDWtype)1 << shift; 1605 return f; 1606#endif |
1607} 1608#endif 1609 |
1610#if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE |
1611/* Reenable the normal types, in case limits.h needs them. */ 1612#undef char 1613#undef short 1614#undef int 1615#undef long 1616#undef unsigned 1617#undef float 1618#undef double --- 5 unchanged lines hidden (view full) --- 1624__fixunsxfSI (XFtype a) 1625{ 1626 if (a >= - (DFtype) Wtype_MIN) 1627 return (Wtype) (a + Wtype_MIN) - Wtype_MIN; 1628 return (Wtype) a; 1629} 1630#endif 1631 |
1632#if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE |
1633/* Reenable the normal types, in case limits.h needs them. */ 1634#undef char 1635#undef short 1636#undef int 1637#undef long 1638#undef unsigned 1639#undef float 1640#undef double --- 5 unchanged lines hidden (view full) --- 1646__fixunsdfSI (DFtype a) 1647{ 1648 if (a >= - (DFtype) Wtype_MIN) 1649 return (Wtype) (a + Wtype_MIN) - Wtype_MIN; 1650 return (Wtype) a; 1651} 1652#endif 1653 |
1654#if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE |
1655/* Reenable the normal types, in case limits.h needs them. */ 1656#undef char 1657#undef short 1658#undef int 1659#undef long 1660#undef unsigned 1661#undef float 1662#undef double --- 5 unchanged lines hidden (view full) --- 1668__fixunssfSI (SFtype a) 1669{ 1670 if (a >= - (SFtype) Wtype_MIN) 1671 return (Wtype) (a + Wtype_MIN) - Wtype_MIN; 1672 return (Wtype) a; 1673} 1674#endif 1675 |
1676/* Integer power helper used from __builtin_powi for non-constant 1677 exponents. */ 1678 1679#if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \ 1680 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \ 1681 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \ 1682 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE) 1683# if defined(L_powisf2) 1684# define TYPE SFtype 1685# define NAME __powisf2 1686# elif defined(L_powidf2) 1687# define TYPE DFtype 1688# define NAME __powidf2 1689# elif defined(L_powixf2) 1690# define TYPE XFtype 1691# define NAME __powixf2 1692# elif defined(L_powitf2) 1693# define TYPE TFtype 1694# define NAME __powitf2 1695# endif 1696 1697#undef int 1698#undef unsigned 1699TYPE 1700NAME (TYPE x, int m) 1701{ 1702 unsigned int n = m < 0 ? -m : m; 1703 TYPE y = n % 2 ? x : 1; 1704 while (n >>= 1) 1705 { 1706 x = x * x; 1707 if (n % 2) 1708 y = y * x; 1709 } 1710 return m < 0 ? 1/y : y; 1711} 1712 1713#endif 1714 1715#if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \ 1716 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \ 1717 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \ 1718 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE) 1719 1720#undef float 1721#undef double 1722#undef long 1723 1724#if defined(L_mulsc3) || defined(L_divsc3) 1725# define MTYPE SFtype 1726# define CTYPE SCtype 1727# define MODE sc 1728# define CEXT f 1729# define NOTRUNC __FLT_EVAL_METHOD__ == 0 1730#elif defined(L_muldc3) || defined(L_divdc3) 1731# define MTYPE DFtype 1732# define CTYPE DCtype 1733# define MODE dc 1734# if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64 1735# define CEXT l 1736# define NOTRUNC 1 1737# else 1738# define CEXT 1739# define NOTRUNC __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1 1740# endif 1741#elif defined(L_mulxc3) || defined(L_divxc3) 1742# define MTYPE XFtype 1743# define CTYPE XCtype 1744# define MODE xc 1745# define CEXT l 1746# define NOTRUNC 1 1747#elif defined(L_multc3) || defined(L_divtc3) 1748# define MTYPE TFtype 1749# define CTYPE TCtype 1750# define MODE tc 1751# define CEXT l 1752# define NOTRUNC 1 1753#else 1754# error 1755#endif 1756 1757#define CONCAT3(A,B,C) _CONCAT3(A,B,C) 1758#define _CONCAT3(A,B,C) A##B##C 1759 1760#define CONCAT2(A,B) _CONCAT2(A,B) 1761#define _CONCAT2(A,B) A##B 1762 1763/* All of these would be present in a full C99 implementation of <math.h> 1764 and <complex.h>. Our problem is that only a few systems have such full 1765 implementations. Further, libgcc_s.so isn't currently linked against 1766 libm.so, and even for systems that do provide full C99, the extra overhead 1767 of all programs using libgcc having to link against libm. So avoid it. */ 1768 1769#define isnan(x) __builtin_expect ((x) != (x), 0) 1770#define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1) 1771#define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0) 1772 1773#define INFINITY CONCAT2(__builtin_inf, CEXT) () 1774#define I 1i 1775 1776/* Helpers to make the following code slightly less gross. */ 1777#define COPYSIGN CONCAT2(__builtin_copysign, CEXT) 1778#define FABS CONCAT2(__builtin_fabs, CEXT) 1779 1780/* Verify that MTYPE matches up with CEXT. */ 1781extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1]; 1782 1783/* Ensure that we've lost any extra precision. */ 1784#if NOTRUNC 1785# define TRUNC(x) 1786#else 1787# define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x)) 1788#endif 1789 1790#if defined(L_mulsc3) || defined(L_muldc3) \ 1791 || defined(L_mulxc3) || defined(L_multc3) 1792 1793CTYPE 1794CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d) 1795{ 1796 MTYPE ac, bd, ad, bc, x, y; 1797 1798 ac = a * c; 1799 bd = b * d; 1800 ad = a * d; 1801 bc = b * c; 1802 1803 TRUNC (ac); 1804 TRUNC (bd); 1805 TRUNC (ad); 1806 TRUNC (bc); 1807 1808 x = ac - bd; 1809 y = ad + bc; 1810 1811 if (isnan (x) && isnan (y)) 1812 { 1813 /* Recover infinities that computed as NaN + iNaN. */ 1814 _Bool recalc = 0; 1815 if (isinf (a) || isinf (b)) 1816 { 1817 /* z is infinite. "Box" the infinity and change NaNs in 1818 the other factor to 0. */ 1819 a = COPYSIGN (isinf (a) ? 1 : 0, a); 1820 b = COPYSIGN (isinf (b) ? 1 : 0, b); 1821 if (isnan (c)) c = COPYSIGN (0, c); 1822 if (isnan (d)) d = COPYSIGN (0, d); 1823 recalc = 1; 1824 } 1825 if (isinf (c) || isinf (d)) 1826 { 1827 /* w is infinite. "Box" the infinity and change NaNs in 1828 the other factor to 0. */ 1829 c = COPYSIGN (isinf (c) ? 1 : 0, c); 1830 d = COPYSIGN (isinf (d) ? 1 : 0, d); 1831 if (isnan (a)) a = COPYSIGN (0, a); 1832 if (isnan (b)) b = COPYSIGN (0, b); 1833 recalc = 1; 1834 } 1835 if (!recalc 1836 && (isinf (ac) || isinf (bd) 1837 || isinf (ad) || isinf (bc))) 1838 { 1839 /* Recover infinities from overflow by changing NaNs to 0. */ 1840 if (isnan (a)) a = COPYSIGN (0, a); 1841 if (isnan (b)) b = COPYSIGN (0, b); 1842 if (isnan (c)) c = COPYSIGN (0, c); 1843 if (isnan (d)) d = COPYSIGN (0, d); 1844 recalc = 1; 1845 } 1846 if (recalc) 1847 { 1848 x = INFINITY * (a * c - b * d); 1849 y = INFINITY * (a * d + b * c); 1850 } 1851 } 1852 1853 return x + I * y; 1854} 1855#endif /* complex multiply */ 1856 1857#if defined(L_divsc3) || defined(L_divdc3) \ 1858 || defined(L_divxc3) || defined(L_divtc3) 1859 1860CTYPE 1861CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d) 1862{ 1863 MTYPE denom, ratio, x, y; 1864 1865 /* ??? We can get better behavior from logarithmic scaling instead of 1866 the division. But that would mean starting to link libgcc against 1867 libm. We could implement something akin to ldexp/frexp as gcc builtins 1868 fairly easily... */ 1869 if (FABS (c) < FABS (d)) 1870 { 1871 ratio = c / d; 1872 denom = (c * ratio) + d; 1873 x = ((a * ratio) + b) / denom; 1874 y = ((b * ratio) - a) / denom; 1875 } 1876 else 1877 { 1878 ratio = d / c; 1879 denom = (d * ratio) + c; 1880 x = ((b * ratio) + a) / denom; 1881 y = (b - (a * ratio)) / denom; 1882 } 1883 1884 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases 1885 are nonzero/zero, infinite/finite, and finite/infinite. */ 1886 if (isnan (x) && isnan (y)) 1887 { 1888 if (c == 0.0 && d == 0.0 && (!isnan (a) || !isnan (b))) 1889 { 1890 x = COPYSIGN (INFINITY, c) * a; 1891 y = COPYSIGN (INFINITY, c) * b; 1892 } 1893 else if ((isinf (a) || isinf (b)) && isfinite (c) && isfinite (d)) 1894 { 1895 a = COPYSIGN (isinf (a) ? 1 : 0, a); 1896 b = COPYSIGN (isinf (b) ? 1 : 0, b); 1897 x = INFINITY * (a * c + b * d); 1898 y = INFINITY * (b * c - a * d); 1899 } 1900 else if ((isinf (c) || isinf (d)) && isfinite (a) && isfinite (b)) 1901 { 1902 c = COPYSIGN (isinf (c) ? 1 : 0, c); 1903 d = COPYSIGN (isinf (d) ? 1 : 0, d); 1904 x = 0.0 * (a * c + b * d); 1905 y = 0.0 * (b * c - a * d); 1906 } 1907 } 1908 1909 return x + I * y; 1910} 1911#endif /* complex divide */ 1912 1913#endif /* all complex float routines */ 1914 |
1915/* From here on down, the routines use normal data types. */ 1916 1917#define SItype bogus_type 1918#define USItype bogus_type 1919#define DItype bogus_type 1920#define UDItype bogus_type 1921#define SFtype bogus_type 1922#define DFtype bogus_type --- 84 unchanged lines hidden (view full) --- 2007#endif /* L_enable_execute_stack */ 2008 2009#ifdef L_trampoline 2010 2011/* Jump to a trampoline, loading the static chain address. */ 2012 2013#if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN) 2014 |
2015int |
2016getpagesize (void) 2017{ 2018#ifdef _ALPHA_ 2019 return 8192; 2020#else 2021 return 4096; 2022#endif 2023} --- 32 unchanged lines hidden (view full) --- 2056TRANSFER_FROM_TRAMPOLINE 2057#endif 2058#endif /* L_trampoline */ 2059 2060#ifndef __CYGWIN__ 2061#ifdef L__main 2062 2063#include "gbl-ctors.h" |
2064 |
2065/* Some systems use __main in a way incompatible with its use in gcc, in these 2066 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to 2067 give the same symbol without quotes for an alternative entry point. You 2068 must define both, or neither. */ 2069#ifndef NAME__MAIN 2070#define NAME__MAIN "__main" 2071#define SYMBOL__MAIN __main 2072#endif 2073 |
2074#if defined (INIT_SECTION_ASM_OP) || defined (INIT_ARRAY_SECTION_ASM_OP) |
2075#undef HAS_INIT_SECTION 2076#define HAS_INIT_SECTION 2077#endif 2078 2079#if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF) 2080 2081/* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this 2082 code to run constructors. In that case, we need to handle EH here, too. */ --- 96 unchanged lines hidden (view full) --- 2179func_ptr __CTOR_LIST__[2] = {0, 0}; 2180func_ptr __DTOR_LIST__[2] = {0, 0}; 2181#else 2182func_ptr __CTOR_LIST__[2]; 2183func_ptr __DTOR_LIST__[2]; 2184#endif 2185#endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */ 2186#endif /* L_ctors */ |
2187#endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */ |