Annotation of OpenXM_contrib/gmp/tests/devel/try.c, Revision 1.1
1.1 ! ohara 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: Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
! 7:
! 8: This file is part of the GNU MP Library.
! 9:
! 10: The GNU MP Library is free software; you can redistribute it and/or modify
! 11: it under the terms of the GNU Lesser General Public License as published by
! 12: the Free Software Foundation; either version 2.1 of the License, or (at your
! 13: option) any later version.
! 14:
! 15: The GNU MP Library is distributed in the hope that it will be useful, but
! 16: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 17: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
! 18: License for more details.
! 19:
! 20: You should have received a copy of the GNU Lesser General Public License
! 21: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
! 22: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
! 23: MA 02111-1307, USA. */
! 24:
! 25:
! 26: /* Usage: try [options] <function>...
! 27:
! 28: For example, "./try mpn_add_n" to run tests of that function.
! 29:
! 30: Combinations of alignments and overlaps are tested, with redzones above
! 31: or below the destinations, and with the sources write-protected.
! 32:
! 33: The number of tests performed becomes ridiculously large with all the
! 34: combinations, and for that reason this can't be a part of a "make check",
! 35: it's meant only for development. The code isn't very pretty either.
! 36:
! 37: During development it can help to disable the redzones, since seeing the
! 38: rest of the destination written can show where the wrong part is, or if
! 39: the dst pointers are off by 1 or whatever. The magic DEADVAL initial
! 40: fill (see below) will show locations never written.
! 41:
! 42: The -s option can be used to test only certain size operands, which is
! 43: useful if some new code doesn't yet support say sizes less than the
! 44: unrolling, or whatever.
! 45:
! 46: When a problem occurs it'll of course be necessary to run the program
! 47: under gdb to find out quite where, how and why it's going wrong. Disable
! 48: the spinner with the -W option when doing this, or single stepping won't
! 49: work. Using the "-1" option to run with simple data can be useful.
! 50:
! 51: New functions to test can be added in try_array[]. If a new TYPE is
! 52: required then add it to the existing constants, set up its parameters in
! 53: param_init(), and add it to the call() function. Extra parameter fields
! 54: can be added if necessary, or further interpretations given to existing
! 55: fields.
! 56:
! 57:
! 58: Bugs:
! 59:
! 60: umul_ppmm support is not very good, lots of source data is generated
! 61: whereas only two limbs are needed.
! 62:
! 63:
! 64: Future:
! 65:
! 66: Make a little scheme for interpreting the "SIZE" selections uniformly.
! 67:
! 68: Make tr->size==SIZE_2 work, for the benefit of find_a which wants just 2
! 69: source limbs. Possibly increase the default repetitions in that case.
! 70:
! 71: Automatically detect gdb and disable the spinner (use -W for now).
! 72:
! 73: Make a way to re-run a failing case in the debugger. Have an option to
! 74: snapshot each test case before it's run so the data is available if a
! 75: segv occurs. (This should be more reliable than the current print_all()
! 76: in the signal handler.)
! 77:
! 78: When alignment means a dst isn't hard against the redzone, check the
! 79: space in between remains unchanged.
! 80:
! 81: See if the 80x86 debug registers can do redzones on byte boundaries.
! 82:
! 83: When a source overlaps a destination, don't run both s[i].high 0 and 1,
! 84: as s[i].high has no effect. Maybe encode s[i].high into overlap->s[i].
! 85:
! 86: When partial overlaps aren't done, don't loop over source alignments
! 87: during overlaps.
! 88:
! 89: Try to make the looping code a bit less horrible. Right now it's pretty
! 90: hard to see what iterations are actually done.
! 91:
! 92: When there's no overlap, run with both src>dst and src<dst. A subtle
! 93: calling-conventions violation occured in a P6 copy which depended on the
! 94: relative location of src and dst.
! 95:
! 96: */
! 97:
! 98:
! 99: /* always do assertion checking */
! 100: #define WANT_ASSERT 1
! 101:
! 102: #include "config.h"
! 103:
! 104: #include <errno.h>
! 105: #include <limits.h>
! 106: #include <signal.h>
! 107: #include <stdio.h>
! 108: #include <stdlib.h>
! 109: #include <string.h>
! 110: #include <time.h>
! 111:
! 112: #if HAVE_UNISTD_H
! 113: #include <unistd.h>
! 114: #endif
! 115:
! 116: #if HAVE_SYS_MMAN_H
! 117: #include <sys/mman.h>
! 118: #endif
! 119:
! 120: #include "gmp.h"
! 121: #include "gmp-impl.h"
! 122: #include "longlong.h"
! 123: #include "tests.h"
! 124:
! 125:
! 126: #if WANT_ASSERT
! 127: #define ASSERT_CARRY(expr) ASSERT_ALWAYS ((expr) != 0)
! 128: #else
! 129: #define ASSERT_CARRY(expr) (expr)
! 130: #endif
! 131:
! 132:
! 133: #if !HAVE_DECL_OPTARG
! 134: extern char *optarg;
! 135: extern int optind, opterr;
! 136: #endif
! 137:
! 138: /* Rumour has it some systems lack a define of PROT_NONE. */
! 139: #ifndef PROT_NONE
! 140: #define PROT_NONE 0
! 141: #endif
! 142:
! 143: /* Dummy defines for when mprotect doesn't exist. */
! 144: #ifndef PROT_READ
! 145: #define PROT_READ 0
! 146: #endif
! 147: #ifndef PROT_WRITE
! 148: #define PROT_WRITE 0
! 149: #endif
! 150:
! 151: #ifdef EXTRA_PROTOS
! 152: EXTRA_PROTOS
! 153: #endif
! 154: #ifdef EXTRA_PROTOS2
! 155: EXTRA_PROTOS2
! 156: #endif
! 157:
! 158:
! 159: #define DEFAULT_REPETITIONS 10
! 160:
! 161: int option_repetitions = DEFAULT_REPETITIONS;
! 162: int option_spinner = 1;
! 163: int option_redzones = 1;
! 164: int option_firstsize = 0;
! 165: int option_lastsize = 500;
! 166: int option_firstsize2 = 0;
! 167:
! 168: #define ALIGNMENTS 4
! 169: #define OVERLAPS 4
! 170: #define CARRY_RANDOMS 5
! 171: #define MULTIPLIER_RANDOMS 5
! 172: #define DIVISOR_RANDOMS 5
! 173: #define FRACTION_COUNT 4
! 174:
! 175: int option_print = 0;
! 176:
! 177: #define DATA_TRAND 0
! 178: #define DATA_ZEROS 1
! 179: #define DATA_SEQ 2
! 180: #define DATA_FFS 3
! 181: #define DATA_2FD 4
! 182: int option_data = DATA_TRAND;
! 183:
! 184:
! 185: mp_size_t pagesize;
! 186: #define PAGESIZE_LIMBS (pagesize / BYTES_PER_MP_LIMB)
! 187:
! 188: /* must be a multiple of the page size */
! 189: #define REDZONE_BYTES (pagesize * 16)
! 190: #define REDZONE_LIMBS (REDZONE_BYTES / BYTES_PER_MP_LIMB)
! 191:
! 192:
! 193: #define MAX3(x,y,z) (MAX (x, MAX (y, z)))
! 194:
! 195: #if BITS_PER_MP_LIMB == 32
! 196: #define DEADVAL CNST_LIMB(0xDEADBEEF)
! 197: #else
! 198: #define DEADVAL CNST_LIMB(0xDEADBEEFBADDCAFE)
! 199: #endif
! 200:
! 201:
! 202: struct region_t {
! 203: mp_ptr ptr;
! 204: mp_size_t size;
! 205: };
! 206:
! 207:
! 208: #define TRAP_NOWHERE 0
! 209: #define TRAP_REF 1
! 210: #define TRAP_FUN 2
! 211: #define TRAP_SETUPS 3
! 212: int trap_location = TRAP_NOWHERE;
! 213:
! 214:
! 215: #define NUM_SOURCES 2
! 216: #define NUM_DESTS 2
! 217:
! 218: struct source_t {
! 219: struct region_t region;
! 220: int high;
! 221: mp_size_t align;
! 222: mp_ptr p;
! 223: };
! 224:
! 225: struct source_t s[NUM_SOURCES];
! 226:
! 227: struct dest_t {
! 228: int high;
! 229: mp_size_t align;
! 230: mp_size_t size;
! 231: };
! 232:
! 233: struct dest_t d[NUM_DESTS];
! 234:
! 235: struct source_each_t {
! 236: mp_ptr p;
! 237: };
! 238:
! 239: struct dest_each_t {
! 240: struct region_t region;
! 241: mp_ptr p;
! 242: };
! 243:
! 244: mp_size_t size;
! 245: mp_size_t size2;
! 246: unsigned long shift;
! 247: mp_limb_t carry;
! 248: mp_limb_t divisor;
! 249: mp_limb_t multiplier;
! 250:
! 251: struct each_t {
! 252: const char *name;
! 253: struct dest_each_t d[NUM_DESTS];
! 254: struct source_each_t s[NUM_SOURCES];
! 255: mp_limb_t retval;
! 256: };
! 257:
! 258: struct each_t ref = { "Ref" };
! 259: struct each_t fun = { "Fun" };
! 260:
! 261: #define SRC_SIZE(n) ((n) == 1 && tr->size2 ? size2 : size)
! 262:
! 263: void validate_fail _PROTO ((void));
! 264:
! 265:
! 266: #if HAVE_TRY_NEW_C
! 267: #include "try-new.c"
! 268: #endif
! 269:
! 270:
! 271: typedef mp_limb_t (*tryfun_t) _PROTO ((ANYARGS));
! 272:
! 273: struct try_t {
! 274: char retval;
! 275:
! 276: char src[2];
! 277: char dst[2];
! 278:
! 279: #define SIZE_YES 1
! 280: #define SIZE_ALLOW_ZERO 2
! 281: #define SIZE_1 3 /* 1 limb */
! 282: #define SIZE_2 4 /* 2 limbs */
! 283: #define SIZE_3 5 /* 3 limbs */
! 284: #define SIZE_FRACTION 6 /* size2 is fraction for divrem etc */
! 285: #define SIZE_SIZE2 7
! 286: #define SIZE_PLUS_1 8
! 287: #define SIZE_SUM 9
! 288: #define SIZE_DIFF 10
! 289: #define SIZE_DIFF_PLUS_1 11
! 290: #define SIZE_RETVAL 12
! 291: #define SIZE_CEIL_HALF 13
! 292: #define SIZE_GET_STR 14
! 293: char size;
! 294: char size2;
! 295: char dst_size[2];
! 296:
! 297: char dst_bytes[2];
! 298:
! 299: char dst0_from_src1;
! 300:
! 301: #define CARRY_BIT 1 /* single bit 0 or 1 */
! 302: #define CARRY_3 2 /* 0, 1, 2 */
! 303: #define CARRY_4 3 /* 0 to 3 */
! 304: #define CARRY_LIMB 4 /* any limb value */
! 305: #define CARRY_DIVISOR 5 /* carry<divisor */
! 306: char carry;
! 307:
! 308: /* a fudge to tell the output when to print negatives */
! 309: char carry_sign;
! 310:
! 311: char multiplier;
! 312: char shift;
! 313:
! 314: #define DIVISOR_LIMB 1
! 315: #define DIVISOR_NORM 2
! 316: #define DIVISOR_ODD 3
! 317: char divisor;
! 318:
! 319: #define DATA_NON_ZERO 1
! 320: #define DATA_GCD 2
! 321: #define DATA_SRC1_ODD 3
! 322: #define DATA_SRC1_HIGHBIT 4
! 323: #define DATA_MULTIPLE_DIVISOR 5
! 324: #define DATA_UDIV_QRNND 6
! 325: char data;
! 326:
! 327: /* Default is allow full overlap. */
! 328: #define OVERLAP_NONE 1
! 329: #define OVERLAP_LOW_TO_HIGH 2
! 330: #define OVERLAP_HIGH_TO_LOW 3
! 331: #define OVERLAP_NOT_SRCS 4
! 332: #define OVERLAP_NOT_SRC2 8
! 333: char overlap;
! 334:
! 335: tryfun_t reference;
! 336: const char *reference_name;
! 337:
! 338: void (*validate) _PROTO ((void));
! 339: const char *validate_name;
! 340: };
! 341:
! 342: struct try_t *tr;
! 343:
! 344:
! 345: void
! 346: validate_mod_34lsub1 (void)
! 347: {
! 348: #define CNST_34LSUB1 ((CNST_LIMB(1) << (3 * (BITS_PER_MP_LIMB / 4))) - 1)
! 349:
! 350: mp_srcptr ptr = s[0].p;
! 351: int error = 0;
! 352: mp_limb_t got, got_mod, want, want_mod;
! 353:
! 354: ASSERT (size >= 1);
! 355:
! 356: got = fun.retval;
! 357: got_mod = got % CNST_34LSUB1;
! 358:
! 359: want = refmpn_mod_34lsub1 (ptr, size);
! 360: want_mod = want % CNST_34LSUB1;
! 361:
! 362: if (got_mod != want_mod)
! 363: {
! 364: printf ("got 0x%lX reduced from 0x%lX\n", got_mod, got);
! 365: printf ("want 0x%lX reduced from 0x%lX\n", want_mod, want);
! 366: error = 1;
! 367: }
! 368:
! 369: if (error)
! 370: validate_fail ();
! 371: }
! 372:
! 373: void
! 374: validate_divexact_1 (void)
! 375: {
! 376: mp_srcptr src = s[0].p;
! 377: mp_srcptr dst = fun.d[0].p;
! 378: int error = 0;
! 379:
! 380: ASSERT (size >= 1);
! 381:
! 382: {
! 383: mp_ptr tp = refmpn_malloc_limbs (size);
! 384: mp_limb_t rem;
! 385:
! 386: rem = refmpn_divrem_1 (tp, 0, src, size, divisor);
! 387: if (rem != 0)
! 388: {
! 389: printf ("Remainder a%%d == 0x%lX, mpn_divexact_1 undefined\n", rem);
! 390: error = 1;
! 391: }
! 392: if (! refmpn_equal_anynail (tp, dst, size))
! 393: {
! 394: printf ("Quotient a/d wrong\n");
! 395: mpn_trace ("fun ", dst, size);
! 396: mpn_trace ("want", tp, size);
! 397: error = 1;
! 398: }
! 399: free (tp);
! 400: }
! 401:
! 402: if (error)
! 403: validate_fail ();
! 404: }
! 405:
! 406:
! 407: void
! 408: validate_modexact_1c_odd (void)
! 409: {
! 410: mp_srcptr ptr = s[0].p;
! 411: mp_limb_t r = fun.retval;
! 412: int error = 0;
! 413:
! 414: ASSERT (size >= 1);
! 415: ASSERT (divisor & 1);
! 416:
! 417: if (carry < divisor)
! 418: {
! 419: if (! (r < divisor))
! 420: {
! 421: printf ("Don't have r < divisor\n");
! 422: error = 1;
! 423: }
! 424: }
! 425: else /* carry >= divisor */
! 426: {
! 427: if (! (r <= divisor))
! 428: {
! 429: printf ("Don't have r <= divisor\n");
! 430: error = 1;
! 431: }
! 432: }
! 433:
! 434: {
! 435: mp_limb_t c = carry % divisor;
! 436: mp_ptr tp = refmpn_malloc_limbs (size+1);
! 437: mp_size_t k;
! 438:
! 439: for (k = size-1; k <= size; k++)
! 440: {
! 441: /* set {tp,size+1} to r*b^k + a - c */
! 442: refmpn_copyi (tp, ptr, size);
! 443: tp[size] = 0;
! 444: ASSERT_NOCARRY (refmpn_add_1 (tp+k, tp+k, size+1-k, r));
! 445: if (refmpn_sub_1 (tp, tp, size+1, c))
! 446: ASSERT_CARRY (mpn_add_1 (tp, tp, size+1, divisor));
! 447:
! 448: if (refmpn_mod_1 (tp, size+1, divisor) == 0)
! 449: goto good_remainder;
! 450: }
! 451: printf ("Remainder matches neither r*b^(size-1) nor r*b^size\n");
! 452: error = 1;
! 453:
! 454: good_remainder:
! 455: free (tp);
! 456: }
! 457:
! 458: if (error)
! 459: validate_fail ();
! 460: }
! 461:
! 462: void
! 463: validate_modexact_1_odd (void)
! 464: {
! 465: carry = 0;
! 466: validate_modexact_1c_odd ();
! 467: }
! 468:
! 469:
! 470: void
! 471: validate_sqrtrem (void)
! 472: {
! 473: mp_srcptr orig_ptr = s[0].p;
! 474: mp_size_t orig_size = size;
! 475: mp_size_t root_size = (size+1)/2;
! 476: mp_srcptr root_ptr = fun.d[0].p;
! 477: mp_size_t rem_size = fun.retval;
! 478: mp_srcptr rem_ptr = fun.d[1].p;
! 479: mp_size_t prod_size = 2*root_size;
! 480: mp_ptr p;
! 481: int error = 0;
! 482:
! 483: if (rem_size < 0 || rem_size > size)
! 484: {
! 485: printf ("Bad remainder size retval %ld\n", rem_size);
! 486: validate_fail ();
! 487: }
! 488:
! 489: p = refmpn_malloc_limbs (prod_size);
! 490:
! 491: p[root_size] = refmpn_lshift (p, root_ptr, root_size, 1);
! 492: if (refmpn_cmp_twosizes (p,root_size+1, rem_ptr,rem_size) < 0)
! 493: {
! 494: printf ("Remainder bigger than 2*root\n");
! 495: error = 1;
! 496: }
! 497:
! 498: refmpn_sqr (p, root_ptr, root_size);
! 499: if (rem_size != 0)
! 500: refmpn_add (p, p, prod_size, rem_ptr, rem_size);
! 501: if (refmpn_cmp_twosizes (p,prod_size, orig_ptr,orig_size) != 0)
! 502: {
! 503: printf ("root^2+rem != original\n");
! 504: mpn_trace ("prod", p, prod_size);
! 505: error = 1;
! 506: }
! 507: free (p);
! 508:
! 509: if (error)
! 510: validate_fail ();
! 511: }
! 512:
! 513:
! 514: /* These types are indexes into the param[] array and are arbitrary so long
! 515: as they're all distinct and within the size of param[]. Renumber
! 516: whenever necessary or desired. */
! 517:
! 518: #define TYPE_ADD 1
! 519: #define TYPE_ADD_N 2
! 520: #define TYPE_ADD_NC 3
! 521: #define TYPE_SUB 4
! 522: #define TYPE_SUB_N 5
! 523: #define TYPE_SUB_NC 6
! 524:
! 525: #define TYPE_MUL_1 7
! 526: #define TYPE_MUL_1C 8
! 527:
! 528: #define TYPE_MUL_2 9
! 529:
! 530: #define TYPE_ADDMUL_1 10
! 531: #define TYPE_ADDMUL_1C 11
! 532: #define TYPE_SUBMUL_1 12
! 533: #define TYPE_SUBMUL_1C 13
! 534:
! 535: #define TYPE_ADDSUB_N 14
! 536: #define TYPE_ADDSUB_NC 15
! 537:
! 538: #define TYPE_RSHIFT 16
! 539: #define TYPE_LSHIFT 17
! 540:
! 541: #define TYPE_COPY 20
! 542: #define TYPE_COPYI 21
! 543: #define TYPE_COPYD 22
! 544: #define TYPE_COM_N 23
! 545:
! 546: #define TYPE_MOD_1 25
! 547: #define TYPE_MOD_1C 26
! 548: #define TYPE_DIVMOD_1 27
! 549: #define TYPE_DIVMOD_1C 28
! 550: #define TYPE_DIVREM_1 29
! 551: #define TYPE_DIVREM_1C 30
! 552: #define TYPE_PREINV_DIVREM_1 31
! 553: #define TYPE_PREINV_MOD_1 32
! 554: #define TYPE_MOD_34LSUB1 33
! 555: #define TYPE_UDIV_QRNND 34
! 556:
! 557: #define TYPE_DIVEXACT_1 35
! 558: #define TYPE_DIVEXACT_BY3 36
! 559: #define TYPE_DIVEXACT_BY3C 37
! 560:
! 561: #define TYPE_MODEXACT_1_ODD 38
! 562: #define TYPE_MODEXACT_1C_ODD 39
! 563:
! 564: #define TYPE_GCD 40
! 565: #define TYPE_GCD_1 41
! 566: #define TYPE_GCD_FINDA 42
! 567: #define TYPE_MPZ_JACOBI 43
! 568: #define TYPE_MPZ_KRONECKER 44
! 569: #define TYPE_MPZ_KRONECKER_UI 45
! 570: #define TYPE_MPZ_KRONECKER_SI 46
! 571: #define TYPE_MPZ_UI_KRONECKER 47
! 572: #define TYPE_MPZ_SI_KRONECKER 48
! 573:
! 574: #define TYPE_AND_N 50
! 575: #define TYPE_NAND_N 51
! 576: #define TYPE_ANDN_N 52
! 577: #define TYPE_IOR_N 53
! 578: #define TYPE_IORN_N 54
! 579: #define TYPE_NIOR_N 55
! 580: #define TYPE_XOR_N 56
! 581: #define TYPE_XNOR_N 57
! 582:
! 583: #define TYPE_POPCOUNT 58
! 584: #define TYPE_HAMDIST 59
! 585:
! 586: #define TYPE_MUL_BASECASE 60
! 587: #define TYPE_MUL_N 61
! 588: #define TYPE_SQR 62
! 589: #define TYPE_UMUL_PPMM 63
! 590: #define TYPE_UMUL_PPMM_R 64
! 591:
! 592: #define TYPE_SB_DIVREM_MN 70
! 593: #define TYPE_TDIV_QR 71
! 594:
! 595: #define TYPE_SQRTREM 80
! 596: #define TYPE_ZERO 81
! 597: #define TYPE_GET_STR 82
! 598:
! 599: #define TYPE_EXTRA 90
! 600:
! 601: struct try_t param[150];
! 602:
! 603:
! 604: void
! 605: param_init (void)
! 606: {
! 607: struct try_t *p;
! 608:
! 609: #define COPY(index) memcpy (p, ¶m[index], sizeof (*p))
! 610:
! 611: #if HAVE_STRINGIZE
! 612: #define REFERENCE(fun) \
! 613: p->reference = (tryfun_t) fun; \
! 614: p->reference_name = #fun
! 615: #define VALIDATE(fun) \
! 616: p->validate = fun; \
! 617: p->validate_name = #fun
! 618: #else
! 619: #define REFERENCE(fun) \
! 620: p->reference = (tryfun_t) fun; \
! 621: p->reference_name = "fun"
! 622: #define VALIDATE(fun) \
! 623: p->validate = fun; \
! 624: p->validate_name = "fun"
! 625: #endif
! 626:
! 627:
! 628: p = ¶m[TYPE_ADD_N];
! 629: p->retval = 1;
! 630: p->dst[0] = 1;
! 631: p->src[0] = 1;
! 632: p->src[1] = 1;
! 633: REFERENCE (refmpn_add_n);
! 634:
! 635: p = ¶m[TYPE_ADD_NC];
! 636: COPY (TYPE_ADD_N);
! 637: p->carry = CARRY_BIT;
! 638: REFERENCE (refmpn_add_nc);
! 639:
! 640: p = ¶m[TYPE_SUB_N];
! 641: COPY (TYPE_ADD_N);
! 642: REFERENCE (refmpn_sub_n);
! 643:
! 644: p = ¶m[TYPE_SUB_NC];
! 645: COPY (TYPE_ADD_NC);
! 646: REFERENCE (refmpn_sub_nc);
! 647:
! 648: p = ¶m[TYPE_ADD];
! 649: COPY (TYPE_ADD_N);
! 650: p->size = SIZE_ALLOW_ZERO;
! 651: p->size2 = 1;
! 652: REFERENCE (refmpn_add);
! 653:
! 654: p = ¶m[TYPE_SUB];
! 655: COPY (TYPE_ADD);
! 656: REFERENCE (refmpn_sub);
! 657:
! 658:
! 659: p = ¶m[TYPE_MUL_1];
! 660: p->retval = 1;
! 661: p->dst[0] = 1;
! 662: p->src[0] = 1;
! 663: p->multiplier = 1;
! 664: p->overlap = OVERLAP_LOW_TO_HIGH;
! 665: REFERENCE (refmpn_mul_1);
! 666:
! 667: p = ¶m[TYPE_MUL_1C];
! 668: COPY (TYPE_MUL_1);
! 669: p->carry = CARRY_LIMB;
! 670: REFERENCE (refmpn_mul_1c);
! 671:
! 672:
! 673: p = ¶m[TYPE_MUL_2];
! 674: p->retval = 1;
! 675: p->dst[0] = 1;
! 676: p->dst_size[0] = SIZE_PLUS_1;
! 677: p->src[0] = 1;
! 678: p->src[1] = 1;
! 679: p->size2 = SIZE_2;
! 680: p->overlap = OVERLAP_NOT_SRC2;
! 681: REFERENCE (refmpn_mul_2);
! 682:
! 683:
! 684: p = ¶m[TYPE_ADDMUL_1];
! 685: p->retval = 1;
! 686: p->dst[0] = 1;
! 687: p->src[0] = 1;
! 688: p->multiplier = 1;
! 689: p->dst0_from_src1 = 1;
! 690: REFERENCE (refmpn_addmul_1);
! 691:
! 692: p = ¶m[TYPE_ADDMUL_1C];
! 693: COPY (TYPE_ADDMUL_1);
! 694: p->carry = CARRY_LIMB;
! 695: REFERENCE (refmpn_addmul_1c);
! 696:
! 697: p = ¶m[TYPE_SUBMUL_1];
! 698: COPY (TYPE_ADDMUL_1);
! 699: REFERENCE (refmpn_submul_1);
! 700:
! 701: p = ¶m[TYPE_SUBMUL_1C];
! 702: COPY (TYPE_ADDMUL_1C);
! 703: REFERENCE (refmpn_submul_1c);
! 704:
! 705:
! 706: p = ¶m[TYPE_AND_N];
! 707: p->dst[0] = 1;
! 708: p->src[0] = 1;
! 709: p->src[1] = 1;
! 710: REFERENCE (refmpn_and_n);
! 711:
! 712: p = ¶m[TYPE_ANDN_N];
! 713: COPY (TYPE_AND_N);
! 714: REFERENCE (refmpn_andn_n);
! 715:
! 716: p = ¶m[TYPE_NAND_N];
! 717: COPY (TYPE_AND_N);
! 718: REFERENCE (refmpn_nand_n);
! 719:
! 720: p = ¶m[TYPE_IOR_N];
! 721: COPY (TYPE_AND_N);
! 722: REFERENCE (refmpn_ior_n);
! 723:
! 724: p = ¶m[TYPE_IORN_N];
! 725: COPY (TYPE_AND_N);
! 726: REFERENCE (refmpn_iorn_n);
! 727:
! 728: p = ¶m[TYPE_NIOR_N];
! 729: COPY (TYPE_AND_N);
! 730: REFERENCE (refmpn_nior_n);
! 731:
! 732: p = ¶m[TYPE_XOR_N];
! 733: COPY (TYPE_AND_N);
! 734: REFERENCE (refmpn_xor_n);
! 735:
! 736: p = ¶m[TYPE_XNOR_N];
! 737: COPY (TYPE_AND_N);
! 738: REFERENCE (refmpn_xnor_n);
! 739:
! 740:
! 741: p = ¶m[TYPE_ADDSUB_N];
! 742: p->retval = 1;
! 743: p->dst[0] = 1;
! 744: p->dst[1] = 1;
! 745: p->src[0] = 1;
! 746: p->src[1] = 1;
! 747: REFERENCE (refmpn_addsub_n);
! 748:
! 749: p = ¶m[TYPE_ADDSUB_NC];
! 750: COPY (TYPE_ADDSUB_N);
! 751: p->carry = CARRY_4;
! 752: REFERENCE (refmpn_addsub_nc);
! 753:
! 754:
! 755: p = ¶m[TYPE_COPY];
! 756: p->dst[0] = 1;
! 757: p->src[0] = 1;
! 758: p->overlap = OVERLAP_NONE;
! 759: p->size = SIZE_ALLOW_ZERO;
! 760: REFERENCE (refmpn_copy);
! 761:
! 762: p = ¶m[TYPE_COPYI];
! 763: p->dst[0] = 1;
! 764: p->src[0] = 1;
! 765: p->overlap = OVERLAP_LOW_TO_HIGH;
! 766: p->size = SIZE_ALLOW_ZERO;
! 767: REFERENCE (refmpn_copyi);
! 768:
! 769: p = ¶m[TYPE_COPYD];
! 770: p->dst[0] = 1;
! 771: p->src[0] = 1;
! 772: p->overlap = OVERLAP_HIGH_TO_LOW;
! 773: p->size = SIZE_ALLOW_ZERO;
! 774: REFERENCE (refmpn_copyd);
! 775:
! 776: p = ¶m[TYPE_COM_N];
! 777: p->dst[0] = 1;
! 778: p->src[0] = 1;
! 779: REFERENCE (refmpn_com_n);
! 780:
! 781:
! 782: p = ¶m[TYPE_MOD_1];
! 783: p->retval = 1;
! 784: p->src[0] = 1;
! 785: p->size = SIZE_ALLOW_ZERO;
! 786: p->divisor = DIVISOR_LIMB;
! 787: REFERENCE (refmpn_mod_1);
! 788:
! 789: p = ¶m[TYPE_MOD_1C];
! 790: COPY (TYPE_MOD_1);
! 791: p->carry = CARRY_DIVISOR;
! 792: REFERENCE (refmpn_mod_1c);
! 793:
! 794: p = ¶m[TYPE_DIVMOD_1];
! 795: COPY (TYPE_MOD_1);
! 796: p->dst[0] = 1;
! 797: REFERENCE (refmpn_divmod_1);
! 798:
! 799: p = ¶m[TYPE_DIVMOD_1C];
! 800: COPY (TYPE_DIVMOD_1);
! 801: p->carry = CARRY_DIVISOR;
! 802: REFERENCE (refmpn_divmod_1c);
! 803:
! 804: p = ¶m[TYPE_DIVREM_1];
! 805: COPY (TYPE_DIVMOD_1);
! 806: p->size2 = SIZE_FRACTION;
! 807: p->dst_size[0] = SIZE_SUM;
! 808: REFERENCE (refmpn_divrem_1);
! 809:
! 810: p = ¶m[TYPE_DIVREM_1C];
! 811: COPY (TYPE_DIVREM_1);
! 812: p->carry = CARRY_DIVISOR;
! 813: REFERENCE (refmpn_divrem_1c);
! 814:
! 815: p = ¶m[TYPE_PREINV_DIVREM_1];
! 816: COPY (TYPE_DIVREM_1);
! 817: p->size = SIZE_YES; /* ie. no size==0 */
! 818: REFERENCE (refmpn_preinv_divrem_1);
! 819:
! 820: p = ¶m[TYPE_PREINV_MOD_1];
! 821: p->retval = 1;
! 822: p->src[0] = 1;
! 823: p->divisor = DIVISOR_NORM;
! 824: REFERENCE (refmpn_preinv_mod_1);
! 825:
! 826: p = ¶m[TYPE_MOD_34LSUB1];
! 827: p->retval = 1;
! 828: p->src[0] = 1;
! 829: VALIDATE (validate_mod_34lsub1);
! 830:
! 831: p = ¶m[TYPE_UDIV_QRNND];
! 832: p->retval = 1;
! 833: p->src[0] = 1;
! 834: p->dst[0] = 1;
! 835: p->dst_size[0] = SIZE_1;
! 836: p->divisor = DIVISOR_LIMB;
! 837: p->data = DATA_UDIV_QRNND;
! 838: p->overlap = OVERLAP_NONE;
! 839: REFERENCE (refmpn_udiv_qrnnd);
! 840:
! 841:
! 842: p = ¶m[TYPE_DIVEXACT_1];
! 843: p->dst[0] = 1;
! 844: p->src[0] = 1;
! 845: p->divisor = 1;
! 846: p->data = DATA_MULTIPLE_DIVISOR;
! 847: VALIDATE (validate_divexact_1);
! 848: REFERENCE (refmpn_divmod_1);
! 849:
! 850:
! 851: p = ¶m[TYPE_DIVEXACT_BY3];
! 852: p->retval = 1;
! 853: p->dst[0] = 1;
! 854: p->src[0] = 1;
! 855: REFERENCE (refmpn_divexact_by3);
! 856:
! 857: p = ¶m[TYPE_DIVEXACT_BY3C];
! 858: COPY (TYPE_DIVEXACT_BY3);
! 859: p->carry = CARRY_3;
! 860: REFERENCE (refmpn_divexact_by3c);
! 861:
! 862:
! 863: p = ¶m[TYPE_MODEXACT_1_ODD];
! 864: p->retval = 1;
! 865: p->src[0] = 1;
! 866: p->divisor = DIVISOR_ODD;
! 867: VALIDATE (validate_modexact_1_odd);
! 868:
! 869: p = ¶m[TYPE_MODEXACT_1C_ODD];
! 870: COPY (TYPE_MODEXACT_1_ODD);
! 871: p->carry = CARRY_LIMB;
! 872: VALIDATE (validate_modexact_1c_odd);
! 873:
! 874:
! 875: p = ¶m[TYPE_GCD_1];
! 876: p->retval = 1;
! 877: p->src[0] = 1;
! 878: p->data = DATA_NON_ZERO;
! 879: p->divisor = DIVISOR_LIMB;
! 880: REFERENCE (refmpn_gcd_1);
! 881:
! 882: p = ¶m[TYPE_GCD];
! 883: p->retval = 1;
! 884: p->dst[0] = 1;
! 885: p->src[0] = 1;
! 886: p->src[1] = 1;
! 887: p->size2 = 1;
! 888: p->dst_size[0] = SIZE_RETVAL;
! 889: p->overlap = OVERLAP_NOT_SRCS;
! 890: p->data = DATA_GCD;
! 891: REFERENCE (refmpn_gcd);
! 892:
! 893: /* FIXME: size==2 */
! 894: p = ¶m[TYPE_GCD_FINDA];
! 895: p->retval = 1;
! 896: p->src[0] = 1;
! 897: REFERENCE (refmpn_gcd_finda);
! 898:
! 899:
! 900: p = ¶m[TYPE_MPZ_JACOBI];
! 901: p->retval = 1;
! 902: p->src[0] = 1;
! 903: p->size = SIZE_ALLOW_ZERO;
! 904: p->src[1] = 1;
! 905: p->size2 = 1;
! 906: p->carry = CARRY_4;
! 907: p->carry_sign = 1;
! 908: REFERENCE (refmpz_jacobi);
! 909:
! 910: p = ¶m[TYPE_MPZ_KRONECKER];
! 911: COPY (TYPE_MPZ_JACOBI);
! 912: REFERENCE (refmpz_kronecker);
! 913:
! 914:
! 915: p = ¶m[TYPE_MPZ_KRONECKER_UI];
! 916: p->retval = 1;
! 917: p->src[0] = 1;
! 918: p->size = SIZE_ALLOW_ZERO;
! 919: p->multiplier = 1;
! 920: p->carry = CARRY_BIT;
! 921: REFERENCE (refmpz_kronecker_ui);
! 922:
! 923: p = ¶m[TYPE_MPZ_KRONECKER_SI];
! 924: COPY (TYPE_MPZ_KRONECKER_UI);
! 925: REFERENCE (refmpz_kronecker_si);
! 926:
! 927: p = ¶m[TYPE_MPZ_UI_KRONECKER];
! 928: COPY (TYPE_MPZ_KRONECKER_UI);
! 929: REFERENCE (refmpz_ui_kronecker);
! 930:
! 931: p = ¶m[TYPE_MPZ_SI_KRONECKER];
! 932: COPY (TYPE_MPZ_KRONECKER_UI);
! 933: REFERENCE (refmpz_si_kronecker);
! 934:
! 935:
! 936: p = ¶m[TYPE_SQR];
! 937: p->dst[0] = 1;
! 938: p->src[0] = 1;
! 939: p->dst_size[0] = SIZE_SUM;
! 940: p->overlap = OVERLAP_NONE;
! 941: REFERENCE (refmpn_sqr);
! 942:
! 943: p = ¶m[TYPE_MUL_N];
! 944: COPY (TYPE_SQR);
! 945: p->src[1] = 1;
! 946: REFERENCE (refmpn_mul_n);
! 947:
! 948: p = ¶m[TYPE_MUL_BASECASE];
! 949: COPY (TYPE_MUL_N);
! 950: p->size2 = 1;
! 951: REFERENCE (refmpn_mul_basecase);
! 952:
! 953: p = ¶m[TYPE_UMUL_PPMM];
! 954: p->retval = 1;
! 955: p->src[0] = 1;
! 956: p->dst[0] = 1;
! 957: p->dst_size[0] = SIZE_1;
! 958: p->overlap = OVERLAP_NONE;
! 959: REFERENCE (refmpn_umul_ppmm);
! 960:
! 961: p = ¶m[TYPE_UMUL_PPMM_R];
! 962: COPY (TYPE_UMUL_PPMM);
! 963: REFERENCE (refmpn_umul_ppmm_r);
! 964:
! 965:
! 966: p = ¶m[TYPE_RSHIFT];
! 967: p->retval = 1;
! 968: p->dst[0] = 1;
! 969: p->src[0] = 1;
! 970: p->shift = 1;
! 971: p->overlap = OVERLAP_LOW_TO_HIGH;
! 972: REFERENCE (refmpn_rshift);
! 973:
! 974: p = ¶m[TYPE_LSHIFT];
! 975: COPY (TYPE_RSHIFT);
! 976: p->overlap = OVERLAP_HIGH_TO_LOW;
! 977: REFERENCE (refmpn_lshift);
! 978:
! 979:
! 980: p = ¶m[TYPE_POPCOUNT];
! 981: p->retval = 1;
! 982: p->src[0] = 1;
! 983: REFERENCE (refmpn_popcount);
! 984:
! 985: p = ¶m[TYPE_HAMDIST];
! 986: COPY (TYPE_POPCOUNT);
! 987: p->src[1] = 1;
! 988: REFERENCE (refmpn_hamdist);
! 989:
! 990:
! 991: p = ¶m[TYPE_SB_DIVREM_MN];
! 992: p->retval = 1;
! 993: p->dst[0] = 1;
! 994: p->dst[1] = 1;
! 995: p->src[0] = 1;
! 996: p->src[1] = 1;
! 997: p->data = DATA_SRC1_HIGHBIT;
! 998: p->size2 = 1;
! 999: p->dst_size[0] = SIZE_DIFF;
! 1000: p->overlap = OVERLAP_NONE;
! 1001: REFERENCE (refmpn_sb_divrem_mn);
! 1002:
! 1003: p = ¶m[TYPE_TDIV_QR];
! 1004: p->dst[0] = 1;
! 1005: p->dst[1] = 1;
! 1006: p->src[0] = 1;
! 1007: p->src[1] = 1;
! 1008: p->size2 = 1;
! 1009: p->dst_size[0] = SIZE_DIFF_PLUS_1;
! 1010: p->dst_size[1] = SIZE_SIZE2;
! 1011: p->overlap = OVERLAP_NONE;
! 1012: REFERENCE (refmpn_tdiv_qr);
! 1013:
! 1014: p = ¶m[TYPE_SQRTREM];
! 1015: p->retval = 1;
! 1016: p->dst[0] = 1;
! 1017: p->dst[1] = 1;
! 1018: p->src[0] = 1;
! 1019: p->dst_size[0] = SIZE_CEIL_HALF;
! 1020: p->dst_size[1] = SIZE_RETVAL;
! 1021: p->overlap = OVERLAP_NONE;
! 1022: VALIDATE (validate_sqrtrem);
! 1023:
! 1024: p = ¶m[TYPE_ZERO];
! 1025: p->dst[0] = 1;
! 1026: p->size = SIZE_ALLOW_ZERO;
! 1027: REFERENCE (refmpn_zero);
! 1028:
! 1029: p = ¶m[TYPE_GET_STR];
! 1030: p->src[0] = 1;
! 1031: p->size = SIZE_ALLOW_ZERO;
! 1032: p->dst[0] = 1;
! 1033: p->dst[1] = 1;
! 1034: p->dst_size[0] = SIZE_GET_STR;
! 1035: p->dst_bytes[0] = 1;
! 1036: p->overlap = OVERLAP_NONE;
! 1037: REFERENCE (refmpn_get_str);
! 1038:
! 1039: #ifdef EXTRA_PARAM_INIT
! 1040: EXTRA_PARAM_INIT
! 1041: #endif
! 1042: }
! 1043:
! 1044:
! 1045: /* The following are macros if there's no native versions, so wrap them in
! 1046: functions that can be in try_array[]. */
! 1047:
! 1048: void
! 1049: MPN_COPY_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
! 1050: { MPN_COPY (rp, sp, size); }
! 1051:
! 1052: void
! 1053: MPN_COPY_INCR_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
! 1054: { MPN_COPY_INCR (rp, sp, size); }
! 1055:
! 1056: void
! 1057: MPN_COPY_DECR_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
! 1058: { MPN_COPY_DECR (rp, sp, size); }
! 1059:
! 1060: void
! 1061: __GMPN_COPY_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
! 1062: { __GMPN_COPY (rp, sp, size); }
! 1063:
! 1064: #ifdef __GMPN_COPY_INCR
! 1065: void
! 1066: __GMPN_COPY_INCR_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
! 1067: { __GMPN_COPY_INCR (rp, sp, size); }
! 1068: #endif
! 1069:
! 1070: void
! 1071: mpn_com_n_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
! 1072: { mpn_com_n (rp, sp, size); }
! 1073:
! 1074: void
! 1075: mpn_and_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
! 1076: { mpn_and_n (rp, s1, s2, size); }
! 1077:
! 1078: void
! 1079: mpn_andn_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
! 1080: { mpn_andn_n (rp, s1, s2, size); }
! 1081:
! 1082: void
! 1083: mpn_nand_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
! 1084: { mpn_nand_n (rp, s1, s2, size); }
! 1085:
! 1086: void
! 1087: mpn_ior_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
! 1088: { mpn_ior_n (rp, s1, s2, size); }
! 1089:
! 1090: void
! 1091: mpn_iorn_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
! 1092: { mpn_iorn_n (rp, s1, s2, size); }
! 1093:
! 1094: void
! 1095: mpn_nior_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
! 1096: { mpn_nior_n (rp, s1, s2, size); }
! 1097:
! 1098: void
! 1099: mpn_xor_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
! 1100: { mpn_xor_n (rp, s1, s2, size); }
! 1101:
! 1102: void
! 1103: mpn_xnor_n_fun (mp_ptr rp, mp_srcptr s1, mp_srcptr s2, mp_size_t size)
! 1104: { mpn_xnor_n (rp, s1, s2, size); }
! 1105:
! 1106: mp_limb_t
! 1107: udiv_qrnnd_fun (mp_limb_t *remptr, mp_limb_t n1, mp_limb_t n0, mp_limb_t d)
! 1108: {
! 1109: mp_limb_t q;
! 1110: udiv_qrnnd (q, *remptr, n1, n0, d);
! 1111: return q;
! 1112: }
! 1113:
! 1114: void
! 1115: mpn_divexact_by3_fun (mp_ptr rp, mp_srcptr sp, mp_size_t size)
! 1116: { mpn_divexact_by3 (rp, sp, size); }
! 1117:
! 1118: void
! 1119: mpn_modexact_1_odd_fun (mp_srcptr ptr, mp_size_t size, mp_limb_t divisor)
! 1120: { mpn_modexact_1_odd (ptr, size, divisor); }
! 1121:
! 1122: void
! 1123: mpn_kara_mul_n_fun (mp_ptr dst, mp_srcptr src1, mp_srcptr src2, mp_size_t size)
! 1124: {
! 1125: mp_ptr tspace;
! 1126: TMP_DECL (marker);
! 1127: TMP_MARK (marker);
! 1128: tspace = TMP_ALLOC_LIMBS (MPN_KARA_MUL_N_TSIZE (size));
! 1129: mpn_kara_mul_n (dst, src1, src2, size, tspace);
! 1130: }
! 1131: void
! 1132: mpn_kara_sqr_n_fun (mp_ptr dst, mp_srcptr src, mp_size_t size)
! 1133: {
! 1134: mp_ptr tspace;
! 1135: TMP_DECL (marker);
! 1136: TMP_MARK (marker);
! 1137: tspace = TMP_ALLOC_LIMBS (MPN_KARA_SQR_N_TSIZE (size));
! 1138: mpn_kara_sqr_n (dst, src, size, tspace);
! 1139: TMP_FREE (marker);
! 1140: }
! 1141: void
! 1142: mpn_toom3_mul_n_fun (mp_ptr dst, mp_srcptr src1, mp_srcptr src2, mp_size_t size)
! 1143: {
! 1144: mp_ptr tspace;
! 1145: TMP_DECL (marker);
! 1146: TMP_MARK (marker);
! 1147: tspace = TMP_ALLOC_LIMBS (MPN_TOOM3_MUL_N_TSIZE (size));
! 1148: mpn_toom3_mul_n (dst, src1, src2, size, tspace);
! 1149: }
! 1150: void
! 1151: mpn_toom3_sqr_n_fun (mp_ptr dst, mp_srcptr src, mp_size_t size)
! 1152: {
! 1153: mp_ptr tspace;
! 1154: TMP_DECL (marker);
! 1155: TMP_MARK (marker);
! 1156: tspace = TMP_ALLOC_LIMBS (MPN_TOOM3_SQR_N_TSIZE (size));
! 1157: mpn_toom3_sqr_n (dst, src, size, tspace);
! 1158: TMP_FREE (marker);
! 1159: }
! 1160: mp_limb_t
! 1161: umul_ppmm_fun (mp_limb_t *lowptr, mp_limb_t m1, mp_limb_t m2)
! 1162: {
! 1163: mp_limb_t high;
! 1164: umul_ppmm (high, *lowptr, m1, m2);
! 1165: return high;
! 1166: }
! 1167: mp_limb_t
! 1168: mpn_umul_ppmm_fun (mp_limb_t *lowptr, mp_limb_t m1, mp_limb_t m2)
! 1169: {
! 1170: mp_limb_t high;
! 1171: umul_ppmm (high, *lowptr, m1, m2);
! 1172: return high;
! 1173: }
! 1174:
! 1175: void
! 1176: MPN_ZERO_fun (mp_ptr ptr, mp_size_t size)
! 1177: { MPN_ZERO (ptr, size); }
! 1178:
! 1179:
! 1180: struct choice_t {
! 1181: const char *name;
! 1182: tryfun_t function;
! 1183: int type;
! 1184: mp_size_t minsize;
! 1185: };
! 1186:
! 1187: #if HAVE_STRINGIZE
! 1188: #define TRY(fun) #fun, (tryfun_t) fun
! 1189: #define TRY_FUNFUN(fun) #fun, (tryfun_t) fun##_fun
! 1190: #else
! 1191: #define TRY(fun) "fun", (tryfun_t) fun
! 1192: #define TRY_FUNFUN(fun) "fun", (tryfun_t) fun/**/_fun
! 1193: #endif
! 1194:
! 1195: const struct choice_t choice_array[] = {
! 1196: { TRY(mpn_add), TYPE_ADD },
! 1197: { TRY(mpn_sub), TYPE_SUB },
! 1198:
! 1199: { TRY(mpn_add_n), TYPE_ADD_N },
! 1200: { TRY(mpn_sub_n), TYPE_SUB_N },
! 1201:
! 1202: #if HAVE_NATIVE_mpn_add_nc
! 1203: { TRY(mpn_add_nc), TYPE_ADD_NC },
! 1204: #endif
! 1205: #if HAVE_NATIVE_mpn_sub_nc
! 1206: { TRY(mpn_sub_nc), TYPE_SUB_NC },
! 1207: #endif
! 1208:
! 1209: { TRY(mpn_addmul_1), TYPE_ADDMUL_1 },
! 1210: { TRY(mpn_submul_1), TYPE_SUBMUL_1 },
! 1211: #if HAVE_NATIVE_mpn_addmul_1c
! 1212: { TRY(mpn_addmul_1c), TYPE_ADDMUL_1C },
! 1213: #endif
! 1214: #if HAVE_NATIVE_mpn_submul_1c
! 1215: { TRY(mpn_submul_1c), TYPE_SUBMUL_1C },
! 1216: #endif
! 1217:
! 1218: { TRY_FUNFUN(mpn_com_n), TYPE_COM_N },
! 1219:
! 1220: { TRY_FUNFUN(MPN_COPY), TYPE_COPY },
! 1221: { TRY_FUNFUN(MPN_COPY_INCR), TYPE_COPYI },
! 1222: { TRY_FUNFUN(MPN_COPY_DECR), TYPE_COPYD },
! 1223:
! 1224: { TRY_FUNFUN(__GMPN_COPY), TYPE_COPY },
! 1225: #ifdef __GMPN_COPY_INCR
! 1226: { TRY_FUNFUN(__GMPN_COPY_INCR), TYPE_COPYI },
! 1227: #endif
! 1228:
! 1229: { TRY_FUNFUN(mpn_and_n), TYPE_AND_N },
! 1230: { TRY_FUNFUN(mpn_andn_n), TYPE_ANDN_N },
! 1231: { TRY_FUNFUN(mpn_nand_n), TYPE_NAND_N },
! 1232: { TRY_FUNFUN(mpn_ior_n), TYPE_IOR_N },
! 1233: { TRY_FUNFUN(mpn_iorn_n), TYPE_IORN_N },
! 1234: { TRY_FUNFUN(mpn_nior_n), TYPE_NIOR_N },
! 1235: { TRY_FUNFUN(mpn_xor_n), TYPE_XOR_N },
! 1236: { TRY_FUNFUN(mpn_xnor_n), TYPE_XNOR_N },
! 1237:
! 1238: { TRY(mpn_divrem_1), TYPE_DIVREM_1 },
! 1239: #if USE_PREINV_DIVREM_1
! 1240: { TRY(mpn_preinv_divrem_1), TYPE_PREINV_DIVREM_1 },
! 1241: #endif
! 1242: { TRY(mpn_mod_1), TYPE_MOD_1 },
! 1243: { TRY(mpn_preinv_mod_1), TYPE_PREINV_MOD_1 },
! 1244: #if HAVE_NATIVE_mpn_divrem_1c
! 1245: { TRY(mpn_divrem_1c), TYPE_DIVREM_1C },
! 1246: #endif
! 1247: #if HAVE_NATIVE_mpn_mod_1c
! 1248: { TRY(mpn_mod_1c), TYPE_MOD_1C },
! 1249: #endif
! 1250: { TRY(mpn_mod_34lsub1), TYPE_MOD_34LSUB1 },
! 1251: { TRY_FUNFUN(udiv_qrnnd), TYPE_UDIV_QRNND, 2 },
! 1252:
! 1253: { TRY(mpn_divexact_1), TYPE_DIVEXACT_1 },
! 1254: { TRY_FUNFUN(mpn_divexact_by3), TYPE_DIVEXACT_BY3 },
! 1255: { TRY(mpn_divexact_by3c), TYPE_DIVEXACT_BY3C },
! 1256:
! 1257: { TRY_FUNFUN(mpn_modexact_1_odd), TYPE_MODEXACT_1_ODD },
! 1258: { TRY(mpn_modexact_1c_odd), TYPE_MODEXACT_1C_ODD },
! 1259:
! 1260:
! 1261: { TRY(mpn_sb_divrem_mn), TYPE_SB_DIVREM_MN, 3},
! 1262: { TRY(mpn_tdiv_qr), TYPE_TDIV_QR },
! 1263:
! 1264: { TRY(mpn_mul_1), TYPE_MUL_1 },
! 1265: #if HAVE_NATIVE_mpn_mul_1c
! 1266: { TRY(mpn_mul_1c), TYPE_MUL_1C },
! 1267: #endif
! 1268: #if HAVE_NATIVE_mpn_mul_2
! 1269: { TRY(mpn_mul_2), TYPE_MUL_2 },
! 1270: #endif
! 1271:
! 1272: { TRY(mpn_rshift), TYPE_RSHIFT },
! 1273: { TRY(mpn_lshift), TYPE_LSHIFT },
! 1274:
! 1275:
! 1276: { TRY(mpn_mul_basecase), TYPE_MUL_BASECASE },
! 1277: { TRY(mpn_sqr_basecase), TYPE_SQR },
! 1278:
! 1279: { TRY(mpn_mul), TYPE_MUL_BASECASE },
! 1280: { TRY(mpn_mul_n), TYPE_MUL_N },
! 1281: { TRY(mpn_sqr_n), TYPE_SQR },
! 1282:
! 1283: { TRY_FUNFUN(umul_ppmm), TYPE_UMUL_PPMM, 2 },
! 1284:
! 1285: { TRY_FUNFUN(mpn_kara_mul_n), TYPE_MUL_N, MPN_KARA_MUL_N_MINSIZE },
! 1286: { TRY_FUNFUN(mpn_kara_sqr_n), TYPE_SQR, MPN_KARA_SQR_N_MINSIZE },
! 1287: { TRY_FUNFUN(mpn_toom3_mul_n), TYPE_MUL_N, MPN_TOOM3_MUL_N_MINSIZE },
! 1288: { TRY_FUNFUN(mpn_toom3_sqr_n), TYPE_SQR, MPN_TOOM3_SQR_N_MINSIZE },
! 1289:
! 1290: { TRY(mpn_gcd_1), TYPE_GCD_1 },
! 1291: { TRY(mpn_gcd), TYPE_GCD },
! 1292: #if HAVE_NATIVE_mpn_gcd_finda
! 1293: { TRY(mpn_gcd_finda), TYPE_GCD_FINDA },
! 1294: #endif
! 1295: { TRY(mpz_jacobi), TYPE_MPZ_JACOBI },
! 1296: { TRY(mpz_kronecker_ui), TYPE_MPZ_KRONECKER_UI },
! 1297: { TRY(mpz_kronecker_si), TYPE_MPZ_KRONECKER_SI },
! 1298: { TRY(mpz_ui_kronecker), TYPE_MPZ_UI_KRONECKER },
! 1299: { TRY(mpz_si_kronecker), TYPE_MPZ_SI_KRONECKER },
! 1300:
! 1301: { TRY(mpn_popcount), TYPE_POPCOUNT },
! 1302: { TRY(mpn_hamdist), TYPE_HAMDIST },
! 1303:
! 1304: { TRY(mpn_sqrtrem), TYPE_SQRTREM },
! 1305:
! 1306: { TRY_FUNFUN(MPN_ZERO), TYPE_ZERO },
! 1307:
! 1308: { TRY(mpn_get_str), TYPE_GET_STR },
! 1309:
! 1310: #ifdef EXTRA_ROUTINES
! 1311: EXTRA_ROUTINES
! 1312: #endif
! 1313: };
! 1314:
! 1315: const struct choice_t *choice = NULL;
! 1316:
! 1317:
! 1318: void
! 1319: mprotect_maybe (void *addr, size_t len, int prot)
! 1320: {
! 1321: if (!option_redzones)
! 1322: return;
! 1323:
! 1324: #if HAVE_MPROTECT
! 1325: if (mprotect (addr, len, prot) != 0)
! 1326: {
! 1327: fprintf (stderr, "Cannot mprotect %p 0x%X 0x%X\n", addr, len, prot);
! 1328: exit (1);
! 1329: }
! 1330: #else
! 1331: {
! 1332: static int warned = 0;
! 1333: if (!warned)
! 1334: {
! 1335: fprintf (stderr,
! 1336: "mprotect not available, bounds testing not performed\n");
! 1337: warned = 1;
! 1338: }
! 1339: }
! 1340: #endif
! 1341: }
! 1342:
! 1343: /* round "a" up to a multiple of "m" */
! 1344: size_t
! 1345: round_up_multiple (size_t a, size_t m)
! 1346: {
! 1347: unsigned long r;
! 1348:
! 1349: r = a % m;
! 1350: if (r == 0)
! 1351: return a;
! 1352: else
! 1353: return a + (m - r);
! 1354: }
! 1355:
! 1356:
! 1357: /* On some systems it seems that only an mmap'ed region can be mprotect'ed,
! 1358: for instance HP-UX 10.
! 1359:
! 1360: mmap will almost certainly return a pointer already aligned to a page
! 1361: boundary, but it's easy enough to share the alignment handling with the
! 1362: malloc case. */
! 1363:
! 1364: void
! 1365: malloc_region (struct region_t *r, mp_size_t n)
! 1366: {
! 1367: mp_ptr p;
! 1368: size_t nbytes;
! 1369:
! 1370: ASSERT ((pagesize % BYTES_PER_MP_LIMB) == 0);
! 1371:
! 1372: n = round_up_multiple (n, PAGESIZE_LIMBS);
! 1373: r->size = n;
! 1374:
! 1375: nbytes = n*BYTES_PER_MP_LIMB + 2*REDZONE_BYTES + pagesize;
! 1376:
! 1377: #if defined (MAP_ANONYMOUS) && ! defined (MAP_ANON)
! 1378: #define MAP_ANON MAP_ANONYMOUS
! 1379: #endif
! 1380:
! 1381: #if HAVE_MMAP && defined (MAP_ANON)
! 1382: /* note must pass fd=-1 for MAP_ANON on BSD */
! 1383: p = mmap (NULL, nbytes, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
! 1384: if (p == (void *) -1)
! 1385: {
! 1386: fprintf (stderr, "Cannot mmap %#x anon bytes\n", nbytes);
! 1387: exit (1);
! 1388: }
! 1389: #else
! 1390: p = malloc (nbytes);
! 1391: ASSERT_ALWAYS (p != NULL);
! 1392: #endif
! 1393:
! 1394: p = align_pointer (p, pagesize);
! 1395:
! 1396: mprotect_maybe (p, REDZONE_BYTES, PROT_NONE);
! 1397: p += REDZONE_LIMBS;
! 1398: r->ptr = p;
! 1399:
! 1400: mprotect_maybe (p + n, REDZONE_BYTES, PROT_NONE);
! 1401: }
! 1402:
! 1403: void
! 1404: mprotect_region (const struct region_t *r, int prot)
! 1405: {
! 1406: mprotect_maybe (r->ptr, r->size, prot);
! 1407: }
! 1408:
! 1409:
! 1410: /* First four entries must be 0,1,2,3 for the benefit of CARRY_BIT, CARRY_3,
! 1411: and CARRY_4 */
! 1412: mp_limb_t carry_array[] = {
! 1413: 0, 1, 2, 3,
! 1414: 4,
! 1415: CNST_LIMB(1) << 8,
! 1416: CNST_LIMB(1) << 16,
! 1417: GMP_NUMB_MAX
! 1418: };
! 1419: int carry_index;
! 1420:
! 1421: #define CARRY_COUNT \
! 1422: ((tr->carry == CARRY_BIT) ? 2 \
! 1423: : tr->carry == CARRY_3 ? 3 \
! 1424: : tr->carry == CARRY_4 ? 4 \
! 1425: : (tr->carry == CARRY_LIMB || tr->carry == CARRY_DIVISOR) \
! 1426: ? numberof(carry_array) + CARRY_RANDOMS \
! 1427: : 1)
! 1428:
! 1429: #define MPN_RANDOM_ALT(index,dst,size) \
! 1430: (((index) & 1) ? refmpn_random (dst, size) : refmpn_random2 (dst, size))
! 1431:
! 1432: /* The dummy value after MPN_RANDOM_ALT ensures both sides of the ":" have
! 1433: the same type */
! 1434: #define CARRY_ITERATION \
! 1435: for (carry_index = 0; \
! 1436: (carry_index < numberof (carry_array) \
! 1437: ? (carry = carry_array[carry_index]) \
! 1438: : (MPN_RANDOM_ALT (carry_index, &carry, 1), (mp_limb_t) 0)), \
! 1439: (tr->carry == CARRY_DIVISOR ? carry %= divisor : 0), \
! 1440: carry_index < CARRY_COUNT; \
! 1441: carry_index++)
! 1442:
! 1443:
! 1444: mp_limb_t multiplier_array[] = {
! 1445: 0, 1, 2, 3,
! 1446: CNST_LIMB(1) << 8,
! 1447: CNST_LIMB(1) << 16,
! 1448: GMP_NUMB_MAX - 2,
! 1449: GMP_NUMB_MAX - 1,
! 1450: GMP_NUMB_MAX
! 1451: };
! 1452: int multiplier_index;
! 1453:
! 1454: mp_limb_t divisor_array[] = {
! 1455: 1, 2, 3,
! 1456: CNST_LIMB(1) << 8,
! 1457: CNST_LIMB(1) << 16,
! 1458: GMP_NUMB_HIGHBIT,
! 1459: GMP_NUMB_HIGHBIT + 1,
! 1460: GMP_NUMB_MAX - 2,
! 1461: GMP_NUMB_MAX - 1,
! 1462: GMP_NUMB_MAX
! 1463: };
! 1464:
! 1465: int divisor_index;
! 1466:
! 1467: /* The dummy value after MPN_RANDOM_ALT ensures both sides of the ":" have
! 1468: the same type */
! 1469: #define ARRAY_ITERATION(var, index, limit, array, randoms, cond) \
! 1470: for (index = 0; \
! 1471: (index < numberof (array) \
! 1472: ? (var = array[index]) \
! 1473: : (MPN_RANDOM_ALT (index, &var, 1), (mp_limb_t) 0)), \
! 1474: index < limit; \
! 1475: index++)
! 1476:
! 1477: #define MULTIPLIER_COUNT \
! 1478: (tr->multiplier \
! 1479: ? numberof (multiplier_array) + MULTIPLIER_RANDOMS \
! 1480: : 1)
! 1481:
! 1482: #define MULTIPLIER_ITERATION \
! 1483: ARRAY_ITERATION(multiplier, multiplier_index, MULTIPLIER_COUNT, \
! 1484: multiplier_array, MULTIPLIER_RANDOMS, TRY_MULTIPLIER)
! 1485:
! 1486: #define DIVISOR_COUNT \
! 1487: (tr->divisor \
! 1488: ? numberof (divisor_array) + DIVISOR_RANDOMS \
! 1489: : 1)
! 1490:
! 1491: #define DIVISOR_ITERATION \
! 1492: ARRAY_ITERATION(divisor, divisor_index, DIVISOR_COUNT, divisor_array, \
! 1493: DIVISOR_RANDOMS, TRY_DIVISOR)
! 1494:
! 1495:
! 1496: /* overlap_array[].s[i] is where s[i] should be, 0 or 1 means overlapping
! 1497: d[0] or d[1] respectively, -1 means a separate (write-protected)
! 1498: location. */
! 1499:
! 1500: struct overlap_t {
! 1501: int s[NUM_SOURCES];
! 1502: } overlap_array[] = {
! 1503: { { -1, -1 } },
! 1504: { { 0, -1 } },
! 1505: { { -1, 0 } },
! 1506: { { 0, 0 } },
! 1507: { { 1, -1 } },
! 1508: { { -1, 1 } },
! 1509: { { 1, 1 } },
! 1510: { { 0, 1 } },
! 1511: { { 1, 0 } },
! 1512: };
! 1513:
! 1514: struct overlap_t *overlap, *overlap_limit;
! 1515:
! 1516: #define OVERLAP_COUNT \
! 1517: (tr->overlap & OVERLAP_NONE ? 1 \
! 1518: : tr->overlap & OVERLAP_NOT_SRCS ? 3 \
! 1519: : tr->overlap & OVERLAP_NOT_SRC2 ? 2 \
! 1520: : tr->dst[1] ? 9 \
! 1521: : tr->src[1] ? 4 \
! 1522: : tr->dst[0] ? 2 \
! 1523: : 1)
! 1524:
! 1525: #define OVERLAP_ITERATION \
! 1526: for (overlap = &overlap_array[0], \
! 1527: overlap_limit = &overlap_array[OVERLAP_COUNT]; \
! 1528: overlap < overlap_limit; \
! 1529: overlap++)
! 1530:
! 1531:
! 1532: int base = 10;
! 1533:
! 1534: #define T_RAND_COUNT 2
! 1535: int t_rand;
! 1536:
! 1537: void
! 1538: t_random (mp_ptr ptr, mp_size_t n)
! 1539: {
! 1540: if (n == 0)
! 1541: return;
! 1542:
! 1543: switch (option_data) {
! 1544: case DATA_TRAND:
! 1545: switch (t_rand) {
! 1546: case 0: refmpn_random (ptr, n); break;
! 1547: case 1: refmpn_random2 (ptr, n); break;
! 1548: default: abort();
! 1549: }
! 1550: break;
! 1551: case DATA_SEQ:
! 1552: {
! 1553: static mp_limb_t counter = 0;
! 1554: mp_size_t i;
! 1555: for (i = 0; i < n; i++)
! 1556: ptr[i] = ++counter;
! 1557: }
! 1558: break;
! 1559: case DATA_ZEROS:
! 1560: refmpn_zero (ptr, n);
! 1561: break;
! 1562: case DATA_FFS:
! 1563: refmpn_fill (ptr, n, GMP_NUMB_MAX);
! 1564: break;
! 1565: case DATA_2FD:
! 1566: /* Special value 0x2FFF...FFFD, which divided by 3 gives 0xFFF...FFF,
! 1567: inducing the q1_ff special case in the mul-by-inverse part of some
! 1568: versions of divrem_1 and mod_1. */
! 1569: refmpn_fill (ptr, n, (mp_limb_t) -1);
! 1570: ptr[n-1] = 2;
! 1571: ptr[0] -= 2;
! 1572: break;
! 1573:
! 1574: default:
! 1575: abort();
! 1576: }
! 1577: }
! 1578: #define T_RAND_ITERATION \
! 1579: for (t_rand = 0; t_rand < T_RAND_COUNT; t_rand++)
! 1580:
! 1581:
! 1582: void
! 1583: print_each (const struct each_t *e)
! 1584: {
! 1585: int i;
! 1586:
! 1587: printf ("%s %s\n", e->name, e == &ref ? tr->reference_name : choice->name);
! 1588: if (tr->retval)
! 1589: mpn_trace (" retval", &e->retval, 1);
! 1590:
! 1591: for (i = 0; i < NUM_DESTS; i++)
! 1592: {
! 1593: if (tr->dst[i])
! 1594: {
! 1595: if (tr->dst_bytes[i])
! 1596: byte_tracen (" d[%d]", i, e->d[i].p, d[i].size);
! 1597: else
! 1598: mpn_tracen (" d[%d]", i, e->d[i].p, d[i].size);
! 1599: printf (" located %p\n", e->d[i].p);
! 1600: }
! 1601: }
! 1602:
! 1603: for (i = 0; i < NUM_SOURCES; i++)
! 1604: if (tr->src[i])
! 1605: printf (" s[%d] located %p\n", i, e->s[i].p);
! 1606: }
! 1607:
! 1608:
! 1609: void
! 1610: print_all (void)
! 1611: {
! 1612: int i;
! 1613:
! 1614: printf ("\n");
! 1615: printf ("size %ld\n", size);
! 1616: if (tr->size2)
! 1617: printf ("size2 %ld\n", size2);
! 1618:
! 1619: for (i = 0; i < NUM_DESTS; i++)
! 1620: if (d[i].size != size)
! 1621: printf ("d[%d].size %ld\n", i, d[i].size);
! 1622:
! 1623: if (tr->multiplier)
! 1624: mpn_trace (" multiplier", &multiplier, 1);
! 1625: if (tr->divisor)
! 1626: mpn_trace (" divisor", &divisor, 1);
! 1627: if (tr->shift)
! 1628: printf (" shift %lu\n", shift);
! 1629: if (tr->carry)
! 1630: mpn_trace (" carry", &carry, 1);
! 1631:
! 1632: for (i = 0; i < NUM_DESTS; i++)
! 1633: if (tr->dst[i])
! 1634: printf (" d[%d] %s, align %ld, size %ld\n",
! 1635: i, d[i].high ? "high" : "low", d[i].align, d[i].size);
! 1636:
! 1637: for (i = 0; i < NUM_SOURCES; i++)
! 1638: {
! 1639: if (tr->src[i])
! 1640: {
! 1641: printf (" s[%d] %s, align %ld, ",
! 1642: i, s[i].high ? "high" : "low", s[i].align);
! 1643: switch (overlap->s[i]) {
! 1644: case -1:
! 1645: printf ("no overlap\n");
! 1646: break;
! 1647: default:
! 1648: printf ("==d[%d]%s\n",
! 1649: overlap->s[i],
! 1650: tr->overlap == OVERLAP_LOW_TO_HIGH ? "+a"
! 1651: : tr->overlap == OVERLAP_HIGH_TO_LOW ? "-a"
! 1652: : "");
! 1653: break;
! 1654: }
! 1655: printf (" s[%d]=", i);
! 1656: if (tr->carry_sign && (carry & (1 << i)))
! 1657: printf ("-");
! 1658: mpn_trace (NULL, s[i].p, SRC_SIZE(i));
! 1659: }
! 1660: }
! 1661:
! 1662: if (tr->dst0_from_src1)
! 1663: mpn_trace (" d[0]", s[1].region.ptr, size);
! 1664:
! 1665: if (tr->reference)
! 1666: print_each (&ref);
! 1667: print_each (&fun);
! 1668: }
! 1669:
! 1670: void
! 1671: compare (void)
! 1672: {
! 1673: int error = 0;
! 1674: int i;
! 1675:
! 1676: if (tr->retval && ref.retval != fun.retval)
! 1677: {
! 1678: printf ("Different return values (%lu, %lu)\n",
! 1679: ref.retval, fun.retval);
! 1680: error = 1;
! 1681: }
! 1682:
! 1683: for (i = 0; i < NUM_DESTS; i++)
! 1684: {
! 1685: switch (tr->dst_size[0]) {
! 1686: case SIZE_RETVAL:
! 1687: d[i].size = ref.retval;
! 1688: break;
! 1689: }
! 1690: }
! 1691:
! 1692: for (i = 0; i < NUM_DESTS; i++)
! 1693: {
! 1694: if (! tr->dst[i])
! 1695: continue;
! 1696:
! 1697: if (tr->dst_bytes[i])
! 1698: {
! 1699: if (memcmp (ref.d[i].p, fun.d[i].p, d[i].size) != 0)
! 1700: {
! 1701: printf ("Different d[%d] data results, low diff at %ld, high diff at %ld\n",
! 1702: i,
! 1703: byte_diff_lowest (ref.d[i].p, fun.d[i].p, d[i].size),
! 1704: byte_diff_highest (ref.d[i].p, fun.d[i].p, d[i].size));
! 1705: error = 1;
! 1706: }
! 1707: }
! 1708: else
! 1709: {
! 1710: if (d[i].size != 0
! 1711: && ! refmpn_equal_anynail (ref.d[i].p, fun.d[i].p, d[i].size))
! 1712: {
! 1713: printf ("Different d[%d] data results, low diff at %ld, high diff at %ld\n",
! 1714: i,
! 1715: mpn_diff_lowest (ref.d[i].p, fun.d[i].p, d[i].size),
! 1716: mpn_diff_highest (ref.d[i].p, fun.d[i].p, d[i].size));
! 1717: error = 1;
! 1718: }
! 1719: }
! 1720: }
! 1721:
! 1722: if (error)
! 1723: {
! 1724: print_all();
! 1725: abort();
! 1726: }
! 1727: }
! 1728:
! 1729:
! 1730: /* The functions are cast if the return value should be a long rather than
! 1731: the default mp_limb_t. This is necessary under _LONG_LONG_LIMB. This
! 1732: might not be enough if some actual calling conventions checking is
! 1733: implemented on a long long limb system. */
! 1734:
! 1735: void
! 1736: call (struct each_t *e, tryfun_t function)
! 1737: {
! 1738: switch (choice->type) {
! 1739: case TYPE_ADD:
! 1740: case TYPE_SUB:
! 1741: e->retval = CALLING_CONVENTIONS (function)
! 1742: (e->d[0].p, e->s[0].p, size, e->s[1].p, size2);
! 1743: break;
! 1744:
! 1745: case TYPE_ADD_N:
! 1746: case TYPE_SUB_N:
! 1747: e->retval = CALLING_CONVENTIONS (function)
! 1748: (e->d[0].p, e->s[0].p, e->s[1].p, size);
! 1749: break;
! 1750: case TYPE_ADD_NC:
! 1751: case TYPE_SUB_NC:
! 1752: e->retval = CALLING_CONVENTIONS (function)
! 1753: (e->d[0].p, e->s[0].p, e->s[1].p, size, carry);
! 1754: break;
! 1755:
! 1756: case TYPE_MUL_1:
! 1757: case TYPE_ADDMUL_1:
! 1758: case TYPE_SUBMUL_1:
! 1759: e->retval = CALLING_CONVENTIONS (function)
! 1760: (e->d[0].p, e->s[0].p, size, multiplier);
! 1761: break;
! 1762: case TYPE_MUL_1C:
! 1763: case TYPE_ADDMUL_1C:
! 1764: case TYPE_SUBMUL_1C:
! 1765: e->retval = CALLING_CONVENTIONS (function)
! 1766: (e->d[0].p, e->s[0].p, size, multiplier, carry);
! 1767: break;
! 1768:
! 1769: case TYPE_MUL_2:
! 1770: e->retval = CALLING_CONVENTIONS (function)
! 1771: (e->d[0].p, e->s[0].p, size, e->s[1].p);
! 1772: break;
! 1773:
! 1774: case TYPE_AND_N:
! 1775: case TYPE_ANDN_N:
! 1776: case TYPE_NAND_N:
! 1777: case TYPE_IOR_N:
! 1778: case TYPE_IORN_N:
! 1779: case TYPE_NIOR_N:
! 1780: case TYPE_XOR_N:
! 1781: case TYPE_XNOR_N:
! 1782: CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, e->s[1].p, size);
! 1783: break;
! 1784:
! 1785: case TYPE_ADDSUB_N:
! 1786: e->retval = CALLING_CONVENTIONS (function)
! 1787: (e->d[0].p, e->d[1].p, e->s[0].p, e->s[1].p, size);
! 1788: break;
! 1789: case TYPE_ADDSUB_NC:
! 1790: e->retval = CALLING_CONVENTIONS (function)
! 1791: (e->d[0].p, e->d[1].p, e->s[0].p, e->s[1].p, size, carry);
! 1792: break;
! 1793:
! 1794: case TYPE_COPY:
! 1795: case TYPE_COPYI:
! 1796: case TYPE_COPYD:
! 1797: case TYPE_COM_N:
! 1798: CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, size);
! 1799: break;
! 1800:
! 1801:
! 1802: case TYPE_DIVEXACT_BY3:
! 1803: e->retval = CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, size);
! 1804: break;
! 1805: case TYPE_DIVEXACT_BY3C:
! 1806: e->retval = CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, size,
! 1807: carry);
! 1808: break;
! 1809:
! 1810:
! 1811: case TYPE_DIVMOD_1:
! 1812: case TYPE_DIVEXACT_1:
! 1813: e->retval = CALLING_CONVENTIONS (function)
! 1814: (e->d[0].p, e->s[0].p, size, divisor);
! 1815: break;
! 1816: case TYPE_DIVMOD_1C:
! 1817: e->retval = CALLING_CONVENTIONS (function)
! 1818: (e->d[0].p, e->s[0].p, size, divisor, carry);
! 1819: break;
! 1820: case TYPE_DIVREM_1:
! 1821: e->retval = CALLING_CONVENTIONS (function)
! 1822: (e->d[0].p, size2, e->s[0].p, size, divisor);
! 1823: break;
! 1824: case TYPE_DIVREM_1C:
! 1825: e->retval = CALLING_CONVENTIONS (function)
! 1826: (e->d[0].p, size2, e->s[0].p, size, divisor, carry);
! 1827: break;
! 1828: case TYPE_PREINV_DIVREM_1:
! 1829: {
! 1830: mp_limb_t dinv;
! 1831: unsigned shift;
! 1832: shift = refmpn_count_leading_zeros (divisor);
! 1833: dinv = refmpn_invert_limb (divisor << shift);
! 1834: e->retval = CALLING_CONVENTIONS (function)
! 1835: (e->d[0].p, size2, e->s[0].p, size, divisor, dinv, shift);
! 1836: }
! 1837: break;
! 1838: case TYPE_MOD_1:
! 1839: case TYPE_MODEXACT_1_ODD:
! 1840: e->retval = CALLING_CONVENTIONS (function)
! 1841: (e->s[0].p, size, divisor);
! 1842: break;
! 1843: case TYPE_MOD_1C:
! 1844: case TYPE_MODEXACT_1C_ODD:
! 1845: e->retval = CALLING_CONVENTIONS (function)
! 1846: (e->s[0].p, size, divisor, carry);
! 1847: break;
! 1848: case TYPE_PREINV_MOD_1:
! 1849: e->retval = CALLING_CONVENTIONS (function)
! 1850: (e->s[0].p, size, divisor, refmpn_invert_limb (divisor));
! 1851: break;
! 1852: case TYPE_MOD_34LSUB1:
! 1853: e->retval = CALLING_CONVENTIONS (function) (e->s[0].p, size);
! 1854: break;
! 1855: case TYPE_UDIV_QRNND:
! 1856: e->retval = CALLING_CONVENTIONS (function)
! 1857: (e->d[0].p, e->s[0].p[1], e->s[0].p[0], divisor);
! 1858: break;
! 1859:
! 1860: case TYPE_SB_DIVREM_MN:
! 1861: refmpn_copyi (e->d[1].p, e->s[0].p, size); /* dividend */
! 1862: refmpn_fill (e->d[0].p, size-size2, 0x98765432); /* quotient */
! 1863: e->retval = CALLING_CONVENTIONS (function)
! 1864: (e->d[0].p, e->d[1].p, size, e->s[1].p, size2);
! 1865: refmpn_zero (e->d[1].p+size2, size-size2); /* excess over remainder */
! 1866: break;
! 1867: case TYPE_TDIV_QR:
! 1868: CALLING_CONVENTIONS (function) (e->d[0].p, e->d[1].p, 0,
! 1869: e->s[0].p, size, e->s[1].p, size2);
! 1870: break;
! 1871:
! 1872: case TYPE_GCD_1:
! 1873: /* Must have a non-zero src, but this probably isn't the best way to do
! 1874: it. */
! 1875: if (refmpn_zero_p (e->s[0].p, size))
! 1876: e->retval = 0;
! 1877: else
! 1878: e->retval = CALLING_CONVENTIONS (function) (e->s[0].p, size, divisor);
! 1879: break;
! 1880:
! 1881: case TYPE_GCD:
! 1882: /* Sources are destroyed, so they're saved and replaced, but a general
! 1883: approach to this might be better. Note that it's still e->s[0].p and
! 1884: e->s[1].p that are passed, to get the desired alignments. */
! 1885: {
! 1886: mp_ptr s0 = refmpn_malloc_limbs (size);
! 1887: mp_ptr s1 = refmpn_malloc_limbs (size2);
! 1888: refmpn_copyi (s0, e->s[0].p, size);
! 1889: refmpn_copyi (s1, e->s[1].p, size2);
! 1890:
! 1891: mprotect_region (&s[0].region, PROT_READ|PROT_WRITE);
! 1892: mprotect_region (&s[1].region, PROT_READ|PROT_WRITE);
! 1893: e->retval = CALLING_CONVENTIONS (function) (e->d[0].p,
! 1894: e->s[0].p, size,
! 1895: e->s[1].p, size2);
! 1896: refmpn_copyi (e->s[0].p, s0, size);
! 1897: refmpn_copyi (e->s[1].p, s1, size2);
! 1898: free (s0);
! 1899: free (s1);
! 1900: }
! 1901: break;
! 1902:
! 1903: case TYPE_GCD_FINDA:
! 1904: {
! 1905: /* FIXME: do this with a flag */
! 1906: mp_limb_t c[2];
! 1907: c[0] = e->s[0].p[0];
! 1908: c[0] += (c[0] == 0);
! 1909: c[1] = e->s[0].p[0];
! 1910: c[1] += (c[1] == 0);
! 1911: e->retval = CALLING_CONVENTIONS (function) (c);
! 1912: }
! 1913: break;
! 1914:
! 1915: case TYPE_MPZ_JACOBI:
! 1916: case TYPE_MPZ_KRONECKER:
! 1917: {
! 1918: mpz_t a, b;
! 1919: PTR(a) = e->s[0].p; SIZ(a) = ((carry&1)==0 ? size : -size);
! 1920: PTR(b) = e->s[1].p; SIZ(b) = ((carry&2)==0 ? size2 : -size2);
! 1921: e->retval = CALLING_CONVENTIONS (function) (a, b);
! 1922: }
! 1923: break;
! 1924: case TYPE_MPZ_KRONECKER_UI:
! 1925: {
! 1926: mpz_t a;
! 1927: PTR(a) = e->s[0].p; SIZ(a) = (carry==0 ? size : -size);
! 1928: e->retval = CALLING_CONVENTIONS(function) (a, (unsigned long)multiplier);
! 1929: }
! 1930: break;
! 1931: case TYPE_MPZ_KRONECKER_SI:
! 1932: {
! 1933: mpz_t a;
! 1934: PTR(a) = e->s[0].p; SIZ(a) = (carry==0 ? size : -size);
! 1935: e->retval = CALLING_CONVENTIONS (function) (a, (long) multiplier);
! 1936: }
! 1937: break;
! 1938: case TYPE_MPZ_UI_KRONECKER:
! 1939: {
! 1940: mpz_t b;
! 1941: PTR(b) = e->s[0].p; SIZ(b) = (carry==0 ? size : -size);
! 1942: e->retval = CALLING_CONVENTIONS(function) ((unsigned long)multiplier, b);
! 1943: }
! 1944: break;
! 1945: case TYPE_MPZ_SI_KRONECKER:
! 1946: {
! 1947: mpz_t b;
! 1948: PTR(b) = e->s[0].p; SIZ(b) = (carry==0 ? size : -size);
! 1949: e->retval = CALLING_CONVENTIONS (function) ((long) multiplier, b);
! 1950: }
! 1951: break;
! 1952:
! 1953: case TYPE_MUL_BASECASE:
! 1954: CALLING_CONVENTIONS (function)
! 1955: (e->d[0].p, e->s[0].p, size, e->s[1].p, size2);
! 1956: break;
! 1957: case TYPE_MUL_N:
! 1958: CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, e->s[1].p, size);
! 1959: break;
! 1960: case TYPE_SQR:
! 1961: CALLING_CONVENTIONS (function) (e->d[0].p, e->s[0].p, size);
! 1962: break;
! 1963:
! 1964: case TYPE_UMUL_PPMM:
! 1965: e->retval = CALLING_CONVENTIONS (function)
! 1966: (e->d[0].p, e->s[0].p[0], e->s[0].p[1]);
! 1967: break;
! 1968: case TYPE_UMUL_PPMM_R:
! 1969: e->retval = CALLING_CONVENTIONS (function)
! 1970: (e->s[0].p[0], e->s[0].p[1], e->d[0].p);
! 1971: break;
! 1972:
! 1973: case TYPE_LSHIFT:
! 1974: case TYPE_RSHIFT:
! 1975: e->retval = CALLING_CONVENTIONS (function)
! 1976: (e->d[0].p, e->s[0].p, size, shift);
! 1977: break;
! 1978:
! 1979: case TYPE_POPCOUNT:
! 1980: e->retval = (* (unsigned long (*)(ANYARGS))
! 1981: CALLING_CONVENTIONS (function)) (e->s[0].p, size);
! 1982: break;
! 1983: case TYPE_HAMDIST:
! 1984: e->retval = (* (unsigned long (*)(ANYARGS))
! 1985: CALLING_CONVENTIONS (function)) (e->s[0].p, e->s[1].p, size);
! 1986: break;
! 1987:
! 1988: case TYPE_SQRTREM:
! 1989: e->retval = (* (long (*)(ANYARGS)) CALLING_CONVENTIONS (function))
! 1990: (e->d[0].p, e->d[1].p, e->s[0].p, size);
! 1991: break;
! 1992:
! 1993: case TYPE_ZERO:
! 1994: CALLING_CONVENTIONS (function) (e->d[0].p, size);
! 1995: break;
! 1996:
! 1997: case TYPE_GET_STR:
! 1998: {
! 1999: size_t sizeinbase, fill;
! 2000: char *dst;
! 2001: MPN_SIZEINBASE (sizeinbase, e->s[0].p, size, base);
! 2002: ASSERT_ALWAYS (sizeinbase <= d[0].size);
! 2003: fill = d[0].size - sizeinbase;
! 2004: if (d[0].high)
! 2005: {
! 2006: memset (e->d[0].p, 0xBA, fill);
! 2007: dst = (char *) e->d[0].p + fill;
! 2008: }
! 2009: else
! 2010: {
! 2011: dst = (char *) e->d[0].p;
! 2012: memset (dst + sizeinbase, 0xBA, fill);
! 2013: }
! 2014: if (POW2_P (base))
! 2015: {
! 2016: e->retval = CALLING_CONVENTIONS (function) (dst, base,
! 2017: e->s[0].p, size);
! 2018: }
! 2019: else
! 2020: {
! 2021: refmpn_copy (e->d[1].p, e->s[0].p, size);
! 2022: e->retval = CALLING_CONVENTIONS (function) (dst, base,
! 2023: e->d[1].p, size);
! 2024: }
! 2025: refmpn_zero (e->d[1].p, size); /* cloberred or unused */
! 2026: }
! 2027: break;
! 2028:
! 2029: #ifdef EXTRA_CALL
! 2030: EXTRA_CALL
! 2031: #endif
! 2032:
! 2033: default:
! 2034: printf ("Unknown routine type %d\n", choice->type);
! 2035: abort ();
! 2036: break;
! 2037: }
! 2038: }
! 2039:
! 2040:
! 2041: void
! 2042: pointer_setup (struct each_t *e)
! 2043: {
! 2044: int i, j;
! 2045:
! 2046: for (i = 0; i < NUM_DESTS; i++)
! 2047: {
! 2048: switch (tr->dst_size[i]) {
! 2049: case 0:
! 2050: case SIZE_RETVAL: /* will be adjusted later */
! 2051: d[i].size = size;
! 2052: break;
! 2053:
! 2054: case SIZE_1:
! 2055: d[i].size = 1;
! 2056: break;
! 2057: case SIZE_2:
! 2058: d[i].size = 2;
! 2059: break;
! 2060: case SIZE_3:
! 2061: d[i].size = 3;
! 2062: break;
! 2063:
! 2064: case SIZE_PLUS_1:
! 2065: d[i].size = size+1;
! 2066: break;
! 2067:
! 2068: case SIZE_SUM:
! 2069: if (tr->size2)
! 2070: d[i].size = size + size2;
! 2071: else
! 2072: d[i].size = 2*size;
! 2073: break;
! 2074:
! 2075: case SIZE_SIZE2:
! 2076: d[i].size = size2;
! 2077: break;
! 2078:
! 2079: case SIZE_DIFF:
! 2080: d[i].size = size - size2;
! 2081: break;
! 2082:
! 2083: case SIZE_DIFF_PLUS_1:
! 2084: d[i].size = size - size2 + 1;
! 2085: break;
! 2086:
! 2087: case SIZE_CEIL_HALF:
! 2088: d[i].size = (size+1)/2;
! 2089: break;
! 2090:
! 2091: case SIZE_GET_STR:
! 2092: {
! 2093: mp_limb_t ff = GMP_NUMB_MAX;
! 2094: MPN_SIZEINBASE (d[i].size, &ff - (size-1), size, base);
! 2095: }
! 2096: break;
! 2097:
! 2098: default:
! 2099: printf ("Unrecognised dst_size type %d\n", tr->dst_size[i]);
! 2100: abort ();
! 2101: }
! 2102: }
! 2103:
! 2104: /* establish e->d[].p destinations */
! 2105: for (i = 0; i < NUM_DESTS; i++)
! 2106: {
! 2107: mp_size_t offset = 0;
! 2108:
! 2109: /* possible room for overlapping sources */
! 2110: for (j = 0; j < numberof (overlap->s); j++)
! 2111: if (overlap->s[j] == i)
! 2112: offset = MAX (offset, s[j].align);
! 2113:
! 2114: if (d[i].high)
! 2115: {
! 2116: if (tr->dst_bytes[i])
! 2117: {
! 2118: e->d[i].p = (mp_ptr)
! 2119: ((char *) (e->d[i].region.ptr + e->d[i].region.size)
! 2120: - d[i].size - d[i].align);
! 2121: }
! 2122: else
! 2123: {
! 2124: e->d[i].p = e->d[i].region.ptr + e->d[i].region.size
! 2125: - d[i].size - d[i].align;
! 2126: if (tr->overlap == OVERLAP_LOW_TO_HIGH)
! 2127: e->d[i].p -= offset;
! 2128: }
! 2129: }
! 2130: else
! 2131: {
! 2132: if (tr->dst_bytes[i])
! 2133: {
! 2134: e->d[i].p = (mp_ptr) ((char *) e->d[i].region.ptr + d[i].align);
! 2135: }
! 2136: else
! 2137: {
! 2138: e->d[i].p = e->d[i].region.ptr + d[i].align;
! 2139: if (tr->overlap == OVERLAP_HIGH_TO_LOW)
! 2140: e->d[i].p += offset;
! 2141: }
! 2142: }
! 2143: }
! 2144:
! 2145: /* establish e->s[].p sources */
! 2146: for (i = 0; i < NUM_SOURCES; i++)
! 2147: {
! 2148: int o = overlap->s[i];
! 2149: switch (o) {
! 2150: case -1:
! 2151: /* no overlap */
! 2152: e->s[i].p = s[i].p;
! 2153: break;
! 2154: case 0:
! 2155: case 1:
! 2156: /* overlap with d[o] */
! 2157: if (tr->overlap == OVERLAP_HIGH_TO_LOW)
! 2158: e->s[i].p = e->d[o].p - s[i].align;
! 2159: else if (tr->overlap == OVERLAP_LOW_TO_HIGH)
! 2160: e->s[i].p = e->d[o].p + s[i].align;
! 2161: else if (tr->size2 == SIZE_FRACTION)
! 2162: e->s[i].p = e->d[o].p + size2;
! 2163: else
! 2164: e->s[i].p = e->d[o].p;
! 2165: break;
! 2166: default:
! 2167: abort();
! 2168: break;
! 2169: }
! 2170: }
! 2171: }
! 2172:
! 2173:
! 2174: void
! 2175: validate_fail (void)
! 2176: {
! 2177: if (tr->reference)
! 2178: {
! 2179: trap_location = TRAP_REF;
! 2180: call (&ref, tr->reference);
! 2181: trap_location = TRAP_NOWHERE;
! 2182: }
! 2183:
! 2184: print_all();
! 2185: abort();
! 2186: }
! 2187:
! 2188:
! 2189: void
! 2190: try_one (void)
! 2191: {
! 2192: int i;
! 2193:
! 2194: if (option_spinner)
! 2195: spinner();
! 2196: spinner_count++;
! 2197:
! 2198: trap_location = TRAP_SETUPS;
! 2199:
! 2200: if (tr->divisor == DIVISOR_NORM)
! 2201: divisor |= GMP_NUMB_HIGHBIT;
! 2202: if (tr->divisor == DIVISOR_ODD)
! 2203: divisor |= 1;
! 2204:
! 2205: for (i = 0; i < NUM_SOURCES; i++)
! 2206: {
! 2207: if (s[i].high)
! 2208: s[i].p = s[i].region.ptr + s[i].region.size - SRC_SIZE(i) - s[i].align;
! 2209: else
! 2210: s[i].p = s[i].region.ptr + s[i].align;
! 2211: }
! 2212:
! 2213: pointer_setup (&ref);
! 2214: pointer_setup (&fun);
! 2215:
! 2216: for (i = 0; i < NUM_DESTS; i++)
! 2217: {
! 2218: if (! tr->dst[i])
! 2219: continue;
! 2220:
! 2221: if (tr->dst0_from_src1 && i==0)
! 2222: {
! 2223: t_random (s[1].region.ptr, d[0].size);
! 2224: MPN_COPY (fun.d[0].p, s[1].region.ptr, d[0].size);
! 2225: MPN_COPY (ref.d[0].p, s[1].region.ptr, d[0].size);
! 2226: }
! 2227: else if (tr->dst_bytes[i])
! 2228: {
! 2229: memset (ref.d[i].p, 0xBA, d[i].size);
! 2230: memset (fun.d[i].p, 0xBA, d[i].size);
! 2231: }
! 2232: else
! 2233: {
! 2234: refmpn_fill (ref.d[i].p, d[i].size, DEADVAL);
! 2235: refmpn_fill (fun.d[i].p, d[i].size, DEADVAL);
! 2236: }
! 2237: }
! 2238:
! 2239: ref.retval = 0x04152637;
! 2240: fun.retval = 0x8C9DAEBF;
! 2241:
! 2242: for (i = 0; i < NUM_SOURCES; i++)
! 2243: {
! 2244: if (! tr->src[i])
! 2245: continue;
! 2246:
! 2247: mprotect_region (&s[i].region, PROT_READ|PROT_WRITE);
! 2248: t_random (s[i].p, SRC_SIZE(i));
! 2249:
! 2250: switch (tr->data) {
! 2251: case DATA_NON_ZERO:
! 2252: if (refmpn_zero_p (s[i].p, SRC_SIZE(i)))
! 2253: s[i].p[0] = 1;
! 2254: break;
! 2255:
! 2256: case DATA_MULTIPLE_DIVISOR:
! 2257: /* same number of low zero bits as divisor */
! 2258: s[i].p[0] &= ~ LOW_ZEROS_MASK (divisor);
! 2259: refmpn_sub_1 (s[i].p, s[i].p, size,
! 2260: refmpn_mod_1 (s[i].p, size, divisor));
! 2261: break;
! 2262:
! 2263: case DATA_GCD:
! 2264: /* s[1] no more bits than s[0] */
! 2265: if (i == 1 && size2 == size)
! 2266: s[1].p[size-1] &= refmpn_msbone_mask (s[0].p[size-1]);
! 2267:
! 2268: /* high limb non-zero */
! 2269: s[i].p[SRC_SIZE(i)-1] += (s[i].p[SRC_SIZE(i)-1] == 0);
! 2270:
! 2271: /* odd */
! 2272: s[i].p[0] |= 1;
! 2273: break;
! 2274:
! 2275: case DATA_SRC1_ODD:
! 2276: if (i == 1)
! 2277: s[i].p[0] |= 1;
! 2278: break;
! 2279:
! 2280: case DATA_SRC1_HIGHBIT:
! 2281: if (i == 1)
! 2282: {
! 2283: if (tr->size2)
! 2284: s[i].p[size2-1] |= GMP_NUMB_HIGHBIT;
! 2285: else
! 2286: s[i].p[size-1] |= GMP_NUMB_HIGHBIT;
! 2287: }
! 2288: break;
! 2289:
! 2290: case DATA_UDIV_QRNND:
! 2291: s[i].p[1] %= divisor;
! 2292: break;
! 2293: }
! 2294:
! 2295: mprotect_region (&s[i].region, PROT_READ);
! 2296:
! 2297: if (ref.s[i].p != s[i].p)
! 2298: {
! 2299: refmpn_copyi (ref.s[i].p, s[i].p, SRC_SIZE(i));
! 2300: refmpn_copyi (fun.s[i].p, s[i].p, SRC_SIZE(i));
! 2301: }
! 2302: }
! 2303:
! 2304: if (option_print)
! 2305: print_all();
! 2306:
! 2307: if (tr->validate != NULL)
! 2308: {
! 2309: trap_location = TRAP_FUN;
! 2310: call (&fun, choice->function);
! 2311: trap_location = TRAP_NOWHERE;
! 2312:
! 2313: if (! CALLING_CONVENTIONS_CHECK ())
! 2314: {
! 2315: print_all();
! 2316: abort();
! 2317: }
! 2318:
! 2319: (*tr->validate) ();
! 2320: }
! 2321: else
! 2322: {
! 2323: trap_location = TRAP_REF;
! 2324: call (&ref, tr->reference);
! 2325: trap_location = TRAP_FUN;
! 2326: call (&fun, choice->function);
! 2327: trap_location = TRAP_NOWHERE;
! 2328:
! 2329: if (! CALLING_CONVENTIONS_CHECK ())
! 2330: {
! 2331: print_all();
! 2332: abort();
! 2333: }
! 2334:
! 2335: compare ();
! 2336: }
! 2337: }
! 2338:
! 2339:
! 2340: #define SIZE_ITERATION \
! 2341: for (size = MAX3 (option_firstsize, \
! 2342: choice->minsize, \
! 2343: (tr->size == SIZE_ALLOW_ZERO) ? 0 : 1); \
! 2344: size <= option_lastsize; \
! 2345: size++)
! 2346:
! 2347: #define SIZE2_FIRST \
! 2348: (tr->size2 == SIZE_2 ? 2 \
! 2349: : tr->size2 == SIZE_FRACTION ? 0 \
! 2350: : tr->size2 ? \
! 2351: MAX (choice->minsize, (option_firstsize2 != 0 \
! 2352: ? option_firstsize2 : 1)) \
! 2353: : 0)
! 2354:
! 2355: #define SIZE2_LAST \
! 2356: (tr->size2 == SIZE_2 ? 2 \
! 2357: : tr->size2 == SIZE_FRACTION ? FRACTION_COUNT-1 \
! 2358: : tr->size2 ? size \
! 2359: : 0)
! 2360:
! 2361: #define SIZE2_ITERATION \
! 2362: for (size2 = SIZE2_FIRST; size2 <= SIZE2_LAST; size2++)
! 2363:
! 2364: #define ALIGN_COUNT(cond) ((cond) ? ALIGNMENTS : 1)
! 2365: #define ALIGN_ITERATION(w,n,cond) \
! 2366: for (w[n].align = 0; w[n].align < ALIGN_COUNT(cond); w[n].align++)
! 2367:
! 2368: #define HIGH_LIMIT(cond) ((cond) != 0)
! 2369: #define HIGH_COUNT(cond) (HIGH_LIMIT (cond) + 1)
! 2370: #define HIGH_ITERATION(w,n,cond) \
! 2371: for (w[n].high = 0; w[n].high <= HIGH_LIMIT(cond); w[n].high++)
! 2372:
! 2373: #define SHIFT_LIMIT \
! 2374: ((unsigned long) (tr->shift ? GMP_NUMB_BITS -1 : 1))
! 2375:
! 2376: #define SHIFT_ITERATION \
! 2377: for (shift = 1; shift <= SHIFT_LIMIT; shift++)
! 2378:
! 2379:
! 2380: void
! 2381: try_many (void)
! 2382: {
! 2383: int i;
! 2384:
! 2385: {
! 2386: unsigned long total = 1;
! 2387:
! 2388: total *= option_repetitions;
! 2389: total *= option_lastsize;
! 2390: if (tr->size2 == SIZE_FRACTION) total *= FRACTION_COUNT;
! 2391: else if (tr->size2) total *= (option_lastsize+1)/2;
! 2392:
! 2393: total *= SHIFT_LIMIT;
! 2394: total *= MULTIPLIER_COUNT;
! 2395: total *= DIVISOR_COUNT;
! 2396: total *= CARRY_COUNT;
! 2397: total *= T_RAND_COUNT;
! 2398:
! 2399: total *= HIGH_COUNT (tr->dst[0]);
! 2400: total *= HIGH_COUNT (tr->dst[1]);
! 2401: total *= HIGH_COUNT (tr->src[0]);
! 2402: total *= HIGH_COUNT (tr->src[1]);
! 2403:
! 2404: total *= ALIGN_COUNT (tr->dst[0]);
! 2405: total *= ALIGN_COUNT (tr->dst[1]);
! 2406: total *= ALIGN_COUNT (tr->src[0]);
! 2407: total *= ALIGN_COUNT (tr->src[1]);
! 2408:
! 2409: total *= OVERLAP_COUNT;
! 2410:
! 2411: printf ("%s %lu\n", choice->name, total);
! 2412: }
! 2413:
! 2414: spinner_count = 0;
! 2415:
! 2416: for (i = 0; i < option_repetitions; i++)
! 2417: SIZE_ITERATION
! 2418: SIZE2_ITERATION
! 2419:
! 2420: SHIFT_ITERATION
! 2421: MULTIPLIER_ITERATION
! 2422: DIVISOR_ITERATION
! 2423: CARRY_ITERATION /* must be after divisor */
! 2424: T_RAND_ITERATION
! 2425:
! 2426: HIGH_ITERATION(d,0, tr->dst[0])
! 2427: HIGH_ITERATION(d,1, tr->dst[1])
! 2428: HIGH_ITERATION(s,0, tr->src[0])
! 2429: HIGH_ITERATION(s,1, tr->src[1])
! 2430:
! 2431: ALIGN_ITERATION(d,0, tr->dst[0])
! 2432: ALIGN_ITERATION(d,1, tr->dst[1])
! 2433: ALIGN_ITERATION(s,0, tr->src[0])
! 2434: ALIGN_ITERATION(s,1, tr->src[1])
! 2435:
! 2436: OVERLAP_ITERATION
! 2437: try_one();
! 2438:
! 2439: printf("\n");
! 2440: }
! 2441:
! 2442:
! 2443: /* Usually print_all() doesn't show much, but it might give a hint as to
! 2444: where the function was up to when it died. */
! 2445: void
! 2446: trap (int sig)
! 2447: {
! 2448: const char *name = "noname";
! 2449:
! 2450: switch (sig) {
! 2451: case SIGILL: name = "SIGILL"; break;
! 2452: #ifdef SIGBUS
! 2453: case SIGBUS: name = "SIGBUS"; break;
! 2454: #endif
! 2455: case SIGSEGV: name = "SIGSEGV"; break;
! 2456: case SIGFPE: name = "SIGFPE"; break;
! 2457: }
! 2458:
! 2459: printf ("\n\nSIGNAL TRAP: %s\n", name);
! 2460:
! 2461: switch (trap_location) {
! 2462: case TRAP_REF:
! 2463: printf (" in reference function: %s\n", tr->reference_name);
! 2464: break;
! 2465: case TRAP_FUN:
! 2466: printf (" in test function: %s\n", choice->name);
! 2467: print_all ();
! 2468: break;
! 2469: case TRAP_SETUPS:
! 2470: printf (" in parameter setups\n");
! 2471: print_all ();
! 2472: break;
! 2473: default:
! 2474: printf (" somewhere unknown\n");
! 2475: break;
! 2476: }
! 2477: exit (1);
! 2478: }
! 2479:
! 2480:
! 2481: void
! 2482: try_init (void)
! 2483: {
! 2484: #if HAVE_GETPAGESIZE
! 2485: /* Prefer getpagesize() over sysconf(), since on SunOS 4 sysconf() doesn't
! 2486: know _SC_PAGESIZE. */
! 2487: pagesize = getpagesize ();
! 2488: #else
! 2489: #if HAVE_SYSCONF
! 2490: if ((pagesize = sysconf (_SC_PAGESIZE)) == -1)
! 2491: {
! 2492: /* According to the linux man page, sysconf doesn't set errno */
! 2493: fprintf (stderr, "Cannot get sysconf _SC_PAGESIZE\n");
! 2494: exit (1);
! 2495: }
! 2496: #else
! 2497: Error, error, cannot get page size
! 2498: #endif
! 2499: #endif
! 2500:
! 2501: printf ("pagesize is 0x%lX bytes\n", pagesize);
! 2502:
! 2503: signal (SIGILL, trap);
! 2504: #ifdef SIGBUS
! 2505: signal (SIGBUS, trap);
! 2506: #endif
! 2507: signal (SIGSEGV, trap);
! 2508: signal (SIGFPE, trap);
! 2509:
! 2510: {
! 2511: int i;
! 2512:
! 2513: for (i = 0; i < NUM_SOURCES; i++)
! 2514: {
! 2515: malloc_region (&s[i].region, 2*option_lastsize+ALIGNMENTS-1);
! 2516: printf ("s[%d] %p to %p (0x%lX bytes)\n",
! 2517: i, s[i].region.ptr,
! 2518: s[i].region.ptr + s[i].region.size,
! 2519: s[i].region.size * BYTES_PER_MP_LIMB);
! 2520: }
! 2521:
! 2522: #define INIT_EACH(e,es) \
! 2523: for (i = 0; i < NUM_DESTS; i++) \
! 2524: { \
! 2525: malloc_region (&e.d[i].region, 2*option_lastsize+ALIGNMENTS-1); \
! 2526: printf ("%s d[%d] %p to %p (0x%lX bytes)\n", \
! 2527: es, i, e.d[i].region.ptr, \
! 2528: e.d[i].region.ptr + e.d[i].region.size, \
! 2529: e.d[i].region.size * BYTES_PER_MP_LIMB); \
! 2530: }
! 2531:
! 2532: INIT_EACH(ref, "ref");
! 2533: INIT_EACH(fun, "fun");
! 2534: }
! 2535: }
! 2536:
! 2537: int
! 2538: strmatch_wild (const char *pattern, const char *str)
! 2539: {
! 2540: size_t plen, slen;
! 2541:
! 2542: /* wildcard at start */
! 2543: if (pattern[0] == '*')
! 2544: {
! 2545: pattern++;
! 2546: plen = strlen (pattern);
! 2547: slen = strlen (str);
! 2548: return (plen == 0
! 2549: || (slen >= plen && memcmp (pattern, str+slen-plen, plen) == 0));
! 2550: }
! 2551:
! 2552: /* wildcard at end */
! 2553: plen = strlen (pattern);
! 2554: if (plen >= 1 && pattern[plen-1] == '*')
! 2555: return (memcmp (pattern, str, plen-1) == 0);
! 2556:
! 2557: /* no wildcards */
! 2558: return (strcmp (pattern, str) == 0);
! 2559: }
! 2560:
! 2561: void
! 2562: try_name (const char *name)
! 2563: {
! 2564: int found = 0;
! 2565: int i;
! 2566:
! 2567: for (i = 0; i < numberof (choice_array); i++)
! 2568: {
! 2569: if (strmatch_wild (name, choice_array[i].name))
! 2570: {
! 2571: choice = &choice_array[i];
! 2572: tr = ¶m[choice->type];
! 2573: try_many ();
! 2574: found = 1;
! 2575: }
! 2576: }
! 2577:
! 2578: if (!found)
! 2579: {
! 2580: printf ("%s unknown\n", name);
! 2581: /* exit (1); */
! 2582: }
! 2583: }
! 2584:
! 2585:
! 2586: void
! 2587: usage (const char *prog)
! 2588: {
! 2589: int col = 0;
! 2590: int i;
! 2591:
! 2592: printf ("Usage: %s [options] function...\n\
! 2593: -1 use limb data 1,2,3,etc\n\
! 2594: -9 use limb data all 0xFF..FFs\n\
! 2595: -a zeros use limb data all zeros\n\
! 2596: -a ffs use limb data all 0xFF..FFs (same as -9)\n\
! 2597: -a 2fd use data 0x2FFF...FFFD\n\
! 2598: -p print each case tried (try this if seg faulting)\n\
! 2599: -R seed random numbers from time()\n\
! 2600: -r reps set repetitions (default %d)\n\
! 2601: -s size starting size to test\n\
! 2602: -S size2 starting size2 to test\n\
! 2603: -s s1-s2 range of sizes to test\n\
! 2604: -W don't show the spinner (use this in gdb)\n\
! 2605: -z disable mprotect() redzones\n\
! 2606: Default data is refmpn_random() and refmpn_random2().\n\
! 2607: \n\
! 2608: Functions that can be tested:\n\
! 2609: ", prog, DEFAULT_REPETITIONS);
! 2610:
! 2611: for (i = 0; i < numberof (choice_array); i++)
! 2612: {
! 2613: if (col + 1 + strlen (choice_array[i].name) > 79)
! 2614: {
! 2615: printf ("\n");
! 2616: col = 0;
! 2617: }
! 2618: printf (" %s", choice_array[i].name);
! 2619: col += 1 + strlen (choice_array[i].name);
! 2620: }
! 2621: printf ("\n");
! 2622:
! 2623: exit(1);
! 2624: }
! 2625:
! 2626:
! 2627: int
! 2628: main (int argc, char *argv[])
! 2629: {
! 2630: int i;
! 2631:
! 2632: /* unbuffered output */
! 2633: setbuf (stdout, NULL);
! 2634: setbuf (stderr, NULL);
! 2635:
! 2636: /* default trace in hex, and in upper-case so can paste into bc */
! 2637: mp_trace_base = -16;
! 2638:
! 2639: param_init ();
! 2640:
! 2641: {
! 2642: unsigned seed = 123;
! 2643: int opt;
! 2644:
! 2645: while ((opt = getopt(argc, argv, "19a:b:pRr:S:s:Wz")) != EOF)
! 2646: {
! 2647: switch (opt) {
! 2648: case '1':
! 2649: /* use limb data values 1, 2, 3, ... etc */
! 2650: option_data = DATA_SEQ;
! 2651: break;
! 2652: case '9':
! 2653: /* use limb data values 0xFFF...FFF always */
! 2654: option_data = DATA_FFS;
! 2655: break;
! 2656: case 'a':
! 2657: if (strcmp (optarg, "zeros") == 0) option_data = DATA_ZEROS;
! 2658: else if (strcmp (optarg, "seq") == 0) option_data = DATA_SEQ;
! 2659: else if (strcmp (optarg, "ffs") == 0) option_data = DATA_FFS;
! 2660: else if (strcmp (optarg, "2fd") == 0) option_data = DATA_2FD;
! 2661: else
! 2662: {
! 2663: fprintf (stderr, "unrecognised data option: %s\n", optarg);
! 2664: exit (1);
! 2665: }
! 2666: break;
! 2667: case 'b':
! 2668: mp_trace_base = atoi (optarg);
! 2669: break;
! 2670: case 'p':
! 2671: option_print = 1;
! 2672: break;
! 2673: case 'R':
! 2674: /* randomize */
! 2675: seed = time (NULL);
! 2676: break;
! 2677: case 'r':
! 2678: option_repetitions = atoi (optarg);
! 2679: break;
! 2680: case 's':
! 2681: {
! 2682: char *p;
! 2683: option_firstsize = atoi (optarg);
! 2684: if ((p = strchr (optarg, '-')) != NULL)
! 2685: option_lastsize = atoi (p+1);
! 2686: }
! 2687: break;
! 2688: case 'S':
! 2689: /* -S <size> sets the starting size for the second of a two size
! 2690: routine (like mpn_mul_basecase) */
! 2691: option_firstsize2 = atoi (optarg);
! 2692: break;
! 2693: case 'W':
! 2694: /* use this when running in the debugger */
! 2695: option_spinner = 0;
! 2696: break;
! 2697: case 'z':
! 2698: /* disable redzones */
! 2699: option_redzones = 0;
! 2700: break;
! 2701: case '?':
! 2702: usage (argv[0]);
! 2703: break;
! 2704: }
! 2705: }
! 2706:
! 2707: gmp_randseed_ui (RANDS, seed);
! 2708: }
! 2709:
! 2710: try_init();
! 2711:
! 2712: if (argc <= optind)
! 2713: usage (argv[0]);
! 2714:
! 2715: for (i = optind; i < argc; i++)
! 2716: try_name (argv[i]);
! 2717:
! 2718: return 0;
! 2719: }
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 / tests / devel