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

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.