test/test53.c

   1 #include <assert.h>
   2 #include <minix/u64.h>
   3 #include <setjmp.h>
   4 #include <signal.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <sys/time.h>
   8 #include <unistd.h>
   9
  10 #define ERR err(__LINE__)
  11 int max_error = 4;
  12 #include "common.h"
  13
  14 #define TIMED 0
  15
  16
  17 static volatile int expect_SIGFPE;
  18 static u64_t i, j, k;
  19 static jmp_buf jmpbuf_SIGFPE, jmpbuf_main;
  20
  21 static void err(int line)
  22 {
  23         /* print error information */
  24         printf("error line %d; i=0x%.8lx%.8lx; j=0x%.8lx%.8lx; k=0x%.8lx%.8lx\n",
  25                 line,
  26                 ex64hi(i), ex64lo(i),
  27                 ex64hi(j), ex64lo(j),
  28                 ex64hi(k), ex64lo(k));
  29
  30         /* quit after too many errors */
  31         e(7);
  32 }
  33
  34 #define LENGTHOF(arr) (sizeof(arr) / sizeof(arr[0]))
  35
  36 static u64_t getargval(int index, int *done)
  37 {
  38         u32_t values[] = {
  39                 /* corner cases */
  40                 0,
  41                 1,
  42                 0x7fffffff,
  43                 0x80000000,
  44                 0x80000001,
  45                 0xffffffff,
  46                 /* random values */
  47                 0xa9,
  48                 0x0d88,
  49                 0x242811,
  50                 0xeb44d1bc,
  51                 0x5b,
  52                 0xfb50,
  53                 0x569c02,
  54                 0xb23c8f7d,
  55                 0xc3,
  56                 0x2366,
  57                 0xfabb73,
  58                 0xcb4e8aef,
  59                 0xe9,
  60                 0xffdc,
  61                 0x05842d,
  62                 0x3fff902d};
  63
  64         assert(done);
  65
  66         /* values with corner case and random 32-bit components */
  67         if (index < LENGTHOF(values) * LENGTHOF(values))
  68                 return make64(values[index / LENGTHOF(values)], values[index % LENGTHOF(values)]);
  69
  70         index -= LENGTHOF(values) * LENGTHOF(values);
  71
  72         /* small numbers */
  73         if (index < 16) return make64(index + 2, 0);
  74         index -= 16;
  75
  76         /* big numbers */
  77         if (index < 16) return make64(-index - 2, -1);
  78         index -= 16;
  79
  80         /* powers of two */
  81         if (index < 14) return make64(1 << (index * 2 + 5), 0);
  82         index -= 14;
  83         if (index < 16) return make64(0, 1 << (index * 2 + 1));
  84         index -= 16;
  85
  86         /* done */
  87         *done = 1;
  88         return make64(0, 0);
  89 }
  90
  91 static void handler_SIGFPE(int signum)
  92 {
  93         assert(signum == SIGFPE);
  94
  95         /* restore the signal handler */
  96         if (signal(SIGFPE, handler_SIGFPE) == SIG_ERR) ERR;
  97
  98         /* division by zero occurred, was this expected? */
  99         if (expect_SIGFPE) {
 100                 /* expected: jump back to test */
 101                 expect_SIGFPE = 0;
 102                 longjmp(jmpbuf_SIGFPE, -1);
 103         } else {
 104                 /* not expected: error and jump back to main */
 105                 longjmp(jmpbuf_main, -1);
 106         }
 107
 108         /* not reachable */
 109         assert(0);
 110         exit(-1);
 111 }
 112
 113 static inline int bsr64(u64_t i)
 114 {
 115         int index;
 116         u64_t mask;
 117
 118         for (index = 63, mask = 1ULL << 63; index >= 0; --index, mask >>= 1) {
 119             if (i & mask)
 120                 return index;
 121         }
 122
 123         return -1;
 124 }
 125
 126 static void testmul(void)
 127 {
 128         int kdone, kidx;
 129         u32_t ilo = ex64lo(i), jlo = ex64lo(j);
 130         u64_t prod = i * j;
 131         int prodbits;
 132
 133         /* compute maximum index of highest-order bit */
 134         prodbits = bsr64(i) + bsr64(j) + 1;
 135         if (i == 0 || j == 0) prodbits = -1;
 136         if (bsr64(prod) > prodbits) ERR;
 137
 138         /* compare to 32-bit multiplication if possible */
 139         if (ex64hi(i) == 0 && ex64hi(j) == 0) {
 140                 if (prod != (u64_t)ilo * jlo) ERR;
 141
 142                 /* if there is no overflow we can check against pure 32-bit */
 143                 if (prodbits < 32 && prod != ilo * jlo) ERR;
 144         }
 145
 146         /* in 32-bit arith low-order DWORD matches regardless of overflow */
 147         if (ex64lo(prod) != ilo * jlo) ERR;
 148
 149         /* multiplication by zero yields zero */
 150         if (prodbits < 0 && prod != 0) ERR;
 151
 152         /* if there is no overflow, check absence of zero divisors */
 153         if (prodbits >= 0 && prodbits < 64 && prod == 0) ERR;
 154
 155         /* commutativity */
 156         if (prod != j * i) ERR;
 157
 158         /* loop though all argument value combinations for third argument */
 159         for (kdone = 0, kidx = 0; k = getargval(kidx, &kdone), !kdone; kidx++) {
 160                 /* associativity */
 161                 if ((i * j) * k != i * (j * k)) ERR;
 162
 163                 /* left and right distributivity */
 164                 if ((i + j) * k != (i * k) + (j * k)) ERR;
 165                 if (i * (j + k) != (i * j) + (i * k)) ERR;
 166         }
 167 }
 168
 169 static void testdiv0(void)
 170 {
 171         int funcidx;
 172         u64_t res;
 173
 174         assert(j == 0);
 175
 176         /* loop through the 5 different division functions */
 177         for (funcidx = 0; funcidx < 5; funcidx++) {
 178                 expect_SIGFPE = 1;
 179                 if (setjmp(jmpbuf_SIGFPE) == 0) {
 180                         /* divide by zero using various functions */
 181                         switch (funcidx) {
 182                                 case 0: res = i / j;            ERR; break;
 183                                 case 1: res = i / ex64lo(j);    ERR; break;
 184                                 case 2: res = i / ex64lo(j);    ERR; break;
 185                                 case 3: res = i % j;            ERR; break;
 186                                 case 4: res = i % ex64lo(j);    ERR; break;
 187                                 default: assert(0);             ERR; break;
 188                         }
 189
 190                         /* if we reach this point there was no signal and an
 191                          * error has been recorded
 192                          */
 193                         expect_SIGFPE = 0;
 194                 } else {
 195                         /* a signal has been received and expect_SIGFPE has
 196                          * been reset; all is ok now
 197                          */
 198                         assert(!expect_SIGFPE);
 199                 }
 200         }
 201 }
 202
 203 static void testdiv(void)
 204 {
 205         u64_t q, r;
 206 #if TIMED
 207         struct timeval tvstart, tvend;
 208
 209         printf("i=0x%.8x%.8x; j=0x%.8x%.8x\n",
 210                 ex64hi(i), ex64lo(i),
 211                 ex64hi(j), ex64lo(j));
 212         fflush(stdout);
 213         if (gettimeofday(&tvstart, NULL) < 0) ERR;
 214 #endif
 215
 216         /* division by zero has a separate test */
 217         if (j == 0) {
 218                 testdiv0();
 219                 return;
 220         }
 221
 222         /* perform division, store q in k to make ERR more informative */
 223         q = i / j;
 224         r = i % j;
 225         k = q;
 226
 227 #if TIMED
 228         if (gettimeofday(&tvend, NULL) < 0) ERR;
 229         tvend.tv_sec -= tvstart.tv_sec;
 230         tvend.tv_usec -= tvstart.tv_usec;
 231         if (tvend.tv_usec < 0) {
 232                 tvend.tv_sec -= 1;
 233                 tvend.tv_usec += 1000000;
 234         }
 235         printf("q=0x%.8x%.8x; r=0x%.8x%.8x; time=%d.%.6d\n",
 236                 ex64hi(q), ex64lo(q),
 237                 ex64hi(r), ex64lo(r),
 238                 tvend.tv_sec, tvend.tv_usec);
 239         fflush(stdout);
 240 #endif
 241
 242         /* compare to 64/32-bit division if possible */
 243         if (!ex64hi(j)) {
 244                 if (q != i / ex64lo(j)) ERR;
 245                 if (!ex64hi(q)) {
 246                         if (q != i / ex64lo(j)) ERR;
 247                 }
 248                 if (r != i % ex64lo(j)) ERR;
 249
 250                 /* compare to 32-bit division if possible */
 251                 if (!ex64hi(i)) {
 252                         if (q != ex64lo(i) / ex64lo(j)) ERR;
 253                         if (r != ex64lo(i) % ex64lo(j)) ERR;
 254                 }
 255         }
 256
 257         /* check results using i = q j + r and r < j */
 258         if (i != (q * j) + r) ERR;
 259         if (r >= j) ERR;
 260 }
 261
 262 static void test(void)
 263 {
 264         int idone, jdone, iidx, jidx;
 265
 266         /* loop though all argument value combinations */
 267         for (idone = 0, iidx = 0; i = getargval(iidx, &idone), !idone; iidx++)
 268         for (jdone = 0, jidx = 0; j = getargval(jidx, &jdone), !jdone; jidx++) {
 269                 testmul();
 270                 testdiv();
 271         }
 272 }
 273
 274 int main(void)
 275 {
 276         start(53);
 277
 278         /* set up signal handler to deal with div by zero */
 279         if (setjmp(jmpbuf_main) == 0) {
 280                 if (signal(SIGFPE, handler_SIGFPE) == SIG_ERR) ERR;
 281
 282                 /* perform tests */
 283                 test();
 284         } else {
 285                 /* an unexpected SIGFPE has occurred */
 286                 ERR;
 287         }
 288
 289         /* this was all */
 290         quit();
 291
 292         return(-1);     /* Unreachable */
 293 }