Return to libgcc1.c CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/libgcc1.c, revision 1.1

1.1     ! root        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 (SItype) a;
        !           132: #endif
        !           133: 
        !           134: #ifndef perform_fixsfsi
        !           135: #define perform_fixsfsi(a) return (SItype) 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 SItype
        !           210: #define SItype long int
        !           211: #endif
        !           212: 
        !           213: /* Define the type to be used for returning an SF mode value
        !           214:    and the method for turning a float into that type.
        !           215:    These definitions work for machines where an SF value is
        !           216:    returned in the same register as an int.  */
        !           217: 
        !           218: #ifndef FLOAT_VALUE_TYPE  
        !           219: #define FLOAT_VALUE_TYPE int
        !           220: #endif
        !           221: 
        !           222: #ifndef INTIFY
        !           223: #define INTIFY(FLOATVAL)  (intify.f = (FLOATVAL), intify.i)
        !           224: #endif
        !           225: 
        !           226: #ifndef FLOATIFY
        !           227: #define FLOATIFY(INTVAL)  ((INTVAL).f)
        !           228: #endif
        !           229: 
        !           230: #ifndef FLOAT_ARG_TYPE
        !           231: #define FLOAT_ARG_TYPE union flt_or_int
        !           232: #endif
        !           233: 
        !           234: union flt_or_value { FLOAT_VALUE_TYPE i; float f; };
        !           235: 
        !           236: union flt_or_int { int i; float f; };
        !           237: 
        !           238: 
        !           239: #ifdef L_mulsi3
        !           240: SItype
        !           241: __mulsi3 (a, b)
        !           242:      SItype a, b;
        !           243: {
        !           244:   perform_mulsi3 (a, b);
        !           245: }
        !           246: #endif
        !           247: 
        !           248: #ifdef L_udivsi3
        !           249: SItype
        !           250: __udivsi3 (a, b)
        !           251:      unsigned SItype a, b;
        !           252: {
        !           253:   perform_udivsi3 (a, b);
        !           254: }
        !           255: #endif
        !           256: 
        !           257: #ifdef L_divsi3
        !           258: SItype
        !           259: __divsi3 (a, b)
        !           260:      SItype a, b;
        !           261: {
        !           262:   perform_divsi3 (a, b);
        !           263: }
        !           264: #endif
        !           265: 
        !           266: #ifdef L_umodsi3
        !           267: SItype
        !           268: __umodsi3 (a, b)
        !           269:      unsigned SItype a, b;
        !           270: {
        !           271:   perform_umodsi3 (a, b);
        !           272: }
        !           273: #endif
        !           274: 
        !           275: #ifdef L_modsi3
        !           276: SItype
        !           277: __modsi3 (a, b)
        !           278:      SItype a, b;
        !           279: {
        !           280:   perform_modsi3 (a, b);
        !           281: }
        !           282: #endif
        !           283: 
        !           284: #ifdef L_lshrsi3
        !           285: SItype
        !           286: __lshrsi3 (a, b)
        !           287:      unsigned SItype a, b;
        !           288: {
        !           289:   perform_lshrsi3 (a, b);
        !           290: }
        !           291: #endif
        !           292: 
        !           293: #ifdef L_lshlsi3
        !           294: SItype
        !           295: __lshlsi3 (a, b)
        !           296:      unsigned SItype a, b;
        !           297: {
        !           298:   perform_lshlsi3 (a, b);
        !           299: }
        !           300: #endif
        !           301: 
        !           302: #ifdef L_ashrsi3
        !           303: SItype
        !           304: __ashrsi3 (a, b)
        !           305:      SItype a, b;
        !           306: {
        !           307:   perform_ashrsi3 (a, b);
        !           308: }
        !           309: #endif
        !           310: 
        !           311: #ifdef L_ashlsi3
        !           312: SItype
        !           313: __ashlsi3 (a, b)
        !           314:      SItype a, b;
        !           315: {
        !           316:   perform_ashlsi3 (a, b);
        !           317: }
        !           318: #endif
        !           319: 
        !           320: #ifdef L_divdf3
        !           321: double
        !           322: __divdf3 (a, b)
        !           323:      double a, b;
        !           324: {
        !           325:   perform_divdf3 (a, b);
        !           326: }
        !           327: #endif
        !           328: 
        !           329: #ifdef L_muldf3
        !           330: double
        !           331: __muldf3 (a, b)
        !           332:      double a, b;
        !           333: {
        !           334:   perform_muldf3 (a, b);
        !           335: }
        !           336: #endif
        !           337: 
        !           338: #ifdef L_negdf2
        !           339: double
        !           340: __negdf2 (a)
        !           341:      double a;
        !           342: {
        !           343:   perform_negdf2 (a);
        !           344: }
        !           345: #endif
        !           346: 
        !           347: #ifdef L_adddf3
        !           348: double
        !           349: __adddf3 (a, b)
        !           350:      double a, b;
        !           351: {
        !           352:   perform_adddf3 (a, b);
        !           353: }
        !           354: #endif
        !           355: 
        !           356: #ifdef L_subdf3
        !           357: double
        !           358: __subdf3 (a, b)
        !           359:      double a, b;
        !           360: {
        !           361:   perform_subdf3 (a, b);
        !           362: }
        !           363: #endif
        !           364: 
        !           365: /* Note that eqdf2 returns a value for "true" that is == 0,
        !           366:    nedf2 returns a value for "true" that is != 0,
        !           367:    gtdf2 returns a value for "true" that is > 0,
        !           368:    and so on.  */
        !           369: 
        !           370: #ifdef L_eqdf2
        !           371: SItype
        !           372: __eqdf2 (a, b)
        !           373:      double a, b;
        !           374: {
        !           375:   /* Value == 0 iff a == b.  */
        !           376:   perform_eqdf2 (a, b);
        !           377: }
        !           378: #endif
        !           379: 
        !           380: #ifdef L_nedf2
        !           381: SItype
        !           382: __nedf2 (a, b)
        !           383:      double a, b;
        !           384: {
        !           385:   /* Value != 0 iff a != b.  */
        !           386:   perform_nedf2 (a, b);
        !           387: }
        !           388: #endif
        !           389: 
        !           390: #ifdef L_gtdf2
        !           391: SItype
        !           392: __gtdf2 (a, b)
        !           393:      double a, b;
        !           394: {
        !           395:   /* Value > 0 iff a > b.  */
        !           396:   perform_gtdf2 (a, b);
        !           397: }
        !           398: #endif
        !           399: 
        !           400: #ifdef L_gedf2
        !           401: SItype
        !           402: __gedf2 (a, b)
        !           403:      double a, b;
        !           404: {
        !           405:   /* Value >= 0 iff a >= b.  */
        !           406:   perform_gedf2 (a, b);
        !           407: }
        !           408: #endif
        !           409: 
        !           410: #ifdef L_ltdf2
        !           411: SItype
        !           412: __ltdf2 (a, b)
        !           413:      double a, b;
        !           414: {
        !           415:   /* Value < 0 iff a < b.  */
        !           416:   perform_ltdf2 (a, b);
        !           417: }
        !           418: #endif
        !           419: 
        !           420: #ifdef L_ledf2
        !           421: SItype
        !           422: __ledf2 (a, b)
        !           423:      double a, b;
        !           424: {
        !           425:   /* Value <= 0 iff a <= b.  */
        !           426:   perform_ledf2 (a, b);
        !           427: }
        !           428: #endif
        !           429: 
        !           430: #ifdef L_fixdfsi
        !           431: SItype
        !           432: __fixdfsi (a)
        !           433:      double a;
        !           434: {
        !           435:   perform_fixdfsi (a);
        !           436: }
        !           437: #endif
        !           438: 
        !           439: #ifdef L_fixsfsi
        !           440: SItype
        !           441: __fixsfsi (a)
        !           442:      FLOAT_ARG_TYPE a;
        !           443: {
        !           444:   union flt_or_value intify;
        !           445:   perform_fixsfsi (FLOATIFY (a));
        !           446: }
        !           447: #endif
        !           448: 
        !           449: #ifdef L_floatsidf
        !           450: double
        !           451: __floatsidf (a)
        !           452:      SItype a;
        !           453: {
        !           454:   perform_floatsidf (a);
        !           455: }
        !           456: #endif
        !           457: 
        !           458: #ifdef L_floatsisf
        !           459: FLOAT_VALUE_TYPE
        !           460: __floatsisf (a)
        !           461:      SItype a;
        !           462: {
        !           463:   union flt_or_value intify;
        !           464:   perform_floatsisf (a);
        !           465: }
        !           466: #endif
        !           467: 
        !           468: #ifdef L_addsf3
        !           469: FLOAT_VALUE_TYPE
        !           470: __addsf3 (a, b)
        !           471:      FLOAT_ARG_TYPE a, b;
        !           472: {
        !           473:   union flt_or_value intify;
        !           474:   perform_addsf3 (FLOATIFY (a), FLOATIFY (b));
        !           475: }
        !           476: #endif
        !           477: 
        !           478: #ifdef L_negsf2
        !           479: FLOAT_VALUE_TYPE
        !           480: __negsf2 (a)
        !           481:      FLOAT_ARG_TYPE a;
        !           482: {
        !           483:   union flt_or_value intify;
        !           484:   perform_negsf2 (FLOATIFY (a));
        !           485: }
        !           486: #endif
        !           487: 
        !           488: #ifdef L_subsf3
        !           489: FLOAT_VALUE_TYPE
        !           490: __subsf3 (a, b)
        !           491:      FLOAT_ARG_TYPE a, b;
        !           492: {
        !           493:   union flt_or_value intify;
        !           494:   perform_subsf3 (FLOATIFY (a), FLOATIFY (b));
        !           495: }
        !           496: #endif
        !           497: 
        !           498: #ifdef L_eqsf2
        !           499: SItype
        !           500: __eqsf2 (a, b)
        !           501:      FLOAT_ARG_TYPE a, b;
        !           502: {
        !           503:   union flt_or_int intify;
        !           504:   /* Value == 0 iff a == b.  */
        !           505:   perform_eqsf2 (FLOATIFY (a), FLOATIFY (b));
        !           506: }
        !           507: #endif
        !           508: 
        !           509: #ifdef L_nesf2
        !           510: SItype
        !           511: __nesf2 (a, b)
        !           512:      FLOAT_ARG_TYPE a, b;
        !           513: {
        !           514:   union flt_or_int intify;
        !           515:   /* Value != 0 iff a != b.  */
        !           516:   perform_nesf2 (FLOATIFY (a), FLOATIFY (b));
        !           517: }
        !           518: #endif
        !           519: 
        !           520: #ifdef L_gtsf2
        !           521: SItype
        !           522: __gtsf2 (a, b)
        !           523:      FLOAT_ARG_TYPE a, b;
        !           524: {
        !           525:   union flt_or_int intify;
        !           526:   /* Value > 0 iff a > b.  */
        !           527:   perform_gtsf2 (FLOATIFY (a), FLOATIFY (b));
        !           528: }
        !           529: #endif
        !           530: 
        !           531: #ifdef L_gesf2
        !           532: SItype
        !           533: __gesf2 (a, b)
        !           534:      FLOAT_ARG_TYPE a, b;
        !           535: {
        !           536:   union flt_or_int intify;
        !           537:   /* Value >= 0 iff a >= b.  */
        !           538:   perform_gesf2 (FLOATIFY (a), FLOATIFY (b));
        !           539: }
        !           540: #endif
        !           541: 
        !           542: #ifdef L_ltsf2
        !           543: SItype
        !           544: __ltsf2 (a, b)
        !           545:      FLOAT_ARG_TYPE a, b;
        !           546: {
        !           547:   union flt_or_int intify;
        !           548:   /* Value < 0 iff a < b.  */
        !           549:   perform_ltsf2 (FLOATIFY (a), FLOATIFY (b));
        !           550: }
        !           551: #endif
        !           552: 
        !           553: #ifdef L_lesf2
        !           554: SItype
        !           555: __lesf2 (a, b)
        !           556:      FLOAT_ARG_TYPE a, b;
        !           557: {
        !           558:   union flt_or_int intify;
        !           559:   /* Value <= 0 iff a <= b.  */
        !           560:   perform_lesf2 (FLOATIFY (a), FLOATIFY (b));
        !           561: }
        !           562: #endif
        !           563: 
        !           564: #ifdef L_mulsf3
        !           565: FLOAT_VALUE_TYPE
        !           566: __mulsf3 (a, b)
        !           567:      FLOAT_ARG_TYPE a, b;
        !           568: {
        !           569:   union flt_or_value intify;
        !           570:   perform_mulsf3 (FLOATIFY (a), FLOATIFY (b));
        !           571: }
        !           572: #endif
        !           573: 
        !           574: #ifdef L_divsf3
        !           575: FLOAT_VALUE_TYPE
        !           576: __divsf3 (a, b)
        !           577:      FLOAT_ARG_TYPE a, b;
        !           578: {
        !           579:   union flt_or_value intify;
        !           580:   perform_divsf3 (FLOATIFY (a), FLOATIFY (b));
        !           581: }
        !           582: #endif
        !           583: 
        !           584: #ifdef L_truncdfsf2
        !           585: FLOAT_VALUE_TYPE
        !           586: __truncdfsf2 (a)
        !           587:      double a;
        !           588: {
        !           589:   union flt_or_value intify;
        !           590:   perform_truncdfsf2 (a);
        !           591: }
        !           592: #endif
        !           593: 
        !           594: #ifdef L_extendsfdf2
        !           595: double
        !           596: __extendsfdf2 (a)
        !           597:      FLOAT_ARG_TYPE a;
        !           598: {
        !           599:   union flt_or_value intify;
        !           600:   perform_extendsfdf2 (FLOATIFY (a));
        !           601: }
        !           602: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.