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 13In addition to the permissions in the GNU General Public License, the 14Free Software Foundation gives you unlimited permission to link the 15compiled version of this file into combinations with other programs, 16and to distribute those combinations without any restriction coming 17from the use of this file. (The General Public License restrictions 18do apply in other respects; for example, they cover modification of 19the file, and distribution when not linked into a combine 20executable.) 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 73__negdi2 (DWtype u) 74{ 75 const DWunion uu = {.ll = u}; 76 const DWunion w = { {.low = -uu.s.low, 77 .high = -uu.s.high - ((UWtype) -uu.s.low > 0) } }; 78 79 return w.ll; 80} 81#endif 82 83#ifdef L_addvsi3 84Wtype 85__addvSI3 (Wtype a, Wtype b) 86{ 87 const Wtype w = a + b; 88 89 if (b >= 0 ? w < a : w > a) 90 abort (); 91 92 return w; 93} 94#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC 95SItype 96__addvsi3 (SItype a, SItype b) 97{ 98 const SItype w = a + b; 99 100 if (b >= 0 ? w < a : w > a) 101 abort (); 102 103 return w; 104} 105#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */ 106#endif 107 108#ifdef L_addvdi3 109DWtype 110__addvDI3 (DWtype a, DWtype b) 111{ 112 const DWtype w = a + b; 113 114 if (b >= 0 ? w < a : w > a) 115 abort (); 116 117 return w; 118} 119#endif 120 121#ifdef L_subvsi3 122Wtype 123__subvSI3 (Wtype a, Wtype b) 124{ 125 const Wtype w = a - b; 126 127 if (b >= 0 ? w > a : w < a) 128 abort (); 129 130 return w; 131} 132#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC 133SItype 134__subvsi3 (SItype a, SItype b) 135{ 136 const SItype w = a - b; 137 138 if (b >= 0 ? w > a : w < a) 139 abort (); 140 141 return w; 142} 143#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */ 144#endif 145 146#ifdef L_subvdi3 147DWtype 148__subvDI3 (DWtype a, DWtype b) 149{ 150 const DWtype w = a - b; 151 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 174__mulvsi3 (SItype a, SItype b) 175{ 176 const DItype w = (DItype) a * (DItype) b; 177 178 if ((SItype) (w >> WORD_SIZE) != (SItype) w >> (WORD_SIZE-1)) 179 abort (); 180 181 return w; 182} 183#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */ 184#endif 185 186#ifdef L_negvsi2 187Wtype 188__negvSI2 (Wtype a) 189{ 190 const Wtype w = -a; 191 192 if (a >= 0 ? w > 0 : w < 0) 193 abort (); 194 195 return w; 196} 197#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC 198SItype 199__negvsi2 (SItype a) 200{ 201 const SItype w = -a; 202 203 if (a >= 0 ? w > 0 : w < 0) 204 abort (); 205 206 return w; 207} 208#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */ 209#endif 210 211#ifdef L_negvdi2 212DWtype 213__negvDI2 (DWtype a) 214{ 215 const DWtype w = -a; 216 217 if (a >= 0 ? w > 0 : w < 0) 218 abort (); 219 220 return w; 221} 222#endif 223 224#ifdef L_absvsi2 225Wtype 226__absvSI2 (Wtype a) 227{ 228 Wtype w = a; 229 230 if (a < 0) 231#ifdef L_negvsi2 232 w = __negvSI2 (a); 233#else 234 w = -a; 235 236 if (w < 0) 237 abort (); 238#endif 239 240 return w; 241} 242#ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC 243SItype 244__absvsi2 (SItype a) 245{ 246 SItype w = a; 247 248 if (a < 0) 249#ifdef L_negvsi2 250 w = __negvsi2 (a); 251#else 252 w = -a; 253 254 if (w < 0) 255 abort (); 256#endif 257 258 return w; 259} 260#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */ 261#endif 262 263#ifdef L_absvdi2 264DWtype 265__absvDI2 (DWtype a) 266{ 267 DWtype w = a; 268 269 if (a < 0) 270#ifdef L_negvdi2 271 w = __negvDI2 (a); 272#else 273 w = -a; 274 275 if (w < 0) 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. */ 346 if (uu.s.high >= 0) 347 { 348 if (vv.s.high >= 0) 349 { 350 if (uu.s.high == 0 && vv.s.high == 0) 351 { 352 const DWtype w = (UDWtype) (UWtype) uu.s.low 353 * (UDWtype) (UWtype) vv.s.low; 354 if (__builtin_expect (w >= 0, 1)) 355 return w; 356 } 357 } 358 else 359 { 360 if (uu.s.high == 0 && vv.s.high == (Wtype) -1) 361 { 362 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low 363 * (UDWtype) (UWtype) vv.s.low}; 364 365 ww.s.high -= uu.s.low; 366 if (__builtin_expect (ww.s.high < 0, 1)) 367 return ww.ll; 368 } 369 } 370 } 371 else 372 { 373 if (vv.s.high >= 0) 374 { 375 if (uu.s.high == (Wtype) -1 && vv.s.high == 0) 376 { 377 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low 378 * (UDWtype) (UWtype) vv.s.low}; 379 380 ww.s.high -= vv.s.low; 381 if (__builtin_expect (ww.s.high < 0, 1)) 382 return ww.ll; 383 } 384 } 385 else 386 { 387 if (uu.s.high == (Wtype) -1 && vv.s.high == (Wtype) - 1) 388 { 389 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low 390 * (UDWtype) (UWtype) vv.s.low}; 391 392 ww.s.high -= uu.s.low; 393 ww.s.high -= vv.s.low; 394 if (__builtin_expect (ww.s.high >= 0, 1)) 395 return ww.ll; 396 } 397 } 398 } 399 } 400 } 401 402 /* Overflow. */ 403 abort (); 404} 405#endif 406 407 408/* Unless shift functions are defined with full ANSI prototypes, 409 parameter b will be promoted to int if word_type is smaller than an int. */ 410#ifdef L_lshrdi3 411DWtype 412__lshrdi3 (DWtype u, word_type b) 413{ 414 if (b == 0) 415 return u; 416 417 const DWunion uu = {.ll = u}; 418 const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b; 419 DWunion w; 420 421 if (bm <= 0) 422 { 423 w.s.high = 0; 424 w.s.low = (UWtype) uu.s.high >> -bm; 425 } 426 else 427 { 428 const UWtype carries = (UWtype) uu.s.high << bm; 429 430 w.s.high = (UWtype) uu.s.high >> b; 431 w.s.low = ((UWtype) uu.s.low >> b) | carries; 432 } 433 434 return w.ll; 435} 436#endif 437 438#ifdef L_ashldi3 439DWtype 440__ashldi3 (DWtype u, word_type b) 441{ 442 if (b == 0) 443 return u; 444 445 const DWunion uu = {.ll = u}; 446 const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b; 447 DWunion w; 448 449 if (bm <= 0) 450 { 451 w.s.low = 0; 452 w.s.high = (UWtype) uu.s.low << -bm; 453 } 454 else 455 { 456 const UWtype carries = (UWtype) uu.s.low >> bm; 457 458 w.s.low = (UWtype) uu.s.low << b; 459 w.s.high = ((UWtype) uu.s.high << b) | carries; 460 } 461 462 return w.ll; 463} 464#endif 465 466#ifdef L_ashrdi3 467DWtype 468__ashrdi3 (DWtype u, word_type b) 469{ 470 if (b == 0) 471 return u; 472 473 const DWunion uu = {.ll = u}; 474 const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b; 475 DWunion w; 476 477 if (bm <= 0) 478 { 479 /* w.s.high = 1..1 or 0..0 */ 480 w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1); 481 w.s.low = uu.s.high >> -bm; 482 } 483 else 484 { 485 const UWtype carries = (UWtype) uu.s.high << bm; 486 487 w.s.high = uu.s.high >> b; 488 w.s.low = ((UWtype) uu.s.low >> b) | carries; 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; 520 else if (uu.s.high != 0) 521 word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype); 522 else 523 return 0; 524 525 count_trailing_zeros (count, word); 526 return count + add + 1; 527} 528#endif 529 530#ifdef L_muldi3 531DWtype 532__muldi3 (DWtype u, DWtype v) 533{ 534 const DWunion uu = {.ll = u}; 535 const DWunion vv = {.ll = v}; 536 DWunion w = {.ll = __umulsidi3 (uu.s.low, vv.s.low)}; 537 538 w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high 539 + (UWtype) uu.s.high * (UWtype) vv.s.low); 540 541 return w.ll; 542} 543#endif 544 545#if (defined (L_udivdi3) || defined (L_divdi3) || \ 546 defined (L_umoddi3) || defined (L_moddi3)) 547#if defined (sdiv_qrnnd) 548#define L_udiv_w_sdiv 549#endif 550#endif 551 552#ifdef L_udiv_w_sdiv 553#if defined (sdiv_qrnnd) 554#if (defined (L_udivdi3) || defined (L_divdi3) || \ 555 defined (L_umoddi3) || defined (L_moddi3)) 556static inline __attribute__ ((__always_inline__)) 557#endif 558UWtype 559__udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d) 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); 586 587 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */ 588 { 589 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */ 590 591 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */ 592 if ((d & 1) != 0) 593 { 594 if (r >= q) 595 r = r - q; 596 else if (q - r <= d) 597 { 598 r = r - q + d; 599 q--; 600 } 601 else 602 { 603 r = r - q + 2*d; 604 q -= 2; 605 } 606 } 607 } 608 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */ 609 { 610 c1 = (b1 - 1) - c1; 611 c0 = ~c0; /* logical NOT */ 612 613 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */ 614 615 q = ~q; /* (A/2)/b1 */ 616 r = (b1 - 1) - r; 617 618 r = 2*r + (a0 & 1); /* A/(2*b1) */ 619 620 if ((d & 1) != 0) 621 { 622 if (r >= q) 623 r = r - q; 624 else if (q - r <= d) 625 { 626 r = r - q + d; 627 q--; 628 } 629 else 630 { 631 r = r - q + 2*d; 632 q -= 2; 633 } 634 } 635 } 636 else /* Implies c1 = b1 */ 637 { /* Hence a1 = d - 1 = 2*b1 - 1 */ 638 if (a0 >= -d) 639 { 640 q = -1; 641 r = a0 + d; 642 } 643 else 644 { 645 q = -2; 646 r = a0 + 2*d; 647 } 648 } 649 } 650 651 *rp = r; 652 return q; 653} 654#else 655/* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */ 656UWtype 657__udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)), 658 UWtype a1 __attribute__ ((__unused__)), 659 UWtype a0 __attribute__ ((__unused__)), 660 UWtype d __attribute__ ((__unused__))) 661{ 662 return 0; 663} 664#endif 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 UWtype 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 UWtype 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; 802#endif 803#if W_TYPE_SIZE > 16 804 x ^= x >> 16; 805#endif 806 x ^= x >> 8; 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" 823#endif 824#if W_TYPE_SIZE > 32 825 nx ^= nx >> 32; 826#endif 827#if W_TYPE_SIZE > 16 828 nx ^= nx >> 16; 829#endif 830 nx ^= nx >> 8; 831 nx ^= nx >> 4; 832 nx &= 0xf; 833 return (0x6996 >> nx) & 1; 834} 835#endif 836 837#ifdef L_udivmoddi4 838 839#if (defined (L_udivdi3) || defined (L_divdi3) || \ 840 defined (L_umoddi3) || defined (L_moddi3)) 841static inline __attribute__ ((__always_inline__)) 842#endif 843UDWtype 844__udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp) 845{ 846 const DWunion nn = {.ll = n}; 847 const DWunion dd = {.ll = d}; 848 DWunion rr; 849 UWtype d0, d1, n0, n1, n2; 850 UWtype q0, q1; 851 UWtype b, bm; 852 853 d0 = dd.s.low; 854 d1 = dd.s.high; 855 n0 = nn.s.low; 856 n1 = nn.s.high; 857 858#if !UDIV_NEEDS_NORMALIZATION 859 if (d1 == 0) 860 { 861 if (d0 > n1) 862 { 863 /* 0q = nn / 0D */ 864 865 udiv_qrnnd (q0, n0, n1, n0, d0); 866 q1 = 0; 867 868 /* Remainder in n0. */ 869 } 870 else 871 { 872 /* qq = NN / 0d */ 873 874 if (d0 == 0) 875 d0 = 1 / d0; /* Divide intentionally by zero. */ 876 877 udiv_qrnnd (q1, n1, 0, n1, d0); 878 udiv_qrnnd (q0, n0, n1, n0, d0); 879 880 /* Remainder in n0. */ 881 } 882 883 if (rp != 0) 884 { 885 rr.s.low = n0; 886 rr.s.high = 0; 887 *rp = rr.ll; 888 } 889 } 890 891#else /* UDIV_NEEDS_NORMALIZATION */ 892 893 if (d1 == 0) 894 { 895 if (d0 > n1) 896 { 897 /* 0q = nn / 0D */ 898 899 count_leading_zeros (bm, d0); 900 901 if (bm != 0) 902 { 903 /* Normalize, i.e. make the most significant bit of the 904 denominator set. */ 905 906 d0 = d0 << bm; 907 n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm)); 908 n0 = n0 << bm; 909 } 910 911 udiv_qrnnd (q0, n0, n1, n0, d0); 912 q1 = 0; 913 914 /* Remainder in n0 >> bm. */ 915 } 916 else 917 { 918 /* qq = NN / 0d */ 919 920 if (d0 == 0) 921 d0 = 1 / d0; /* Divide intentionally by zero. */ 922 923 count_leading_zeros (bm, d0); 924 925 if (bm == 0) 926 { 927 /* From (n1 >= d0) /\ (the most significant bit of d0 is set), 928 conclude (the most significant bit of n1 is set) /\ (the 929 leading quotient digit q1 = 1). 930 931 This special case is necessary, not an optimization. 932 (Shifts counts of W_TYPE_SIZE are undefined.) */ 933 934 n1 -= d0; 935 q1 = 1; 936 } 937 else 938 { 939 /* Normalize. */ 940 941 b = W_TYPE_SIZE - bm; 942 943 d0 = d0 << bm; 944 n2 = n1 >> b; 945 n1 = (n1 << bm) | (n0 >> b); 946 n0 = n0 << bm; 947 948 udiv_qrnnd (q1, n1, n2, n1, d0); 949 } 950 951 /* n1 != d0... */ 952 953 udiv_qrnnd (q0, n0, n1, n0, d0); 954 955 /* Remainder in n0 >> bm. */ 956 } 957 958 if (rp != 0) 959 { 960 rr.s.low = n0 >> bm; 961 rr.s.high = 0; 962 *rp = rr.ll; 963 } 964 } 965#endif /* UDIV_NEEDS_NORMALIZATION */ 966 967 else 968 { 969 if (d1 > n1) 970 { 971 /* 00 = nn / DD */ 972 973 q0 = 0; 974 q1 = 0; 975 976 /* Remainder in n1n0. */ 977 if (rp != 0) 978 { 979 rr.s.low = n0; 980 rr.s.high = n1; 981 *rp = rr.ll; 982 } 983 } 984 else 985 { 986 /* 0q = NN / dd */ 987 988 count_leading_zeros (bm, d1); 989 if (bm == 0) 990 { 991 /* From (n1 >= d1) /\ (the most significant bit of d1 is set), 992 conclude (the most significant bit of n1 is set) /\ (the 993 quotient digit q0 = 0 or 1). 994 995 This special case is necessary, not an optimization. */ 996 997 /* The condition on the next line takes advantage of that 998 n1 >= d1 (true due to program flow). */ 999 if (n1 > d1 || n0 >= d0) 1000 { 1001 q0 = 1; 1002 sub_ddmmss (n1, n0, n1, n0, d1, d0); 1003 } 1004 else 1005 q0 = 0; 1006 1007 q1 = 0; 1008 1009 if (rp != 0) 1010 { 1011 rr.s.low = n0; 1012 rr.s.high = n1; 1013 *rp = rr.ll; 1014 } 1015 } 1016 else 1017 { 1018 UWtype m1, m0; 1019 /* Normalize. */ 1020 1021 b = W_TYPE_SIZE - bm; 1022 1023 d1 = (d1 << bm) | (d0 >> b); 1024 d0 = d0 << bm; 1025 n2 = n1 >> b; 1026 n1 = (n1 << bm) | (n0 >> b); 1027 n0 = n0 << bm; 1028 1029 udiv_qrnnd (q0, n1, n2, n1, d1); 1030 umul_ppmm (m1, m0, q0, d0); 1031 1032 if (m1 > n1 || (m1 == n1 && m0 > n0)) 1033 { 1034 q0--; 1035 sub_ddmmss (m1, m0, m1, m0, d1, d0); 1036 } 1037 1038 q1 = 0; 1039 1040 /* Remainder in (n1n0 - m1m0) >> bm. */ 1041 if (rp != 0) 1042 { 1043 sub_ddmmss (n1, n0, n1, n0, m1, m0); 1044 rr.s.low = (n1 << b) | (n0 >> bm); 1045 rr.s.high = n1 >> bm; 1046 *rp = rr.ll; 1047 } 1048 } 1049 } 1050 } 1051 1052 const DWunion ww = {{.low = q0, .high = q1}}; 1053 return ww.ll; 1054} 1055#endif 1056 1057#ifdef L_divdi3 1058DWtype 1059__divdi3 (DWtype u, DWtype v) 1060{ 1061 word_type c = 0; 1062 DWunion uu = {.ll = u}; 1063 DWunion vv = {.ll = v}; 1064 DWtype w; 1065 1066 if (uu.s.high < 0) 1067 c = ~c, 1068 uu.ll = -uu.ll; 1069 if (vv.s.high < 0) 1070 c = ~c, 1071 vv.ll = -vv.ll; 1072 1073 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0); 1074 if (c) 1075 w = -w; 1076 1077 return w; 1078} 1079#endif 1080 1081#ifdef L_moddi3 1082DWtype 1083__moddi3 (DWtype u, DWtype v) 1084{ 1085 word_type c = 0; 1086 DWunion uu = {.ll = u}; 1087 DWunion vv = {.ll = v}; 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 1105UDWtype 1106__umoddi3 (UDWtype u, UDWtype v) 1107{ 1108 UDWtype w; 1109 1110 (void) __udivmoddi4 (u, v, &w); 1111 1112 return w; 1113} 1114#endif 1115 1116#ifdef L_udivdi3 1117UDWtype 1118__udivdi3 (UDWtype n, UDWtype d) 1119{ 1120 return __udivmoddi4 (n, d, (UDWtype *) 0); 1121} 1122#endif 1123 1124#ifdef L_cmpdi2 1125word_type 1126__cmpdi2 (DWtype a, DWtype b) 1127{ 1128 const DWunion au = {.ll = a}; 1129 const DWunion bu = {.ll = b}; 1130 1131 if (au.s.high < bu.s.high) 1132 return 0; 1133 else if (au.s.high > bu.s.high) 1134 return 2; 1135 if ((UWtype) au.s.low < (UWtype) bu.s.low) 1136 return 0; 1137 else if ((UWtype) au.s.low > (UWtype) bu.s.low) 1138 return 2; 1139 return 1; 1140} 1141#endif 1142 1143#ifdef L_ucmpdi2 1144word_type 1145__ucmpdi2 (DWtype a, DWtype b) 1146{ 1147 const DWunion au = {.ll = a}; 1148 const DWunion bu = {.ll = b}; 1149 1150 if ((UWtype) au.s.high < (UWtype) bu.s.high) 1151 return 0; 1152 else if ((UWtype) au.s.high > (UWtype) bu.s.high) 1153 return 2; 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 XFtype d = (Wtype) (u >> W_TYPE_SIZE); 1342 d *= Wtype_MAXp1_F; 1343 d += (UWtype)u; 1344 return d; 1345} 1346#endif 1347 1348#if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE 1349TFtype 1350__floatditf (DWtype u) 1351{ 1352 TFtype d = (Wtype) (u >> W_TYPE_SIZE); 1353 d *= Wtype_MAXp1_F; 1354 d += (UWtype)u; 1355 return d; 1356} 1357#endif 1358 1359#if defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE 1360DFtype 1361__floatdidf (DWtype u) 1362{ 1363 DFtype d = (Wtype) (u >> W_TYPE_SIZE); 1364 d *= Wtype_MAXp1_F; 1365 d += (UWtype)u; 1366 return d; 1367} 1368#endif 1369 1370#if defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE 1371#define DI_SIZE (W_TYPE_SIZE * 2) 1372#define SF_SIZE FLT_MANT_DIG 1373 1374SFtype 1375__floatdisf (DWtype u) 1376{ 1377#if SF_SIZE >= W_TYPE_SIZE 1378 /* When the word size is small, we never get any rounding error. */ 1379 SFtype f = (Wtype) (u >> W_TYPE_SIZE); 1380 f *= Wtype_MAXp1_F; 1381 f += (UWtype)u; 1382 return f; 1383#elif LIBGCC2_HAS_DF_MODE 1384 1385#if LIBGCC2_DOUBLE_TYPE_SIZE == 64 1386#define DF_SIZE DBL_MANT_DIG 1387#elif LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64 1388#define DF_SIZE LDBL_MANT_DIG 1389#else 1390# error 1391#endif 1392 1393#define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE)) 1394 1395 /* Protect against double-rounding error. 1396 Represent any low-order bits, that might be truncated by a bit that 1397 won't be lost. The bit can go in anywhere below the rounding position 1398 of the SFmode. A fixed mask and bit position handles all usual 1399 configurations. It doesn't handle the case of 128-bit DImode, however. */ 1400 if (DF_SIZE < DI_SIZE 1401 && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE)) 1402 { 1403 if (! (- ((DWtype) 1 << DF_SIZE) < u 1404 && u < ((DWtype) 1 << DF_SIZE))) 1405 { 1406 if ((UDWtype) u & (REP_BIT - 1)) 1407 { 1408 u &= ~ (REP_BIT - 1); 1409 u |= REP_BIT; 1410 } 1411 } 1412 } 1413 1414 /* Do the calculation in DFmode so that we don't lose any of the 1415 precision of the high word while multiplying it. */ 1416 DFtype f = (Wtype) (u >> W_TYPE_SIZE); 1417 f *= Wtype_MAXp1_F; 1418 f += (UWtype)u; 1419 return (SFtype) f; 1420#else 1421 /* Finally, the word size is larger than the number of bits in SFmode, 1422 and we've got no DFmode. The only way to avoid double rounding is 1423 to special case the extraction. */ 1424 1425 /* If there are no high bits set, fall back to one conversion. */ 1426 if ((Wtype)u == u) 1427 return (SFtype)(Wtype)u; 1428 1429 /* Otherwise, find the power of two. */ 1430 Wtype hi = u >> W_TYPE_SIZE; 1431 if (hi < 0) 1432 hi = -hi; 1433 1434 UWtype count, shift; 1435 count_leading_zeros (count, hi); 1436 1437 /* No leading bits means u == minimum. */ 1438 if (count == 0) 1439 return -(Wtype_MAXp1_F * Wtype_MAXp1_F / 2); 1440 1441 shift = W_TYPE_SIZE - count; 1442 1443 /* Shift down the most significant bits. */ 1444 hi = u >> shift; 1445 1446 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */ 1447 if (u & ((1 << shift) - 1)) 1448 hi |= 1; 1449 1450 /* Convert the one word of data, and rescale. */ 1451 SFtype f = hi; 1452 f *= (UWtype)1 << shift; 1453 return f; 1454#endif 1455} 1456#endif 1457 1458#if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE 1459/* Reenable the normal types, in case limits.h needs them. */ 1460#undef char 1461#undef short 1462#undef int 1463#undef long 1464#undef unsigned 1465#undef float 1466#undef double 1467#undef MIN 1468#undef MAX 1469#include <limits.h> 1470 1471UWtype 1472__fixunsxfSI (XFtype a) 1473{ 1474 if (a >= - (DFtype) Wtype_MIN) 1475 return (Wtype) (a + Wtype_MIN) - Wtype_MIN; 1476 return (Wtype) a; 1477} 1478#endif 1479 1480#if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE 1481/* Reenable the normal types, in case limits.h needs them. */ 1482#undef char 1483#undef short 1484#undef int 1485#undef long 1486#undef unsigned 1487#undef float 1488#undef double 1489#undef MIN 1490#undef MAX 1491#include <limits.h> 1492 1493UWtype 1494__fixunsdfSI (DFtype a) 1495{ 1496 if (a >= - (DFtype) Wtype_MIN) 1497 return (Wtype) (a + Wtype_MIN) - Wtype_MIN; 1498 return (Wtype) a; 1499} 1500#endif 1501 1502#if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE 1503/* Reenable the normal types, in case limits.h needs them. */ 1504#undef char 1505#undef short 1506#undef int 1507#undef long 1508#undef unsigned 1509#undef float 1510#undef double 1511#undef MIN 1512#undef MAX 1513#include <limits.h> 1514 1515UWtype 1516__fixunssfSI (SFtype a) 1517{ 1518 if (a >= - (SFtype) Wtype_MIN) 1519 return (Wtype) (a + Wtype_MIN) - Wtype_MIN; 1520 return (Wtype) a; 1521} 1522#endif 1523 1524/* Integer power helper used from __builtin_powi for non-constant 1525 exponents. */ 1526 1527#if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \ 1528 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \ 1529 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \ 1530 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE) 1531# if defined(L_powisf2) 1532# define TYPE SFtype 1533# define NAME __powisf2 1534# elif defined(L_powidf2) 1535# define TYPE DFtype 1536# define NAME __powidf2 1537# elif defined(L_powixf2) 1538# define TYPE XFtype 1539# define NAME __powixf2 1540# elif defined(L_powitf2) 1541# define TYPE TFtype 1542# define NAME __powitf2 1543# endif 1544 1545#undef int 1546#undef unsigned 1547TYPE 1548NAME (TYPE x, int m) 1549{ 1550 unsigned int n = m < 0 ? -m : m; 1551 TYPE y = n % 2 ? x : 1; 1552 while (n >>= 1) 1553 { 1554 x = x * x; 1555 if (n % 2) 1556 y = y * x; 1557 } 1558 return m < 0 ? 1/y : y; 1559} 1560 1561#endif 1562 1563#if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \ 1564 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \ 1565 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \ 1566 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE) 1567 1568#undef float 1569#undef double 1570#undef long 1571 1572#if defined(L_mulsc3) || defined(L_divsc3) 1573# define MTYPE SFtype 1574# define CTYPE SCtype 1575# define MODE sc 1576# define CEXT f 1577# define NOTRUNC __FLT_EVAL_METHOD__ == 0 1578#elif defined(L_muldc3) || defined(L_divdc3) 1579# define MTYPE DFtype 1580# define CTYPE DCtype 1581# define MODE dc 1582# if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64 1583# define CEXT l 1584# define NOTRUNC 1 1585# else 1586# define CEXT 1587# define NOTRUNC __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1 1588# endif 1589#elif defined(L_mulxc3) || defined(L_divxc3) 1590# define MTYPE XFtype 1591# define CTYPE XCtype 1592# define MODE xc 1593# define CEXT l 1594# define NOTRUNC 1 1595#elif defined(L_multc3) || defined(L_divtc3) 1596# define MTYPE TFtype 1597# define CTYPE TCtype 1598# define MODE tc 1599# define CEXT l 1600# define NOTRUNC 1 1601#else 1602# error 1603#endif 1604 1605#define CONCAT3(A,B,C) _CONCAT3(A,B,C) 1606#define _CONCAT3(A,B,C) A##B##C 1607 1608#define CONCAT2(A,B) _CONCAT2(A,B) 1609#define _CONCAT2(A,B) A##B 1610 1611/* All of these would be present in a full C99 implementation of <math.h> 1612 and <complex.h>. Our problem is that only a few systems have such full 1613 implementations. Further, libgcc_s.so isn't currently linked against 1614 libm.so, and even for systems that do provide full C99, the extra overhead 1615 of all programs using libgcc having to link against libm. So avoid it. */ 1616 1617#define isnan(x) __builtin_expect ((x) != (x), 0) 1618#define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1) 1619#define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0) 1620 1621#if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT 1622#define INFINITY CONCAT2(__builtin_inf, CEXT) () 1623#endif 1624#define I 1i 1625 1626/* Helpers to make the following code slightly less gross. */ 1627#define COPYSIGN CONCAT2(__builtin_copysign, CEXT) 1628#define FABS CONCAT2(__builtin_fabs, CEXT) 1629 1630/* Verify that MTYPE matches up with CEXT. */ 1631#ifdef INFINITY 1632extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1]; 1633#endif 1634 1635/* Ensure that we've lost any extra precision. */ 1636#if NOTRUNC 1637# define TRUNC(x) 1638#else 1639# define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x)) 1640#endif 1641 1642#if defined(L_mulsc3) || defined(L_muldc3) \ 1643 || defined(L_mulxc3) || defined(L_multc3) 1644 1645CTYPE 1646CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d) 1647{ 1648 MTYPE ac, bd, ad, bc, x, y; 1649 1650 ac = a * c; 1651 bd = b * d; 1652 ad = a * d; 1653 bc = b * c; 1654 1655 TRUNC (ac); 1656 TRUNC (bd); 1657 TRUNC (ad); 1658 TRUNC (bc); 1659 1660 x = ac - bd; 1661 y = ad + bc; 1662 1663#ifdef INFINITY 1664 if (isnan (x) && isnan (y)) 1665 { 1666 /* Recover infinities that computed as NaN + iNaN. */ 1667 _Bool recalc = 0; 1668 if (isinf (a) || isinf (b)) 1669 { 1670 /* z is infinite. "Box" the infinity and change NaNs in 1671 the other factor to 0. */ 1672 a = COPYSIGN (isinf (a) ? 1 : 0, a); 1673 b = COPYSIGN (isinf (b) ? 1 : 0, b); 1674 if (isnan (c)) c = COPYSIGN (0, c); 1675 if (isnan (d)) d = COPYSIGN (0, d); 1676 recalc = 1; 1677 } 1678 if (isinf (c) || isinf (d)) 1679 { 1680 /* w is infinite. "Box" the infinity and change NaNs in 1681 the other factor to 0. */ 1682 c = COPYSIGN (isinf (c) ? 1 : 0, c); 1683 d = COPYSIGN (isinf (d) ? 1 : 0, d); 1684 if (isnan (a)) a = COPYSIGN (0, a); 1685 if (isnan (b)) b = COPYSIGN (0, b); 1686 recalc = 1; 1687 } 1688 if (!recalc 1689 && (isinf (ac) || isinf (bd) 1690 || isinf (ad) || isinf (bc))) 1691 { 1692 /* Recover infinities from overflow by changing NaNs to 0. */ 1693 if (isnan (a)) a = COPYSIGN (0, a); 1694 if (isnan (b)) b = COPYSIGN (0, b); 1695 if (isnan (c)) c = COPYSIGN (0, c); 1696 if (isnan (d)) d = COPYSIGN (0, d); 1697 recalc = 1; 1698 } 1699 if (recalc) 1700 { 1701 x = INFINITY * (a * c - b * d); 1702 y = INFINITY * (a * d + b * c); 1703 } 1704 } 1705#endif 1706 1707 return x + I * y; 1708} 1709#endif /* complex multiply */ 1710 1711#if defined(L_divsc3) || defined(L_divdc3) \ 1712 || defined(L_divxc3) || defined(L_divtc3) 1713 1714CTYPE 1715CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d) 1716{ 1717 MTYPE denom, ratio, x, y; 1718 1719 /* ??? We can get better behavior from logarithmic scaling instead of 1720 the division. But that would mean starting to link libgcc against 1721 libm. We could implement something akin to ldexp/frexp as gcc builtins 1722 fairly easily... */ 1723 if (FABS (c) < FABS (d)) 1724 { 1725 ratio = c / d; 1726 denom = (c * ratio) + d; 1727 x = ((a * ratio) + b) / denom; 1728 y = ((b * ratio) - a) / denom; 1729 } 1730 else 1731 { 1732 ratio = d / c; 1733 denom = (d * ratio) + c; 1734 x = ((b * ratio) + a) / denom; 1735 y = (b - (a * ratio)) / denom; 1736 } 1737 1738 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases 1739 are nonzero/zero, infinite/finite, and finite/infinite. */ 1740#ifdef INFINITY 1741 if (isnan (x) && isnan (y)) 1742 { 1743 if (c == 0.0 && d == 0.0 && (!isnan (a) || !isnan (b))) 1744 { 1745 x = COPYSIGN (INFINITY, c) * a; 1746 y = COPYSIGN (INFINITY, c) * b; 1747 } 1748 else if ((isinf (a) || isinf (b)) && isfinite (c) && isfinite (d)) 1749 { 1750 a = COPYSIGN (isinf (a) ? 1 : 0, a); 1751 b = COPYSIGN (isinf (b) ? 1 : 0, b); 1752 x = INFINITY * (a * c + b * d); 1753 y = INFINITY * (b * c - a * d); 1754 } 1755 else if ((isinf (c) || isinf (d)) && isfinite (a) && isfinite (b)) 1756 { 1757 c = COPYSIGN (isinf (c) ? 1 : 0, c); 1758 d = COPYSIGN (isinf (d) ? 1 : 0, d); 1759 x = 0.0 * (a * c + b * d); 1760 y = 0.0 * (b * c - a * d); 1761 } 1762 } 1763#endif 1764 1765 return x + I * y; 1766} 1767#endif /* complex divide */ 1768#undef INFINITY 1769#endif /* all complex float routines */ 1770 1771/* From here on down, the routines use normal data types. */ 1772 1773#define SItype bogus_type 1774#define USItype bogus_type 1775#define DItype bogus_type 1776#define UDItype bogus_type 1777#define SFtype bogus_type 1778#define DFtype bogus_type 1779#undef Wtype 1780#undef UWtype 1781#undef HWtype 1782#undef UHWtype 1783#undef DWtype 1784#undef UDWtype 1785 1786#undef char 1787#undef short 1788#undef int 1789#undef long 1790#undef unsigned 1791#undef float 1792#undef double 1793 1794#ifdef L__gcc_bcmp 1795 1796/* Like bcmp except the sign is meaningful. 1797 Result is negative if S1 is less than S2, 1798 positive if S1 is greater, 0 if S1 and S2 are equal. */ 1799 1800int 1801__gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size) 1802{ 1803 while (size > 0) 1804 { 1805 const unsigned char c1 = *s1++, c2 = *s2++; 1806 if (c1 != c2) 1807 return c1 - c2; 1808 size--; 1809 } 1810 return 0; 1811} 1812 1813#endif 1814 1815/* __eprintf used to be used by GCC's private version of <assert.h>. 1816 We no longer provide that header, but this routine remains in libgcc.a 1817 for binary backward compatibility. Note that it is not included in 1818 the shared version of libgcc. */ 1819#ifdef L_eprintf 1820#ifndef inhibit_libc 1821 1822#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */ 1823#include <stdio.h> 1824 1825void 1826__eprintf (const char *string, const char *expression, 1827 unsigned int line, const char *filename) 1828{ 1829 fprintf (stderr, string, expression, line, filename); 1830 fflush (stderr); 1831 abort (); 1832} 1833 1834#endif 1835#endif 1836 1837 1838#ifdef L_clear_cache 1839/* Clear part of an instruction cache. */ 1840 1841void 1842__clear_cache (char *beg __attribute__((__unused__)), 1843 char *end __attribute__((__unused__))) 1844{ 1845#ifdef CLEAR_INSN_CACHE 1846 CLEAR_INSN_CACHE (beg, end); 1847#endif /* CLEAR_INSN_CACHE */ 1848} 1849 1850#endif /* L_clear_cache */ 1851 1852#ifdef L_enable_execute_stack 1853/* Attempt to turn on execute permission for the stack. */ 1854 1855#ifdef ENABLE_EXECUTE_STACK 1856 ENABLE_EXECUTE_STACK 1857#else 1858void 1859__enable_execute_stack (void *addr __attribute__((__unused__))) 1860{} 1861#endif /* ENABLE_EXECUTE_STACK */ 1862 1863#endif /* L_enable_execute_stack */ 1864 1865#ifdef L_trampoline 1866 1867/* Jump to a trampoline, loading the static chain address. */ 1868 1869#if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN) 1870 1871int 1872getpagesize (void) 1873{ 1874#ifdef _ALPHA_ 1875 return 8192; 1876#else 1877 return 4096; 1878#endif 1879} 1880 1881#ifdef __i386__ 1882extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall)); 1883#endif 1884 1885int 1886mprotect (char *addr, int len, int prot) 1887{ 1888 int np, op; 1889 1890 if (prot == 7) 1891 np = 0x40; 1892 else if (prot == 5) 1893 np = 0x20; 1894 else if (prot == 4) 1895 np = 0x10; 1896 else if (prot == 3) 1897 np = 0x04; 1898 else if (prot == 1) 1899 np = 0x02; 1900 else if (prot == 0) 1901 np = 0x01; 1902 1903 if (VirtualProtect (addr, len, np, &op)) 1904 return 0; 1905 else 1906 return -1; 1907} 1908 1909#endif /* WINNT && ! __CYGWIN__ && ! _UWIN */ 1910 1911#ifdef TRANSFER_FROM_TRAMPOLINE 1912TRANSFER_FROM_TRAMPOLINE 1913#endif 1914#endif /* L_trampoline */ 1915 1916#ifndef __CYGWIN__ 1917#ifdef L__main 1918 1919#include "gbl-ctors.h" 1920 1921/* Some systems use __main in a way incompatible with its use in gcc, in these 1922 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to 1923 give the same symbol without quotes for an alternative entry point. You 1924 must define both, or neither. */ 1925#ifndef NAME__MAIN 1926#define NAME__MAIN "__main" 1927#define SYMBOL__MAIN __main 1928#endif 1929 1930#if defined (INIT_SECTION_ASM_OP) || defined (INIT_ARRAY_SECTION_ASM_OP) 1931#undef HAS_INIT_SECTION 1932#define HAS_INIT_SECTION 1933#endif 1934 1935#if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF) 1936 1937/* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this 1938 code to run constructors. In that case, we need to handle EH here, too. */ 1939 1940#ifdef EH_FRAME_SECTION_NAME 1941#include "unwind-dw2-fde.h" 1942extern unsigned char __EH_FRAME_BEGIN__[]; 1943#endif 1944 1945/* Run all the global destructors on exit from the program. */ 1946 1947void 1948__do_global_dtors (void) 1949{ 1950#ifdef DO_GLOBAL_DTORS_BODY 1951 DO_GLOBAL_DTORS_BODY; 1952#else 1953 static func_ptr *p = __DTOR_LIST__ + 1; 1954 while (*p) 1955 { 1956 p++; 1957 (*(p-1)) (); 1958 } 1959#endif 1960#if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION) 1961 { 1962 static int completed = 0; 1963 if (! completed) 1964 { 1965 completed = 1; 1966 __deregister_frame_info (__EH_FRAME_BEGIN__); 1967 } 1968 } 1969#endif 1970} 1971#endif 1972 1973#ifndef HAS_INIT_SECTION 1974/* Run all the global constructors on entry to the program. */ 1975 1976void 1977__do_global_ctors (void) 1978{ 1979#ifdef EH_FRAME_SECTION_NAME 1980 { 1981 static struct object object; 1982 __register_frame_info (__EH_FRAME_BEGIN__, &object); 1983 } 1984#endif 1985 DO_GLOBAL_CTORS_BODY; 1986 atexit (__do_global_dtors); 1987} 1988#endif /* no HAS_INIT_SECTION */ 1989 1990#if !defined (HAS_INIT_SECTION) || defined (INVOKE__main) 1991/* Subroutine called automatically by `main'. 1992 Compiling a global function named `main' 1993 produces an automatic call to this function at the beginning. 1994 1995 For many systems, this routine calls __do_global_ctors. 1996 For systems which support a .init section we use the .init section 1997 to run __do_global_ctors, so we need not do anything here. */ 1998 1999extern void SYMBOL__MAIN (void); 2000void 2001SYMBOL__MAIN (void) 2002{ 2003 /* Support recursive calls to `main': run initializers just once. */ 2004 static int initialized; 2005 if (! initialized) 2006 { 2007 initialized = 1; 2008 __do_global_ctors (); 2009 } 2010} 2011#endif /* no HAS_INIT_SECTION or INVOKE__main */ 2012 2013#endif /* L__main */ 2014#endif /* __CYGWIN__ */ 2015 2016#ifdef L_ctors 2017 2018#include "gbl-ctors.h" 2019 2020/* Provide default definitions for the lists of constructors and 2021 destructors, so that we don't get linker errors. These symbols are 2022 intentionally bss symbols, so that gld and/or collect will provide 2023 the right values. */ 2024 2025/* We declare the lists here with two elements each, 2026 so that they are valid empty lists if no other definition is loaded. 2027 2028 If we are using the old "set" extensions to have the gnu linker 2029 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__ 2030 must be in the bss/common section. 2031 2032 Long term no port should use those extensions. But many still do. */ 2033#if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY) 2034#if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2) 2035func_ptr __CTOR_LIST__[2] = {0, 0}; 2036func_ptr __DTOR_LIST__[2] = {0, 0}; 2037#else 2038func_ptr __CTOR_LIST__[2]; 2039func_ptr __DTOR_LIST__[2]; 2040#endif 2041#endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */ 2042#endif /* L_ctors */ 2043#endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */ 2044