Return to test-cond.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / tests / alpha

Annotation of qemu/tests/alpha/test-cond.c, revision 1.1

1.1     ! root        1: 
        !             2: #ifdef TEST_CMOV
        !             3: 
        !             4: #define TEST_COND(N)                           \
        !             5: int test_##N (long a)                          \
        !             6: {                                              \
        !             7:   int res = 1;                                 \
        !             8:                                                \
        !             9:   asm ("cmov"#N" %1,$31,%0"                    \
        !            10:        : "+r" (res) : "r" (a));                        \
        !            11:   return !res;                                 \
        !            12: }
        !            13: 
        !            14: #else
        !            15: 
        !            16: #define TEST_COND(N)                           \
        !            17: int test_##N (long a)                          \
        !            18: {                                              \
        !            19:   int res = 1;                                 \
        !            20:                                                \
        !            21:   asm ("b"#N" %1,1f\n\t"                       \
        !            22:        "addq $31,$31,%0\n\t"                   \
        !            23:        "1: unop\n"                             \
        !            24:        : "+r" (res) : "r" (a));                        \
        !            25:   return res;                                  \
        !            26: }
        !            27: 
        !            28: #endif
        !            29: 
        !            30: TEST_COND(eq)
        !            31: TEST_COND(ne)
        !            32: TEST_COND(ge)
        !            33: TEST_COND(gt)
        !            34: TEST_COND(lbc)
        !            35: TEST_COND(lbs)
        !            36: TEST_COND(le)
        !            37: TEST_COND(lt)
        !            38: 
        !            39: static struct {
        !            40:   int (*func)(long);
        !            41:   long v;
        !            42:   int r;
        !            43: } vectors[] =
        !            44:   {
        !            45:     {test_eq, 0, 1},
        !            46:     {test_eq, 1, 0},
        !            47: 
        !            48:     {test_ne, 0, 0},
        !            49:     {test_ne, 1, 1},
        !            50: 
        !            51:     {test_ge, 0, 1},
        !            52:     {test_ge, 1, 1},
        !            53:     {test_ge, -1, 0},
        !            54: 
        !            55:     {test_gt, 0, 0},
        !            56:     {test_gt, 1, 1},
        !            57:     {test_gt, -1, 0},
        !            58: 
        !            59:     {test_lbc, 0, 1},
        !            60:     {test_lbc, 1, 0},
        !            61:     {test_lbc, -1, 0},
        !            62: 
        !            63:     {test_lbs, 0, 0},
        !            64:     {test_lbs, 1, 1},
        !            65:     {test_lbs, -1, 1},
        !            66: 
        !            67:     {test_le, 0, 1},
        !            68:     {test_le, 1, 0},
        !            69:     {test_le, -1, 1},
        !            70: 
        !            71:     {test_lt, 0, 0},
        !            72:     {test_lt, 1, 0},
        !            73:     {test_lt, -1, 1},
        !            74:   };
        !            75: 
        !            76: int main (void)
        !            77: {
        !            78:   int i;
        !            79: 
        !            80:   for (i = 0; i < sizeof (vectors)/sizeof(vectors[0]); i++)
        !            81:     if ((*vectors[i].func)(vectors[i].v) != vectors[i].r) {
        !            82:       write(1, "Failed\n", 7);
        !            83:       return 1;
        !            84:     }
        !            85:   write(1, "OK\n", 3);
        !            86:   return 0;
        !            87: }

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