Annotation of OpenXM_contrib/gmp/mpn/tests/try.c, Revision 1.1.1.1
1.1 maekawa 1: /* Run some tests on various mpn routines.
2:
3: THIS IS A TEST PROGRAM USED ONLY FOR DEVELOPMENT. IT'S ALMOST CERTAIN TO
4: BE SUBJECT TO INCOMPATIBLE CHANGES IN FUTURE VERSIONS OF GMP. */
5:
6: /*
7: Copyright (C) 2000 Free Software Foundation, Inc.
8:
9: This file is part of the GNU MP Library.
10:
11: The GNU MP Library is free software; you can redistribute it and/or modify
12: it under the terms of the GNU Lesser General Public License as published by
13: the Free Software Foundation; either version 2.1 of the License, or (at your
14: option) any later version.
15:
16: The GNU MP Library is distributed in the hope that it will be useful, but
17: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
19: License for more details.
20:
21: You should have received a copy of the GNU Lesser General Public License
22: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
23: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
24: MA 02111-1307, USA.
25: */
26:
27:
28: /* Usage: try [options] <function>...
29:
30: For example, "./try mpn_add_n" to run tests of that function.
31:
32: Combinations of alignments and overlaps are tested, with redzones above
33: or below the destinations, and with the sources write-protected.
34:
35: The number of tests performed becomes ridiculously large with all the
36: combinations, and for that reason this can't be a part of a "make check",
37: it's meant only for development. The code isn't very pretty either.
38:
39: During development it can help to disable the redzones, since seeing the
40: rest of the destination written can show where the wrong part is, or if
41: the dst pointers are off by 1 or whatever. The magic DEADVAL initial
42: fill (see below) will show locations never written.
43:
44: The -s option can be used to test only certain size operands, which is
45: useful if some new code doesn't yet support say sizes less than the
46: unrolling, or whatever.
47:
48: When a problem occurs it'll of course be necessary to run the program
49: under gdb to find out quite where, how and why it's going wrong. Disable
50: the spinner with the -W option when doing this, or single stepping won't
51: work. Using -1 to run with simple data can be useful.
52:
53: New functions to test can be added by defining a TRY_TYPE_, adding an
54: entry to try_array[] and adding a call to the call() function (if the
55: type isn't already supported). Extra TRY_TYPE_ bits can be easily added
56: if necessary.
57:
58:
59: Future:
60:
61: Automatically detect gdb and disable the spinner timer (use -W for now).
62:
63: Make a way to re-run a failing case in the debugger. Have an option to
64: snapshot each test case before it's run so the data is available if a
65: segv occurs. (This should be more reliable than the current print_all()
66: in the signal handler.)
67:
68: When alignment means a dst isn't hard against the redzone, check the
69: space in between remains unchanged.
70:
71: See if the 80x86 debug registers can do redzones on byte boundaries.
72:
73: When a source overlaps a destination, don't run both s[i].high 0 and 1,
74: as s[i].high has no effect. Maybe encode s[i].high into overlap->s[i].
75:
76: When partial overlaps aren't done, don't loop over source alignments
77: during overlaps.
78:
79: */
80:
81:
82: /* always do assertion checking */
83: #define WANT_ASSERT 1
84:
85: #include "config.h"
86:
87: #if HAVE_GETOPT_H
88: #include <getopt.h> /* for getopt_long() */
89: #endif
90: #include <limits.h>
91: #include <signal.h>
92: #include <stdio.h>
93: #include <stdlib.h>
94: #include <string.h>
95: #include <time.h>
96: #include <unistd.h>
97: #include <sys/mman.h>
98:
99: #include "gmp.h"
100: #include "gmp-impl.h"
101:
102: #include "ref.h"
103: #include "try.h"
104:
105: #if HAVE_SPA_EXTRAS
106: #include "spa-out.asm.h"
107: #endif
108:
109: #if !HAVE_DECL_OPTARG
110: extern char *optarg;
111: extern int optind, opterr;
112: #endif
113:
114:
115: #define DEFAULT_REPETITIONS 10
116:
117: int option_repetitions = DEFAULT_REPETITIONS;
118: int option_spinner = 1;
119: int option_redzones = 1;
120: int option_firstsize = 0;
121: int option_lastsize = 500;
122: int option_firstsize2 = 0;
123:
124: #define ALIGNMENTS 4
125: #define OVERLAPS 4
126: #define CARRY_RANDOMS 5
127: #define MULTIPLIER_RANDOMS 5
128: #define DIVISOR_RANDOMS 5
129: #define XSIZE_COUNT 4
130:
131: int option_print = 0;
132:
133: #define DATA_TRAND 0
134: #define DATA_ZEROS 1
135: #define DATA_SEQ 2
136: #define DATA_FFS 3
137: #define DATA_2FD 4
138: int option_data = DATA_TRAND;
139:
140:
141: mp_size_t pagesize;
142: #define PAGESIZE_LIMBS (pagesize / BYTES_PER_MP_LIMB)
143:
144: /* must be a multiple of the page size */
145: #define REDZONE_BYTES (pagesize * 16)
146: #define REDZONE_LIMBS (REDZONE_BYTES / BYTES_PER_MP_LIMB)
147:
148:
149: #define MAX3(x,y,z) (MAX (x, MAX (y, z)))
150:
151: #if BITS_PER_MP_LIMB == 32
152: #define DEADVAL CNST_LIMB(0xDEADBEEF)
153: #else
154: #define DEADVAL CNST_LIMB(0xDEADBEEFBADDCAFE)
155: #endif
156:
157:
158: #define TRY_RETVAL (1<<0)
159: #define TRY_SIZE2 (1<<1)
160: #define TRY_SHIFT (1<<2)
161: #define TRY_CARRYBIT (1<<3)
162: #define TRY_CARRY3 (1<<4)
163: #define TRY_CARRY4 (1<<4)
164: #define TRY_CARRYLIMB (1<<5)
165: #define TRY_MULTIPLIER (1<<6)
166: #define TRY_DIVISOR (1<<7)
167: #define TRY_DOUBLE_DST (1<<8)
168: #define TRY_DST0_INIT (1<<9)
169: #define TRY_XSIZE (1<<10)
170: #define TRY_SIZE_ZERO (1<<11)
171: #define TRY_DST_SIZE_RETVAL (1<<12)
172: #define TRY_SRC1_GCDDATA (1<<13)
173:
174: #define TRY_OVERLAP_LOW_TO_HIGH (1<<15) /* Default is allow full overlap. */
175: #define TRY_OVERLAP_HIGH_TO_LOW (1<<16)
176: #define TRY_OVERLAP_NONE (1<<17)
177: #define TRY_OVERLAP_NOTSRCS (1<<18)
178:
179: #define TRY_SRC0 (1<<20)
180: #define TRY_SRC1 (TRY_SRC0 << 1)
181:
182: #define TRY_DST0 (1<<24)
183: #define TRY_DST1 (TRY_DST0 << 1)
184:
185:
186: #define TRY_SRC(n) (TRY_SRC0 << (n))
187: #define TRY_DST(n) (TRY_DST0 << (n))
188:
189: #define TRY_CARRYANY (TRY_CARRYBIT | TRY_CARRY3 | TRY_CARRY4 | TRY_CARRYLIMB)
190:
191:
192: #define TRY_TYPE_AORS_N (TRY_RETVAL | TRY_DST0 | TRY_SRC0 | TRY_SRC1)
193: #define TRY_TYPE_AORS_NC (TRY_TYPE_AORS_N | TRY_CARRYBIT)
194:
195: #define TRY_TYPE_AORSMUL_1 (TRY_TYPE_MUL_1 | TRY_DST0_INIT)
196: #define TRY_TYPE_AORSMUL_1C (TRY_TYPE_MUL_1C | TRY_DST0_INIT)
197:
198: #define TRY_TYPE_LOGOPS_N (TRY_DST0 | TRY_SRC0 | TRY_SRC1)
199:
200: #define TRY_TYPE_ADDSUB_N \
201: (TRY_RETVAL | TRY_DST0 | TRY_DST1 | TRY_SRC0 | TRY_SRC1)
202: #define TRY_TYPE_ADDSUB_NC \
203: (TRY_TYPE_ADDSUB_N | TRY_CARRY4)
204:
205: #define TRY_TYPE_COPYI \
206: (TRY_DST0 | TRY_SRC0 | TRY_OVERLAP_LOW_TO_HIGH | TRY_SIZE_ZERO)
207: #define TRY_TYPE_COPYD \
208: (TRY_DST0 | TRY_SRC0 | TRY_OVERLAP_HIGH_TO_LOW | TRY_SIZE_ZERO)
209: #define TRY_TYPE_COM_N (TRY_DST0 | TRY_SRC0)
210:
211: #define TRY_TYPE_MOD_1 (TRY_RETVAL | TRY_SRC0 | TRY_DIVISOR | TRY_SIZE_ZERO)
212: #define TRY_TYPE_MOD_1C (TRY_TYPE_MOD_1 | TRY_CARRYLIMB)
213: #define TRY_TYPE_DIVMOD_1 (TRY_TYPE_MOD_1 | TRY_DST0)
214: #define TRY_TYPE_DIVMOD_1C (TRY_TYPE_MOD_1C | TRY_DST0)
215: #define TRY_TYPE_DIVREM_1 (TRY_TYPE_DIVMOD_1 | TRY_XSIZE)
216: #define TRY_TYPE_DIVREM_1C (TRY_TYPE_DIVMOD_1C | TRY_XSIZE)
217: #define TRY_TYPE_MOD_1_RSHIFT (TRY_RETVAL | TRY_SRC0 | TRY_SHIFT | TRY_DIVISOR)
218:
219: #define TRY_TYPE_DIVEXACT_BY3 (TRY_RETVAL | TRY_DST0 | TRY_SRC0)
220: #define TRY_TYPE_DIVEXACT_BY3C (TRY_TYPE_DIVEXACT_BY3 | TRY_CARRY3)
221:
222: #define TRY_TYPE_GCD_1 (TRY_RETVAL | TRY_SRC0 | TRY_DIVISOR)
223: #define TRY_TYPE_GCD \
224: (TRY_RETVAL | TRY_DST0 | TRY_SRC0 | TRY_SRC1 | TRY_SIZE2 \
225: | TRY_DST_SIZE_RETVAL | TRY_OVERLAP_NOTSRCS | TRY_SRC1_GCDDATA)
226:
227: #define TRY_TYPE_MUL_1 (TRY_RETVAL | TRY_DST0 | TRY_SRC0 | TRY_MULTIPLIER)
228: #define TRY_TYPE_MUL_1C (TRY_TYPE_MUL_1 | TRY_CARRYLIMB)
229:
230: #define TRY_TYPE_MUL_BASECASE \
231: (TRY_DST0 | TRY_SRC0 | TRY_SRC1 | TRY_SIZE2 | TRY_OVERLAP_NONE)
232: #define TRY_TYPE_MUL_N \
233: (TRY_DST0 | TRY_SRC0 | TRY_SRC1 | TRY_DOUBLE_DST | TRY_OVERLAP_NONE)
234: #define TRY_TYPE_SQR \
235: (TRY_DST0 | TRY_SRC0 | TRY_DOUBLE_DST | TRY_OVERLAP_NONE)
236:
237: #define TRY_TYPE_RSHIFT \
238: (TRY_RETVAL | TRY_DST0 | TRY_SRC0 | TRY_SHIFT | TRY_OVERLAP_LOW_TO_HIGH)
239: #define TRY_TYPE_LSHIFT \
240: (TRY_RETVAL | TRY_DST0 | TRY_SRC0 | TRY_SHIFT | TRY_OVERLAP_HIGH_TO_LOW)
241:
242: #define TRY_TYPE_POPCOUNT (TRY_RETVAL | TRY_SRC0 | TRY_SIZE_ZERO)
243: #define TRY_TYPE_HAMDIST (TRY_TYPE_POPCOUNT | TRY_SRC1)
244:
245:
246: /* The following are macros if there's no native versions, so wrap them in
247: functions that can be in try_array[]. */
248:
249: void
250: MPN_COPY_INCR_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
251: { MPN_COPY_INCR (rp, sp, size); }
252:
253: void
254: MPN_COPY_DECR_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
255: { MPN_COPY_DECR (rp, sp, size); }
256:
257: void
258: mpn_com_n_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
259: { mpn_com_n (rp, sp, size); }
260:
261: void
262: mpn_and_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
263: { mpn_and_n (rp, s1, s2, size); }
264:
265: void
266: mpn_andn_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
267: { mpn_andn_n (rp, s1, s2, size); }
268:
269: void
270: mpn_nand_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
271: { mpn_nand_n (rp, s1, s2, size); }
272:
273: void
274: mpn_ior_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
275: { mpn_ior_n (rp, s1, s2, size); }
276:
277: void
278: mpn_iorn_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
279: { mpn_iorn_n (rp, s1, s2, size); }
280:
281: void
282: mpn_nior_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
283: { mpn_nior_n (rp, s1, s2, size); }
284:
285: void
286: mpn_xor_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
287: { mpn_xor_n (rp, s1, s2, size); }
288:
289: void
290: mpn_xnor_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
291: { mpn_xnor_n (rp, s1, s2, size); }
292:
293: void
294: mpn_divexact_by3_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
295: { mpn_divexact_by3 (rp, sp, size); }
296:
297:
298: struct try_t {
299: struct try_one_t {
300: tryfun_t function;
301: const char *name;
302: } ref, fun;
303: int flag;
304: mp_size_t minsize;
305: };
306:
307: #if HAVE_STRINGIZE
308: #define TRY(fun) { (tryfun_t) fun, #fun }
309: #define TRY_FUNFUN(fun) { (tryfun_t) fun##_fun, #fun }
310: #else
311: #define TRY(fun) { (tryfun_t) fun, "fun" }
312: #define TRY_FUNFUN(fun) { (tryfun_t) fun/**/_fun, "fun" }
313: #endif
314:
315: struct try_t try_array[] = {
316: { TRY(refmpn_add_n), TRY(mpn_add_n), TRY_TYPE_AORS_N },
317: { TRY(refmpn_sub_n), TRY(mpn_sub_n), TRY_TYPE_AORS_N },
318: #if HAVE_NATIVE_mpn_add_nc
319: { TRY(refmpn_add_nc), TRY(mpn_add_nc), TRY_TYPE_AORS_NC },
320: #endif
321: #if HAVE_NATIVE_mpn_sub_nc
322: { TRY(refmpn_sub_nc), TRY(mpn_sub_nc), TRY_TYPE_AORS_NC },
323: #endif
324:
325: { TRY(refmpn_addmul_1), TRY(mpn_addmul_1), TRY_TYPE_AORSMUL_1 },
326: { TRY(refmpn_submul_1), TRY(mpn_submul_1), TRY_TYPE_AORSMUL_1 },
327: #if HAVE_NATIVE_mpn_addmul_1c
328: { TRY(refmpn_addmul_1c), TRY(mpn_addmul_1c), TRY_TYPE_AORSMUL_1C },
329: #endif
330: #if HAVE_NATIVE_mpn_submul_1c
331: { TRY(refmpn_submul_1c), TRY(mpn_submul_1c), TRY_TYPE_AORSMUL_1C },
332: #endif
333:
334: { TRY(refmpn_com_n), TRY_FUNFUN(mpn_com_n), TRY_TYPE_COM_N },
335:
336: { TRY(refmpn_copyi), TRY_FUNFUN(MPN_COPY_INCR), TRY_TYPE_COPYI },
337: { TRY(refmpn_copyd), TRY_FUNFUN(MPN_COPY_DECR), TRY_TYPE_COPYD },
338:
339: { TRY(refmpn_and_n), TRY_FUNFUN(mpn_and_n), TRY_TYPE_LOGOPS_N },
340: { TRY(refmpn_andn_n), TRY_FUNFUN(mpn_andn_n), TRY_TYPE_LOGOPS_N },
341: { TRY(refmpn_nand_n), TRY_FUNFUN(mpn_nand_n), TRY_TYPE_LOGOPS_N },
342: { TRY(refmpn_ior_n), TRY_FUNFUN(mpn_ior_n), TRY_TYPE_LOGOPS_N },
343: { TRY(refmpn_iorn_n), TRY_FUNFUN(mpn_iorn_n), TRY_TYPE_LOGOPS_N },
344: { TRY(refmpn_nior_n), TRY_FUNFUN(mpn_nior_n), TRY_TYPE_LOGOPS_N },
345: { TRY(refmpn_xor_n), TRY_FUNFUN(mpn_xor_n), TRY_TYPE_LOGOPS_N },
346: { TRY(refmpn_xnor_n), TRY_FUNFUN(mpn_xnor_n), TRY_TYPE_LOGOPS_N },
347:
348: { TRY(refmpn_divrem_1), TRY(mpn_divrem_1), TRY_TYPE_DIVREM_1 },
349: { TRY(refmpn_mod_1), TRY(mpn_mod_1), TRY_TYPE_MOD_1 },
350: { TRY(refmpn_mod_1_rshift), TRY(mpn_mod_1_rshift), TRY_TYPE_MOD_1_RSHIFT },
351: #if HAVE_NATIVE_mpn_divrem_1c
352: { TRY(refmpn_divrem_1c), TRY(mpn_divrem_1c), TRY_TYPE_DIVREM_1C },
353: #endif
354: #if HAVE_NATIVE_mpn_mod_1c
355: { TRY(refmpn_mod_1c), TRY(mpn_mod_1c), TRY_TYPE_MOD_1C },
356: #endif
357: { TRY(refmpn_divexact_by3), TRY_FUNFUN(mpn_divexact_by3),
358: TRY_TYPE_DIVEXACT_BY3 },
359: { TRY(refmpn_divexact_by3c),TRY(mpn_divexact_by3c),TRY_TYPE_DIVEXACT_BY3C },
360:
361: { TRY(refmpn_mul_1), TRY(mpn_mul_1), TRY_TYPE_MUL_1 },
362: #if HAVE_NATIVE_mpn_mul_1c
363: { TRY(refmpn_mul_1c), TRY(mpn_mul_1c), TRY_TYPE_MUL_1C },
364: #endif
365:
366: { TRY(refmpn_rshift), TRY(mpn_rshift), TRY_TYPE_RSHIFT },
367: { TRY(refmpn_lshift), TRY(mpn_lshift), TRY_TYPE_LSHIFT },
368:
369:
370: { TRY(refmpn_mul_basecase), TRY(mpn_mul_basecase), TRY_TYPE_MUL_BASECASE },
371: { TRY(refmpn_sqr), TRY(mpn_sqr_basecase), TRY_TYPE_SQR },
372:
373: { TRY(refmpn_mul_basecase), TRY(mpn_mul), TRY_TYPE_MUL_BASECASE },
374: { TRY(refmpn_mul_n), TRY(mpn_mul_n), TRY_TYPE_MUL_N },
375: { TRY(refmpn_sqr), TRY(mpn_sqr_n), TRY_TYPE_SQR },
376:
377: { TRY(refmpn_gcd_1), TRY(mpn_gcd_1), TRY_TYPE_GCD_1 },
378: { TRY(refmpn_gcd), TRY(mpn_gcd), TRY_TYPE_GCD },
379:
380: { TRY(refmpn_popcount), TRY(mpn_popcount), TRY_TYPE_POPCOUNT },
381: { TRY(refmpn_hamdist), TRY(mpn_hamdist), TRY_TYPE_HAMDIST },
382:
383: #if 0
384: /* need wrapper functions since they take workspace arguments */
385: { TRY(refmpn_mul_n), TRY_FUNFUN(mpn_kara_mul_n), TRY_TYPE_MUL_N,
386: MPN_KARA_MINSIZE},
387: { TRY(refmpn_sqr), TRY_FUNFUN(mpn_kara_sqr_n), TRY_TYPE_SQR,
388: MPN_KARA_MINSIZE},
389: { TRY(refmpn_mul_n), TRY_FUNFUN(mpn_toom3_mul_n), TRY_TYPE_MUL_N,
390: MPN_TOOM3_MINSIZE},
391: { TRY(refmpn_sqr), TRY_FUNFUN(mpn_toom3_sqr_n), TRY_TYPE_SQR,
392: MPN_TOOM3_MINSIZE },
393: #endif
394:
395: #if HAVE_SPA_EXTRAS
396: #include "spa-out.t-table.i"
397: #endif
398: };
399:
400: struct try_t *tr = &try_array[0];
401:
402:
403: struct region_t {
404: mp_ptr ptr;
405: mp_size_t size;
406: };
407:
408:
409: #define TRAP_NOWHERE 0
410: #define TRAP_REF 1
411: #define TRAP_FUN 2
412: #define TRAP_SETUPS 3
413: int trap_location = TRAP_NOWHERE;
414:
415:
416: /* Find least significant limb position where p1,size and p2,size differ. */
417: mp_size_t
418: mpn_diff_lowest (mp_srcptr p1, mp_srcptr p2, mp_size_t size)
419: {
420: mp_size_t i;
421:
422: for (i = 0; i < size; i++)
423: if (p1[i] != p2[i])
424: return i;
425:
426: /* no differences */
427: return -1;
428: }
429:
430:
431: /* Find most significant limb position where p1,size and p2,size differ. */
432: mp_size_t
433: mpn_diff_highest (mp_srcptr p1, mp_srcptr p2, mp_size_t size)
434: {
435: mp_size_t i;
436:
437: for (i = size-1; i >= 0; i--)
438: if (p1[i] != p2[i])
439: return i;
440:
441: /* no differences */
442: return -1;
443: }
444:
445:
446: /* Return p advanced to the next multiple of "align" bytes. "align" must be
447: a power of 2. Care is taken not to assume sizeof(int)==sizeof(pointer). */
448: void *
449: align_pointer (void *p, size_t align)
450: {
451: unsigned d;
452: d = ((unsigned) p) & (align-1);
453: d = (d != 0 ? align-d : 0);
454: return (void *) (((char *) p) + d);
455: }
456:
457: /* malloc n limbs on a multiple of m bytes boundary */
458: mp_ptr
459: malloc_limbs_aligned (size_t n, size_t m)
460: {
461: return (mp_ptr) align_pointer (refmpn_malloc_limbs (n + m-1), m);
462: }
463:
464: void
465: mprotect_maybe (void *addr, size_t len, int prot)
466: {
467: if (!option_redzones)
468: return;
469:
470: if (mprotect (addr, len, prot) != 0)
471: {
472: fprintf (stderr, "Cannot mprotect %p 0x%X 0x%X\n", addr, len, prot);
473: exit (1);
474: }
475: }
476:
477: /* round "a" up to a multiple of "m" */
478: size_t
479: round_up_multiple (size_t a, size_t m)
480: {
481: unsigned long r;
482:
483: r = a % m;
484: if (r == 0)
485: return a;
486: else
487: return a + (m - r);
488: }
489:
490: void
491: malloc_region (struct region_t *r, mp_size_t n)
492: {
493: mp_ptr p;
494:
495: ASSERT ((pagesize % BYTES_PER_MP_LIMB) == 0);
496:
497: r->size = round_up_multiple (n, PAGESIZE_LIMBS);
498: p = malloc_limbs_aligned (r->size + REDZONE_LIMBS*2, pagesize);
499: mprotect_maybe (p, REDZONE_BYTES, PROT_NONE);
500:
501: r->ptr = p + REDZONE_LIMBS;
502: mprotect_maybe (r->ptr + r->size, REDZONE_BYTES, PROT_NONE);
503: }
504:
505: void
506: mprotect_region (const struct region_t *r, int prot)
507: {
508: mprotect_maybe (r->ptr, r->size, prot);
509: }
510:
511:
512: #define NUM_SOURCES 2
513: #define NUM_DESTS 2
514:
515: struct source_t {
516: struct region_t region;
517: int high;
518: mp_size_t align;
519: mp_ptr p;
520: };
521:
522: struct source_t s[NUM_SOURCES];
523:
524: struct dest_t {
525: int high;
526: mp_size_t align;
527: };
528:
529: struct dest_t d[NUM_SOURCES];
530:
531: struct source_each_t {
532: mp_ptr p;
533: };
534:
535: struct dest_each_t {
536: struct region_t region;
537: mp_ptr p;
538: };
539:
540: mp_size_t size;
541: mp_size_t size2;
542: mp_size_t dsize;
543: unsigned long shift;
544:
545: struct each_t {
546: const char *name;
547: struct dest_each_t d[numberof(d)];
548: struct source_each_t s[numberof(s)];
549: mp_limb_t retval;
550: };
551:
552: struct each_t ref = { "Ref" };
553: struct each_t fun = { "Fun" };
554:
555: #define SRC_SIZE(n) \
556: ((n) == 1 && (tr->flag & (TRY_SIZE2|TRY_XSIZE)) ? size2 : size)
557:
558:
559: /* First four entries must be 0,1,2,3 for TRY_CARRYBIT, TRY_CARRY3, and
560: TRY_CARRY4 */
561: mp_limb_t carry_array[] = {
562: 0, 1, 2, 3,
563: 4,
564: (mp_limb_t) 1 << 8,
565: (mp_limb_t) 1 << 16,
566: (mp_limb_t) -1
567: };
568: mp_limb_t carry;
569: int carry_index;
570:
571: #define CARRY_COUNT \
572: ((tr->flag & TRY_CARRYBIT) ? 2 \
573: : (tr->flag & TRY_CARRY3) ? 3 \
574: : (tr->flag & TRY_CARRY4) ? 4 \
575: : (tr->flag & TRY_CARRYLIMB) ? numberof(carry_array) + CARRY_RANDOMS \
576: : 1)
577:
578: #define MPN_RANDOM_ALT(index,dst,size) \
579: (((index) & 1) ? mpn_random (dst, size) : mpn_random2 (dst, size))
580:
581: /* The dummy value after MPN_RANDOM_ALT ensures both sides of the ":" have
582: the same type */
583: #define CARRY_ITERATION \
584: for (carry_index = 0; \
585: (carry_index < numberof (carry_array) \
586: ? (carry = carry_array[carry_index]) \
587: : (MPN_RANDOM_ALT (carry_index, &carry, 1), (mp_limb_t) 0)), \
588: carry_index < CARRY_COUNT; \
589: carry_index++)
590:
591:
592: mp_limb_t multiplier_array[] = {
593: 0, 1, 2, 3,
594: (mp_limb_t) 1 << 8,
595: (mp_limb_t) 1 << 16,
596: (mp_limb_t) -3,
597: (mp_limb_t) -2,
598: (mp_limb_t) -1,
599: };
600: mp_limb_t multiplier;
601: int multiplier_index;
602:
603: mp_limb_t divisor_array[] = {
604: 1, 2, 3,
605: (mp_limb_t) 1 << 8,
606: (mp_limb_t) 1 << 16,
607: (mp_limb_t) -3,
608: (mp_limb_t) -2,
609: (mp_limb_t) -1,
610: };
611:
612: mp_limb_t divisor;
613: int divisor_index;
614:
615: /* The dummy value after MPN_RANDOM_ALT ensures both sides of the ":" have
616: the same type */
617: #define ARRAY_ITERATION(var, index, limit, array, randoms, cond) \
618: for (index = 0; \
619: (index < numberof (array) \
620: ? CAST_TO_VOID (var = array[index]) \
621: : (MPN_RANDOM_ALT (index, &var, 1), (mp_limb_t) 0)), \
622: index < limit; \
623: index++)
624:
625: #define MULTIPLIER_COUNT \
626: ((tr->flag & TRY_MULTIPLIER) \
627: ? numberof (multiplier_array) + MULTIPLIER_RANDOMS \
628: : 1)
629:
630: #define MULTIPLIER_ITERATION \
631: ARRAY_ITERATION(multiplier, multiplier_index, MULTIPLIER_COUNT, \
632: multiplier_array, MULTIPLIER_RANDOMS, TRY_MULTIPLIER)
633:
634: #define DIVISOR_COUNT \
635: ((tr->flag & TRY_DIVISOR) \
636: ? numberof (divisor_array) + DIVISOR_RANDOMS \
637: : 1)
638:
639: #define DIVISOR_ITERATION \
640: ARRAY_ITERATION(divisor, divisor_index, DIVISOR_COUNT, divisor_array, \
641: DIVISOR_RANDOMS, TRY_DIVISOR)
642:
643:
644: /* overlap_array[].s[i] is where s[i] should be, 0 or 1 means overlapping
645: d[0] or d[1] respectively, -1 means a separate (write-protected)
646: location. */
647:
648: struct overlap_t {
649: int s[NUM_SOURCES];
650: } overlap_array[] = {
651: { { -1, -1 } },
652: { { 0, -1 } },
653: { { -1, 0 } },
654: { { 0, 0 } },
655: { { 1, -1 } },
656: { { -1, 1 } },
657: { { 1, 1 } },
658: { { 0, 1 } },
659: { { 1, 0 } },
660: };
661:
662: struct overlap_t *overlap, *overlap_limit;
663:
664: #define OVERLAP_COUNT \
665: (tr->flag & TRY_OVERLAP_NONE ? 1 \
666: : tr->flag & TRY_OVERLAP_NOTSRCS ? 3 \
667: : tr->flag & TRY_DST1 ? 9 \
668: : tr->flag & TRY_SRC1 ? 4 \
669: : tr->flag & TRY_DST0 ? 2 \
670: : 1)
671:
672: #define OVERLAP_ITERATION \
673: for (overlap = &overlap_array[0], \
674: overlap_limit = &overlap_array[OVERLAP_COUNT]; \
675: overlap < overlap_limit; \
676: overlap++)
677:
678:
679: #define T_RAND_COUNT 2
680: int t_rand;
681:
682: void
683: t_random (mp_ptr ptr, mp_size_t n)
684: {
685: if (size == 0)
686: return;
687:
688: switch (option_data) {
689: case DATA_TRAND:
690: switch (t_rand) {
691: case 0: mpn_random (ptr, n); break;
692: case 1: mpn_random2 (ptr, n); break;
693: default: abort();
694: }
695: break;
696: case DATA_SEQ:
697: {
698: static mp_limb_t counter = 0;
699: mp_size_t i;
700: for (i = 0; i < n; i++)
701: ptr[i] = ++counter;
702: }
703: break;
704: case DATA_ZEROS:
705: refmpn_fill (ptr, n, (mp_limb_t) 0);
706: break;
707: case DATA_FFS:
708: refmpn_fill (ptr, n, (mp_limb_t) -1);
709: break;
710: case DATA_2FD:
711: /* Special value 0x2FFF...FFFD, which divided by 3 gives 0xFFF...FFF,
712: inducing the q1_ff special case in the mul-by-inverse part of some
713: versions of divrem_1 and mod_1. */
714: refmpn_fill (ptr, n, (mp_limb_t) -1);
715: ptr[n-1] = 2;
716: ptr[0] -= 2;
717: break;
718:
719: default:
720: abort();
721: }
722: }
723: #define T_RAND_ITERATION \
724: for (t_rand = 0; t_rand < T_RAND_COUNT; t_rand++)
725:
726:
727: void
728: print_each (const struct each_t *e)
729: {
730: int i;
731:
732: printf ("%s %s\n", e->name, e == &ref ? tr->ref.name : tr->fun.name);
733: if (tr->flag & TRY_RETVAL)
734: printf (" retval %08lX\n", e->retval);
735:
736: for (i = 0; i < numberof (e->d); i++)
737: {
738: if (tr->flag & TRY_DST(i))
739: {
740: mpn_tracen (" d[%d]", i, e->d[i].p, dsize);
741: printf (" located %p\n", e->d[i].p);
742: }
743: }
744:
745: for (i = 0; i < numberof (e->s); i++)
746: if (tr->flag & TRY_SRC(i))
747: printf (" s[%d] located %p\n", i, e->s[i].p);
748: }
749:
750: void
751: print_all (void)
752: {
753: int i;
754:
755: printf ("\n");
756: printf ("size %ld\n", size);
757: if (tr->flag & (TRY_SIZE2|TRY_XSIZE))
758: printf ("size2 %ld\n", size2);
759: if (dsize != size)
760: printf ("dsize %ld\n", dsize);
761: if (tr->flag & TRY_MULTIPLIER)
762: printf (" multiplier 0x%lX\n", multiplier);
763: if (tr->flag & TRY_DIVISOR)
764: printf (" divisor 0x%lX\n", divisor);
765: if (tr->flag & TRY_SHIFT)
766: printf (" shift %lu\n", shift);
767: if (tr->flag & TRY_CARRYANY)
768: printf (" carry %lX\n", carry);
769:
770: for (i = 0; i < numberof (d); i++)
771: if (tr->flag & TRY_DST(i))
772: printf (" d[%d] %s, align %ld\n",
773: i, d[i].high ? "high" : "low", d[i].align);
774:
775: for (i = 0; i < numberof (s); i++)
776: {
777: if (tr->flag & TRY_SRC(i))
778: {
779: printf (" s[%d] %s, align %ld, ",
780: i, s[i].high ? "high" : "low", s[i].align);
781: switch (overlap->s[i]) {
782: case -1:
783: printf ("no overlap\n");
784: break;
785: default:
786: printf ("==d[%d]%s\n",
787: overlap->s[i],
788: tr->flag & TRY_OVERLAP_LOW_TO_HIGH ? "+a"
789: : tr->flag & TRY_OVERLAP_HIGH_TO_LOW ? "-a"
790: : "");
791: break;
792: }
793: mpn_tracen (" s[%d]", i, s[i].p, SRC_SIZE(i));
794: }
795: }
796:
797: if (tr->flag & TRY_DST0_INIT)
798: mpn_trace (" d[0]", s[1].region.ptr, size);
799:
800: print_each (&ref);
801: print_each (&fun);
802: }
803:
804: void
805: compare (void)
806: {
807: int error = 0;
808: int i;
809:
810: if ((tr->flag & TRY_RETVAL) && ref.retval != fun.retval)
811: {
812: printf ("Different return values\n");
813: error = 1;
814: }
815:
816: if (! CALLING_CONVENTIONS_CHECK ())
817: error = 1;
818:
819: if (tr->flag & TRY_DST_SIZE_RETVAL)
820: dsize = ref.retval;
821:
822: for (i = 0; i < numberof (ref.d); i++)
823: {
824: if (!(tr->flag & TRY_DST(i)))
825: continue;
826:
827: if (dsize != 0 && refmpn_cmp (ref.d[i].p, fun.d[i].p, dsize) != 0)
828: {
829: printf ("Different d[%d] data results, low diff at %ld, high diff at %ld\n",
830: i,
831: mpn_diff_lowest (ref.d[i].p, fun.d[i].p, dsize),
832: mpn_diff_highest (ref.d[i].p, fun.d[i].p, dsize));
833: error = 1;
834: }
835: }
836:
837: if (error)
838: {
839: print_all();
840: abort();
841: }
842: }
843:
844: void
845: call (struct each_t *e, tryfun_t function)
846: {
847: switch (tr->flag) {
848: case TRY_TYPE_AORS_N:
849: e->retval = CALLING_CONVENTIONS (function)
850: (e->d[0].p, e->s[0].p, e->s[1].p, size);
851: break;
852: case TRY_TYPE_AORS_NC:
853: e->retval = CALLING_CONVENTIONS (function)
854: (e->d[0].p, e->s[0].p, e->s[1].p, size, carry);
855: break;
856:
857: case TRY_TYPE_LOGOPS_N:
858: CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, e->s[1].p, size);
859: break;
860:
861: case TRY_TYPE_ADDSUB_N:
862: e->retval = CALLING_CONVENTIONS (function)
863: (e->d[0].p, e->d[1].p, e->s[0].p, e->s[1].p, size);
864: break;
865: case TRY_TYPE_ADDSUB_NC:
866: e->retval = CALLING_CONVENTIONS (function)
867: (e->d[0].p, e->d[1].p, e->s[0].p, e->s[1].p, size, carry);
868: break;
869:
870: case TRY_TYPE_COPYI:
871: case TRY_TYPE_COPYD:
872: case TRY_TYPE_COM_N:
873: CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, size);
874: break;
875:
876: case TRY_TYPE_DIVEXACT_BY3:
877: e->retval = CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, size);
878: break;
879: case TRY_TYPE_DIVEXACT_BY3C:
880: e->retval = CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, size,
881: carry);
882: break;
883:
884: case TRY_TYPE_DIVMOD_1:
885: e->retval = CALLING_CONVENTIONS (function)
886: (e->d[0].p, e->s[0].p, size, divisor);
887: break;
888: case TRY_TYPE_DIVMOD_1C:
889: e->retval = CALLING_CONVENTIONS (function)
890: (e->d[0].p, e->s[0].p, size, divisor, carry);
891: break;
892: case TRY_TYPE_DIVREM_1:
893: e->retval = CALLING_CONVENTIONS (function)
894: (e->d[0].p, size2, e->s[0].p, size, divisor);
895: break;
896: case TRY_TYPE_DIVREM_1C:
897: e->retval = CALLING_CONVENTIONS (function)
898: (e->d[0].p, size2, e->s[0].p, size, divisor, carry);
899: break;
900: case TRY_TYPE_MOD_1:
901: e->retval = CALLING_CONVENTIONS (function)
902: (e->s[0].p, size, divisor);
903: break;
904: case TRY_TYPE_MOD_1C:
905: e->retval = CALLING_CONVENTIONS (function)
906: (e->s[0].p, size, divisor, carry);
907: break;
908: case TRY_TYPE_MOD_1_RSHIFT:
909: e->retval = CALLING_CONVENTIONS (function)
910: (e->s[0].p, size, shift, divisor);
911: break;
912:
913: case TRY_TYPE_GCD_1:
914: /* Must have a non-zero src, but this probably isn't the best way to do
915: it. */
916: if (refmpn_zero_p (e->s[0].p, size))
917: e->retval = 0;
918: else
919: e->retval = CALLING_CONVENTIONS (function) (e->s[0].p, size, divisor);
920: break;
921:
922: case TRY_TYPE_GCD:
923: /* Sources are destroyed, so they're saved and replaced, but a general
924: approach to this might be better. Note that it's still e->s[0].p and
925: e->s[1].p that are passed, to get the desired alignments. */
926: {
927: mp_ptr s0 = refmpn_malloc_limbs (size);
928: mp_ptr s1 = refmpn_malloc_limbs (size2);
929: refmpn_copyi (s0, e->s[0].p, size);
930: refmpn_copyi (s1, e->s[1].p, size2);
931:
932: mprotect_region (&s[0].region, PROT_READ|PROT_WRITE);
933: mprotect_region (&s[1].region, PROT_READ|PROT_WRITE);
934: e->retval = CALLING_CONVENTIONS (function) (e->d[0].p,
935: e->s[0].p, size,
936: e->s[1].p, size2);
937: refmpn_copyi (e->s[0].p, s0, size);
938: refmpn_copyi (e->s[1].p, s1, size2);
939: free (s0);
940: free (s1);
941: }
942: break;
943:
944: case TRY_TYPE_MUL_1:
945: case TRY_TYPE_AORSMUL_1:
946: e->retval = CALLING_CONVENTIONS (function)
947: (e->d[0].p, e->s[0].p, size, multiplier);
948: break;
949: case TRY_TYPE_MUL_1C:
950: case TRY_TYPE_AORSMUL_1C:
951: /* TRY_TYPE_AORSMUL_1C same */
952: e->retval = CALLING_CONVENTIONS (function)
953: (e->d[0].p, e->s[0].p, size, multiplier, carry);
954: break;
955:
956: case TRY_TYPE_MUL_BASECASE:
957: CALLING_CONVENTIONS (function)
958: (e->d[0].p, e->s[0].p, size, e->s[1].p, size2);
959: break;
960: case TRY_TYPE_MUL_N:
961: CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, e->s[1].p, size);
962: break;
963: case TRY_TYPE_SQR:
964: CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, size);
965: break;
966:
967: case TRY_TYPE_LSHIFT:
968: case TRY_TYPE_RSHIFT:
969: e->retval = CALLING_CONVENTIONS (function)
970: (e->d[0].p, e->s[0].p, size, shift);
971: break;
972:
973: case TRY_TYPE_POPCOUNT:
974: e->retval = CALLING_CONVENTIONS (function) (e->s[0].p, size);
975: break;
976: case TRY_TYPE_HAMDIST:
977: e->retval = CALLING_CONVENTIONS (function) (e->s[0].p, e->s[1].p, size);
978: break;
979:
980: default:
981: printf ("Unknown routine type 0x%X\n", tr->flag);
982: abort ();
983: break;
984: }
985: }
986:
987:
988: void
989: pointer_setup (struct each_t *e)
990: {
991: int i, j;
992:
993: if (tr->flag & TRY_DOUBLE_DST)
994: dsize = 2*size;
995: else if (tr->flag & (TRY_SIZE2|TRY_XSIZE))
996: dsize = size+size2;
997: else
998: dsize = size;
999:
1000: /* establish e->d[].p destinations */
1001: for (i = 0; i < numberof (e->d); i++)
1002: {
1003: mp_size_t offset = 0;
1004:
1005: /* possible room for overlapping sources */
1006: for (j = 0; j < numberof (overlap->s); j++)
1007: if (overlap->s[j] == i)
1008: offset = MAX (offset, s[j].align);
1009:
1010: if (d[i].high)
1011: {
1012: e->d[i].p = e->d[i].region.ptr + e->d[i].region.size
1013: - dsize - d[i].align;
1014: if (tr->flag & TRY_OVERLAP_LOW_TO_HIGH)
1015: e->d[i].p -= offset;
1016: }
1017: else
1018: {
1019: e->d[i].p = e->d[i].region.ptr + d[i].align;
1020: if (tr->flag & TRY_OVERLAP_HIGH_TO_LOW)
1021: e->d[i].p += offset;
1022: }
1023: }
1024:
1025: /* establish e->s[].p sources */
1026: for (i = 0; i < numberof (s); i++)
1027: {
1028: int o = overlap->s[i];
1029: switch (o) {
1030: case -1:
1031: /* no overlap */
1032: e->s[i].p = s[i].p;
1033: break;
1034: case 0:
1035: case 1:
1036: /* overlap with d[o] */
1037: if (tr->flag & TRY_OVERLAP_HIGH_TO_LOW)
1038: e->s[i].p = e->d[o].p - s[i].align;
1039: else if (tr->flag & TRY_OVERLAP_LOW_TO_HIGH)
1040: e->s[i].p = e->d[o].p + s[i].align;
1041: else if (tr->flag & TRY_XSIZE)
1042: e->s[i].p = e->d[o].p + size2;
1043: else
1044: e->s[i].p = e->d[o].p;
1045: break;
1046: default:
1047: abort();
1048: break;
1049: }
1050: }
1051: }
1052:
1053:
1054: void
1055: try_one (void)
1056: {
1057: int i;
1058:
1059: if (option_spinner)
1060: spinner();
1061: spinner_count++;
1062:
1063: trap_location = TRAP_SETUPS;
1064:
1065: for (i = 0; i < numberof (s); i++)
1066: {
1067: if (s[i].high)
1068: s[i].p = s[i].region.ptr + s[i].region.size - SRC_SIZE(i) - s[i].align;
1069: else
1070: s[i].p = s[i].region.ptr + s[i].align;
1071: }
1072:
1073: pointer_setup (&ref);
1074: pointer_setup (&fun);
1075:
1076: if (tr->flag & TRY_DST0_INIT)
1077: {
1078: t_random (s[1].region.ptr, dsize);
1079: MPN_COPY (fun.d[0].p, s[1].region.ptr, dsize);
1080: MPN_COPY (ref.d[0].p, s[1].region.ptr, dsize);
1081: }
1082: else if (tr->flag & TRY_DST0)
1083: {
1084: refmpn_fill (ref.d[0].p, dsize, DEADVAL);
1085: refmpn_fill (fun.d[0].p, dsize, DEADVAL);
1086: }
1087: for (i = 1; i < numberof (d); i++)
1088: {
1089: if (!(tr->flag & TRY_DST(i)))
1090: continue;
1091:
1092: refmpn_fill (ref.d[i].p, dsize, DEADVAL);
1093: refmpn_fill (fun.d[i].p, dsize, DEADVAL);
1094: }
1095:
1096: ref.retval = 0x04152637;
1097: fun.retval = 0x8C9DAEBF;
1098:
1099: for (i = 0; i < numberof (s); i++)
1100: {
1101: if (!(tr->flag & TRY_SRC(i)))
1102: continue;
1103:
1104: mprotect_region (&s[i].region, PROT_READ|PROT_WRITE);
1105: t_random (s[i].p, SRC_SIZE(i));
1106:
1107: if (tr->flag & TRY_SRC1_GCDDATA)
1108: {
1109: /* s[1] no more bits than s[0] */
1110: if (i == 1 && size2 == size)
1111: s[1].p[size-1] &= refmpn_msbone_mask (s[0].p[size-1]);
1112:
1113: /* normalized */
1114: s[i].p[SRC_SIZE(i)-1] += (s[i].p[SRC_SIZE(i)-1] == 0);
1115:
1116: /* odd */
1117: s[i].p[0] |= 1;
1118: }
1119:
1120: mprotect_region (&s[i].region, PROT_READ);
1121:
1122: if (ref.s[i].p != s[i].p)
1123: {
1124: MPN_COPY (ref.s[i].p, s[i].p, SRC_SIZE(i));
1125: MPN_COPY (fun.s[i].p, s[i].p, SRC_SIZE(i));
1126: }
1127: }
1128:
1129: /* special requirement of divmod_1c,divrem_1c,mod_1c */
1130: if (tr->flag == TRY_TYPE_DIVMOD_1C
1131: || tr->flag == TRY_TYPE_DIVREM_1C
1132: || tr->flag == TRY_TYPE_MOD_1C)
1133: carry %= divisor;
1134:
1135: if (option_print)
1136: print_all();
1137:
1138: trap_location = TRAP_REF;
1139: call (&ref, tr->ref.function);
1140: trap_location = TRAP_FUN;
1141: call (&fun, tr->fun.function);
1142: trap_location = TRAP_NOWHERE;
1143:
1144: compare ();
1145: }
1146:
1147:
1148: #define SIZE_ITERATION \
1149: for (size = MAX3 (option_firstsize, \
1150: tr->minsize, \
1151: (tr->flag & TRY_SIZE_ZERO) ? 0 : 1); \
1152: size <= option_lastsize; \
1153: size++)
1154:
1155: #define SIZE2_FIRST \
1156: (option_firstsize2 != 0 ? option_firstsize2 \
1157: : tr->flag & TRY_SIZE2 ? 1 \
1158: : tr->flag & TRY_XSIZE ? 0 \
1159: : 0)
1160: #define SIZE2_LAST \
1161: (tr->flag & TRY_SIZE2 ? size \
1162: : tr->flag & TRY_XSIZE ? XSIZE_COUNT-1 \
1163: : 0)
1164:
1165: #define SIZE2_ITERATION \
1166: for (size2 = SIZE2_FIRST; size2 <= SIZE2_LAST; size2++)
1167:
1168: #define ALIGN_COUNT(cond) ((cond) ? ALIGNMENTS : 1)
1169: #define ALIGN_ITERATION(w,n,cond) \
1170: for (w[n].align = 0; w[n].align < ALIGN_COUNT(cond); w[n].align++)
1171:
1172: #define HIGH_LIMIT(cond) ((cond) != 0)
1173: #define HIGH_COUNT(cond) (HIGH_LIMIT (cond) + 1)
1174: #define HIGH_ITERATION(w,n,cond) \
1175: for (w[n].high = 0; w[n].high <= HIGH_LIMIT(cond); w[n].high++)
1176:
1177: #define SHIFT_LIMIT \
1178: ((unsigned long) ((tr->flag & TRY_SHIFT) ? BITS_PER_MP_LIMB-1 : 1))
1179:
1180: #define SHIFT_ITERATION \
1181: for (shift = 1; shift <= SHIFT_LIMIT; shift++)
1182:
1183:
1184: void
1185: try_many (void)
1186: {
1187: int i;
1188:
1189: {
1190: unsigned long total = 1;
1191:
1192: total *= option_repetitions;
1193: total *= option_lastsize;
1194: if (tr->flag & TRY_SIZE2) total *= (option_lastsize+1)/2;
1195: if (tr->flag & TRY_XSIZE) total *= XSIZE_COUNT;
1196:
1197: total *= SHIFT_LIMIT;
1198: total *= MULTIPLIER_COUNT;
1199: total *= DIVISOR_COUNT;
1200: total *= CARRY_COUNT;
1201: total *= T_RAND_COUNT;
1202:
1203: total *= HIGH_COUNT (tr->flag & TRY_DST0);
1204: total *= HIGH_COUNT (tr->flag & TRY_DST1);
1205: total *= HIGH_COUNT (tr->flag & TRY_SRC0);
1206: total *= HIGH_COUNT (tr->flag & TRY_SRC1);
1207:
1208: total *= ALIGN_COUNT (tr->flag & TRY_DST0);
1209: total *= ALIGN_COUNT (tr->flag & TRY_DST1);
1210: total *= ALIGN_COUNT (tr->flag & TRY_SRC0);
1211: total *= ALIGN_COUNT (tr->flag & TRY_SRC1);
1212:
1213: total *= OVERLAP_COUNT;
1214:
1215: printf ("%s %lu\n", tr->fun.name, total);
1216: }
1217:
1218: spinner_count = 0;
1219:
1220: for (i = 0; i < option_repetitions; i++)
1221: SIZE_ITERATION
1222: SIZE2_ITERATION
1223:
1224: SHIFT_ITERATION
1225: MULTIPLIER_ITERATION
1226: DIVISOR_ITERATION
1227: CARRY_ITERATION /* must be after divisor */
1228: T_RAND_ITERATION
1229:
1230: HIGH_ITERATION(d,0, tr->flag & TRY_DST0)
1231: HIGH_ITERATION(d,1, tr->flag & TRY_DST1)
1232: HIGH_ITERATION(s,0, tr->flag & TRY_SRC0)
1233: HIGH_ITERATION(s,1, tr->flag & TRY_SRC1)
1234:
1235: ALIGN_ITERATION(d,0, tr->flag & TRY_DST0)
1236: ALIGN_ITERATION(d,1, tr->flag & TRY_DST1)
1237: ALIGN_ITERATION(s,0, tr->flag & TRY_SRC0)
1238: ALIGN_ITERATION(s,1, tr->flag & TRY_SRC1)
1239:
1240: OVERLAP_ITERATION
1241: try_one();
1242:
1243: printf("\n");
1244: }
1245:
1246:
1247: /* Usually print_all() doesn't show much, but it might give a hint as to
1248: where the function was up to when it died. */
1249: void
1250: trap (int sig)
1251: {
1252: const char *name = "noname";
1253:
1254: switch (sig) {
1255: case SIGILL: name = "SIGILL"; break;
1256: #ifdef SIGBUS
1257: case SIGBUS: name = "SIGBUS"; break;
1258: #endif
1259: case SIGSEGV: name = "SIGSEGV"; break;
1260: case SIGFPE: name = "SIGFPE"; break;
1261: }
1262:
1263: printf ("\n\nSIGNAL TRAP: %s\n", name);
1264:
1265: switch (trap_location) {
1266: case TRAP_REF:
1267: printf (" in reference function: %s\n", tr->ref.name);
1268: break;
1269: case TRAP_FUN:
1270: printf (" in test function: %s\n", tr->fun.name);
1271: print_all ();
1272: break;
1273: case TRAP_SETUPS:
1274: printf (" in parameter setups\n");
1275: print_all ();
1276: break;
1277: default:
1278: printf (" somewhere unknown\n");
1279: break;
1280: }
1281: exit (1);
1282: }
1283:
1284:
1285: void
1286: try_init (void)
1287: {
1288: #if HAVE_GETPAGESIZE
1289: /* Prefer getpagesize() over sysconf(), since on SunOS 4 sysconf() doesn't
1290: know _SC_PAGESIZE. */
1291: pagesize = getpagesize ();
1292: #else
1293: #if HAVE_SYSCONF
1294: if ((pagesize = sysconf (_SC_PAGESIZE)) == -1)
1295: {
1296: /* According to the linux man page, sysconf doesn't set errno */
1297: fprintf (stderr, "Cannot get sysconf _SC_PAGESIZE\n");
1298: exit (1);
1299: }
1300: #else
1301: Error, error, cannot get page size
1302: #endif
1303: #endif
1304:
1305: printf ("pagesize is 0x%lX bytes\n", pagesize);
1306:
1307: signal (SIGILL, trap);
1308: #ifdef SIGBUS
1309: signal (SIGBUS, trap);
1310: #endif
1311: signal (SIGSEGV, trap);
1312: signal (SIGFPE, trap);
1313:
1314: {
1315: int i;
1316:
1317: for (i = 0; i < numberof (s); i++)
1318: {
1319: malloc_region (&s[i].region, 2*option_lastsize+ALIGNMENTS-1);
1320: printf ("s[%d] %p to %p (0x%lX bytes)\n",
1321: i, s[i].region.ptr,
1322: s[i].region.ptr + s[i].region.size,
1323: s[i].region.size * BYTES_PER_MP_LIMB);
1324: }
1325:
1326: #define INIT_EACH(e,es) \
1327: for (i = 0; i < numberof (e.d); i++) \
1328: { \
1329: malloc_region (&e.d[i].region, 2*option_lastsize+ALIGNMENTS-1); \
1330: printf ("%s d[%d] %p to %p (0x%lX bytes)\n", \
1331: es, i, e.d[i].region.ptr, \
1332: e.d[i].region.ptr + e.d[i].region.size, \
1333: e.d[i].region.size * BYTES_PER_MP_LIMB); \
1334: }
1335:
1336: INIT_EACH(ref, "ref");
1337: INIT_EACH(fun, "fun");
1338: }
1339: }
1340:
1341: int
1342: strmatch_wild (const char *pattern, const char *str)
1343: {
1344: size_t plen, slen;
1345:
1346: /* wildcard at start */
1347: if (pattern[0] == '*')
1348: {
1349: pattern++;
1350: plen = strlen (pattern);
1351: slen = strlen (str);
1352: return (plen == 0
1353: || (slen >= plen && memcmp (pattern, str+slen-plen, plen) == 0));
1354: }
1355:
1356: /* wildcard at end */
1357: plen = strlen (pattern);
1358: if (plen >= 1 && pattern[plen-1] == '*')
1359: return (memcmp (pattern, str, plen-1) == 0);
1360:
1361: /* no wildcards */
1362: return (strcmp (pattern, str) == 0);
1363: }
1364:
1365: void
1366: try_name (const char *name)
1367: {
1368: int found = 0;
1369: int i;
1370:
1371: for (i = 0; i < numberof (try_array); i++)
1372: {
1373: if (strmatch_wild (name, try_array[i].fun.name))
1374: {
1375: tr = &try_array[i];
1376: try_many ();
1377: found = 1;
1378: }
1379: }
1380:
1381: if (!found)
1382: {
1383: printf ("%s unknown\n", name);
1384: /* exit (1); */
1385: }
1386: }
1387:
1388:
1389: void
1390: usage (const char *prog)
1391: {
1392: int col = 0;
1393: int i;
1394:
1395: printf ("Usage: %s [options] function...\n\
1396: -1 use limb data 1,2,3,etc\n\
1397: -9 use limb data all 0xFF..FFs\n\
1398: -a zeros use limb data all zeros\n\
1399: -a ffs use limb data all 0xFF..FFs (same as -9)\n\
1400: -a 2fd use data 0x2FFF...FFFD\n\
1401: -p print each case tried (try this if seg faulting)\n\
1402: -R seed random numbers from time()\n\
1403: -r reps set repetitions (default %d)\n\
1404: -S seed randomize from given seed\n\
1405: -s size starting size to test\n\
1406: -s s1-s2 range of sizes to test\n\
1407: -W don't show the spinner (use this in gdb)\n\
1408: -z disable mprotect() redzones\n\
1409: Default data is mpn_random() and mpn_random2().\n\
1410: \n\
1411: Functions that can be tested:\n\
1412: ", prog, DEFAULT_REPETITIONS);
1413:
1414: for (i = 0; i < numberof (try_array); i++)
1415: {
1416: if (col + 1 + strlen (try_array[i].fun.name) > 79)
1417: {
1418: printf ("\n");
1419: col = 0;
1420: }
1421: printf (" %s", try_array[i].fun.name);
1422: col += 1 + strlen (try_array[i].fun.name);
1423: }
1424: printf ("\n");
1425:
1426: exit(1);
1427: }
1428:
1429:
1430: int
1431: main (int argc, char *argv[])
1432: {
1433: int i;
1434:
1435: /* unbuffered output */
1436: setbuf (stdout, NULL);
1437: setbuf (stderr, NULL);
1438:
1439: /* always trace in hex, upper-case so can paste into bc */
1440: mp_trace_base = -16;
1441:
1442: {
1443: unsigned seed = 123;
1444: int opt;
1445:
1446: while ((opt = getopt(argc, argv, "19a:pRr:S:s:Wz")) != EOF)
1447: {
1448: switch (opt) {
1449: case '1':
1450: /* use limb data values 1, 2, 3, ... etc */
1451: option_data = DATA_SEQ;
1452: break;
1453: case '9':
1454: /* use limb data values 0xFFF...FFF always */
1455: option_data = DATA_FFS;
1456: break;
1457: case 'a':
1458: if (strcmp (optarg, "zeros") == 0) option_data = DATA_ZEROS;
1459: else if (strcmp (optarg, "seq") == 0) option_data = DATA_SEQ;
1460: else if (strcmp (optarg, "ffs") == 0) option_data = DATA_FFS;
1461: else if (strcmp (optarg, "2fd") == 0) option_data = DATA_2FD;
1462: else
1463: {
1464: fprintf (stderr, "unrecognised data option: %s\n", optarg);
1465: exit (1);
1466: }
1467: break;
1468: case 'p':
1469: option_print = 1;
1470: break;
1471: case 'R':
1472: /* randomize */
1473: seed = time (NULL);
1474: break;
1475: case 'r':
1476: option_repetitions = atoi (optarg);
1477: break;
1478: case 's':
1479: {
1480: char *p;
1481: option_firstsize = atoi (optarg);
1482: if ((p = strchr (optarg, '-')) != NULL)
1483: option_lastsize = atoi (p+1);
1484: }
1485: break;
1486: case 'S':
1487: /* -S <size> sets the starting size for the second of a two size
1488: routine (like mpn_mul_basecase) */
1489: option_firstsize2 = atoi (optarg);
1490: break;
1491: case 'W':
1492: /* use this when running in the debugger */
1493: option_spinner = 0;
1494: break;
1495: case 'z':
1496: /* disable redzones */
1497: option_redzones = 0;
1498: break;
1499: case '?':
1500: usage (argv[0]);
1501: break;
1502: }
1503: }
1504:
1505: srandom (seed);
1506: }
1507:
1508: try_init();
1509:
1510: if (argc <= optind)
1511: usage (argv[0]);
1512:
1513: for (i = optind; i < argc; i++)
1514: try_name (argv[i]);
1515:
1516: return 0;
1517: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to try.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / mpn / tests