void call_bignum_add__4_4()

in benchmarks/benchmark.c [184:590]

• 229 lines of code
• 3 McCabe index (conditional complexity)

void call_bignum_add__4_4(void) repeat(bignum_add(4,b0,4,b1,4,b2))

void call_bignum_add__6_6(void) repeat(bignum_add(6,b0,6,b1,6,b2))

void call_bignum_add__32_32(void) repeat(bignum_add(32,b0,32,b1,32,b2))

void call_bignum_sub__4_4(void) repeat(bignum_sub(4,b0,4,b1,4,b2))

void call_bignum_sub__6_6(void) repeat(bignum_sub(6,b0,6,b1,6,b2))

void call_bignum_sub__32_32(void) repeat(bignum_sub(32,b0,32,b1,32,b2))

void call_bignum_add_p256(void) repeat(bignum_add_p256(b0,b1,b2))

void call_bignum_add_p256k1(void) repeat(bignum_add_p256k1(b0,b1,b2))

void call_bignum_add_p384(void) repeat(bignum_add_p384(b0,b1,b2))

void call_bignum_add_p521(void) repeat(bignum_add_p521(b0,b1,b2))

void call_bignum_sub_p256(void) repeat(bignum_sub_p256(b0,b1,b2))

void call_bignum_sub_p256k1(void) repeat(bignum_sub_p256k1(b0,b1,b2))

void call_bignum_sub_p384(void) repeat(bignum_sub_p384(b0,b1,b2))

void call_bignum_sub_p521(void) repeat(bignum_sub_p521(b0,b1,b2))

void call_bignum_cmul_p256(void) repeat(bignum_cmul_p256(b0,b1[0],b2))

void call_bignum_cmul_p256_alt(void) repeat(bignum_cmul_p256_alt(b0,b1[0],b2))

void call_bignum_cmul_p256k1(void) repeat(bignum_cmul_p256k1(b0,b1[0],b2))

void call_bignum_cmul_p256k1_alt(void) repeat(bignum_cmul_p256k1_alt(b0,b1[0],b2))

void call_bignum_cmul_p384(void) repeat(bignum_cmul_p384(b0,b1[0],b2))

void call_bignum_cmul_p384_alt(void) repeat(bignum_cmul_p384_alt(b0,b1[0],b2))

void call_bignum_cmul_p521(void) repeat(bignum_cmul_p521(b0,b1[0],b2))

void call_bignum_optneg_p256(void) repeat(bignum_optneg_p256(b0,b1[0],b2))

void call_bignum_optneg_p256k1(void) repeat(bignum_optneg_p256k1(b0,b1[0],b2))

void call_bignum_optneg_p384(void) repeat(bignum_optneg_p384(b0,b1[0],b2))

void call_bignum_optneg_p521(void) repeat(bignum_optneg_p521(b0,b1[0],b2))

void call_bignum_deamont_p256(void) repeat(bignum_deamont_p256(b0,b1))

void call_bignum_deamont_p256_alt(void) repeat(bignum_deamont_p256_alt(b0,b1))

void call_bignum_deamont_p256k1(void) repeat(bignum_deamont_p256k1(b0,b1))

void call_bignum_deamont_p384(void) repeat(bignum_deamont_p384(b0,b1))

void call_bignum_deamont_p384_alt(void) repeat(bignum_deamont_p384_alt(b0,b1))

void call_bignum_deamont_p521(void) repeat(bignum_deamont_p521(b0,b1))

void call_bignum_demont_p256(void) repeat(bignum_demont_p256(b0,b1))

void call_bignum_demont_p256_alt(void) repeat(bignum_demont_p256_alt(b0,b1))

void call_bignum_demont_p256k1(void) repeat(bignum_demont_p256k1(b0,b1))

void call_bignum_demont_p384(void) repeat(bignum_demont_p384(b0,b1))

void call_bignum_demont_p384_alt(void) repeat(bignum_demont_p384_alt(b0,b1))

void call_bignum_demont_p521(void) repeat(bignum_demont_p521(b0,b1))

void call_bignum_tomont_p256(void) repeat(bignum_tomont_p256(b0,b1))

void call_bignum_tomont_p256_alt(void) repeat(bignum_tomont_p256_alt(b0,b1))

void call_bignum_tomont_p256k1(void) repeat(bignum_tomont_p256k1(b0,b1))

void call_bignum_tomont_p256k1_alt(void) repeat(bignum_tomont_p256k1_alt(b0,b1))

void call_bignum_tomont_p384(void) repeat(bignum_tomont_p384(b0,b1))

void call_bignum_tomont_p384_alt(void) repeat(bignum_tomont_p384_alt(b0,b1))

void call_bignum_tomont_p521(void) repeat(bignum_tomont_p521(b0,b1))

void call_bignum_double_p256(void) repeat(bignum_double_p256(b0,b1))

void call_bignum_double_p256k1(void) repeat(bignum_double_p256k1(b0,b1))

void call_bignum_double_p384(void) repeat(bignum_double_p384(b0,b1))

void call_bignum_double_p521(void) repeat(bignum_double_p521(b0,b1))

void call_bignum_half_p256(void) repeat(bignum_half_p256(b0,b1))

void call_bignum_half_p256k1(void) repeat(bignum_half_p256k1(b0,b1))

void call_bignum_half_p384(void) repeat(bignum_half_p384(b0,b1))

void call_bignum_half_p521(void) repeat(bignum_half_p521(b0,b1))

void call_bignum_triple_p256(void) repeat(bignum_triple_p256(b0,b1))

void call_bignum_triple_p256_alt(void) repeat(bignum_triple_p256_alt(b0,b1))

void call_bignum_triple_p256k1(void) repeat(bignum_triple_p256k1(b0,b1))

void call_bignum_triple_p256k1_alt(void) repeat(bignum_triple_p256k1_alt(b0,b1))

void call_bignum_triple_p384(void) repeat(bignum_triple_p384(b0,b1))

void call_bignum_triple_p384_alt(void) repeat(bignum_triple_p384_alt(b0,b1))

void call_bignum_triple_p521(void) repeat(bignum_triple_p521(b0,b1))

void call_bignum_montmul_p256(void) repeat(bignum_montmul_p256(b0,b1,b2))

void call_bignum_montmul_p256_alt(void) repeat(bignum_montmul_p256_alt(b0,b1,b2))

void call_bignum_montmul_p256k1(void) repeat(bignum_montmul_p256k1(b0,b1,b2))

void call_bignum_montmul_p256k1_alt(void) repeat(bignum_montmul_p256k1_alt(b0,b1,b2))

void call_bignum_montmul_p384(void) repeat(bignum_montmul_p384(b0,b1,b2))

void call_bignum_montmul_p384_alt(void) repeat(bignum_montmul_p384_alt(b0,b1,b2))

void call_bignum_montmul_p521(void) repeat(bignum_montmul_p521(b0,b1,b2))

void call_bignum_montsqr_p256(void) repeat(bignum_montsqr_p256(b0,b1))

void call_bignum_montsqr_p256_alt(void) repeat(bignum_montsqr_p256_alt(b0,b1))

void call_bignum_montsqr_p256k1(void) repeat(bignum_montsqr_p256k1(b0,b1))

void call_bignum_montsqr_p256k1_alt(void) repeat(bignum_montsqr_p256k1_alt(b0,b1))

void call_bignum_montsqr_p384(void) repeat(bignum_montsqr_p384(b0,b1))

void call_bignum_montsqr_p384_alt(void) repeat(bignum_montsqr_p384_alt(b0,b1))

void call_bignum_montsqr_p521(void) repeat(bignum_montsqr_p521(b0,b1))

void call_bignum_neg_p256(void) repeat(bignum_neg_p256(b0,b1))

void call_bignum_neg_p256k1(void) repeat(bignum_neg_p256k1(b0,b1))

void call_bignum_neg_p384(void) repeat(bignum_neg_p384(b0,b1))

void call_bignum_neg_p521(void) repeat(bignum_neg_p521(b0,b1))

void call_bignum_sqr_p256k1(void) repeat(bignum_sqr_p256k1(b0,b1))

void call_bignum_sqr_p256k1_alt(void) repeat(bignum_sqr_p256k1_alt(b0,b1))

void call_bignum_sqr_p521(void) repeat(bignum_sqr_p521(b0,b1))

void call_bignum_mul_p256k1(void) repeat(bignum_mul_p256k1(b0,b1,b2))

void call_bignum_mul_p256k1_alt(void) repeat(bignum_mul_p256k1_alt(b0,b1,b2))

void call_bignum_mul_p521(void) repeat(bignum_mul_p521(b0,b1,b2))

void call_bignum_mul_4_8(void) repeat(bignum_mul_4_8(b0,b1,b2))

void call_bignum_mul_4_8_alt(void) repeat(bignum_mul_4_8_alt(b0,b1,b2))

void call_bignum_mul_6_12(void) repeat(bignum_mul_6_12(b0,b1,b2))

void call_bignum_mul_6_12_alt(void) repeat(bignum_mul_6_12_alt(b0,b1,b2))

void call_bignum_mul_8_16(void) repeat(bignum_mul_8_16(b0,b1,b2))

void call_bignum_sqr_4_8(void) repeat(bignum_sqr_4_8(b0,b1))

void call_bignum_sqr_4_8_alt(void) repeat(bignum_sqr_4_8_alt(b0,b1))

void call_bignum_sqr_6_12(void) repeat(bignum_sqr_6_12(b0,b1))

void call_bignum_sqr_6_12_alt(void) repeat(bignum_sqr_6_12_alt(b0,b1))

void call_bignum_sqr_8_16(void) repeat(bignum_sqr_8_16(b0,b1))

void call_bignum_kmul_16_32(void) repeat(bignum_kmul_16_32(b0,b1,b2,b3))

void call_bignum_ksqr_16_32(void) repeat(bignum_ksqr_16_32(b0,b1,b2))

void call_bignum_kmul_32_64(void) repeat(bignum_kmul_32_64(b0,b1,b2,b3))

void call_bignum_ksqr_32_64(void) repeat(bignum_ksqr_32_64(b0,b1,b2))

void call_bignum_mul__4_8(void) repeat(bignum_mul(8,b0,4,b1,4,b2))

void call_bignum_mul__6_12(void) repeat(bignum_mul(12,b0,6,b1,6,b2))

void call_bignum_mul__8_16(void) repeat(bignum_mul(16,b0,8,b1,8,b2))

void call_bignum_mul__16_32(void) repeat(bignum_mul(32,b0,16,b1,16,b2))

void call_bignum_mul__32_64(void) repeat(bignum_mul(64,b0,32,b1,32,b2))

void call_bignum_madd__4_8(void) repeat(bignum_madd(8,b0,4,b1,4,b2))

void call_bignum_madd__6_12(void) repeat(bignum_madd(12,b0,6,b1,6,b2))

void call_bignum_madd__8_16(void) repeat(bignum_madd(16,b0,8,b1,8,b2))

void call_bignum_madd__16_32(void) repeat(bignum_madd(32,b0,16,b1,16,b2))

void call_bignum_madd__32_64(void) repeat(bignum_madd(64,b0,32,b1,32,b2))

void call_bignum_sqr__4_8(void) repeat(bignum_sqr(8,b0,4,b1))

void call_bignum_sqr__6_12(void) repeat(bignum_sqr(12,b0,6,b1))

void call_bignum_sqr__8_16(void) repeat(bignum_sqr(16,b0,8,b1))

void call_bignum_sqr__16_32(void) repeat(bignum_sqr(32,b0,16,b1))

void call_bignum_sqr__32_64(void) repeat(bignum_sqr(64,b0,32,b1))

void call_word_bytereverse(void) repeat(word_bytereverse(b0[0]))

void call_word_clz(void) repeat(word_clz(b0[0]))

void call_word_ctz(void) repeat(word_ctz(b0[0]))

void call_word_max(void) repeat(word_max(b0[0],b1[0]))

void call_word_min(void) repeat(word_min(b0[0],b1[0]))

void call_word_negmodinv(void) repeat(word_negmodinv(b0[0]))

void call_word_recip(void) repeat(word_recip(b0[0]))

void call_bignum_bigendian_4(void) repeat(bignum_bigendian_4(b0,b1))
void call_bignum_littleendian_4(void) repeat(bignum_littleendian_4(b0,b1))
void call_bignum_tolebytes_4(void) repeat(bignum_tolebytes_4((unsigned char *)b0,b1))
void call_bignum_tobebytes_4(void) repeat(bignum_tobebytes_4((unsigned char *)b0,b1))
void call_bignum_fromlebytes_4(void) repeat(bignum_fromlebytes_4(b0,(unsigned char *) b1))
void call_bignum_frombebytes_4(void) repeat(bignum_frombebytes_4(b0,(unsigned char *) b1))

void call_bignum_bigendian_6(void) repeat(bignum_bigendian_6(b0,b1))
void call_bignum_littleendian_6(void) repeat(bignum_littleendian_6(b0,b1))
void call_bignum_tolebytes_6(void) repeat(bignum_tolebytes_6((unsigned char *)b0,b1))
void call_bignum_tobebytes_6(void) repeat(bignum_tobebytes_6((unsigned char *)b0,b1))
void call_bignum_fromlebytes_6(void) repeat(bignum_fromlebytes_6(b0,(unsigned char *) b1))
void call_bignum_frombebytes_6(void) repeat(bignum_frombebytes_6(b0,(unsigned char *) b1))

void call_bignum_mod_n256_4(void) repeat(bignum_mod_n256_4(b0,b1))
void call_bignum_mod_p256_4(void) repeat(bignum_mod_p256_4(b0,b1))
void call_bignum_mod_n256k1_4(void) repeat(bignum_mod_n256k1_4(b0,b1))
void call_bignum_mod_p256k1_4(void) repeat(bignum_mod_p256k1_4(b0,b1))
void call_bignum_mod_n384_6(void) repeat(bignum_mod_n384_6(b0,b1))
void call_bignum_mod_p384_6(void) repeat(bignum_mod_p384_6(b0,b1))
void call_bignum_mod_n521_9(void) repeat(bignum_mod_n521_9(b0,b1))
void call_bignum_mod_p521_9(void) repeat(bignum_mod_p521_9(b0,b1))

void call_bignum_mod_n256__8(void) repeat(bignum_mod_n256(b0,8,b1))
void call_bignum_mod_n256_alt__8(void) repeat(bignum_mod_n256_alt(b0,8,b1))
void call_bignum_mod_n384__12(void) repeat(bignum_mod_n384(b0,12,b1))
void call_bignum_mod_n384_alt__12(void) repeat(bignum_mod_n384_alt(b0,12,b1))
void call_bignum_mod_p256__8(void) repeat(bignum_mod_p256(b0,8,b1))
void call_bignum_mod_p256_alt__8(void) repeat(bignum_mod_p256_alt(b0,8,b1))
void call_bignum_mod_p384__12(void) repeat(bignum_mod_p384(b0,12,b1))
void call_bignum_mod_p384_alt__12(void) repeat(bignum_mod_p384_alt(b0,12,b1))

void call_bignum_nonzero_4(void) repeat(bignum_nonzero_4(b0))
void call_bignum_nonzero_6(void) repeat(bignum_nonzero_6(b0))

void call_bignum_mux_4(void) repeat(bignum_mux_4(b1[0],b0,b2,b3))
void call_bignum_mux_6(void) repeat(bignum_mux_6(b1[0],b0,b2,b3))

void call_bignum_bitfield__32(void) repeat(bignum_bitfield(32,b0,(b1[0] % 1000),(b2[0] % 70)))
void call_bignum_digit__32(void) repeat(bignum_digit(32,b0,(b1[0] % 70)))

void call_bignum_cmul__4_4(void) repeat(bignum_cmul(4,b0,b1[0],4,b2))
void call_bignum_cmul__6_6(void) repeat(bignum_cmul(6,b0,b1[0],6,b2))
void call_bignum_cmul__32_32(void) repeat(bignum_cmul(32,b0,b1[0],32,b2))

void call_bignum_cmadd__4_4(void) repeat(bignum_cmadd(4,b0,b1[0],4,b2))
void call_bignum_cmadd__6_6(void) repeat(bignum_cmadd(6,b0,b1[0],6,b2))
void call_bignum_cmadd__32_32(void) repeat(bignum_cmadd(32,b0,b1[0],32,b2))

void call_bignum_cmnegadd__4_4(void) repeat(bignum_cmnegadd(4,b0,b1[0],4,b2))
void call_bignum_cmnegadd__6_6(void) repeat(bignum_cmnegadd(6,b0,b1[0],6,b2))
void call_bignum_cmnegadd__32_32(void) repeat(bignum_cmnegadd(32,b0,b1[0],32,b2))

void call_bignum_cdiv__4_4(void) repeat(bignum_cdiv(4,b0,4,b1,b2[0]))
void call_bignum_cdiv__6_6(void) repeat(bignum_cdiv(6,b0,6,b1,b2[0]))
void call_bignum_cdiv__32_32(void) repeat(bignum_cdiv(32,b0,32,b1,b2[0]))

void call_bignum_cdiv_exact__4_4(void) repeat(bignum_cdiv_exact(4,b0,4,b1,b2[0]))
void call_bignum_cdiv_exact__6_6(void) repeat(bignum_cdiv_exact(6,b0,6,b1,b2[0]))
void call_bignum_cdiv_exact__32_32(void) repeat(bignum_cdiv_exact(32,b0,32,b1,b2[0]))

void call_bignum_cmod__4(void) repeat(bignum_cmod(4,b0,b1[0]))
void call_bignum_cmod__6(void) repeat(bignum_cmod(6,b0,b1[0]))
void call_bignum_cmod__32(void) repeat(bignum_cmod(32,b0,b1[0]))

void call_bignum_of_word__32(void) repeat(bignum_of_word(32,b0,b1[0]))
void call_bignum_divmod10__32(void) repeat(bignum_divmod10(32,b0))
void call_bignum_muladd10__32(void) repeat(bignum_muladd10(32,b0,b1[0]))

void call_bignum_normalize__32(void) repeat(bignum_normalize(32,b0))

void call_bignum_shl_small__32_32(void) repeat(bignum_shl_small(32,b0,32,b1,b2[0]))
void call_bignum_shr_small__32_32(void) repeat(bignum_shr_small(32,b0,32,b1,b2[0]))

void call_bignum_amontredc__32_16(void) repeat(bignum_amontredc(16,b0,32,b1,b2,16))
void call_bignum_montredc__32_16(void) repeat(bignum_montredc(16,b0,32,b1,b2,16))

void call_bignum_emontredc__4(void) repeat(bignum_emontredc(4,b0,b1,b2[0]))
void call_bignum_emontredc__6(void) repeat(bignum_emontredc(6,b0,b1,b2[0]))
void call_bignum_emontredc__32(void) repeat(bignum_emontredc(32,b0,b1,b2[0]))

void call_bignum_emontredc_8n__32(void) repeat(bignum_emontredc_8n(32,b0,b1,b2[0]))

void call_bignum_modoptneg__32(void) repeat(bignum_modoptneg(32,b0,b1[0],b2,b3))

void call_bignum_amontifier__32(void) repeat(bignum_amontifier(32,b0,b1,b2))

void call_bignum_amontmul__32(void) repeat(bignum_amontmul(32,b0,b1,b2,b3))

void call_bignum_amontsqr__32(void) repeat(bignum_amontsqr(32,b0,b1,b2))

void call_bignum_bitsize__32(void) repeat(bignum_bitsize(32,b1))

void call_bignum_cld__32(void) repeat(bignum_cld(32,b1))

void call_bignum_clz__32(void) repeat(bignum_clz(32,b1))

void call_bignum_coprime__4_4(void) repeat(bignum_coprime(4,b1,4,b2,b3))

void call_bignum_coprime__6_6(void) repeat(bignum_coprime(6,b1,6,b2,b3))

void call_bignum_coprime__16_16(void) repeat(bignum_coprime(16,b1,16,b2,b3))

void call_bignum_copy__32_32(void) repeat(bignum_copy(32,b0,32,b1))

void call_bignum_ctd__32(void) repeat(bignum_ctd(32,b1))

void call_bignum_ctz__32(void) repeat(bignum_ctz(32,b1))

void call_bignum_demont__32(void) repeat(bignum_demont(32,b0,b1,b2))

void call_bignum_digitsize__32(void) repeat(bignum_digitsize(32,b1))

void call_bignum_eq__32_32(void) repeat(bignum_eq(32,b1,32,b2))

void call_bignum_even__32(void) repeat(bignum_even(32,b1))

void call_bignum_ge__32_32(void) repeat(bignum_ge(32,b1,32,b2))

void call_bignum_gt__32_32(void) repeat(bignum_gt(32,b1,32,b2))

void call_bignum_iszero__32(void) repeat(bignum_iszero(32,b1))

void call_bignum_le__32_32(void) repeat(bignum_le(32,b1,32,b2))

void call_bignum_lt__32_32(void) repeat(bignum_lt(32,b1,32,b2))

void call_bignum_modadd__32(void) repeat(bignum_modadd(32,b0,b1,b2,b3))

void call_bignum_moddouble__32(void) repeat(bignum_moddouble(32,b0,b1,b2))

void call_bignum_modifier__32(void) repeat(bignum_modifier(32,b0,b1,b2))

void call_bignum_modinv__4(void) repeat(bignum_modinv(4,b0,b1,b2,b3))

void call_bignum_modinv__6(void) repeat(bignum_modinv(6,b0,b1,b2,b3))

void call_bignum_modinv__16(void) repeat(bignum_modinv(16,b0,b1,b2,b3))

void call_bignum_modsub__32(void) repeat(bignum_modsub(32,b0,b1,b2,b3))

void call_bignum_montifier__32(void) repeat(bignum_montifier(32,b0,b1,b2))

void call_bignum_montmul__32(void) repeat(bignum_montmul(32,b0,b1,b2,b3))

void call_bignum_montsqr__32(void) repeat(bignum_montsqr(32,b0,b1,b2))

void call_bignum_negmodinv__32(void) repeat(bignum_negmodinv(32,b0,b1))

void call_bignum_nonzero__32(void) repeat(bignum_nonzero(32,b1))

void call_bignum_odd__32(void) repeat(bignum_odd(32,b1))

void call_bignum_optadd__32(void) repeat(bignum_optadd(32,b0,b1,b2[0],b3))

void call_bignum_optneg__32(void) repeat(bignum_optneg(32,b0,b1[0],b2))

void call_bignum_optsub__32(void) repeat(bignum_optsub(32,b0,b1,b2[0],b3))

void call_bignum_optsubadd__32(void) repeat(bignum_optsubadd(32,b0,b1,b2[0],b3))

void call_bignum_pow2__32(void) repeat(bignum_pow2(32,b0,b1[0] % 1000))

void call_bignum_mux16__4()
{ int i, j;
  for (i = 0; i < 16; ++i) for (j = 0; j < 4; ++j)
    bb[i][j] = b1[(i+j)%BUFFERSIZE];
  repeat(bignum_mux16(4,b0,(uint64_t *)bb,b2[0]%16));
}