Return to libgcc1-test.c CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/libgcc1-test.c, revision 1.1

1.1     ! root        1: /* This small function uses all the arithmetic operators that
        !             2:    libgcc1.c can handle.  If you can link it, then
        !             3:    you have provided replacements for all the libgcc1.c functions that
        !             4:    your target machine needs.  */
        !             5: 
        !             6: int foo ();
        !             7: double dfoo ();
        !             8: 
        !             9: /* We don't want __main here because that can drag in atexit (among other
        !            10:    things) which won't necessarily exist yet.  */
        !            11: 
        !            12: main_without__main ()
        !            13: {
        !            14:   int a = foo (), b = foo ();
        !            15:   unsigned int au = foo (), bu = foo ();
        !            16:   float af = dfoo (), bf = dfoo ();
        !            17:   double ad = dfoo (), bd = dfoo ();
        !            18: 
        !            19:   discard (a * b);
        !            20:   discard (a / b);
        !            21:   discard (a % b);
        !            22: 
        !            23:   discard (au / bu);
        !            24:   discard (au % bu);
        !            25: 
        !            26:   discard (a >> b);
        !            27:   discard (a << b);
        !            28: 
        !            29:   discard (au >> bu);
        !            30:   discard (au << bu);
        !            31: 
        !            32:   ddiscard (ad + bd);
        !            33:   ddiscard (ad - bd);
        !            34:   ddiscard (ad * bd);
        !            35:   ddiscard (ad / bd);
        !            36:   ddiscard (-ad);
        !            37: 
        !            38:   ddiscard (af + bf);
        !            39:   ddiscard (af - bf);
        !            40:   ddiscard (af * bf);
        !            41:   ddiscard (af / bf);
        !            42:   ddiscard (-af);
        !            43: 
        !            44:   discard ((int) ad);
        !            45:   discard ((int) af);
        !            46: 
        !            47:   ddiscard ((double) a);
        !            48:   ddiscard ((float) a);
        !            49:   ddiscard ((float) ad);
        !            50: 
        !            51:   discard (ad == bd);
        !            52:   discard (ad < bd);
        !            53:   discard (ad > bd);
        !            54:   discard (ad != bd);
        !            55:   discard (ad <= bd);
        !            56:   discard (ad >= bd);
        !            57: 
        !            58:   discard (af == bf);
        !            59:   discard (af < bf);
        !            60:   discard (af > bf);
        !            61:   discard (af != bf);
        !            62:   discard (af <= bf);
        !            63:   discard (af >= bf);
        !            64: 
        !            65:   return 0;
        !            66: }
        !            67: 
        !            68: discard (x)
        !            69:      int x;
        !            70: {}
        !            71: 
        !            72: ddiscard (x)
        !            73:      double x;
        !            74: {}
        !            75: 
        !            76: foo ()
        !            77: {
        !            78:   static int table[] = {20, 69, 4, 12};
        !            79:   static int idx;
        !            80: 
        !            81:   return table[idx++];
        !            82: }
        !            83: 
        !            84: double
        !            85: dfoo ()
        !            86: {
        !            87:   static double table[] = {20.4, 69.96, 4.4, 202.202};
        !            88:   static int idx;
        !            89: 
        !            90:   return table[idx++];
        !            91: }
        !            92: 
        !            93: /* Provide functions that some versions of the linker use to default
        !            94:    the start address if -e symbol is not used, to avoid the warning
        !            95:    message saying the start address is defaulted.  */
        !            96: extern void start() __asm__("start");
        !            97: extern void _start() __asm__("_start");
        !            98: 
        !            99: void start() {}
        !           100: void _start() {}

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