1  /* Functional test for DI comparisons.  */
       2  
       3  /* { dg-do run } */
       4  /* { dg-options "-pedantic-errors" } */
       5  
       6  /* The default test suite options use "-ansi", which
       7     generates spurious errors by enabling "-Wlong-long".
       8     Thus override the options and drop "-ansi", in order
       9     to freely use 64-bit (long long) types for PRU.  */
      10  
      11  #include <stddef.h>
      12  #include <stdint.h>
      13  
      14  extern void abort (void);
      15  
      16  char __attribute__((noinline)) test_lt (int64_t a, int64_t b)
      17  {
      18    return a < b;
      19  }
      20  
      21  char __attribute__((noinline)) test_ltu (uint64_t a, uint64_t b)
      22  {
      23    return a < b;
      24  }
      25  
      26  char __attribute__((noinline)) test_le (int64_t a, int64_t b)
      27  {
      28    return a <= b;
      29  }
      30  
      31  char __attribute__((noinline)) test_leu (uint64_t a, uint64_t b)
      32  {
      33    return a <= b;
      34  }
      35  
      36  char __attribute__((noinline)) test_gt (int64_t a, int64_t b)
      37  {
      38    return a > b;
      39  }
      40  
      41  char __attribute__((noinline)) test_gtu (uint64_t a, uint64_t b)
      42  {
      43    return a > b;
      44  }
      45  
      46  char __attribute__((noinline)) test_ge (int64_t a, int64_t b)
      47  {
      48    return a >= b;
      49  }
      50  
      51  char __attribute__((noinline)) test_geu (uint64_t a, uint64_t b)
      52  {
      53    return a >= b;
      54  }
      55  
      56  char __attribute__((noinline)) test_eq (uint64_t a, uint64_t b)
      57  {
      58    return a == b;
      59  }
      60  
      61  char __attribute__((noinline)) test_ne (uint64_t a, uint64_t b)
      62  {
      63    return a != b;
      64  }
      65  
      66  struct test_case {
      67      uint64_t a;
      68      uint64_t b;
      69      char lt;
      70      char ltu;
      71      char le;
      72      char leu;
      73      char gt;
      74      char gtu;
      75      char ge;
      76      char geu;
      77      char eq;
      78      char ne;
      79  };
      80  
      81  const struct test_case cases[] = {
      82    /*                       LT,LTU,LE,LEU,GT,GTU,GE,GEU,EQ,NE */
      83    { 0x1234567800112233ULL,
      84      0x1234567800112233ULL, 0,  0, 1,  1, 0,  0, 1,  1, 1, 0 },
      85    { 0x0000000000000000ULL,
      86      0x0000000000000000ULL, 0,  0, 1,  1, 0,  0, 1,  1, 1, 0 },
      87    { 0xffffffffffffffffULL,
      88      0xffffffffffffffffULL, 0,  0, 1,  1, 0,  0, 1,  1, 1, 0 },
      89  
      90    { 0xffffffffffffffefULL,
      91      0xffffffffffffffffULL, 1,  1, 1,  1, 0,  0, 0,  0, 0, 1 },
      92    { 0x8000000000000000ULL,
      93      0xffffffffffffffffULL, 1,  1, 1,  1, 0,  0, 0,  0, 0, 1 },
      94    { 0x80000000ffffffffULL,
      95      0xffffffffffffffffULL, 1,  1, 1,  1, 0,  0, 0,  0, 0, 1 },
      96    { 0x80000000ffffffffULL,
      97      0xffffffff00000000ULL, 1,  1, 1,  1, 0,  0, 0,  0, 0, 1 },
      98    { 0xffefffffffffffffULL,
      99      0xffffffffffffffffULL, 1,  1, 1,  1, 0,  0, 0,  0, 0, 1 },
     100  
     101    { 0x0000000000000000ULL,
     102      0xffffffffffffffffULL, 0,  1, 0,  1, 1,  0, 1,  0, 0, 1 },
     103    { 0x0000000000000001ULL,
     104      0xffffffffffffffffULL, 0,  1, 0,  1, 1,  0, 1,  0, 0, 1 },
     105    { 0x0000000000000001ULL,
     106      0x8000000000000000ULL, 0,  1, 0,  1, 1,  0, 1,  0, 0, 1 },
     107    { 0x7fffffffffffffffULL,
     108      0x8000000000000000ULL, 0,  1, 0,  1, 1,  0, 1,  0, 0, 1 },
     109  
     110    /* Ensure lo uses unsigned comparison if hi parts are same.  */
     111    { 0x12345678ffffffffULL,
     112      0x1234567800000001ULL, 0,  0, 0,  0, 1,  1, 1,  1, 0, 1 },
     113    { 0xf23456780fffffffULL,
     114      0xf234567800000001ULL, 0,  0, 0,  0, 1,  1, 1,  1, 0, 1 },
     115    { 0xf2345678ffffffffULL,
     116      0xf234567800000001ULL, 0,  0, 0,  0, 1,  1, 1,  1, 0, 1 },
     117    { 0x1234567800000002ULL,
     118      0x1234567800000001ULL, 0,  0, 0,  0, 1,  1, 1,  1, 0, 1 },
     119    { 0x1234567800000002ULL,
     120      0x1234567800000003ULL, 1,  1, 1,  1, 0,  0, 0,  0, 0, 1 },
     121  };
     122  
     123  int
     124  main (void)
     125  {
     126    size_t i;
     127  
     128    for (i = 0; i < (sizeof (cases)/sizeof (cases[0])); i++)
     129      {
     130        const int64_t sa = (int64_t)cases[i].a;
     131        const int64_t sb = (int64_t)cases[i].b;
     132        const uint64_t ua = cases[i].a;
     133        const uint64_t ub = cases[i].b;
     134  
     135        if (cases[i].lt != test_lt (sa, sb))
     136  	abort ();
     137        if (cases[i].ltu != test_ltu (ua, ub))
     138  	abort ();
     139        if (cases[i].le != test_le (sa, sb))
     140  	abort ();
     141        if (cases[i].leu != test_leu (ua, ub))
     142  	abort ();
     143        if (cases[i].gt != test_gt (sa, sb))
     144  	abort ();
     145        if (cases[i].gtu != test_gtu (ua, ub))
     146  	abort ();
     147        if (cases[i].ge != test_ge (sa, sb))
     148  	abort ();
     149        if (cases[i].geu != test_geu (ua, ub))
     150  	abort ();
     151        if (cases[i].eq != test_eq (ua, ub))
     152  	abort ();
     153        if (cases[i].ne != test_ne (ua, ub))
     154  	abort ();
     155      }
     156  
     157    return 0;
     158  }
     159