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 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 3, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17Under Section 7 of GPL version 3, you are granted additional 18permissions described in the GCC Runtime Library Exception, version 193.1, as published by the Free Software Foundation. 20 21You should have received a copy of the GNU General Public License and 22a copy of the GCC Runtime Library Exception along with this program; 23see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 24<http://www.gnu.org/licenses/>. */ 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) 63DWtype 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 75Wtype 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 86SItype 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 100DWtype 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 113Wtype 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 124SItype 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 138DWtype 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 151Wtype 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) 164SItype 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 178Wtype 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 189SItype 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 203DWtype 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 216Wtype 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 234SItype 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 255DWtype 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 275DWtype 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 402DWtype 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 430DWtype 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 458DWtype 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 487SItype 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 497DItype 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 512int 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 527int 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 546DWtype 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)) 571static inline __attribute__ ((__always_inline__)) 572#endif 573UWtype 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 c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */ 589 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1)); 590 /* Divide (c1*2^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^32*b1, so A/2 < 2^31*b1 */ 603 { 604 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */ 605 606 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */ 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 = 2*r + (a0 & 1); /* A/(2*b1) */ 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 = 2*b1 - 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. */ 671UWtype 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 688const 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 703int 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 716int 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 735int 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 748int 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 767int 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 783int 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 809const 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 839int 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 863int 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 893int 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 914int 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)) 941static inline __attribute__ ((__always_inline__)) 942#endif 943UDWtype 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)) 1008static inline __attribute__ ((__always_inline__)) 1009#endif 1010UDWtype 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 1226DWtype 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 1250DWtype 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 1273UDWtype 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 1285UDWtype 1286__udivdi3 (UDWtype n, UDWtype d) 1287{ 1288 return __udivmoddi4 (n, d, (UDWtype *) 0); 1289} 1290#endif 1291 1292#ifdef L_cmpdi2 1293cmp_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 1312cmp_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 1331UDWtype 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 1357DWtype 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 1367UDWtype 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 1393DWtype 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 1403UDWtype 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 1422DWtype 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 1432UDWtype 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 1496DWtype 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 1506XFtype 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 1520XFtype 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 1534TFtype 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 1548TFtype 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 1578FSTYPE 1579FUNC (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 1694FSTYPE 1695FUNC (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 1787UWtype 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 1797UWtype 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 1807UWtype 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 1839TYPE 1840NAME (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 <math.h> 1899 and <complex.h>. 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. */ 1916extern 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 1928CTYPE 1929CONCAT3(__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 1998CTYPE 1999CONCAT3(__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 2085int 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 <assert.h>. 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 <stdio.h> 2109 2110void 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 2126void 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 <windows.h> 2143int getpagesize (void); 2144int mprotect (char *,int, int); 2145 2146int 2147getpagesize (void) 2148{ 2149#ifdef _ALPHA_ 2150 return 8192; 2151#else 2152 return 4096; 2153#endif 2154} 2155 2156int 2157mprotect (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 2185TRANSFER_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" 2221extern unsigned char __EH_FRAME_BEGIN__[]; 2222#endif 2223 2224/* Run all the global destructors on exit from the program. */ 2225 2226void 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 2255void 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 2278extern void SYMBOL__MAIN (void); 2279void 2280SYMBOL__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) 2315func_ptr __CTOR_LIST__[2] = {0, 0}; 2316func_ptr __DTOR_LIST__[2] = {0, 0}; 2317#else 2318func_ptr __CTOR_LIST__[2]; 2319func_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 */ 2324