1 /* 2 * main.c 3 * 4 * Copyright (c) 1999-2019, Arm Limited. 5 * SPDX-License-Identifier: MIT 6 */ 7 8 #include <assert.h> 9 #include <stdio.h> 10 #include <string.h> 11 #include <ctype.h> 12 #include <stdlib.h> 13 #include <time.h> 14 15 #include "intern.h" 16 17 void gencases(Testable *fn, int number); 18 void docase(Testable *fn, uint32 *args); 19 void vet_for_decline(Testable *fn, uint32 *args, uint32 *result, int got_errno_in); 20 void seed_random(uint32 seed); 21 22 int check_declines = 0; 23 int lib_fo = 0; 24 int lib_no_arith = 0; 25 int ntests = 0; 26 27 int nargs_(Testable* f) { 28 switch((f)->type) { 29 case args2: 30 case args2f: 31 case semi2: 32 case semi2f: 33 case t_ldexp: 34 case t_ldexpf: 35 case args1c: 36 case args1fc: 37 case args1cr: 38 case args1fcr: 39 case compare: 40 case comparef: 41 return 2; 42 case args2c: 43 case args2fc: 44 return 4; 45 default: 46 return 1; 47 } 48 } 49 50 static int isdouble(Testable *f) 51 { 52 switch (f->type) { 53 case args1: 54 case rred: 55 case semi1: 56 case t_frexp: 57 case t_modf: 58 case classify: 59 case t_ldexp: 60 case args2: 61 case semi2: 62 case args1c: 63 case args1cr: 64 case compare: 65 case args2c: 66 return 1; 67 case args1f: 68 case rredf: 69 case semi1f: 70 case t_frexpf: 71 case t_modff: 72 case classifyf: 73 case args2f: 74 case semi2f: 75 case t_ldexpf: 76 case comparef: 77 case args1fc: 78 case args1fcr: 79 case args2fc: 80 return 0; 81 default: 82 assert(0 && "Bad function type"); 83 } 84 } 85 86 Testable *find_function(const char *func) 87 { 88 int i; 89 for (i = 0; i < nfunctions; i++) { 90 if (func && !strcmp(func, functions[i].name)) { 91 return &functions[i]; 92 } 93 } 94 return NULL; 95 } 96 97 void get_operand(const char *str, Testable *f, uint32 *word0, uint32 *word1) 98 { 99 struct special { 100 unsigned dblword0, dblword1, sglword; 101 const char *name; 102 } specials[] = { 103 {0x00000000,0x00000000,0x00000000,"0"}, 104 {0x3FF00000,0x00000000,0x3f800000,"1"}, 105 {0x7FF00000,0x00000000,0x7f800000,"inf"}, 106 {0x7FF80000,0x00000001,0x7fc00000,"qnan"}, 107 {0x7FF00000,0x00000001,0x7f800001,"snan"}, 108 {0x3ff921fb,0x54442d18,0x3fc90fdb,"pi2"}, 109 {0x400921fb,0x54442d18,0x40490fdb,"pi"}, 110 {0x3fe921fb,0x54442d18,0x3f490fdb,"pi4"}, 111 {0x4002d97c,0x7f3321d2,0x4016cbe4,"3pi4"}, 112 }; 113 int i; 114 115 for (i = 0; i < (int)(sizeof(specials)/sizeof(*specials)); i++) { 116 if (!strcmp(str, specials[i].name) || 117 ((str[0] == '-' || str[0] == '+') && 118 !strcmp(str+1, specials[i].name))) { 119 assert(f); 120 if (isdouble(f)) { 121 *word0 = specials[i].dblword0; 122 *word1 = specials[i].dblword1; 123 } else { 124 *word0 = specials[i].sglword; 125 *word1 = 0; 126 } 127 if (str[0] == '-') 128 *word0 |= 0x80000000U; 129 return; 130 } 131 } 132 133 sscanf(str, "%"I32"x.%"I32"x", word0, word1); 134 } 135 136 void dofile(FILE *fp, int translating) { 137 char buf[1024], sparebuf[1024], *p; 138 139 /* 140 * Command syntax is: 141 * 142 * - "seed <integer>" sets a random seed 143 * 144 * - "test <function> <ntests>" generates random test lines 145 * 146 * - "<function> op1=foo [op2=bar]" generates a specific test 147 * - "func=<function> op1=foo [op2=bar]" does the same 148 * - "func=<function> op1=foo result=bar" will just output the line as-is 149 * 150 * - a semicolon or a blank line is ignored 151 */ 152 while (fgets(buf, sizeof(buf), fp)) { 153 buf[strcspn(buf, "\r\n")] = '\0'; 154 strcpy(sparebuf, buf); 155 p = buf; 156 while (*p && isspace(*p)) p++; 157 if (!*p || *p == ';') { 158 /* Comment or blank line. Only print if `translating' is set. */ 159 if (translating) 160 printf("%s\n", buf); 161 continue; 162 } 163 if (!strncmp(buf, "seed ", 5)) { 164 seed_random(atoi(buf+5)); 165 } else if (!strncmp(buf, "random=", 7)) { 166 /* 167 * Copy 'random=on' / 'random=off' lines unconditionally 168 * to the output, so that random test failures can be 169 * accumulated into a recent-failures-list file and 170 * still identified as random-in-origin when re-run the 171 * next day. 172 */ 173 printf("%s\n", buf); 174 } else if (!strncmp(buf, "test ", 5)) { 175 char *p = buf+5; 176 char *q; 177 int ntests, i; 178 q = p; 179 while (*p && !isspace(*p)) p++; 180 if (*p) *p++ = '\0'; 181 while (*p && isspace(*p)) p++; 182 if (*p) 183 ntests = atoi(p); 184 else 185 ntests = 100; /* *shrug* */ 186 for (i = 0; i < nfunctions; i++) { 187 if (!strcmp(q, functions[i].name)) { 188 gencases(&functions[i], ntests); 189 break; 190 } 191 } 192 if (i == nfunctions) { 193 fprintf(stderr, "unknown test `%s'\n", q); 194 } 195 } else { 196 /* 197 * Parse a specific test line. 198 */ 199 uint32 ops[8], result[8]; 200 int got_op = 0; /* &1 for got_op1, &4 for got_op3 etc. */ 201 Testable *f = 0; 202 char *q, *r; 203 int got_result = 0, got_errno_in = 0; 204 205 for (q = strtok(p, " \t"); q; q = strtok(NULL, " \t")) { 206 r = strchr(q, '='); 207 if (!r) { 208 f = find_function(q); 209 } else { 210 *r++ = '\0'; 211 212 if (!strcmp(q, "func")) 213 f = find_function(r); 214 else if (!strcmp(q, "op1") || !strcmp(q, "op1r")) { 215 get_operand(r, f, &ops[0], &ops[1]); 216 got_op |= 1; 217 } else if (!strcmp(q, "op2") || !strcmp(q, "op1i")) { 218 get_operand(r, f, &ops[2], &ops[3]); 219 got_op |= 2; 220 } else if (!strcmp(q, "op2r")) { 221 get_operand(r, f, &ops[4], &ops[5]); 222 got_op |= 4; 223 } else if (!strcmp(q, "op2i")) { 224 get_operand(r, f, &ops[6], &ops[7]); 225 got_op |= 8; 226 } else if (!strcmp(q, "result") || !strcmp(q, "resultr")) { 227 get_operand(r, f, &result[0], &result[1]); 228 got_result |= 1; 229 } else if (!strcmp(q, "resulti")) { 230 get_operand(r, f, &result[4], &result[5]); 231 got_result |= 2; 232 } else if (!strcmp(q, "res2")) { 233 get_operand(r, f, &result[2], &result[3]); 234 got_result |= 4; 235 } else if (!strcmp(q, "errno_in")) { 236 got_errno_in = 1; 237 } 238 } 239 } 240 241 /* 242 * Test cases already set up by the input are not 243 * reprocessed by default, unlike the fplib tests. (This 244 * is mostly for historical reasons, because we used to 245 * use a very slow and incomplete internal reference 246 * implementation; now our ref impl is MPFR/MPC it 247 * probably wouldn't be such a bad idea, though we'd still 248 * have to make sure all the special cases came out 249 * right.) If translating==2 (corresponding to the -T 250 * command-line option) then we regenerate everything 251 * regardless. 252 */ 253 if (got_result && translating < 2) { 254 if (f) 255 vet_for_decline(f, ops, result, got_errno_in); 256 puts(sparebuf); 257 continue; 258 } 259 260 if (f && got_op==(1<<nargs_(f))-1) { 261 /* 262 * And do it! 263 */ 264 docase(f, ops); 265 } 266 } 267 } 268 } 269 270 int main(int argc, char **argv) { 271 int errs = 0, opts = 1, files = 0, translating = 0; 272 unsigned int seed = 1; /* in case no explicit seed provided */ 273 274 seed_random(seed); 275 276 setvbuf(stdout, NULL, _IOLBF, BUFSIZ); /* stops incomplete lines being printed when out of time */ 277 278 while (--argc) { 279 FILE *fp; 280 char *p = *++argv; 281 282 if (opts && *p == '-') { 283 if(*(p+1) == 0) { /* single -, read from stdin */ 284 break; 285 } else if (!strcmp(p, "-t")) { 286 translating = 1; 287 } else if (!strcmp(p, "-T")) { 288 translating = 2; 289 } else if (!strcmp(p, "-c")) { 290 check_declines = 1; 291 } else if (!strcmp(p, "--")) { 292 opts = 0; 293 } else if (!strcmp(p,"--seed") && argc > 1 && 1==sscanf(*(argv+1),"%u",&seed)) { 294 seed_random(seed); 295 argv++; /* next in argv is seed value, so skip */ 296 --argc; 297 } else if (!strcmp(p, "-fo")) { 298 lib_fo = 1; 299 } else if (!strcmp(p, "-noarith")) { 300 lib_no_arith = 1; 301 } else { 302 fprintf(stderr, 303 "rtest: ignoring unrecognised option '%s'\n", p); 304 errs = 1; 305 } 306 } else { 307 files = 1; 308 if (!errs) { 309 fp = fopen(p, "r"); 310 if (fp) { 311 dofile(fp, translating); 312 fclose(fp); 313 } else { 314 perror(p); 315 errs = 1; 316 } 317 } 318 } 319 } 320 321 /* 322 * If no filename arguments, use stdin. 323 */ 324 if (!files && !errs) { 325 dofile(stdin, translating); 326 } 327 328 if (check_declines) { 329 fprintf(stderr, "Tests expected to run: %d\n", ntests); 330 fflush(stderr); 331 } 332 333 return errs; 334 } 335