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