int
main (int argc, char *argv[])
{
mp_limb_t want_bb, want_bb_inv;
int base, want_chars_per_limb;
want_chars_per_limb = refmpn_chars_per_limb (10);
if (MP_BASES_CHARS_PER_LIMB_10 != want_chars_per_limb)
{
printf ("MP_BASES_CHARS_PER_LIMB_10 wrong\n");
abort ();
}
want_bb = refmpn_big_base (10);
if (MP_BASES_BIG_BASE_10 != want_bb)
{
printf ("MP_BASES_BIG_BASE_10 wrong\n");
abort ();
}
want_bb_inv = refmpn_invert_limb
(want_bb << refmpn_count_leading_zeros (want_bb));
if (MP_BASES_BIG_BASE_INVERTED_10 != want_bb_inv)
{
printf ("MP_BASES_BIG_BASE_INVERTED_10 wrong\n");
abort ();
}
if (MP_BASES_NORMALIZATION_STEPS_10
!= refmpn_count_leading_zeros (MP_BASES_BIG_BASE_10))
{
printf ("MP_BASES_NORMALIZATION_STEPS_10 wrong\n");
abort ();
}
for (base = 2; base < numberof (mp_bases); base++)
{
want_chars_per_limb = refmpn_chars_per_limb (base);
if (mp_bases[base].chars_per_limb != want_chars_per_limb)
{
printf ("mp_bases[%d].chars_per_limb wrong\n", base);
printf (" got %d\n", mp_bases[base].chars_per_limb);
printf (" want %d\n", want_chars_per_limb);
abort ();
}
if (POW2_P (base))
{
want_bb = refmpn_count_trailing_zeros ((mp_limb_t) base);
if (mp_bases[base].big_base != want_bb)
{
printf ("mp_bases[%d].big_base (log2 of base) wrong\n", base);
abort ();
}
}
else
{
want_bb = refmpn_big_base (base);
if (mp_bases[base].big_base != want_bb)
{
printf ("mp_bases[%d].big_base wrong\n", base);
abort ();
}
#if USE_PREINV_DIVREM_1
want_bb_inv = refmpn_invert_limb
(want_bb << refmpn_count_leading_zeros (want_bb));
if (mp_bases[base].big_base_inverted != want_bb_inv)
{
printf ("mp_bases[%d].big_base_inverted wrong\n", base);
abort ();
}
#endif
}
}
exit (0);
}
void
check (void)
{
mp_limb_t wp[100], xp[100], yp[100];
mp_size_t size = 100;
refmpn_zero (xp, size);
refmpn_zero (yp, size);
refmpn_zero (wp, size);
pre ("mpn_add_n");
mpn_add_n (wp, xp, yp, size);
post ();
#if HAVE_NATIVE_mpn_add_nc
pre ("mpn_add_nc");
mpn_add_nc (wp, xp, yp, size, CNST_LIMB(0));
post ();
#endif
#if HAVE_NATIVE_mpn_addlsh1_n
pre ("mpn_addlsh1_n");
mpn_addlsh1_n (wp, xp, yp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_and_n
pre ("mpn_and_n");
mpn_and_n (wp, xp, yp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_andn_n
pre ("mpn_andn_n");
mpn_andn_n (wp, xp, yp, size);
post ();
#endif
pre ("mpn_addmul_1");
mpn_addmul_1 (wp, xp, size, yp[0]);
post ();
#if HAVE_NATIVE_mpn_addmul_1c
pre ("mpn_addmul_1c");
mpn_addmul_1c (wp, xp, size, yp[0], CNST_LIMB(0));
post ();
#endif
#if HAVE_NATIVE_mpn_com_n
pre ("mpn_com_n");
mpn_com_n (wp, xp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_copyd
pre ("mpn_copyd");
mpn_copyd (wp, xp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_copyi
pre ("mpn_copyi");
mpn_copyi (wp, xp, size);
post ();
#endif
pre ("mpn_divexact_1");
mpn_divexact_1 (wp, xp, size, CNST_LIMB(123));
post ();
pre ("mpn_divexact_by3c");
mpn_divexact_by3c (wp, xp, size, CNST_LIMB(0));
post ();
pre ("mpn_divrem_1");
mpn_divrem_1 (wp, (mp_size_t) 0, xp, size, CNST_LIMB(123));
post ();
#if HAVE_NATIVE_mpn_divrem_1c
pre ("mpn_divrem_1c");
mpn_divrem_1c (wp, (mp_size_t) 0, xp, size, CNST_LIMB(123), CNST_LIMB(122));
post ();
#endif
pre ("mpn_gcd_1");
xp[0] |= 1;
notdead += (unsigned long) mpn_gcd_1 (xp, size, CNST_LIMB(123));
post ();
#if HAVE_NATIVE_mpn_gcd_finda
pre ("mpn_gcd_finda");
xp[0] |= 1;
xp[1] |= 1;
notdead += mpn_gcd_finda (xp);
post ();
#endif
pre ("mpn_hamdist");
notdead += mpn_hamdist (xp, yp, size);
post ();
#if HAVE_NATIVE_mpn_ior_n
pre ("mpn_ior_n");
mpn_ior_n (wp, xp, yp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_iorn_n
pre ("mpn_iorn_n");
mpn_iorn_n (wp, xp, yp, size);
post ();
#endif
pre ("mpn_lshift");
mpn_lshift (wp, xp, size, 1);
post ();
pre ("mpn_mod_1");
notdead += mpn_mod_1 (xp, size, CNST_LIMB(123));
post ();
#if HAVE_NATIVE_mpn_mod_1c
pre ("mpn_mod_1c");
notdead += mpn_mod_1c (xp, size, CNST_LIMB(123), CNST_LIMB(122));
post ();
#endif
#if GMP_NUMB_BITS % 4 == 0
pre ("mpn_mod_34lsub1");
notdead += mpn_mod_34lsub1 (xp, size);
post ();
#endif
pre ("mpn_modexact_1_odd");
notdead += mpn_modexact_1_odd (xp, size, CNST_LIMB(123));
post ();
pre ("mpn_modexact_1c_odd");
notdead += mpn_modexact_1c_odd (xp, size, CNST_LIMB(123), CNST_LIMB(456));
post ();
pre ("mpn_mul_1");
mpn_mul_1 (wp, xp, size, yp[0]);
post ();
#if HAVE_NATIVE_mpn_mul_1c
pre ("mpn_mul_1c");
mpn_mul_1c (wp, xp, size, yp[0], CNST_LIMB(0));
post ();
#endif
#if HAVE_NATIVE_mpn_mul_2
pre ("mpn_mul_2");
mpn_mul_2 (wp, xp, size-1, yp);
post ();
#endif
pre ("mpn_mul_basecase");
mpn_mul_basecase (wp, xp, (mp_size_t) 3, yp, (mp_size_t) 3);
post ();
#if HAVE_NATIVE_mpn_nand_n
pre ("mpn_nand_n");
mpn_nand_n (wp, xp, yp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_nior_n
pre ("mpn_nior_n");
mpn_nior_n (wp, xp, yp, size);
post ();
#endif
pre ("mpn_popcount");
notdead += mpn_popcount (xp, size);
post ();
pre ("mpn_preinv_mod_1");
notdead += mpn_preinv_mod_1 (xp, size, GMP_NUMB_MAX,
refmpn_invert_limb (GMP_NUMB_MAX));
post ();
#if USE_PREINV_DIVREM_1 || HAVE_NATIVE_mpn_preinv_divrem_1
pre ("mpn_preinv_divrem_1");
mpn_preinv_divrem_1 (wp, (mp_size_t) 0, xp, size, GMP_NUMB_MAX,
refmpn_invert_limb (GMP_NUMB_MAX), 0);
post ();
#endif
#if HAVE_NATIVE_mpn_rsh1add_n
pre ("mpn_rsh1add_n");
mpn_rsh1add_n (wp, xp, yp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_rsh1sub_n
pre ("mpn_rsh1sub_n");
mpn_rsh1sub_n (wp, xp, yp, size);
post ();
#endif
pre ("mpn_rshift");
mpn_rshift (wp, xp, size, 1);
post ();
pre ("mpn_sqr_basecase");
mpn_sqr_basecase (wp, xp, (mp_size_t) 3);
post ();
pre ("mpn_submul_1");
mpn_submul_1 (wp, xp, size, yp[0]);
post ();
#if HAVE_NATIVE_mpn_submul_1c
pre ("mpn_submul_1c");
mpn_submul_1c (wp, xp, size, yp[0], CNST_LIMB(0));
post ();
#endif
pre ("mpn_sub_n");
mpn_sub_n (wp, xp, yp, size);
post ();
#if HAVE_NATIVE_mpn_sub_nc
pre ("mpn_sub_nc");
mpn_sub_nc (wp, xp, yp, size, CNST_LIMB(0));
post ();
#endif
#if HAVE_NATIVE_mpn_sublsh1_n
pre ("mpn_sublsh1_n");
mpn_sublsh1_n (wp, xp, yp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_udiv_qrnnd
pre ("mpn_udiv_qrnnd");
mpn_udiv_qrnnd (&wp[0], CNST_LIMB(122), xp[0], CNST_LIMB(123));
post ();
#endif
#if HAVE_NATIVE_mpn_udiv_qrnnd_r
pre ("mpn_udiv_qrnnd_r");
mpn_udiv_qrnnd (CNST_LIMB(122), xp[0], CNST_LIMB(123), &wp[0]);
post ();
#endif
#if HAVE_NATIVE_mpn_umul_ppmm
pre ("mpn_umul_ppmm");
mpn_umul_ppmm (&wp[0], xp[0], yp[0]);
post ();
#endif
#if HAVE_NATIVE_mpn_umul_ppmm_r
pre ("mpn_umul_ppmm_r");
mpn_umul_ppmm_r (&wp[0], xp[0], yp[0]);
post ();
#endif
#if HAVE_NATIVE_mpn_xor_n
pre ("mpn_xor_n");
mpn_xor_n (wp, xp, yp, size);
post ();
#endif
#if HAVE_NATIVE_mpn_xnor_n
pre ("mpn_xnor_n");
mpn_xnor_n (wp, xp, yp, size);
post ();
#endif
}
void
check_functions (void)
{
mp_limb_t wp[2], wp2[2], xp[2], yp[2], r;
int i;
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 123;
yp[0] = 456;
mpn_add_n (wp, xp, yp, (mp_size_t) 1);
ASSERT_ALWAYS (wp[0] == 579);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 123;
wp[0] = 456;
r = mpn_addmul_1 (wp, xp, (mp_size_t) 1, CNST_LIMB(2));
ASSERT_ALWAYS (wp[0] == 702);
ASSERT_ALWAYS (r == 0);
}
#if HAVE_NATIVE_mpn_copyd
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 123;
xp[1] = 456;
mpn_copyd (xp+1, xp, (mp_size_t) 1);
ASSERT_ALWAYS (xp[1] == 123);
}
#endif
#if HAVE_NATIVE_mpn_copyi
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 123;
xp[1] = 456;
mpn_copyi (xp, xp+1, (mp_size_t) 1);
ASSERT_ALWAYS (xp[0] == 456);
}
#endif
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 1605;
mpn_divexact_1 (wp, xp, (mp_size_t) 1, CNST_LIMB(5));
ASSERT_ALWAYS (wp[0] == 321);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 1296;
r = mpn_divexact_by3c (wp, xp, (mp_size_t) 1, CNST_LIMB(0));
ASSERT_ALWAYS (wp[0] == 432);
ASSERT_ALWAYS (r == 0);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 578;
r = mpn_divexact_byfobm1 (wp, xp, (mp_size_t) 1, CNST_LIMB(17),CNST_LIMB(-1)/CNST_LIMB(17));
ASSERT_ALWAYS (wp[0] == 34);
ASSERT_ALWAYS (r == 0);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 287;
r = mpn_divrem_1 (wp, (mp_size_t) 1, xp, (mp_size_t) 1, CNST_LIMB(7));
ASSERT_ALWAYS (wp[1] == 41);
ASSERT_ALWAYS (wp[0] == 0);
ASSERT_ALWAYS (r == 0);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 290;
r = mpn_divrem_euclidean_qr_1 (wp, 0, xp, (mp_size_t) 1, CNST_LIMB(7));
ASSERT_ALWAYS (wp[0] == 41);
ASSERT_ALWAYS (r == 3);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 12;
r = mpn_gcd_1 (xp, (mp_size_t) 1, CNST_LIMB(9));
ASSERT_ALWAYS (r == 3);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 0x1001;
mpn_lshift (wp, xp, (mp_size_t) 1, 1);
ASSERT_ALWAYS (wp[0] == 0x2002);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 14;
r = mpn_mod_1 (xp, (mp_size_t) 1, CNST_LIMB(4));
ASSERT_ALWAYS (r == 2);
}
#if (GMP_NUMB_BITS % 4) == 0
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
int bits = (GMP_NUMB_BITS / 4) * 3;
mp_limb_t mod = (CNST_LIMB(1) << bits) - 1;
mp_limb_t want = GMP_NUMB_MAX % mod;
xp[0] = GMP_NUMB_MAX;
r = mpn_mod_34lsub1 (xp, (mp_size_t) 1);
ASSERT_ALWAYS (r % mod == want);
}
#endif
// DECL_modexact_1c_odd ((*modexact_1c_odd));
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 14;
r = mpn_mul_1 (wp, xp, (mp_size_t) 1, CNST_LIMB(4));
ASSERT_ALWAYS (wp[0] == 56);
ASSERT_ALWAYS (r == 0);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 5;
yp[0] = 7;
mpn_mul_basecase (wp, xp, (mp_size_t) 1, yp, (mp_size_t) 1);
ASSERT_ALWAYS (wp[0] == 35);
ASSERT_ALWAYS (wp[1] == 0);
}
#if HAVE_NATIVE_mpn_preinv_divrem_1 && GMP_NAIL_BITS == 0
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 0x101;
r = mpn_preinv_divrem_1 (wp, (mp_size_t) 1, xp, (mp_size_t) 1,
GMP_LIMB_HIGHBIT,
refmpn_invert_limb (GMP_LIMB_HIGHBIT), 0);
ASSERT_ALWAYS (wp[0] == 0x202);
ASSERT_ALWAYS (wp[1] == 0);
ASSERT_ALWAYS (r == 0);
}
#endif
#if GMP_NAIL_BITS == 0
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = GMP_LIMB_HIGHBIT+123;
r = mpn_preinv_mod_1 (xp, (mp_size_t) 1, GMP_LIMB_HIGHBIT,
refmpn_invert_limb (GMP_LIMB_HIGHBIT));
ASSERT_ALWAYS (r == 123);
}
#endif
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 5;
modlimb_invert(r,xp[0]);
r=-r;
yp[0]=43;
yp[1]=75;
mpn_redc_1 (wp, yp, xp, (mp_size_t) 1,r);
ASSERT_ALWAYS (wp[0] == 78);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0]=5;
yp[0]=3;
mpn_sumdiff_n (wp, wp2,xp, yp,1);
ASSERT_ALWAYS (wp[0] == 8);
ASSERT_ALWAYS (wp2[0] == 2);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 0x8008;
mpn_rshift (wp, xp, (mp_size_t) 1, 1);
ASSERT_ALWAYS (wp[0] == 0x4004);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 5;
mpn_sqr_basecase (wp, xp, (mp_size_t) 1);
ASSERT_ALWAYS (wp[0] == 25);
ASSERT_ALWAYS (wp[1] == 0);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 999;
yp[0] = 666;
mpn_sub_n (wp, xp, yp, (mp_size_t) 1);
ASSERT_ALWAYS (wp[0] == 333);
}
memcpy (&__gmpn_cpuvec, &initial_cpuvec, sizeof (__gmpn_cpuvec));
for (i = 0; i < 2; i++)
{
xp[0] = 123;
wp[0] = 456;
r = mpn_submul_1 (wp, xp, (mp_size_t) 1, CNST_LIMB(2));
ASSERT_ALWAYS (wp[0] == 210);
ASSERT_ALWAYS (r == 0);
}
}
void
check_data (void)
{
static const struct {
mp_limb_t n[1];
mp_size_t nsize;
mp_limb_t d;
mp_size_t qxn;
mp_limb_t want_q[5];
mp_limb_t want_r;
} data[] = {
{ { 0 }, 1, 1, 0,
{ 0 }, 0},
{ { 5 }, 1, 2, 0,
{ 2 }, 1},
#if GMP_NUMB_BITS == 32
{ { 0x3C }, 1, 0xF2, 1,
{ 0x3F789854, 0 }, 0x98 },
#endif
#if GMP_NUMB_BITS == 64
{ { 0x3C }, 1, 0xF2, 1,
{ CNST_LIMB(0x3F789854A0CB1B81), 0 }, 0x0E },
/* This case exposed some wrong code generated by SGI cc on mips64 irix
6.5 with -n32 -O2, in the fractional loop for normalized divisor
using udiv_qrnnd_preinv. A test "x>al" in one of the sub_ddmmss
expansions came out wrong, leading to an incorrect quotient. */
{ { CNST_LIMB(0x3C00000000000000) }, 1, CNST_LIMB(0xF200000000000000), 1,
{ CNST_LIMB(0x3F789854A0CB1B81), 0 }, CNST_LIMB(0x0E00000000000000) },
#endif
};
mp_limb_t dinv, got_r, got_q[numberof(data[0].want_q)];
mp_size_t qsize;
int i, shift;
for (i = 0; i < numberof (data); i++)
{
qsize = data[i].nsize + data[i].qxn;
ASSERT_ALWAYS (qsize <= numberof (got_q));
got_r = mpn_divrem_1 (got_q, data[i].qxn, data[i].n, data[i].nsize,
data[i].d);
if (got_r != data[i].want_r
|| refmpn_cmp (got_q, data[i].want_q, qsize) != 0)
{
printf ("mpn_divrem_1 wrong at data[%d]\n", i);
bad:
mpn_trace (" n", data[i].n, data[i].nsize);
printf (" nsize=%ld\n", (long) data[i].nsize);
mp_limb_trace (" d", data[i].d);
printf (" qxn=%ld\n", (long) data[i].qxn);
mpn_trace (" want q", data[i].want_q, qsize);
mpn_trace (" got q", got_q, qsize);
mp_limb_trace (" want r", data[i].want_r);
mp_limb_trace (" got r", got_r);
abort ();
}
/* test if available */
#if USE_PREINV_DIVREM_1 || HAVE_NATIVE_mpn_preinv_divrem_1
shift = refmpn_count_leading_zeros (data[i].d);
dinv = refmpn_invert_limb (data[i].d << shift);
got_r = mpn_preinv_divrem_1 (got_q, data[i].qxn,
data[i].n, data[i].nsize,
data[i].d, dinv, shift);
if (got_r != data[i].want_r
|| refmpn_cmp (got_q, data[i].want_q, qsize) != 0)
{
printf ("mpn_preinv divrem_1 wrong at data[%d]\n", i);
printf (" shift=%d\n", shift);
mp_limb_trace (" dinv", dinv);
goto bad;
}
#endif
}
}
