36 u64 seed = 0xa11ce01234567890ull;
38 for (
int iter = 0; iter < 20; ++iter) {
39 mp_ptr a = alloc_limbs(
n), b = alloc_limbs(
n), d = alloc_limbs(
n),
t = alloc_limbs(
n);
40 random_limbs_with_top(a,
n, &seed,
false);
41 random_limbs_with_top(b,
n, &seed,
false);
45 const u64 c_values[] = {0u, 1u};
46 for (
size_t c_index = 0; c_index <
ARRAY_SIZE(c_values); ++c_index) {
47 u64 c = c_values[c_index];
52 u64 ovf = c ? add_small_inplace(e,
n, 1) : 0;
59 u64 unf = c ? sub_small_inplace(e,
n, 1) : 0;
70TEST_CASE(
"asm/mul1", mul_1_addmul_submul_random_inplace) {
71 u64 seed = 0xb0b0c0d0e0f01020ull;
73 for (
int iter = 0; iter < 20; ++iter) {
74 mp_ptr a = alloc_limbs(
n), d = alloc_limbs(
n + 1),
t = alloc_limbs(
n + 2),
75 acc = alloc_limbs(
n + 1), acc2 = alloc_limbs(
n + 1);
76 random_limbs_with_top(a,
n, &seed,
false);
77 u64 x = xorshift64(&seed) | 1;
97 random_limbs_with_top(acc,
n, &seed,
false);
98 memcpy(acc2, acc,
n * 8);
107 memcpy(acc2, acc,
n * 8);
116 memcpy(acc2, acc,
n * 8);
126 memcpy(acc2, acc,
n * 8);
141 mp_ptr r1 = alloc_limbs(
n + 3),
r2 = alloc_limbs(
n + 3),
r3 = alloc_limbs(
n + 3),
142 t = alloc_limbs(
n + 2);
143 mp_ptr vv = alloc_limbs(2);
144 vv[0] =
v0; vv[1] =
v1;
145 memset(
r1, 0xCC, (
n + 3) * 8);
146 memcpy(
r1,
rp,
n * 8);
151 memset(
r2, 0xCC, (
n + 3) * 8);
152 memcpy(
r2,
rp,
n * 8);
176 mp_ptr r4 = alloc_limbs(
n + 1),
a2 = alloc_limbs(
n + 1);
177 memcpy(
r4, a,
n * 8);
178 memcpy(
a2, a,
n * 8);
188TEST_CASE(
"asm/addmul2", addmul_2_vs_composition_and_fullmul) {
189 u64 seed = 0xa44a2badcafe01ull;
192 for (
int iter = 0; iter < 16; ++iter) {
193 mp_ptr a = alloc_limbs(
n),
rp = alloc_limbs(
n);
194 random_limbs_with_top(a,
n, &seed,
false);
195 random_limbs_with_top(
rp,
n, &seed,
false);
196 mp_limb_t v[2] = {xorshift64(&seed) | 1, xorshift64(&seed) | 1};
203 mp_ptr a = alloc_limbs(
n),
rp = alloc_limbs(
n);
204 memset(a, 0xFF,
n * 8);
205 memset(
rp, 0xFF,
n * 8);
207 memset(
rp, 0,
n * 8);
217 u64 seed = 0xc1c2c3c4c5c6c7c8ull;
219 for (
int iter = 0; iter < 5; ++iter) {
220 mp_ptr a = alloc_limbs(
n), d = alloc_limbs(
n), tsh = alloc_limbs(
n),
221 tshr = alloc_limbs(
n);
222 random_limbs_with_top(a,
n, &seed,
false);
228 u64 lowmask =
s ? (((
u64)1 <<
s) - 1) : 0;
232 u64 c_shl =
s ? (xorshift64(&seed) & lowmask) : 0;
245 u64 c_shr =
s ? (xorshift64(&seed) << (64 -
s)) : 0;
246 u64 topmask =
s ? (~0ull << (64 -
s)) : 0;
259TEST_CASE(
"asm/shift", shlnot_not_addshl1_subshl1_random) {
260 u64 seed = 0xd1d2d3d4d5d6d7d8ull;
262 for (
int iter = 0; iter < 10; ++iter) {
263 mp_ptr a = alloc_limbs(
n), b = alloc_limbs(
n), d = alloc_limbs(
n + 1),
264 t = alloc_limbs(
n + 1),
b2 = alloc_limbs(
n + 1);
265 random_limbs_with_top(a,
n, &seed,
false);
266 random_limbs_with_top(b,
n, &seed,
false);
302 u64 seed = 0xe1e2e3e4e5e6e7e8ull;
304 for (
int iter = 0; iter < 20; ++iter) {
305 mp_ptr a = alloc_limbs(
n), b = alloc_limbs(
n), d = alloc_limbs(
n),
t = alloc_limbs(
n);
306 random_limbs_with_top(a,
n, &seed,
false);
307 random_limbs_with_top(b,
n, &seed,
false);
309 const u64 c_values[] = {0u, 1u};
310 for (
size_t c_index = 0; c_index <
ARRAY_SIZE(c_values); ++c_index) {
311 u64 c = c_values[c_index];
314 u64 low = shr1_inplace(
t,
n, cout);
320 u64 low2 = shr1_inplace(
t,
n, bout);
335 u64 seed = 0xf1f2f3f4f5f6f7f8ull;
336 for (
int iter = 0; iter < 500; ++iter) {
337 mp_ptr np = alloc_limbs(3), npw = alloc_limbs(3), dp = alloc_limbs(2);
338 dp[1] = xorshift64(&seed) |
LIMB_B_2;
339 dp[0] = xorshift64(&seed);
340 u64 q = xorshift64(&seed);
348 add_small_inplace(np, 3, r);
351 memcpy(npw, np, 3 * 8);
366 u64 seed = 0x0123456789abcdefull;
368 for (
int iter = 0; iter < 10; ++iter) {
369 mp_ptr a = alloc_limbs(
n), q = alloc_limbs(
n + 1),
t = alloc_limbs(
n + 2),
371 random_limbs_with_top(a,
n, &seed,
false);
372 u64 x = xorshift64(&seed) | 1;
382 add_small_inplace(
t,
n + 1, r_div);
387 memcpy(
a2, a,
n * 8);
388 mp_ptr qs = alloc_limbs(
n + 1);
407 u64 seed = 0x0badf00dcafefaceull;
409 for (
int iter = 0; iter < 10; ++iter) {
410 mp_ptr a = alloc_limbs(
n), q = alloc_limbs(
n + 1), b = alloc_limbs(2),
411 b2 = alloc_limbs(2),
a2 = alloc_limbs(
n),
t = alloc_limbs(
n + 2);
412 random_limbs_with_top(a,
n, &seed,
false);
413 b[1] = xorshift64(&seed) |
LIMB_B_2;
414 b[0] = xorshift64(&seed);
417 memcpy(
a2, a,
n * 8);
418 memcpy(
b2, b, 2 * 8);
423 memcpy(
b2, b, 2 * 8);
435 add_small_inplace(
t,
n + 1,
b2[0]);
436 add_small_inplace(
t + 1,
n,
b2[1]);
441 u64 rem0 =
b2[0], rem1 =
b2[1];
442 memcpy(
a2, a,
n * 8);
443 memcpy(
b2, b, 2 * 8);
444 mp_ptr qs = alloc_limbs(
n + 1);
463 u64 seed = 0x1111222233334444ull;
464 for (
int i = 0; i < 2000; ++i) {
477 u64 xl = xorshift64(&seed);
484 TEST_RUN(
"asm/addsub", add_nc_sub_nc_random);
485 TEST_RUN(
"asm/mul1", mul_1_addmul_submul_random_inplace);
486 TEST_RUN(
"asm/addmul2", addmul_2_vs_composition_and_fullmul);
487 TEST_RUN(
"asm/shift", shl_shr_carry_random);
488 TEST_RUN(
"asm/shift", shlnot_not_addshl1_subshl1_random);
489 TEST_RUN(
"asm/rsh1", shr1add_shr1sub_random);
490 TEST_RUN(
"asm/div", div_3_2_random);
491 TEST_RUN(
"asm/div", div_1_mod_1_random_extra);
492 TEST_RUN(
"asm/div", div_2_mod_2_random_extra);
493 TEST_RUN(
"asm/inv", inv_1_inv_2_1_random);
const mp_limb_t * mp_srcptr
void lmmp_free(void *ptr)
内存释放函数(调用lmmp_heap_free_fn)
mp_limb_t u64
Copyright (C) 2026 HJimmyK (Jericho Knox)
void test_asm_functions(void)
mp_limb_t lmmp_shlnot_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shl)
左移后按位取反操作 [dst,na] = ~([numa,na] << shl),dst的低shl位填充1
mp_limb_t lmmp_div_3_2_(mp_ptr numa, mp_srcptr numb, mp_limb_t inv21)
3/2位除法运算 [numa,2]=[numa,3] mod [numb,2]
mp_limb_t lmmp_div_1_s_(mp_ptr dstq, mp_ptr numa, mp_size_t na, mp_limb_t x)
单精度数除法(除数为1个limb)
mp_limb_t lmmp_div_1_(mp_ptr dstq, mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数除法
mp_limb_t lmmp_shr1add_nc_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t c)
带进位加法后右移1位 [dst,n] = ([numa,n] + [numb,n] + c) >> 1
mp_limb_t lmmp_shr_c_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shr, mp_limb_t c)
带进位的右移操作 [dst,na] = [numa,na]>>shr,dst的高shr位填充c的高shr位
mp_limb_t lmmp_addmul_2_(mp_ptr numa, mp_srcptr numb, mp_size_t n, mp_srcptr bp)
乘以双limb并累加 [numa,n] += [numb,n] * [bp,2]
void lmmp_div_2_(mp_ptr dstq, mp_srcptr numa, mp_size_t na, mp_ptr numb)
双精度数除法 (除数为2个limb)
mp_limb_t lmmp_subshl1_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
减法结合左移1位操作 [dst,n] = [numa,n] - ([numb,n] << 1)
mp_limb_t lmmp_shr_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shr)
右移操作 [dst,na] = [numa,na]>>shr,dst的高shr位填充0
mp_limb_t lmmp_mod_1_(mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数取余
void lmmp_mod_2_(mp_srcptr numa, mp_size_t na, mp_ptr numb)
双精度数取余 (除数为2个limb)
void lmmp_mul_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_srcptr numb, mp_size_t nb)
不等长乘法操作 [dst,na+nb] = [numa,na] * [numb,nb]
mp_limb_t lmmp_shl_c_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shl, mp_limb_t c)
带进位的左移操作 [dst,na] = [numa,na]<<shl,dst的低shl位填充c的低shl位
mp_limb_t lmmp_addshl1_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
加法结合左移1位操作 [dst,n] = [numa,n] + ([numb,n] << 1)
mp_limb_t lmmp_add_nc_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t c)
带进位的n位加法 [dst,n] = [numa,n] + [numb,n] + c
mp_limb_t lmmp_shr1sub_nc_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t c)
带借位减法后右移1位 [dst,n] = ([numa,n] - [numb,n] - c) >> 1
mp_limb_t lmmp_shl_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shl)
左移操作 [dst,na] = [numa,na]<<shl,dst的低shl位填充0
mp_limb_t lmmp_addmul_1_(mp_ptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t b)
乘以单limb并累加操作 [numa,n] += [numb,n] * b
mp_limb_t lmmp_mul_1_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_limb_t x)
乘以单limb操作 [dst,na] = [numa,na] * x
mp_limb_t lmmp_div_2_s_(mp_ptr dstq, mp_ptr numa, mp_size_t na, mp_srcptr numb)
双精度数除法(除数为2个limb)
void lmmp_not_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
按位取反操作 [dst,na] = ~[numa,na] (对每个limb执行按位非操作)
mp_limb_t lmmp_submul_1_(mp_ptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t b)
乘以单limb并累减操作 [numa,n] -= [numb,n] * b
mp_limb_t lmmp_sub_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
无借位的n位减法 [dst,n] = [numa,n] - [numb,n]
mp_limb_t lmmp_inv_1_(mp_limb_t x)
1阶逆元计算 (inv1)
mp_limb_t lmmp_inv_2_1_(mp_limb_t xh, mp_limb_t xl)
2-1阶逆元计算 (inv21)
mp_limb_t lmmp_sub_nc_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t c)
带借位的n位减法 [dst,n] = [numa,n] - [numb,n] - c
mp_limb_t lmmp_add_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
无进位的n位加法 [dst,n] = [numa,n] + [numb,n]
#define ARRAY_SIZE(a)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define TEST_CHECK_MSG(cond, msg)
#define TEST_CASE(category, name)
#define TEST_CHECK_EQ(a, b)
#define TEST_RUN(category, name)
static void check_addmul_2(mp_srcptr a, mp_srcptr rp, mp_size_t n, mp_limb_t v0, mp_limb_t v1)