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