Return to cross-test.c CVS log

Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/cross-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: main ()
        !            10: {
        !            11:   int a = foo (), b = foo ();
        !            12:   unsigned int au = foo (), bu = foo ();
        !            13:   float af = dfoo (), bf = dfoo ();
        !            14:   double ad = dfoo (), bd = dfoo ();
        !            15: 
        !            16:   discard (a * b);
        !            17:   discard (a / b);
        !            18:   discard (a % b);
        !            19: 
        !            20:   discard (au / bu);
        !            21:   discard (au % bu);
        !            22: 
        !            23:   discard (a >> b);
        !            24:   discard (a << b);
        !            25: 
        !            26:   discard (au >> bu);
        !            27:   discard (au << bu);
        !            28: 
        !            29:   ddiscard (ad + bd);
        !            30:   ddiscard (ad - bd);
        !            31:   ddiscard (ad * bd);
        !            32:   ddiscard (ad / bd);
        !            33:   ddiscard (-ad);
        !            34: 
        !            35:   ddiscard (af + bf);
        !            36:   ddiscard (af - bf);
        !            37:   ddiscard (af * bf);
        !            38:   ddiscard (af / bf);
        !            39:   ddiscard (-af);
        !            40: 
        !            41:   discard ((int) ad);
        !            42:   discard ((int) af);
        !            43: 
        !            44:   ddiscard ((double) a);
        !            45:   ddiscard ((float) a);
        !            46:   ddiscard ((float) ad);
        !            47: 
        !            48:   discard (ad == bd);
        !            49:   discard (ad < bd);
        !            50:   discard (ad > bd);
        !            51:   discard (ad != bd);
        !            52:   discard (ad <= bd);
        !            53:   discard (ad >= bd);
        !            54: 
        !            55:   discard (af == bf);
        !            56:   discard (af < bf);
        !            57:   discard (af > bf);
        !            58:   discard (af != bf);
        !            59:   discard (af <= bf);
        !            60:   discard (af >= bf);
        !            61: 
        !            62:   return 0;
        !            63: }
        !            64: 
        !            65: discard (x)
        !            66:      int x;
        !            67: {}
        !            68: 
        !            69: ddiscard (x)
        !            70:      double x;
        !            71: {}
        !            72: 
        !            73: foo ()
        !            74: {
        !            75:   static int table[] = {20, 69, 4, 202};
        !            76:   static int idx;
        !            77: 
        !            78:   return table[idx++];
        !            79: }
        !            80: 
        !            81: double
        !            82: dfoo ()
        !            83: {
        !            84:   static double table[] = {20.4, 69.96, 4.4, 202.202};
        !            85:   static int idx;
        !            86: 
        !            87:   return table[idx++];
        !            88: }
        !            89: 

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