gcc/libgcc1.c

   1 /* Subroutines needed by GCC output code on some machines.  */
   2 /* Compile this file with the Unix C compiler!  */
   3 /* Copyright (C) 1987, 1988, 1992, 1994, 1995 Free Software Foundation, Inc.
   4
   5 This file is free software; you can redistribute it and/or modify it
   6 under the terms of the GNU General Public License as published by the
   7 Free Software Foundation; either version 2, or (at your option) any
   8 later version.
   9
  10 In addition to the permissions in the GNU General Public License, the
  11 Free Software Foundation gives you unlimited permission to link the
  12 compiled version of this file with other programs, and to distribute
  13 those programs without any restriction coming from the use of this
  14 file.  (The General Public License restrictions do apply in other
  15 respects; for example, they cover modification of the file, and
  16 distribution when not linked into another program.)
  17
  18 This file is distributed in the hope that it will be useful, but
  19 WITHOUT ANY WARRANTY; without even the implied warranty of
  20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 General Public License for more details.
  22
  23 You should have received a copy of the GNU General Public License
  24 along with this program; see the file COPYING.  If not, write to
  25 the Free Software Foundation, 59 Temple Place - Suite 330,
  26 Boston, MA 02111-1307, USA.  */
  27
  28 /* As a special exception, if you link this library with other files,
  29    some of which are compiled with GCC, to produce an executable,
  30    this library does not by itself cause the resulting executable
  31    to be covered by the GNU General Public License.
  32    This exception does not however invalidate any other reasons why
  33    the executable file might be covered by the GNU General Public License.  */
  34
  35 #include "config.h"
  36
  37 /* Don't use `fancy_abort' here even if config.h says to use it.  */
  38 #ifdef abort
  39 #undef abort
  40 #endif
  41
  42 /* On some machines, cc is really GCC.  For these machines, we can't
  43    expect these functions to be properly compiled unless GCC open codes
  44    the operation (which is precisely when the function won't be used).
  45    So allow tm.h to specify ways of accomplishing the operations
  46    by defining the macros perform_*.
  47
  48    On a machine where cc is some other compiler, there is usually no
  49    reason to define perform_*.  The other compiler normally has other ways
  50    of implementing all of these operations.
  51
  52    In some cases a certain machine may come with GCC installed as cc
  53    or may have some other compiler.  Then it may make sense for tm.h
  54    to define perform_* only if __GNUC__ is defined.  */
  55
  56 #ifndef perform_mulsi3
  57 #define perform_mulsi3(a, b) return a * b
  58 #endif
  59
  60 #ifndef perform_divsi3
  61 #define perform_divsi3(a, b) return a / b
  62 #endif
  63
  64 #ifndef perform_udivsi3
  65 #define perform_udivsi3(a, b) return a / b
  66 #endif
  67
  68 #ifndef perform_modsi3
  69 #define perform_modsi3(a, b) return a % b
  70 #endif
  71
  72 #ifndef perform_umodsi3
  73 #define perform_umodsi3(a, b) return a % b
  74 #endif
  75
  76 #ifndef perform_lshrsi3
  77 #define perform_lshrsi3(a, b) return a >> b
  78 #endif
  79
  80 #ifndef perform_ashrsi3
  81 #define perform_ashrsi3(a, b) return a >> b
  82 #endif
  83
  84 #ifndef perform_ashlsi3
  85 #define perform_ashlsi3(a, b) return a << b
  86 #endif
  87
  88 #ifndef perform_adddf3
  89 #define perform_adddf3(a, b) return a + b
  90 #endif
  91
  92 #ifndef perform_subdf3
  93 #define perform_subdf3(a, b) return a - b
  94 #endif
  95
  96 #ifndef perform_muldf3
  97 #define perform_muldf3(a, b) return a * b
  98 #endif
  99
 100 #ifndef perform_divdf3
 101 #define perform_divdf3(a, b) return a / b
 102 #endif
 103
 104 #ifndef perform_addsf3
 105 #define perform_addsf3(a, b) return INTIFY (a + b)
 106 #endif
 107
 108 #ifndef perform_subsf3
 109 #define perform_subsf3(a, b) return INTIFY (a - b)
 110 #endif
 111
 112 #ifndef perform_mulsf3
 113 #define perform_mulsf3(a, b) return INTIFY (a * b)
 114 #endif
 115
 116 #ifndef perform_divsf3
 117 #define perform_divsf3(a, b) return INTIFY (a / b)
 118 #endif
 119
 120 #ifndef perform_negdf2
 121 #define perform_negdf2(a) return -a
 122 #endif
 123
 124 #ifndef perform_negsf2
 125 #define perform_negsf2(a) return INTIFY (-a)
 126 #endif
 127
 128 #ifndef perform_fixdfsi
 129 #define perform_fixdfsi(a) return (nongcc_SI_type) a;
 130 #endif
 131
 132 #ifndef perform_fixsfsi
 133 #define perform_fixsfsi(a) return (nongcc_SI_type) a
 134 #endif
 135
 136 #ifndef perform_floatsidf
 137 #define perform_floatsidf(a) return (double) a
 138 #endif
 139
 140 #ifndef perform_floatsisf
 141 #define perform_floatsisf(a)  return INTIFY ((float) a)
 142 #endif
 143
 144 #ifndef perform_extendsfdf2
 145 #define perform_extendsfdf2(a)  return a
 146 #endif
 147
 148 #ifndef perform_truncdfsf2
 149 #define perform_truncdfsf2(a)  return INTIFY (a)
 150 #endif
 151
 152 /* Note that eqdf2 returns a value for "true" that is == 0,
 153    nedf2 returns a value for "true" that is != 0,
 154    gtdf2 returns a value for "true" that is > 0,
 155    and so on.  */
 156
 157 #ifndef perform_eqdf2
 158 #define perform_eqdf2(a, b) return !(a == b)
 159 #endif
 160
 161 #ifndef perform_nedf2
 162 #define perform_nedf2(a, b) return a != b
 163 #endif
 164
 165 #ifndef perform_gtdf2
 166 #define perform_gtdf2(a, b) return a > b
 167 #endif
 168
 169 #ifndef perform_gedf2
 170 #define perform_gedf2(a, b) return (a >= b) - 1
 171 #endif
 172
 173 #ifndef perform_ltdf2
 174 #define perform_ltdf2(a, b) return -(a < b)
 175 #endif
 176
 177 #ifndef perform_ledf2
 178 #define perform_ledf2(a, b) return 1 - (a <= b)
 179 #endif
 180
 181 #ifndef perform_eqsf2
 182 #define perform_eqsf2(a, b) return !(a == b)
 183 #endif
 184
 185 #ifndef perform_nesf2
 186 #define perform_nesf2(a, b) return a != b
 187 #endif
 188
 189 #ifndef perform_gtsf2
 190 #define perform_gtsf2(a, b) return a > b
 191 #endif
 192
 193 #ifndef perform_gesf2
 194 #define perform_gesf2(a, b) return (a >= b) - 1
 195 #endif
 196
 197 #ifndef perform_ltsf2
 198 #define perform_ltsf2(a, b) return -(a < b)
 199 #endif
 200
 201 #ifndef perform_lesf2
 202 #define perform_lesf2(a, b) return 1 - (a <= b);
 203 #endif
 204 \f
 205 /* Define the C data type to use for an SImode value.  */
 206
 207 #ifndef nongcc_SI_type
 208 #define nongcc_SI_type long int
 209 #endif
 210
 211 /* Define the C data type to use for a value of word size */
 212 #ifndef nongcc_word_type
 213 #define nongcc_word_type nongcc_SI_type
 214 #endif
 215
 216 /* Define the type to be used for returning an SF mode value
 217    and the method for turning a float into that type.
 218    These definitions work for machines where an SF value is
 219    returned in the same register as an int.  */
 220
 221 #ifndef FLOAT_VALUE_TYPE
 222 #define FLOAT_VALUE_TYPE int
 223 #endif
 224
 225 #ifndef INTIFY
 226 #define INTIFY(FLOATVAL)  (intify.f = (FLOATVAL), intify.i)
 227 #endif
 228
 229 #ifndef FLOATIFY
 230 #define FLOATIFY(INTVAL)  ((INTVAL).f)
 231 #endif
 232
 233 #ifndef FLOAT_ARG_TYPE
 234 #define FLOAT_ARG_TYPE union flt_or_int
 235 #endif
 236
 237 union flt_or_value { FLOAT_VALUE_TYPE i; float f; };
 238
 239 union flt_or_int { int i; float f; };
 240
 241
 242 #ifdef L_mulsi3
 243 nongcc_SI_type
 244 __mulsi3 (a, b)
 245      nongcc_SI_type a, b;
 246 {
 247   perform_mulsi3 (a, b);
 248 }
 249 #endif
 250
 251 #ifdef L_udivsi3
 252 nongcc_SI_type
 253 __udivsi3 (a, b)
 254      unsigned nongcc_SI_type a, b;
 255 {
 256   perform_udivsi3 (a, b);
 257 }
 258 #endif
 259
 260 #ifdef L_divsi3
 261 nongcc_SI_type
 262 __divsi3 (a, b)
 263      nongcc_SI_type a, b;
 264 {
 265   perform_divsi3 (a, b);
 266 }
 267 #endif
 268
 269 #ifdef L_umodsi3
 270 nongcc_SI_type
 271 __umodsi3 (a, b)
 272      unsigned nongcc_SI_type a, b;
 273 {
 274   perform_umodsi3 (a, b);
 275 }
 276 #endif
 277
 278 #ifdef L_modsi3
 279 nongcc_SI_type
 280 __modsi3 (a, b)
 281      nongcc_SI_type a, b;
 282 {
 283   perform_modsi3 (a, b);
 284 }
 285 #endif
 286
 287 #ifdef L_lshrsi3
 288 nongcc_SI_type
 289 __lshrsi3 (a, b)
 290      unsigned nongcc_SI_type a, b;
 291 {
 292   perform_lshrsi3 (a, b);
 293 }
 294 #endif
 295
 296 #ifdef L_ashrsi3
 297 nongcc_SI_type
 298 __ashrsi3 (a, b)
 299      nongcc_SI_type a, b;
 300 {
 301   perform_ashrsi3 (a, b);
 302 }
 303 #endif
 304
 305 #ifdef L_ashlsi3
 306 nongcc_SI_type
 307 __ashlsi3 (a, b)
 308      nongcc_SI_type a, b;
 309 {
 310   perform_ashlsi3 (a, b);
 311 }
 312 #endif
 313 \f
 314 #ifdef L_divdf3
 315 double
 316 __divdf3 (a, b)
 317      double a, b;
 318 {
 319   perform_divdf3 (a, b);
 320 }
 321 #endif
 322
 323 #ifdef L_muldf3
 324 double
 325 __muldf3 (a, b)
 326      double a, b;
 327 {
 328   perform_muldf3 (a, b);
 329 }
 330 #endif
 331
 332 #ifdef L_negdf2
 333 double
 334 __negdf2 (a)
 335      double a;
 336 {
 337   perform_negdf2 (a);
 338 }
 339 #endif
 340
 341 #ifdef L_adddf3
 342 double
 343 __adddf3 (a, b)
 344      double a, b;
 345 {
 346   perform_adddf3 (a, b);
 347 }
 348 #endif
 349
 350 #ifdef L_subdf3
 351 double
 352 __subdf3 (a, b)
 353      double a, b;
 354 {
 355   perform_subdf3 (a, b);
 356 }
 357 #endif
 358
 359 /* Note that eqdf2 returns a value for "true" that is == 0,
 360    nedf2 returns a value for "true" that is != 0,
 361    gtdf2 returns a value for "true" that is > 0,
 362    and so on.  */
 363
 364 #ifdef L_eqdf2
 365 nongcc_word_type
 366 __eqdf2 (a, b)
 367      double a, b;
 368 {
 369   /* Value == 0 iff a == b.  */
 370   perform_eqdf2 (a, b);
 371 }
 372 #endif
 373
 374 #ifdef L_nedf2
 375 nongcc_word_type
 376 __nedf2 (a, b)
 377      double a, b;
 378 {
 379   /* Value != 0 iff a != b.  */
 380   perform_nedf2 (a, b);
 381 }
 382 #endif
 383
 384 #ifdef L_gtdf2
 385 nongcc_word_type
 386 __gtdf2 (a, b)
 387      double a, b;
 388 {
 389   /* Value > 0 iff a > b.  */
 390   perform_gtdf2 (a, b);
 391 }
 392 #endif
 393
 394 #ifdef L_gedf2
 395 nongcc_word_type
 396 __gedf2 (a, b)
 397      double a, b;
 398 {
 399   /* Value >= 0 iff a >= b.  */
 400   perform_gedf2 (a, b);
 401 }
 402 #endif
 403
 404 #ifdef L_ltdf2
 405 nongcc_word_type
 406 __ltdf2 (a, b)
 407      double a, b;
 408 {
 409   /* Value < 0 iff a < b.  */
 410   perform_ltdf2 (a, b);
 411 }
 412 #endif
 413
 414 #ifdef L_ledf2
 415 nongcc_word_type
 416 __ledf2 (a, b)
 417      double a, b;
 418 {
 419   /* Value <= 0 iff a <= b.  */
 420   perform_ledf2 (a, b);
 421 }
 422 #endif
 423 \f
 424 #ifdef L_fixdfsi
 425 nongcc_SI_type
 426 __fixdfsi (a)
 427      double a;
 428 {
 429   perform_fixdfsi (a);
 430 }
 431 #endif
 432
 433 #ifdef L_fixsfsi
 434 nongcc_SI_type
 435 __fixsfsi (a)
 436      FLOAT_ARG_TYPE a;
 437 {
 438   union flt_or_value intify;
 439   perform_fixsfsi (FLOATIFY (a));
 440 }
 441 #endif
 442
 443 #ifdef L_floatsidf
 444 double
 445 __floatsidf (a)
 446      nongcc_SI_type a;
 447 {
 448   perform_floatsidf (a);
 449 }
 450 #endif
 451
 452 #ifdef L_floatsisf
 453 FLOAT_VALUE_TYPE
 454 __floatsisf (a)
 455      nongcc_SI_type a;
 456 {
 457   union flt_or_value intify;
 458   perform_floatsisf (a);
 459 }
 460 #endif
 461 \f
 462 #ifdef L_addsf3
 463 FLOAT_VALUE_TYPE
 464 __addsf3 (a, b)
 465      FLOAT_ARG_TYPE a, b;
 466 {
 467   union flt_or_value intify;
 468   perform_addsf3 (FLOATIFY (a), FLOATIFY (b));
 469 }
 470 #endif
 471
 472 #ifdef L_negsf2
 473 FLOAT_VALUE_TYPE
 474 __negsf2 (a)
 475      FLOAT_ARG_TYPE a;
 476 {
 477   union flt_or_value intify;
 478   perform_negsf2 (FLOATIFY (a));
 479 }
 480 #endif
 481
 482 #ifdef L_subsf3
 483 FLOAT_VALUE_TYPE
 484 __subsf3 (a, b)
 485      FLOAT_ARG_TYPE a, b;
 486 {
 487   union flt_or_value intify;
 488   perform_subsf3 (FLOATIFY (a), FLOATIFY (b));
 489 }
 490 #endif
 491
 492 #ifdef L_eqsf2
 493 nongcc_word_type
 494 __eqsf2 (a, b)
 495      FLOAT_ARG_TYPE a, b;
 496 {
 497   union flt_or_int intify;
 498   /* Value == 0 iff a == b.  */
 499   perform_eqsf2 (FLOATIFY (a), FLOATIFY (b));
 500 }
 501 #endif
 502
 503 #ifdef L_nesf2
 504 nongcc_word_type
 505 __nesf2 (a, b)
 506      FLOAT_ARG_TYPE a, b;
 507 {
 508   union flt_or_int intify;
 509   /* Value != 0 iff a != b.  */
 510   perform_nesf2 (FLOATIFY (a), FLOATIFY (b));
 511 }
 512 #endif
 513
 514 #ifdef L_gtsf2
 515 nongcc_word_type
 516 __gtsf2 (a, b)
 517      FLOAT_ARG_TYPE a, b;
 518 {
 519   union flt_or_int intify;
 520   /* Value > 0 iff a > b.  */
 521   perform_gtsf2 (FLOATIFY (a), FLOATIFY (b));
 522 }
 523 #endif
 524
 525 #ifdef L_gesf2
 526 nongcc_word_type
 527 __gesf2 (a, b)
 528      FLOAT_ARG_TYPE a, b;
 529 {
 530   union flt_or_int intify;
 531   /* Value >= 0 iff a >= b.  */
 532   perform_gesf2 (FLOATIFY (a), FLOATIFY (b));
 533 }
 534 #endif
 535
 536 #ifdef L_ltsf2
 537 nongcc_word_type
 538 __ltsf2 (a, b)
 539      FLOAT_ARG_TYPE a, b;
 540 {
 541   union flt_or_int intify;
 542   /* Value < 0 iff a < b.  */
 543   perform_ltsf2 (FLOATIFY (a), FLOATIFY (b));
 544 }
 545 #endif
 546
 547 #ifdef L_lesf2
 548 nongcc_word_type
 549 __lesf2 (a, b)
 550      FLOAT_ARG_TYPE a, b;
 551 {
 552   union flt_or_int intify;
 553   /* Value <= 0 iff a <= b.  */
 554   perform_lesf2 (FLOATIFY (a), FLOATIFY (b));
 555 }
 556 #endif
 557
 558 #ifdef L_mulsf3
 559 FLOAT_VALUE_TYPE
 560 __mulsf3 (a, b)
 561      FLOAT_ARG_TYPE a, b;
 562 {
 563   union flt_or_value intify;
 564   perform_mulsf3 (FLOATIFY (a), FLOATIFY (b));
 565 }
 566 #endif
 567
 568 #ifdef L_divsf3
 569 FLOAT_VALUE_TYPE
 570 __divsf3 (a, b)
 571      FLOAT_ARG_TYPE a, b;
 572 {
 573   union flt_or_value intify;
 574   perform_divsf3 (FLOATIFY (a), FLOATIFY (b));
 575 }
 576 #endif
 577
 578 #ifdef L_truncdfsf2
 579 FLOAT_VALUE_TYPE
 580 __truncdfsf2 (a)
 581      double a;
 582 {
 583   union flt_or_value intify;
 584   perform_truncdfsf2 (a);
 585 }
 586 #endif
 587
 588 #ifdef L_extendsfdf2
 589 double
 590 __extendsfdf2 (a)
 591      FLOAT_ARG_TYPE a;
 592 {
 593   union flt_or_value intify;
 594   perform_extendsfdf2 (FLOATIFY (a));
 595 }
 596 #endif