_Z7to_charPKh: 11| 2.91k|char *to_char(const uint8_t *x) { 12| 2.91k| return reinterpret_cast(const_cast(x)); 13| 2.91k|} _Z11check_equalP9bignum_stP6mp_intm: 22| 4.37k|void check_equal(BIGNUM *b, mp_int *m, size_t max_size) { 23| 4.37k| char *bnBc = BN_bn2hex(b); 24| 4.37k| char mpiMc[max_size]; 25| 4.37k| mp_tohex(m, mpiMc); ------------------ | | 294| 4.37k|#define mp_tohex(M, S) mp_toradix((M), (S), 16) ------------------ 26| 4.37k| std::string bnA(bnBc); 27| 4.37k| std::string mpiA(mpiMc); 28| 4.37k| OPENSSL_free(bnBc); 29| | // We have to strip leading zeros from bignums, ignoring the sign. 30| 4.37k| if (bnA.at(0) != '-') { ------------------ | Branch (30:7): [True: 3.85k, False: 522] ------------------ 31| 3.85k| bnA.erase(0, std::min(bnA.find_first_not_of('0'), bnA.size() - 1)); 32| 3.85k| } else if (bnA.at(1) == '0') { ------------------ | Branch (32:14): [True: 56, False: 466] ------------------ 33| 56| bnA.erase(1, std::min(bnA.find_first_not_of('0', 1) - 1, bnA.size() - 1)); 34| 56| } 35| | 36| 4.37k| if (mpiA != bnA) { ------------------ | Branch (36:7): [True: 0, False: 4.37k] ------------------ 37| 0| std::cout << "openssl: " << std::hex << bnA << std::endl; 38| 0| std::cout << "nss: " << std::hex << mpiA << std::endl; 39| 0| } 40| | 41| 4.37k| assert(mpiA == bnA); 42| 4.37k|} _Z11parse_inputPKhmP9bignum_stS2_P6mp_intS4_: 46| 1.45k| mp_int *a, mp_int *b) { 47| | // Note that b might overlap a. 48| 1.45k| size_t len = (size_t)size / 2; 49| 1.45k| assert(mp_read_raw(a, to_char(data), len) == MP_OKAY); 50| 1.45k| assert(mp_read_raw(b, to_char(data) + len, len) == MP_OKAY); 51| | // Force a positive sign. 52| | // TODO: add tests for negatives. 53| 1.45k| MP_SIGN(a) = MP_ZPOS; ------------------ | | 144| 1.45k|#define MP_SIGN(MP) ((MP)->sign) ------------------ MP_SIGN(a) = MP_ZPOS; ------------------ | | 37| 1.45k|#define MP_ZPOS 0 ------------------ 54| 1.45k| MP_SIGN(b) = MP_ZPOS; ------------------ | | 144| 1.45k|#define MP_SIGN(MP) ((MP)->sign) ------------------ MP_SIGN(b) = MP_ZPOS; ------------------ | | 37| 1.45k|#define MP_ZPOS 0 ------------------ 55| | 56| | // Skip the first byte as it's interpreted as sign by NSS. 57| 1.45k| assert(BN_bin2bn(data + 1, len - 1, A) != nullptr); 58| 1.45k| assert(BN_bin2bn(data + len + 1, len - 1, B) != nullptr); 59| | 60| 1.45k| check_equal(A, a, 2 * size + 1); 61| 1.45k| check_equal(B, b, 2 * size + 1); 62| 1.45k|} LLVMFuzzerTestOneInput: 12| 1.46k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 13| | // We require at least size 3 to get two integers from Data. 14| 1.46k| if (size < 3) { ------------------ | Branch (14:7): [True: 2, False: 1.45k] ------------------ 15| 2| return 0; 16| 2| } 17| 7.29k| INIT_FOUR_NUMBERS ------------------ | | 31| 1.45k| mp_int a, b, c, r; \ | | 32| 1.45k| mp_int *m1 = nullptr; \ | | 33| 1.45k| BN_CTX *ctx = BN_CTX_new(); \ | | 34| 1.45k| BN_CTX_start(ctx); \ | | 35| 1.45k| BIGNUM *A = BN_CTX_get(ctx); \ | | 36| 1.45k| BIGNUM *B = BN_CTX_get(ctx); \ | | 37| 1.45k| BIGNUM *C = BN_CTX_get(ctx); \ | | 38| 1.45k| BIGNUM *R = BN_CTX_get(ctx); \ | | 39| 1.45k| assert(mp_init(&a) == MP_OKAY); \ | | 40| 1.45k| assert(mp_init(&b) == MP_OKAY); \ | | 41| 1.45k| assert(mp_init(&c) == MP_OKAY); \ | | 42| 1.45k| assert(mp_init(&r) == MP_OKAY); \ | | 43| 1.45k| size_t max_size = 2 * size + 1; \ | | 44| 1.45k| parse_input(data, size, A, B, &a, &b); \ | | 45| 1.45k| do { \ | | 46| 1.45k| (void)(R); \ | | 47| 1.45k| } while (0); | | ------------------ | | | Branch (47:12): [Folded - Ignored] | | ------------------ ------------------ 18| | 19| | // Compare with OpenSSL subtraction 20| 7.29k| assert(mp_sub(&a, &b, &c) == MP_OKAY); 21| 1.45k| (void)BN_sub(C, A, B); 22| 1.45k| check_equal(C, &c, max_size); 23| | 24| | // Check a - b == a + -b 25| 1.45k| mp_neg(&b, &b); 26| 1.45k| assert(mp_add(&a, &b, &r) == MP_OKAY); 27| 1.45k| bool eq = mp_cmp(&r, &c) == 0; 28| 1.45k| if (!eq) { ------------------ | Branch (28:7): [True: 0, False: 1.45k] ------------------ 29| 0| char rC[max_size], cC[max_size], aC[max_size], bC[max_size]; 30| 0| mp_tohex(&r, rC); ------------------ | | 294| 0|#define mp_tohex(M, S) mp_toradix((M), (S), 16) ------------------ 31| 0| mp_tohex(&c, cC); ------------------ | | 294| 0|#define mp_tohex(M, S) mp_toradix((M), (S), 16) ------------------ 32| 0| mp_tohex(&a, aC); ------------------ | | 294| 0|#define mp_tohex(M, S) mp_toradix((M), (S), 16) ------------------ 33| 0| mp_tohex(&b, bC); ------------------ | | 294| 0|#define mp_tohex(M, S) mp_toradix((M), (S), 16) ------------------ 34| 0| std::cout << "a = " << std::hex << aC << std::endl; 35| 0| std::cout << "-b = " << std::hex << bC << std::endl; 36| 0| std::cout << "a - b = " << std::hex << cC << std::endl; 37| 0| std::cout << "a + -b = " << std::hex << rC << std::endl; 38| 0| } 39| 1.45k| assert(eq); 40| | 41| 1.45k| CLEANUP_AND_RETURN ------------------ | | 68| 1.45k| mp_clear(&a); \ | | 69| 1.45k| mp_clear(&b); \ | | 70| 1.45k| mp_clear(&c); \ | | 71| 1.45k| mp_clear(&r); \ | | 72| 1.45k| if (m1) { \ | | ------------------ | | | Branch (72:7): [True: 0, False: 1.45k] | | ------------------ | | 73| 0| mp_clear(m1); \ | | 74| 0| } \ | | 75| 1.45k| BN_CTX_end(ctx); \ | | 76| 1.45k| BN_CTX_free(ctx); \ | | 77| 1.45k| return 0; ------------------ 42| 1.45k|} mp_init: 121| 5.83k|{ 122| 5.83k| return mp_init_size(mp, s_mp_defprec); 123| | 124| 5.83k|} /* end mp_init() */ mp_init_size: 140| 5.83k|{ 141| 5.83k| ARGCHK(mp != NULL && prec > 0, MP_BADARG); ------------------ | | 350| 5.83k|#define ARGCHK(X, Y) assert(X) ------------------ 142| | 143| 5.83k| prec = MP_ROUNDUP(prec, s_mp_defprec); ------------------ | | 89| 5.83k|#define MP_ROUNDUP(a, b) (MP_HOWMANY(a, b) * (b)) | | ------------------ | | | | 88| 5.83k|#define MP_HOWMANY(a, b) (((a) + (b)-1) / (b)) | | ------------------ ------------------ 144| 5.83k| if ((DIGITS(mp) = s_mp_alloc(prec, sizeof(mp_digit))) == NULL) ------------------ | | 330| 5.83k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 5.83k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ | Branch (144:9): [True: 0, False: 5.83k] ------------------ 145| 0| return MP_MEM; ------------------ | | 42| 0|#define MP_MEM -2 /* out of memory */ ------------------ 146| | 147| 5.83k| SIGN(mp) = ZPOS; ------------------ | | 327| 5.83k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 5.83k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(mp) = ZPOS; ------------------ | | 321| 5.83k|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 5.83k|#define MP_ZPOS 0 | | ------------------ ------------------ 148| 5.83k| USED(mp) = 1; ------------------ | | 328| 5.83k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 5.83k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 149| 5.83k| ALLOC(mp) = prec; ------------------ | | 329| 5.83k|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 5.83k|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 150| | 151| 5.83k| return MP_OKAY; ------------------ | | 39| 5.83k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 152| | 153| 5.83k|} /* end mp_init_size() */ mp_init_copy: 169| 128k|{ 170| 128k| ARGCHK(mp != NULL && from != NULL, MP_BADARG); ------------------ | | 350| 128k|#define ARGCHK(X, Y) assert(X) ------------------ 171| | 172| 128k| if (mp == from) ------------------ | Branch (172:9): [True: 0, False: 128k] ------------------ 173| 0| return MP_OKAY; ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ 174| | 175| 128k| if ((DIGITS(mp) = s_mp_alloc(ALLOC(from), sizeof(mp_digit))) == NULL) ------------------ | | 330| 128k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 128k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ if ((DIGITS(mp) = s_mp_alloc(ALLOC(from), sizeof(mp_digit))) == NULL) ------------------ | | 329| 128k|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 128k|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ | Branch (175:9): [True: 0, False: 128k] ------------------ 176| 0| return MP_MEM; ------------------ | | 42| 0|#define MP_MEM -2 /* out of memory */ ------------------ 177| | 178| 128k| s_mp_copy(DIGITS(from), DIGITS(mp), USED(from)); ------------------ | | 330| 128k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 128k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_copy(DIGITS(from), DIGITS(mp), USED(from)); ------------------ | | 330| 128k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 128k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_copy(DIGITS(from), DIGITS(mp), USED(from)); ------------------ | | 328| 128k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 128k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 179| 128k| USED(mp) = USED(from); ------------------ | | 328| 128k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 128k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ USED(mp) = USED(from); ------------------ | | 328| 128k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 128k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 180| 128k| ALLOC(mp) = ALLOC(from); ------------------ | | 329| 128k|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 128k|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ ALLOC(mp) = ALLOC(from); ------------------ | | 329| 128k|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 128k|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 181| 128k| SIGN(mp) = SIGN(from); ------------------ | | 327| 128k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 128k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(mp) = SIGN(from); ------------------ | | 327| 128k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 128k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ 182| | 183| 128k| return MP_OKAY; ------------------ | | 39| 128k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 184| | 185| 128k|} /* end mp_init_copy() */ mp_copy: 201| 458k|{ 202| 458k| ARGCHK(from != NULL && to != NULL, MP_BADARG); ------------------ | | 350| 458k|#define ARGCHK(X, Y) assert(X) ------------------ 203| | 204| 458k| if (from == to) ------------------ | Branch (204:9): [True: 458k, False: 0] ------------------ 205| 458k| return MP_OKAY; ------------------ | | 39| 458k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 206| | 207| 0| { /* copy */ 208| 0| mp_digit *tmp; 209| | 210| | /* 211| | If the allocated buffer in 'to' already has enough space to hold 212| | all the used digits of 'from', we'll re-use it to avoid hitting 213| | the memory allocater more than necessary; otherwise, we'd have 214| | to grow anyway, so we just allocate a hunk and make the copy as 215| | usual 216| | */ 217| 0| if (ALLOC(to) >= USED(from)) { ------------------ | | 329| 0|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 0|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ if (ALLOC(to) >= USED(from)) { ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ | Branch (217:13): [True: 0, False: 0] ------------------ 218| 0| s_mp_setz(DIGITS(to) + USED(from), ALLOC(to) - USED(from)); ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_setz(DIGITS(to) + USED(from), ALLOC(to) - USED(from)); ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ s_mp_setz(DIGITS(to) + USED(from), ALLOC(to) - USED(from)); ------------------ | | 329| 0|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 0|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ s_mp_setz(DIGITS(to) + USED(from), ALLOC(to) - USED(from)); ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 219| 0| s_mp_copy(DIGITS(from), DIGITS(to), USED(from)); ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_copy(DIGITS(from), DIGITS(to), USED(from)); ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_copy(DIGITS(from), DIGITS(to), USED(from)); ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 220| | 221| 0| } else { 222| 0| if ((tmp = s_mp_alloc(ALLOC(from), sizeof(mp_digit))) == NULL) ------------------ | | 329| 0|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 0|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ | Branch (222:17): [True: 0, False: 0] ------------------ 223| 0| return MP_MEM; ------------------ | | 42| 0|#define MP_MEM -2 /* out of memory */ ------------------ 224| | 225| 0| s_mp_copy(DIGITS(from), tmp, USED(from)); ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_copy(DIGITS(from), tmp, USED(from)); ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 226| | 227| 0| if (DIGITS(to) != NULL) { ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ | Branch (227:17): [True: 0, False: 0] ------------------ 228| 0| s_mp_setz(DIGITS(to), ALLOC(to)); ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_setz(DIGITS(to), ALLOC(to)); ------------------ | | 329| 0|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 0|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 229| 0| s_mp_free(DIGITS(to)); ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ 230| 0| } 231| | 232| 0| DIGITS(to) = tmp; ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ 233| 0| ALLOC(to) = ALLOC(from); ------------------ | | 329| 0|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 0|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ ALLOC(to) = ALLOC(from); ------------------ | | 329| 0|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 0|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 234| 0| } 235| | 236| | /* Copy the precision and sign from the original */ 237| 0| USED(to) = USED(from); ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ USED(to) = USED(from); ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 238| 0| SIGN(to) = SIGN(from); ------------------ | | 327| 0|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 0|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(to) = SIGN(from); ------------------ | | 327| 0|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 0|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ 239| 0| } /* end copy */ 240| | 241| 0| return MP_OKAY; ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ 242| | 243| 0|} /* end mp_copy() */ mp_clear: 285| 134k|{ 286| 134k| if (mp == NULL) ------------------ | Branch (286:9): [True: 0, False: 134k] ------------------ 287| 0| return; 288| | 289| 134k| if (DIGITS(mp) != NULL) { ------------------ | | 330| 134k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 134k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ | Branch (289:9): [True: 134k, False: 0] ------------------ 290| 134k| s_mp_setz(DIGITS(mp), ALLOC(mp)); ------------------ | | 330| 134k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 134k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_setz(DIGITS(mp), ALLOC(mp)); ------------------ | | 329| 134k|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 134k|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 291| 134k| s_mp_free(DIGITS(mp)); ------------------ | | 330| 134k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 134k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ 292| 134k| DIGITS(mp) = NULL; ------------------ | | 330| 134k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 134k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ 293| 134k| } 294| | 295| 134k| USED(mp) = 0; ------------------ | | 328| 134k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 134k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 296| 134k| ALLOC(mp) = 0; ------------------ | | 329| 134k|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 134k|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 297| | 298| 134k|} /* end mp_clear() */ mp_zero: 312| 2.94k|{ 313| 2.94k| if (mp == NULL) ------------------ | Branch (313:9): [True: 0, False: 2.94k] ------------------ 314| 0| return; 315| | 316| 2.94k| s_mp_setz(DIGITS(mp), ALLOC(mp)); ------------------ | | 330| 2.94k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 2.94k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_setz(DIGITS(mp), ALLOC(mp)); ------------------ | | 329| 2.94k|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 2.94k|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 317| 2.94k| USED(mp) = 1; ------------------ | | 328| 2.94k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 2.94k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 318| 2.94k| SIGN(mp) = ZPOS; ------------------ | | 327| 2.94k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 2.94k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(mp) = ZPOS; ------------------ | | 321| 2.94k|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 2.94k|#define MP_ZPOS 0 | | ------------------ ------------------ 319| | 320| 2.94k|} /* end mp_zero() */ mp_add_d: 408| 124k|{ 409| 124k| mp_int tmp; 410| 124k| mp_err res; 411| | 412| 124k| ARGCHK(a != NULL && b != NULL, MP_BADARG); ------------------ | | 350| 124k|#define ARGCHK(X, Y) assert(X) ------------------ 413| | 414| 124k| if ((res = mp_init_copy(&tmp, a)) != MP_OKAY) ------------------ | | 39| 124k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (414:9): [True: 0, False: 124k] ------------------ 415| 0| return res; 416| | 417| 124k| if (SIGN(&tmp) == ZPOS) { ------------------ | | 327| 124k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 124k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ if (SIGN(&tmp) == ZPOS) { ------------------ | | 321| 124k|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 124k|#define MP_ZPOS 0 | | ------------------ ------------------ | Branch (417:9): [True: 124k, False: 0] ------------------ 418| 124k| if ((res = s_mp_add_d(&tmp, d)) != MP_OKAY) ------------------ | | 39| 124k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (418:13): [True: 0, False: 124k] ------------------ 419| 0| goto CLEANUP; 420| 124k| } else if (s_mp_cmp_d(&tmp, d) >= 0) { ------------------ | Branch (420:16): [True: 0, False: 0] ------------------ 421| 0| if ((res = s_mp_sub_d(&tmp, d)) != MP_OKAY) ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (421:13): [True: 0, False: 0] ------------------ 422| 0| goto CLEANUP; 423| 0| } else { 424| 0| mp_neg(&tmp, &tmp); 425| | 426| 0| DIGIT(&tmp, 0) = d - DIGIT(&tmp, 0); ------------------ | | 331| 0|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 0|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ DIGIT(&tmp, 0) = d - DIGIT(&tmp, 0); ------------------ | | 331| 0|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 0|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ 427| 0| } 428| | 429| 124k| if (s_mp_cmp_d(&tmp, 0) == 0) ------------------ | Branch (429:9): [True: 13.5k, False: 110k] ------------------ 430| 13.5k| SIGN(&tmp) = ZPOS; ------------------ | | 327| 13.5k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 13.5k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(&tmp) = ZPOS; ------------------ | | 321| 13.5k|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 13.5k|#define MP_ZPOS 0 | | ------------------ ------------------ 431| | 432| 124k| s_mp_exch(&tmp, b); 433| | 434| 124k|CLEANUP: 435| 124k| mp_clear(&tmp); 436| 124k| return res; 437| | 438| 124k|} /* end mp_add_d() */ mp_mul_d: 499| 124k|{ 500| 124k| mp_err res; 501| | 502| 124k| ARGCHK(a != NULL && b != NULL, MP_BADARG); ------------------ | | 350| 124k|#define ARGCHK(X, Y) assert(X) ------------------ 503| | 504| 124k| if (d == 0) { ------------------ | Branch (504:9): [True: 0, False: 124k] ------------------ 505| 0| mp_zero(b); 506| 0| return MP_OKAY; ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ 507| 0| } 508| | 509| 124k| if ((res = mp_copy(a, b)) != MP_OKAY) ------------------ | | 39| 124k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (509:9): [True: 0, False: 124k] ------------------ 510| 0| return res; 511| | 512| 124k| res = s_mp_mul_d(b, d); 513| | 514| 124k| return res; 515| | 516| 124k|} /* end mp_mul_d() */ mp_div_d: 550| 332k|{ 551| 332k| mp_err res; 552| 332k| mp_int qp; 553| 332k| mp_digit rem = 0; 554| 332k| int pow; 555| | 556| 332k| ARGCHK(a != NULL, MP_BADARG); ------------------ | | 350| 332k|#define ARGCHK(X, Y) assert(X) ------------------ 557| | 558| 332k| if (d == 0) ------------------ | Branch (558:9): [True: 0, False: 332k] ------------------ 559| 0| return MP_RANGE; ------------------ | | 43| 0|#define MP_RANGE -3 /* argument out of range */ ------------------ 560| | 561| | /* Shortcut for powers of two ... */ 562| 332k| if ((pow = s_mp_ispow2d(d)) >= 0) { ------------------ | Branch (562:9): [True: 332k, False: 0] ------------------ 563| 332k| mp_digit mask; 564| | 565| 332k| mask = ((mp_digit)1 << pow) - 1; 566| 332k| rem = DIGIT(a, 0) & mask; ------------------ | | 331| 332k|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 332k|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ 567| | 568| 332k| if (q) { ------------------ | Branch (568:13): [True: 332k, False: 0] ------------------ 569| 332k| if ((res = mp_copy(a, q)) != MP_OKAY) { ------------------ | | 39| 332k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (569:17): [True: 0, False: 332k] ------------------ 570| 0| return res; 571| 0| } 572| 332k| s_mp_div_2d(q, pow); 573| 332k| } 574| | 575| 332k| if (r) ------------------ | Branch (575:13): [True: 332k, False: 0] ------------------ 576| 332k| *r = rem; 577| | 578| 332k| return MP_OKAY; ------------------ | | 39| 332k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 579| 332k| } 580| | 581| 0| if ((res = mp_init_copy(&qp, a)) != MP_OKAY) ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (581:9): [True: 0, False: 0] ------------------ 582| 0| return res; 583| | 584| 0| res = s_mp_div_d(&qp, d, &rem); 585| | 586| 0| if (s_mp_cmp_d(&qp, 0) == 0) ------------------ | Branch (586:9): [True: 0, False: 0] ------------------ 587| 0| SIGN(q) = ZPOS; ------------------ | | 327| 0|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 0|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(q) = ZPOS; ------------------ | | 321| 0|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 0|#define MP_ZPOS 0 | | ------------------ ------------------ 588| | 589| 0| if (r) { ------------------ | Branch (589:9): [True: 0, False: 0] ------------------ 590| 0| *r = rem; 591| 0| } 592| | 593| 0| if (q) ------------------ | Branch (593:9): [True: 0, False: 0] ------------------ 594| 0| s_mp_exch(&qp, q); 595| | 596| 0| mp_clear(&qp); 597| 0| return res; 598| | 599| 0|} /* end mp_div_d() */ mp_neg: 712| 1.45k|{ 713| 1.45k| mp_err res; 714| | 715| 1.45k| ARGCHK(a != NULL && b != NULL, MP_BADARG); ------------------ | | 350| 1.45k|#define ARGCHK(X, Y) assert(X) ------------------ 716| | 717| 1.45k| if ((res = mp_copy(a, b)) != MP_OKAY) ------------------ | | 39| 1.45k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (717:9): [True: 0, False: 1.45k] ------------------ 718| 0| return res; 719| | 720| 1.45k| if (s_mp_cmp_d(b, 0) == MP_EQ) ------------------ | | 96| 1.45k|#define MP_EQ 0 ------------------ | Branch (720:9): [True: 287, False: 1.17k] ------------------ 721| 287| SIGN(b) = ZPOS; ------------------ | | 327| 287|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 287|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(b) = ZPOS; ------------------ | | 321| 287|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 287|#define MP_ZPOS 0 | | ------------------ ------------------ 722| 1.17k| else 723| 1.17k| SIGN(b) = (SIGN(b) == NEG) ? ZPOS : NEG; ------------------ | | 327| 1.17k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 1.17k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(b) = (SIGN(b) == NEG) ? ZPOS : NEG; ------------------ | | 327| 1.17k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 1.17k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(b) = (SIGN(b) == NEG) ? ZPOS : NEG; ------------------ | | 320| 1.17k|#define NEG MP_NEG | | ------------------ | | | | 36| 1.17k|#define MP_NEG 1 | | ------------------ ------------------ SIGN(b) = (SIGN(b) == NEG) ? ZPOS : NEG; ------------------ | | 321| 0|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 0|#define MP_ZPOS 0 | | ------------------ ------------------ SIGN(b) = (SIGN(b) == NEG) ? ZPOS : NEG; ------------------ | | 320| 1.17k|#define NEG MP_NEG | | ------------------ | | | | 36| 1.17k|#define MP_NEG 1 | | ------------------ ------------------ | Branch (723:19): [True: 0, False: 1.17k] ------------------ 724| | 725| 1.45k| return MP_OKAY; ------------------ | | 39| 1.45k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 726| | 727| 1.45k|} /* end mp_neg() */ mp_add: 741| 1.45k|{ 742| 1.45k| mp_err res; 743| | 744| 1.45k| ARGCHK(a != NULL && b != NULL && c != NULL, MP_BADARG); ------------------ | | 350| 1.45k|#define ARGCHK(X, Y) assert(X) ------------------ 745| | 746| 1.45k| if (SIGN(a) == SIGN(b)) { /* same sign: add values, keep sign */ ------------------ | | 327| 1.45k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 1.45k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ if (SIGN(a) == SIGN(b)) { /* same sign: add values, keep sign */ ------------------ | | 327| 1.45k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 1.45k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ | Branch (746:9): [True: 287, False: 1.17k] ------------------ 747| 287| MP_CHECKOK(s_mp_add_3arg(a, b, c)); ------------------ | | 314| 287| if (MP_OKAY > (res = (x))) \ | | ------------------ | | | | 39| 287|#define MP_OKAY 0 /* no error, all is well */ | | ------------------ | | | Branch (314:9): [True: 0, False: 287] | | ------------------ | | 315| 287| goto CLEANUP ------------------ 748| 1.17k| } else if (s_mp_cmp(a, b) >= 0) { /* different sign: |a| >= |b| */ ------------------ | Branch (748:16): [True: 650, False: 522] ------------------ 749| 650| MP_CHECKOK(s_mp_sub_3arg(a, b, c)); ------------------ | | 314| 650| if (MP_OKAY > (res = (x))) \ | | ------------------ | | | | 39| 650|#define MP_OKAY 0 /* no error, all is well */ | | ------------------ | | | Branch (314:9): [True: 0, False: 650] | | ------------------ | | 315| 650| goto CLEANUP ------------------ 750| 650| } else { /* different sign: |a| < |b| */ 751| 522| MP_CHECKOK(s_mp_sub_3arg(b, a, c)); ------------------ | | 314| 522| if (MP_OKAY > (res = (x))) \ | | ------------------ | | | | 39| 522|#define MP_OKAY 0 /* no error, all is well */ | | ------------------ | | | Branch (314:9): [True: 0, False: 522] | | ------------------ | | 315| 522| goto CLEANUP ------------------ 752| 522| } 753| | 754| 1.45k| if (s_mp_cmp_d(c, 0) == MP_EQ) ------------------ | | 96| 1.45k|#define MP_EQ 0 ------------------ | Branch (754:9): [True: 22, False: 1.43k] ------------------ 755| 22| SIGN(c) = ZPOS; ------------------ | | 327| 22|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 22|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(c) = ZPOS; ------------------ | | 321| 22|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 22|#define MP_ZPOS 0 | | ------------------ ------------------ 756| | 757| 1.45k|CLEANUP: 758| 1.45k| return res; 759| | 760| 1.45k|} /* end mp_add() */ mp_sub: 774| 1.45k|{ 775| 1.45k| mp_err res; 776| 1.45k| int magDiff; 777| | 778| 1.45k| ARGCHK(a != NULL && b != NULL && c != NULL, MP_BADARG); ------------------ | | 350| 1.45k|#define ARGCHK(X, Y) assert(X) ------------------ 779| | 780| 1.45k| if (a == b) { ------------------ | Branch (780:9): [True: 0, False: 1.45k] ------------------ 781| 0| mp_zero(c); 782| 0| return MP_OKAY; ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ 783| 0| } 784| | 785| 1.45k| if (MP_SIGN(a) != MP_SIGN(b)) { ------------------ | | 144| 1.45k|#define MP_SIGN(MP) ((MP)->sign) ------------------ if (MP_SIGN(a) != MP_SIGN(b)) { ------------------ | | 144| 1.45k|#define MP_SIGN(MP) ((MP)->sign) ------------------ | Branch (785:9): [True: 0, False: 1.45k] ------------------ 786| 0| MP_CHECKOK(s_mp_add_3arg(a, b, c)); ------------------ | | 314| 0| if (MP_OKAY > (res = (x))) \ | | ------------------ | | | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ | | ------------------ | | | Branch (314:9): [True: 0, False: 0] | | ------------------ | | 315| 0| goto CLEANUP ------------------ 787| 1.45k| } else if (!(magDiff = s_mp_cmp(a, b))) { ------------------ | Branch (787:16): [True: 22, False: 1.43k] ------------------ 788| 22| mp_zero(c); 789| 22| res = MP_OKAY; ------------------ | | 39| 22|#define MP_OKAY 0 /* no error, all is well */ ------------------ 790| 1.43k| } else if (magDiff > 0) { ------------------ | Branch (790:16): [True: 915, False: 522] ------------------ 791| 915| MP_CHECKOK(s_mp_sub_3arg(a, b, c)); ------------------ | | 314| 915| if (MP_OKAY > (res = (x))) \ | | ------------------ | | | | 39| 915|#define MP_OKAY 0 /* no error, all is well */ | | ------------------ | | | Branch (314:9): [True: 0, False: 915] | | ------------------ | | 315| 915| goto CLEANUP ------------------ 792| 915| } else { 793| 522| MP_CHECKOK(s_mp_sub_3arg(b, a, c)); ------------------ | | 314| 522| if (MP_OKAY > (res = (x))) \ | | ------------------ | | | | 39| 522|#define MP_OKAY 0 /* no error, all is well */ | | ------------------ | | | Branch (314:9): [True: 0, False: 522] | | ------------------ | | 315| 522| goto CLEANUP ------------------ 794| 522| MP_SIGN(c) = !MP_SIGN(a); ------------------ | | 144| 522|#define MP_SIGN(MP) ((MP)->sign) ------------------ MP_SIGN(c) = !MP_SIGN(a); ------------------ | | 144| 522|#define MP_SIGN(MP) ((MP)->sign) ------------------ 795| 522| } 796| | 797| 1.45k| if (s_mp_cmp_d(c, 0) == MP_EQ) ------------------ | | 96| 1.45k|#define MP_EQ 0 ------------------ | Branch (797:9): [True: 22, False: 1.43k] ------------------ 798| 22| MP_SIGN(c) = MP_ZPOS; ------------------ | | 144| 22|#define MP_SIGN(MP) ((MP)->sign) ------------------ MP_SIGN(c) = MP_ZPOS; ------------------ | | 37| 22|#define MP_ZPOS 0 ------------------ 799| | 800| 1.45k|CLEANUP: 801| 1.45k| return res; 802| | 803| 1.45k|} /* end mp_sub() */ mp_cmp_z: 1790| 340k|{ 1791| 340k| ARGMPCHK(a != NULL); ------------------ | | 349| 340k|#define ARGMPCHK(X) assert(X) ------------------ 1792| | 1793| 340k| if (SIGN(a) == NEG) ------------------ | | 327| 340k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 340k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ if (SIGN(a) == NEG) ------------------ | | 320| 340k|#define NEG MP_NEG | | ------------------ | | | | 36| 340k|#define MP_NEG 1 | | ------------------ ------------------ | Branch (1793:9): [True: 522, False: 340k] ------------------ 1794| 522| return MP_LT; ------------------ | | 95| 522|#define MP_LT -1 ------------------ 1795| 340k| else if (USED(a) == 1 && DIGIT(a, 0) == 0) ------------------ | | 328| 340k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 340k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ else if (USED(a) == 1 && DIGIT(a, 0) == 0) ------------------ | | 331| 61.9k|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 61.9k|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ | Branch (1795:14): [True: 61.9k, False: 278k] | Branch (1795:30): [True: 4.37k, False: 57.5k] ------------------ 1796| 4.37k| return MP_EQ; ------------------ | | 96| 4.37k|#define MP_EQ 0 ------------------ 1797| 335k| else 1798| 335k| return MP_GT; ------------------ | | 97| 335k|#define MP_GT 1 ------------------ 1799| | 1800| 340k|} /* end mp_cmp_z() */ mp_cmp: 1830| 1.45k|{ 1831| 1.45k| ARGCHK(a != NULL && b != NULL, MP_EQ); ------------------ | | 350| 1.45k|#define ARGCHK(X, Y) assert(X) ------------------ 1832| | 1833| 1.45k| if (SIGN(a) == SIGN(b)) { ------------------ | | 327| 1.45k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 1.45k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ if (SIGN(a) == SIGN(b)) { ------------------ | | 327| 1.45k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 1.45k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ | Branch (1833:9): [True: 1.45k, False: 0] ------------------ 1834| 1.45k| int mag; 1835| | 1836| 1.45k| if ((mag = s_mp_cmp(a, b)) == MP_EQ) ------------------ | | 96| 1.45k|#define MP_EQ 0 ------------------ | Branch (1836:13): [True: 1.45k, False: 0] ------------------ 1837| 1.45k| return MP_EQ; ------------------ | | 96| 1.45k|#define MP_EQ 0 ------------------ 1838| | 1839| 0| if (SIGN(a) == ZPOS) ------------------ | | 327| 0|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 0|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ if (SIGN(a) == ZPOS) ------------------ | | 321| 0|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 0|#define MP_ZPOS 0 | | ------------------ ------------------ | Branch (1839:13): [True: 0, False: 0] ------------------ 1840| 0| return mag; 1841| 0| else 1842| 0| return -mag; 1843| | 1844| 0| } else if (SIGN(a) == ZPOS) { ------------------ | | 327| 0|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 0|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ } else if (SIGN(a) == ZPOS) { ------------------ | | 321| 0|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 0|#define MP_ZPOS 0 | | ------------------ ------------------ | Branch (1844:16): [True: 0, False: 0] ------------------ 1845| 0| return MP_GT; ------------------ | | 97| 0|#define MP_GT 1 ------------------ 1846| 0| } else { 1847| 0| return MP_LT; ------------------ | | 95| 0|#define MP_LT -1 ------------------ 1848| 0| } 1849| | 1850| 1.45k|} /* end mp_cmp() */ mp_read_raw: 2735| 2.91k|{ 2736| 2.91k| int ix; 2737| 2.91k| mp_err res; 2738| 2.91k| unsigned char *ustr = (unsigned char *)str; 2739| | 2740| 2.91k| ARGCHK(mp != NULL && str != NULL && len > 0, MP_BADARG); ------------------ | | 350| 2.91k|#define ARGCHK(X, Y) assert(X) ------------------ 2741| | 2742| 2.91k| mp_zero(mp); 2743| | 2744| | /* Read the rest of the digits */ 2745| 127k| for (ix = 1; ix < len; ix++) { ------------------ | Branch (2745:18): [True: 124k, False: 2.91k] ------------------ 2746| 124k| if ((res = mp_mul_d(mp, 256, mp)) != MP_OKAY) ------------------ | | 39| 124k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (2746:13): [True: 0, False: 124k] ------------------ 2747| 0| return res; 2748| 124k| if ((res = mp_add_d(mp, ustr[ix], mp)) != MP_OKAY) ------------------ | | 39| 124k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (2748:13): [True: 0, False: 124k] ------------------ 2749| 0| return res; 2750| 124k| } 2751| | 2752| | /* Get sign from first byte */ 2753| 2.91k| if (ustr[0]) ------------------ | Branch (2753:9): [True: 2.24k, False: 677] ------------------ 2754| 2.24k| SIGN(mp) = NEG; ------------------ | | 327| 2.24k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 2.24k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(mp) = NEG; ------------------ | | 320| 2.24k|#define NEG MP_NEG | | ------------------ | | | | 36| 2.24k|#define MP_NEG 1 | | ------------------ ------------------ 2755| 677| else 2756| 677| SIGN(mp) = ZPOS; ------------------ | | 327| 677|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 677|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(mp) = ZPOS; ------------------ | | 321| 677|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 677|#define MP_ZPOS 0 | | ------------------ ------------------ 2757| | 2758| 2.91k| return MP_OKAY; ------------------ | | 39| 2.91k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 2759| | 2760| 2.91k|} /* end mp_read_raw() */ mp_toradix: 2924| 4.37k|{ 2925| 4.37k| int ix, pos = 0; 2926| | 2927| 4.37k| ARGCHK(mp != NULL && str != NULL, MP_BADARG); ------------------ | | 350| 4.37k|#define ARGCHK(X, Y) assert(X) ------------------ 2928| 4.37k| ARGCHK(radix > 1 && radix <= MAX_RADIX, MP_RANGE); ------------------ | | 350| 4.37k|#define ARGCHK(X, Y) assert(X) ------------------ 2929| | 2930| 4.37k| if (mp_cmp_z(mp) == MP_EQ) { ------------------ | | 96| 4.37k|#define MP_EQ 0 ------------------ | Branch (2930:9): [True: 355, False: 4.02k] ------------------ 2931| 355| str[0] = '0'; 2932| 355| str[1] = '\0'; 2933| 4.02k| } else { 2934| 4.02k| mp_err res; 2935| 4.02k| mp_int tmp; 2936| 4.02k| mp_sign sgn; 2937| 4.02k| mp_digit rem, rdx = (mp_digit)radix; 2938| 4.02k| char ch; 2939| | 2940| 4.02k| if ((res = mp_init_copy(&tmp, mp)) != MP_OKAY) ------------------ | | 39| 4.02k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (2940:13): [True: 0, False: 4.02k] ------------------ 2941| 0| return res; 2942| | 2943| | /* Save sign for later, and take absolute value */ 2944| 4.02k| sgn = SIGN(&tmp); ------------------ | | 327| 4.02k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 4.02k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ 2945| 4.02k| SIGN(&tmp) = ZPOS; ------------------ | | 327| 4.02k|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 4.02k|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(&tmp) = ZPOS; ------------------ | | 321| 4.02k|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 4.02k|#define MP_ZPOS 0 | | ------------------ ------------------ 2946| | 2947| | /* Generate output digits in reverse order */ 2948| 336k| while (mp_cmp_z(&tmp) != 0) { ------------------ | Branch (2948:16): [True: 332k, False: 4.02k] ------------------ 2949| 332k| if ((res = mp_div_d(&tmp, rdx, &tmp, &rem)) != MP_OKAY) { ------------------ | | 39| 332k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (2949:17): [True: 0, False: 332k] ------------------ 2950| 0| mp_clear(&tmp); 2951| 0| return res; 2952| 0| } 2953| | 2954| | /* Generate digits, use capital letters */ 2955| 332k| ch = s_mp_todigit(rem, radix, 0); 2956| | 2957| 332k| str[pos++] = ch; 2958| 332k| } 2959| | 2960| | /* Add - sign if original value was negative */ 2961| 4.02k| if (sgn == NEG) ------------------ | | 320| 4.02k|#define NEG MP_NEG | | ------------------ | | | | 36| 4.02k|#define MP_NEG 1 | | ------------------ ------------------ | Branch (2961:13): [True: 522, False: 3.50k] ------------------ 2962| 522| str[pos++] = '-'; 2963| | 2964| | /* Add trailing NUL to end the string */ 2965| 4.02k| str[pos--] = '\0'; 2966| | 2967| | /* Reverse the digits and sign indicator */ 2968| 4.02k| ix = 0; 2969| 169k| while (ix < pos) { ------------------ | Branch (2969:16): [True: 165k, False: 4.02k] ------------------ 2970| 165k| char tmpc = str[ix]; 2971| | 2972| 165k| str[ix] = str[pos]; 2973| 165k| str[pos] = tmpc; 2974| 165k| ++ix; 2975| 165k| --pos; 2976| 165k| } 2977| | 2978| 4.02k| mp_clear(&tmp); 2979| 4.02k| } 2980| | 2981| 4.37k| return MP_OKAY; ------------------ | | 39| 4.37k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 2982| | 2983| 4.37k|} /* end mp_toradix() */ s_mp_grow: 3038| 99|{ 3039| 99| ARGCHK(mp != NULL, MP_BADARG); ------------------ | | 350| 99|#define ARGCHK(X, Y) assert(X) ------------------ 3040| | 3041| 99| if (min > ALLOC(mp)) { ------------------ | | 329| 99|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 99|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ | Branch (3041:9): [True: 99, False: 0] ------------------ 3042| 99| mp_digit *tmp; 3043| | 3044| | /* Set min to next nearest default precision block size */ 3045| 99| min = MP_ROUNDUP(min, s_mp_defprec); ------------------ | | 89| 99|#define MP_ROUNDUP(a, b) (MP_HOWMANY(a, b) * (b)) | | ------------------ | | | | 88| 99|#define MP_HOWMANY(a, b) (((a) + (b)-1) / (b)) | | ------------------ ------------------ 3046| | 3047| 99| if ((tmp = s_mp_alloc(min, sizeof(mp_digit))) == NULL) ------------------ | Branch (3047:13): [True: 0, False: 99] ------------------ 3048| 0| return MP_MEM; ------------------ | | 42| 0|#define MP_MEM -2 /* out of memory */ ------------------ 3049| | 3050| 99| s_mp_copy(DIGITS(mp), tmp, USED(mp)); ------------------ | | 330| 99|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 99|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_copy(DIGITS(mp), tmp, USED(mp)); ------------------ | | 328| 99|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 99|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 3051| | 3052| 99| s_mp_setz(DIGITS(mp), ALLOC(mp)); ------------------ | | 330| 99|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 99|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_setz(DIGITS(mp), ALLOC(mp)); ------------------ | | 329| 99|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 99|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 3053| 99| s_mp_free(DIGITS(mp)); ------------------ | | 330| 99|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 99|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ 3054| 99| DIGITS(mp) = tmp; ------------------ | | 330| 99|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 99|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ 3055| 99| ALLOC(mp) = min; ------------------ | | 329| 99|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 99|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 3056| 99| } 3057| | 3058| 99| return MP_OKAY; ------------------ | | 39| 99|#define MP_OKAY 0 /* no error, all is well */ ------------------ 3059| | 3060| 99|} /* end s_mp_grow() */ s_mp_pad: 3069| 127k|{ 3070| 127k| ARGCHK(mp != NULL, MP_BADARG); ------------------ | | 350| 127k|#define ARGCHK(X, Y) assert(X) ------------------ 3071| | 3072| 127k| if (min > USED(mp)) { ------------------ | | 328| 127k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 127k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ | Branch (3072:9): [True: 14.6k, False: 112k] ------------------ 3073| 14.6k| mp_err res; 3074| | 3075| | /* Make sure there is room to increase precision */ 3076| 14.6k| if (min > ALLOC(mp)) { ------------------ | | 329| 14.6k|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 14.6k|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ | Branch (3076:13): [True: 99, False: 14.5k] ------------------ 3077| 99| if ((res = s_mp_grow(mp, min)) != MP_OKAY) ------------------ | | 39| 99|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (3077:17): [True: 0, False: 99] ------------------ 3078| 0| return res; 3079| 14.5k| } else { 3080| 14.5k| s_mp_setz(DIGITS(mp) + USED(mp), min - USED(mp)); ------------------ | | 330| 14.5k|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 14.5k|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_setz(DIGITS(mp) + USED(mp), min - USED(mp)); ------------------ | | 328| 14.5k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 14.5k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ s_mp_setz(DIGITS(mp) + USED(mp), min - USED(mp)); ------------------ | | 328| 14.5k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 14.5k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 3081| 14.5k| } 3082| | 3083| | /* Increase precision; should already be 0-filled */ 3084| 14.6k| USED(mp) = min; ------------------ | | 328| 14.6k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 14.6k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 3085| 14.6k| } 3086| | 3087| 127k| return MP_OKAY; ------------------ | | 39| 127k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 3088| | 3089| 127k|} /* end s_mp_pad() */ s_mp_setz: 3098| 151k|{ 3099| 151k| memset(dp, 0, count * sizeof(mp_digit)); 3100| 151k|} /* end s_mp_setz() */ s_mp_copy: 3109| 128k|{ 3110| 128k| memcpy(dp, sp, count * sizeof(mp_digit)); 3111| 128k|} /* end s_mp_copy() */ s_mp_alloc: 3120| 134k|{ 3121| 134k| return calloc(nb, ni); 3122| | 3123| 134k|} /* end s_mp_alloc() */ s_mp_free: 3132| 134k|{ 3133| 134k| if (ptr) { ------------------ | Branch (3133:9): [True: 134k, False: 0] ------------------ 3134| 134k| free(ptr); 3135| 134k| } 3136| 134k|} /* end s_mp_free() */ s_mp_clamp: 3145| 459k|{ 3146| 459k| mp_size used = MP_USED(mp); ------------------ | | 145| 459k|#define MP_USED(MP) ((MP)->used) ------------------ 3147| 479k| while (used > 1 && DIGIT(mp, used - 1) == 0) ------------------ | | 331| 387k|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 387k|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ | Branch (3147:12): [True: 387k, False: 91.9k] | Branch (3147:24): [True: 20.4k, False: 367k] ------------------ 3148| 20.4k| --used; 3149| 459k| MP_USED(mp) = used; ------------------ | | 145| 459k|#define MP_USED(MP) ((MP)->used) ------------------ 3150| 459k| if (used == 1 && DIGIT(mp, 0) == 0) ------------------ | | 331| 91.9k|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 91.9k|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ | Branch (3150:9): [True: 91.9k, False: 367k] | Branch (3150:22): [True: 20.1k, False: 71.7k] ------------------ 3151| 20.1k| MP_SIGN(mp) = ZPOS; ------------------ | | 144| 20.1k|#define MP_SIGN(MP) ((MP)->sign) ------------------ MP_SIGN(mp) = ZPOS; ------------------ | | 321| 20.1k|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 20.1k|#define MP_ZPOS 0 | | ------------------ ------------------ 3152| 459k|} /* end s_mp_clamp() */ s_mp_exch: 3161| 124k|{ 3162| 124k| mp_int tmp; 3163| 124k| if (!a || !b) { ------------------ | Branch (3163:9): [True: 0, False: 124k] | Branch (3163:15): [True: 0, False: 124k] ------------------ 3164| 0| return; 3165| 0| } 3166| | 3167| 124k| tmp = *a; 3168| 124k| *a = *b; 3169| 124k| *b = tmp; 3170| | 3171| 124k|} /* end s_mp_exch() */ s_mp_mul_2d: 3227| 124k|{ 3228| 124k| mp_err res; 3229| 124k| mp_digit dshift, rshift, mask, x, prev = 0; 3230| 124k| mp_digit *pa = NULL; 3231| 124k| int i; 3232| | 3233| 124k| ARGCHK(mp != NULL, MP_BADARG); ------------------ | | 350| 124k|#define ARGCHK(X, Y) assert(X) ------------------ 3234| | 3235| 124k| dshift = d / MP_DIGIT_BIT; ------------------ | | 132| 124k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE) | | ------------------ | | | | 131| 124k|#define MP_DIGIT_SIZE sizeof(mp_digit) | | ------------------ ------------------ 3236| 124k| d %= MP_DIGIT_BIT; ------------------ | | 132| 124k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE) | | ------------------ | | | | 131| 124k|#define MP_DIGIT_SIZE sizeof(mp_digit) | | ------------------ ------------------ 3237| | /* mp_digit >> rshift is undefined behavior for rshift >= MP_DIGIT_BIT */ 3238| | /* mod and corresponding mask logic avoid that when d = 0 */ 3239| 124k| rshift = MP_DIGIT_BIT - d; ------------------ | | 132| 124k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE) | | ------------------ | | | | 131| 124k|#define MP_DIGIT_SIZE sizeof(mp_digit) | | ------------------ ------------------ 3240| 124k| rshift %= MP_DIGIT_BIT; ------------------ | | 132| 124k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE) | | ------------------ | | | | 131| 124k|#define MP_DIGIT_SIZE sizeof(mp_digit) | | ------------------ ------------------ 3241| | /* mask = (2**d - 1) * 2**(w-d) mod 2**w */ 3242| 124k| mask = (DIGIT_MAX << rshift) + 1; ------------------ | | 322| 124k|#define DIGIT_MAX MP_DIGIT_MAX | | ------------------ | | | | 74| 124k|#define MP_DIGIT_MAX ULONG_MAX | | ------------------ ------------------ 3243| 124k| mask &= DIGIT_MAX - 1; ------------------ | | 322| 124k|#define DIGIT_MAX MP_DIGIT_MAX | | ------------------ | | | | 74| 124k|#define MP_DIGIT_MAX ULONG_MAX | | ------------------ ------------------ 3244| | /* bits to be shifted out of the top word */ 3245| 124k| x = MP_DIGIT(mp, MP_USED(mp) - 1) & mask; ------------------ | | 148| 124k|#define MP_DIGIT(MP, N) (MP)->dp[(N)] ------------------ 3246| | 3247| 124k| if (MP_OKAY != (res = s_mp_pad(mp, MP_USED(mp) + dshift + (x != 0)))) ------------------ | | 39| 124k|#define MP_OKAY 0 /* no error, all is well */ ------------------ if (MP_OKAY != (res = s_mp_pad(mp, MP_USED(mp) + dshift + (x != 0)))) ------------------ | | 145| 124k|#define MP_USED(MP) ((MP)->used) ------------------ | Branch (3247:9): [True: 0, False: 124k] ------------------ 3248| 0| return res; 3249| | 3250| 124k| if (dshift && MP_OKAY != (res = s_mp_lshd(mp, dshift))) ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (3250:9): [True: 0, False: 124k] | Branch (3250:19): [True: 0, False: 0] ------------------ 3251| 0| return res; 3252| | 3253| 124k| pa = MP_DIGITS(mp) + dshift; ------------------ | | 147| 124k|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 3254| | 3255| 2.98M| for (i = MP_USED(mp) - dshift; i > 0; i--) { ------------------ | | 145| 124k|#define MP_USED(MP) ((MP)->used) ------------------ | Branch (3255:36): [True: 2.86M, False: 124k] ------------------ 3256| 2.86M| x = *pa; 3257| 2.86M| *pa++ = (x << d) | prev; 3258| 2.86M| prev = (x & mask) >> rshift; 3259| 2.86M| } 3260| | 3261| 124k| s_mp_clamp(mp); 3262| 124k| return MP_OKAY; ------------------ | | 39| 124k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 3263| 124k|} /* end s_mp_mul_2d() */ s_mp_rshd: 3275| 332k|{ 3276| 332k| mp_size ix; 3277| 332k| mp_digit *src, *dst; 3278| | 3279| 332k| if (p == 0) ------------------ | Branch (3279:9): [True: 332k, False: 0] ------------------ 3280| 332k| return; 3281| | 3282| | /* Shortcut when all digits are to be shifted off */ 3283| 0| if (p >= USED(mp)) { ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ | Branch (3283:9): [True: 0, False: 0] ------------------ 3284| 0| s_mp_setz(DIGITS(mp), ALLOC(mp)); ------------------ | | 330| 0|#define DIGITS(MP) MP_DIGITS(MP) | | ------------------ | | | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) | | ------------------ ------------------ s_mp_setz(DIGITS(mp), ALLOC(mp)); ------------------ | | 329| 0|#define ALLOC(MP) MP_ALLOC(MP) | | ------------------ | | | | 146| 0|#define MP_ALLOC(MP) ((MP)->alloc) | | ------------------ ------------------ 3285| 0| USED(mp) = 1; ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ 3286| 0| SIGN(mp) = ZPOS; ------------------ | | 327| 0|#define SIGN(MP) MP_SIGN(MP) | | ------------------ | | | | 144| 0|#define MP_SIGN(MP) ((MP)->sign) | | ------------------ ------------------ SIGN(mp) = ZPOS; ------------------ | | 321| 0|#define ZPOS MP_ZPOS | | ------------------ | | | | 37| 0|#define MP_ZPOS 0 | | ------------------ ------------------ 3287| 0| return; 3288| 0| } 3289| | 3290| | /* Shift all the significant figures over as needed */ 3291| 0| dst = MP_DIGITS(mp); ------------------ | | 147| 0|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 3292| 0| src = dst + p; 3293| 0| for (ix = USED(mp) - p; ix > 0; ix--) ------------------ | | 328| 0|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 0|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ | Branch (3293:29): [True: 0, False: 0] ------------------ 3294| 0| *dst++ = *src++; 3295| | 3296| 0| MP_USED(mp) -= p; ------------------ | | 145| 0|#define MP_USED(MP) ((MP)->used) ------------------ 3297| | /* Fill the top digits with zeroes */ 3298| 0| while (p-- > 0) ------------------ | Branch (3298:12): [True: 0, False: 0] ------------------ 3299| 0| *dst++ = 0; 3300| | 3301| 0|} /* end s_mp_rshd() */ s_mp_div_2d: 3395| 332k|{ 3396| 332k| int ix; 3397| 332k| mp_digit save, next, mask, lshift; 3398| | 3399| 332k| s_mp_rshd(mp, d / DIGIT_BIT); ------------------ | | 323| 332k|#define DIGIT_BIT MP_DIGIT_BIT | | ------------------ | | | | 132| 332k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE) | | | | ------------------ | | | | | | 131| 332k|#define MP_DIGIT_SIZE sizeof(mp_digit) | | | | ------------------ | | ------------------ ------------------ 3400| 332k| d %= DIGIT_BIT; ------------------ | | 323| 332k|#define DIGIT_BIT MP_DIGIT_BIT | | ------------------ | | | | 132| 332k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE) | | | | ------------------ | | | | | | 131| 332k|#define MP_DIGIT_SIZE sizeof(mp_digit) | | | | ------------------ | | ------------------ ------------------ 3401| | /* mp_digit << lshift is undefined behavior for lshift >= MP_DIGIT_BIT */ 3402| | /* mod and corresponding mask logic avoid that when d = 0 */ 3403| 332k| lshift = DIGIT_BIT - d; ------------------ | | 323| 332k|#define DIGIT_BIT MP_DIGIT_BIT | | ------------------ | | | | 132| 332k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE) | | | | ------------------ | | | | | | 131| 332k|#define MP_DIGIT_SIZE sizeof(mp_digit) | | | | ------------------ | | ------------------ ------------------ 3404| 332k| lshift %= DIGIT_BIT; ------------------ | | 323| 332k|#define DIGIT_BIT MP_DIGIT_BIT | | ------------------ | | | | 132| 332k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE) | | | | ------------------ | | | | | | 131| 332k|#define MP_DIGIT_SIZE sizeof(mp_digit) | | | | ------------------ | | ------------------ ------------------ 3405| 332k| mask = ((mp_digit)1 << d) - 1; 3406| 332k| save = 0; 3407| 8.96M| for (ix = USED(mp) - 1; ix >= 0; ix--) { ------------------ | | 328| 332k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 332k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ | Branch (3407:29): [True: 8.63M, False: 332k] ------------------ 3408| 8.63M| next = DIGIT(mp, ix) & mask; ------------------ | | 331| 8.63M|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 8.63M|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ 3409| 8.63M| DIGIT(mp, ix) = (save << lshift) | (DIGIT(mp, ix) >> d); ------------------ | | 331| 8.63M|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 8.63M|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ DIGIT(mp, ix) = (save << lshift) | (DIGIT(mp, ix) >> d); ------------------ | | 331| 8.63M|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 8.63M|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ 3410| 8.63M| save = next; 3411| 8.63M| } 3412| 332k| s_mp_clamp(mp); 3413| | 3414| 332k|} /* end s_mp_div_2d() */ s_mp_add_d: 3471| 124k|{ 3472| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_ADD_WORD) 3473| | mp_word w, k = 0; 3474| | mp_size ix = 1; 3475| | 3476| | w = (mp_word)DIGIT(mp, 0) + d; 3477| | DIGIT(mp, 0) = ACCUM(w); 3478| | k = CARRYOUT(w); 3479| | 3480| | while (ix < USED(mp) && k) { 3481| | w = (mp_word)DIGIT(mp, ix) + k; 3482| | DIGIT(mp, ix) = ACCUM(w); 3483| | k = CARRYOUT(w); 3484| | ++ix; 3485| | } 3486| | 3487| | if (k != 0) { 3488| | mp_err res; 3489| | 3490| | if ((res = s_mp_pad(mp, USED(mp) + 1)) != MP_OKAY) 3491| | return res; 3492| | 3493| | DIGIT(mp, ix) = (mp_digit)k; 3494| | } 3495| | 3496| | return MP_OKAY; 3497| |#else 3498| 124k| mp_digit *pmp = MP_DIGITS(mp); ------------------ | | 147| 124k|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 3499| 124k| mp_digit sum, mp_i, carry = 0; 3500| 124k| mp_err res = MP_OKAY; ------------------ | | 39| 124k|#define MP_OKAY 0 /* no error, all is well */ ------------------ 3501| 124k| int used = (int)MP_USED(mp); ------------------ | | 145| 124k|#define MP_USED(MP) ((MP)->used) ------------------ 3502| | 3503| 124k| mp_i = *pmp; 3504| 124k| *pmp++ = sum = d + mp_i; 3505| 124k| carry = (sum < d); 3506| 124k| while (carry && --used > 0) { ------------------ | Branch (3506:12): [True: 0, False: 124k] | Branch (3506:21): [True: 0, False: 0] ------------------ 3507| 0| mp_i = *pmp; 3508| 0| *pmp++ = sum = carry + mp_i; 3509| 0| carry = !sum; 3510| 0| } 3511| 124k| if (carry && !used) { ------------------ | Branch (3511:9): [True: 0, False: 124k] | Branch (3511:18): [True: 0, False: 0] ------------------ 3512| | /* mp is growing */ 3513| 0| used = MP_USED(mp); ------------------ | | 145| 0|#define MP_USED(MP) ((MP)->used) ------------------ 3514| 0| MP_CHECKOK(s_mp_pad(mp, used + 1)); ------------------ | | 314| 0| if (MP_OKAY > (res = (x))) \ | | ------------------ | | | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ | | ------------------ | | | Branch (314:9): [True: 0, False: 0] | | ------------------ | | 315| 0| goto CLEANUP ------------------ 3515| 0| MP_DIGIT(mp, used) = carry; ------------------ | | 148| 0|#define MP_DIGIT(MP, N) (MP)->dp[(N)] ------------------ 3516| 0| } 3517| 124k|CLEANUP: 3518| 124k| return res; 3519| 124k|#endif 3520| 124k|} /* end s_mp_add_d() */ s_mp_mul_d: 3580| 124k|{ 3581| 124k| mp_err res; 3582| 124k| mp_size used; 3583| 124k| int pow; 3584| | 3585| 124k| if (!d) { ------------------ | Branch (3585:9): [True: 0, False: 124k] ------------------ 3586| 0| mp_zero(a); 3587| 0| return MP_OKAY; ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ 3588| 0| } 3589| 124k| if (d == 1) ------------------ | Branch (3589:9): [True: 0, False: 124k] ------------------ 3590| 0| return MP_OKAY; ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ 3591| 124k| if (0 <= (pow = s_mp_ispow2d(d))) { ------------------ | Branch (3591:9): [True: 124k, False: 0] ------------------ 3592| 124k| return s_mp_mul_2d(a, (mp_digit)pow); 3593| 124k| } 3594| | 3595| 0| used = MP_USED(a); ------------------ | | 145| 0|#define MP_USED(MP) ((MP)->used) ------------------ 3596| 0| MP_CHECKOK(s_mp_pad(a, used + 1)); ------------------ | | 314| 0| if (MP_OKAY > (res = (x))) \ | | ------------------ | | | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ | | ------------------ | | | Branch (314:9): [True: 0, False: 0] | | ------------------ | | 315| 0| goto CLEANUP ------------------ 3597| | 3598| 0| s_mpv_mul_d(MP_DIGITS(a), used, d, MP_DIGITS(a)); ------------------ | | 189| 0| ((mp_digit *)c)[a_len] = s_mpv_mul_set_vec64(c, a, a_len, b) ------------------ 3599| | 3600| 0| s_mp_clamp(a); 3601| | 3602| 0|CLEANUP: 3603| 0| return res; 3604| | 3605| 0|} /* end s_mp_mul_d() */ s_mp_add_3arg: 3824| 287|{ 3825| 287| mp_digit *pa, *pb, *pc; 3826| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_ADD_WORD) 3827| | mp_word w = 0; 3828| |#else 3829| 287| mp_digit sum, carry = 0, d; 3830| 287|#endif 3831| 287| mp_size ix; 3832| 287| mp_size used; 3833| 287| mp_err res; 3834| | 3835| 287| MP_SIGN(c) = MP_SIGN(a); ------------------ | | 144| 287|#define MP_SIGN(MP) ((MP)->sign) ------------------ MP_SIGN(c) = MP_SIGN(a); ------------------ | | 144| 287|#define MP_SIGN(MP) ((MP)->sign) ------------------ 3836| 287| if (MP_USED(a) < MP_USED(b)) { ------------------ | | 145| 287|#define MP_USED(MP) ((MP)->used) ------------------ if (MP_USED(a) < MP_USED(b)) { ------------------ | | 145| 287|#define MP_USED(MP) ((MP)->used) ------------------ | Branch (3836:9): [True: 0, False: 287] ------------------ 3837| 0| const mp_int *xch = a; 3838| 0| a = b; 3839| 0| b = xch; 3840| 0| } 3841| | 3842| | /* Make sure a has enough precision for the output value */ 3843| 287| if (MP_OKAY != (res = s_mp_pad(c, MP_USED(a)))) ------------------ | | 39| 287|#define MP_OKAY 0 /* no error, all is well */ ------------------ if (MP_OKAY != (res = s_mp_pad(c, MP_USED(a)))) ------------------ | | 145| 287|#define MP_USED(MP) ((MP)->used) ------------------ | Branch (3843:9): [True: 0, False: 287] ------------------ 3844| 0| return res; 3845| | 3846| | /* 3847| | Add up all digits up to the precision of b. If b had initially 3848| | the same precision as a, or greater, we took care of it by the 3849| | exchange step above, so there is no problem. If b had initially 3850| | less precision, we'll have to make sure the carry out is duly 3851| | propagated upward among the higher-order digits of the sum. 3852| | */ 3853| 287| pa = MP_DIGITS(a); ------------------ | | 147| 287|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 3854| 287| pb = MP_DIGITS(b); ------------------ | | 147| 287|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 3855| 287| pc = MP_DIGITS(c); ------------------ | | 147| 287|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 3856| 287| used = MP_USED(b); ------------------ | | 145| 287|#define MP_USED(MP) ((MP)->used) ------------------ 3857| 574| for (ix = 0; ix < used; ix++) { ------------------ | Branch (3857:18): [True: 287, False: 287] ------------------ 3858| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_ADD_WORD) 3859| | w = w + *pa++ + *pb++; 3860| | *pc++ = ACCUM(w); 3861| | w = CARRYOUT(w); 3862| |#else 3863| 287| d = *pa++; 3864| 287| sum = d + *pb++; 3865| 287| d = (sum < d); /* detect overflow */ 3866| 287| *pc++ = sum += carry; 3867| 287| carry = d + (sum < carry); /* detect overflow */ 3868| 287|#endif 3869| 287| } 3870| | 3871| | /* If we run out of 'b' digits before we're actually done, make 3872| | sure the carries get propagated upward... 3873| | */ 3874| 1.18k| for (used = MP_USED(a); ix < used; ++ix) { ------------------ | | 145| 287|#define MP_USED(MP) ((MP)->used) ------------------ | Branch (3874:29): [True: 899, False: 287] ------------------ 3875| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_ADD_WORD) 3876| | w = w + *pa++; 3877| | *pc++ = ACCUM(w); 3878| | w = CARRYOUT(w); 3879| |#else 3880| 899| *pc++ = sum = carry + *pa++; 3881| 899| carry = (sum < carry); 3882| 899|#endif 3883| 899| } 3884| | 3885| |/* If there's an overall carry out, increase precision and include 3886| | it. We could have done this initially, but why touch the memory 3887| | allocator unless we're sure we have to? 3888| | */ 3889| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_ADD_WORD) 3890| | if (w) { 3891| | if ((res = s_mp_pad(c, used + 1)) != MP_OKAY) 3892| | return res; 3893| | 3894| | DIGIT(c, used) = (mp_digit)w; 3895| | ++used; 3896| | } 3897| |#else 3898| 287| if (carry) { ------------------ | Branch (3898:9): [True: 0, False: 287] ------------------ 3899| 0| if ((res = s_mp_pad(c, used + 1)) != MP_OKAY) ------------------ | | 39| 0|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (3899:13): [True: 0, False: 0] ------------------ 3900| 0| return res; 3901| | 3902| 0| DIGIT(c, used) = carry; ------------------ | | 331| 0|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 0|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ 3903| 0| ++used; 3904| 0| } 3905| 287|#endif 3906| 287| MP_USED(c) = used; ------------------ | | 145| 287|#define MP_USED(MP) ((MP)->used) ------------------ 3907| 287| return MP_OKAY; ------------------ | | 39| 287|#define MP_OKAY 0 /* no error, all is well */ ------------------ 3908| 287|} s_mp_sub_3arg: 4068| 2.60k|{ 4069| 2.60k| mp_digit *pa, *pb, *pc; 4070| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_SUB_WORD) 4071| | mp_sword w = 0; 4072| |#else 4073| 2.60k| mp_digit d, diff, borrow = 0; 4074| 2.60k|#endif 4075| 2.60k| int ix, limit; 4076| 2.60k| mp_err res; 4077| | 4078| 2.60k| MP_SIGN(c) = MP_SIGN(a); ------------------ | | 144| 2.60k|#define MP_SIGN(MP) ((MP)->sign) ------------------ MP_SIGN(c) = MP_SIGN(a); ------------------ | | 144| 2.60k|#define MP_SIGN(MP) ((MP)->sign) ------------------ 4079| | 4080| | /* Make sure a has enough precision for the output value */ 4081| 2.60k| if (MP_OKAY != (res = s_mp_pad(c, MP_USED(a)))) ------------------ | | 39| 2.60k|#define MP_OKAY 0 /* no error, all is well */ ------------------ if (MP_OKAY != (res = s_mp_pad(c, MP_USED(a)))) ------------------ | | 145| 2.60k|#define MP_USED(MP) ((MP)->used) ------------------ | Branch (4081:9): [True: 0, False: 2.60k] ------------------ 4082| 0| return res; 4083| | 4084| | /* 4085| | Subtract and propagate borrow. Up to the precision of b, this 4086| | accounts for the digits of b; after that, we just make sure the 4087| | carries get to the right place. This saves having to pad b out to 4088| | the precision of a just to make the loops work right... 4089| | */ 4090| 2.60k| pa = MP_DIGITS(a); ------------------ | | 147| 2.60k|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 4091| 2.60k| pb = MP_DIGITS(b); ------------------ | | 147| 2.60k|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 4092| 2.60k| pc = MP_DIGITS(c); ------------------ | | 147| 2.60k|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 4093| 2.60k| limit = MP_USED(b); ------------------ | | 145| 2.60k|#define MP_USED(MP) ((MP)->used) ------------------ 4094| 16.5k| for (ix = 0; ix < limit; ++ix) { ------------------ | Branch (4094:18): [True: 13.9k, False: 2.60k] ------------------ 4095| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_SUB_WORD) 4096| | w = w + *pa++ - *pb++; 4097| | *pc++ = ACCUM(w); 4098| | w >>= MP_DIGIT_BIT; 4099| |#else 4100| 13.9k| d = *pa++; 4101| 13.9k| diff = d - *pb++; 4102| 13.9k| d = (diff > d); 4103| 13.9k| if (borrow && --diff == MP_DIGIT_MAX) ------------------ | | 74| 5.22k|#define MP_DIGIT_MAX ULONG_MAX ------------------ | Branch (4103:13): [True: 5.22k, False: 8.68k] | Branch (4103:23): [True: 1.45k, False: 3.77k] ------------------ 4104| 1.45k| ++d; 4105| 13.9k| *pc++ = diff; 4106| 13.9k| borrow = d; 4107| 13.9k|#endif 4108| 13.9k| } 4109| 4.26k| for (limit = MP_USED(a); ix < limit; ++ix) { ------------------ | | 145| 2.60k|#define MP_USED(MP) ((MP)->used) ------------------ | Branch (4109:30): [True: 1.65k, False: 2.60k] ------------------ 4110| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_SUB_WORD) 4111| | w = w + *pa++; 4112| | *pc++ = ACCUM(w); 4113| | w >>= MP_DIGIT_BIT; 4114| |#else 4115| 1.65k| d = *pa++; 4116| 1.65k| *pc++ = diff = d - borrow; 4117| 1.65k| borrow = (diff > d); 4118| 1.65k|#endif 4119| 1.65k| } 4120| | 4121| | /* Clobber any leading zeroes we created */ 4122| 2.60k| MP_USED(c) = ix; ------------------ | | 145| 2.60k|#define MP_USED(MP) ((MP)->used) ------------------ 4123| 2.60k| s_mp_clamp(c); 4124| | 4125| |/* 4126| | If there was a borrow out, then |b| > |a| in violation 4127| | of our input invariant. We've already done the work, 4128| | but we'll at least complain about it... 4129| | */ 4130| |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_SUB_WORD) 4131| | return w ? MP_RANGE : MP_OKAY; 4132| |#else 4133| 2.60k| return borrow ? MP_RANGE : MP_OKAY; ------------------ | | 43| 0|#define MP_RANGE -3 /* argument out of range */ ------------------ return borrow ? MP_RANGE : MP_OKAY; ------------------ | | 39| 2.60k|#define MP_OKAY 0 /* no error, all is well */ ------------------ | Branch (4133:12): [True: 0, False: 2.60k] ------------------ 4134| 2.60k|#endif 4135| 2.60k|} s_mp_cmp: 4742| 4.09k|{ 4743| 4.09k| ARGMPCHK(a != NULL && b != NULL); ------------------ | | 349| 4.09k|#define ARGMPCHK(X) assert(X) ------------------ 4744| | 4745| 4.09k| mp_size used_a = MP_USED(a); ------------------ | | 145| 4.09k|#define MP_USED(MP) ((MP)->used) ------------------ 4746| 4.09k| { 4747| 4.09k| mp_size used_b = MP_USED(b); ------------------ | | 145| 4.09k|#define MP_USED(MP) ((MP)->used) ------------------ 4748| | 4749| 4.09k| if (used_a > used_b) ------------------ | Branch (4749:13): [True: 321, False: 3.76k] ------------------ 4750| 321| goto IS_GT; 4751| 3.76k| if (used_a < used_b) ------------------ | Branch (4751:13): [True: 130, False: 3.63k] ------------------ 4752| 130| goto IS_LT; 4753| 3.76k| } 4754| 3.63k| { 4755| 3.63k| mp_digit *pa, *pb; 4756| 3.63k| mp_digit da = 0, db = 0; 4757| | 4758| 3.63k|#define CMP_AB(n) \ 4759| 3.63k| if ((da = pa[n]) != (db = pb[n])) \ 4760| 3.63k| goto done 4761| | 4762| 3.63k| pa = MP_DIGITS(a) + used_a; ------------------ | | 147| 3.63k|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 4763| 3.63k| pb = MP_DIGITS(b) + used_a; ------------------ | | 147| 3.63k|#define MP_DIGITS(MP) ((MP)->dp) ------------------ 4764| 5.12k| while (used_a >= 4) { ------------------ | Branch (4764:16): [True: 2.43k, False: 2.68k] ------------------ 4765| 2.43k| pa -= 4; 4766| 2.43k| pb -= 4; 4767| 2.43k| used_a -= 4; 4768| 2.43k| CMP_AB(3); ------------------ | | 4759| 2.43k| if ((da = pa[n]) != (db = pb[n])) \ | | ------------------ | | | Branch (4759:9): [True: 354, False: 2.08k] | | ------------------ | | 4760| 2.43k| goto done ------------------ 4769| 2.08k| CMP_AB(2); ------------------ | | 4759| 2.08k| if ((da = pa[n]) != (db = pb[n])) \ | | ------------------ | | | Branch (4759:9): [True: 204, False: 1.87k] | | ------------------ | | 4760| 2.08k| goto done ------------------ 4770| 1.87k| CMP_AB(1); ------------------ | | 4759| 1.87k| if ((da = pa[n]) != (db = pb[n])) \ | | ------------------ | | | Branch (4759:9): [True: 202, False: 1.67k] | | ------------------ | | 4760| 1.87k| goto done ------------------ 4771| 1.67k| CMP_AB(0); ------------------ | | 4759| 1.67k| if ((da = pa[n]) != (db = pb[n])) \ | | ------------------ | | | Branch (4759:9): [True: 192, False: 1.48k] | | ------------------ | | 4760| 1.67k| goto done ------------------ 4772| 1.67k| } 4773| 4.91k| while (used_a-- > 0 && ((da = *--pa) == (db = *--pb))) ------------------ | Branch (4773:16): [True: 3.43k, False: 1.48k] | Branch (4773:32): [True: 2.23k, False: 1.19k] ------------------ 4774| 2.23k| /* do nothing */; 4775| 3.63k| done: 4776| 3.63k| if (da > db) ------------------ | Branch (4776:13): [True: 1.23k, False: 2.40k] ------------------ 4777| 1.23k| goto IS_GT; 4778| 2.40k| if (da < db) ------------------ | Branch (4778:13): [True: 914, False: 1.48k] ------------------ 4779| 914| goto IS_LT; 4780| 2.40k| } 4781| 1.48k| return MP_EQ; ------------------ | | 96| 1.48k|#define MP_EQ 0 ------------------ 4782| 1.04k|IS_LT: 4783| 1.04k| return MP_LT; ------------------ | | 95| 1.04k|#define MP_LT -1 ------------------ 4784| 1.55k|IS_GT: 4785| 1.55k| return MP_GT; ------------------ | | 97| 1.55k|#define MP_GT 1 ------------------ 4786| 2.40k|} /* end s_mp_cmp() */ s_mp_cmp_d: 4795| 128k|{ 4796| 128k| ARGMPCHK(a != NULL); ------------------ | | 349| 128k|#define ARGMPCHK(X) assert(X) ------------------ 4797| | 4798| 128k| if (USED(a) > 1) ------------------ | | 328| 128k|#define USED(MP) MP_USED(MP) | | ------------------ | | | | 145| 128k|#define MP_USED(MP) ((MP)->used) | | ------------------ ------------------ | Branch (4798:9): [True: 95.1k, False: 33.6k] ------------------ 4799| 95.1k| return MP_GT; ------------------ | | 97| 95.1k|#define MP_GT 1 ------------------ 4800| | 4801| 33.6k| if (DIGIT(a, 0) < d) ------------------ | | 331| 33.6k|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 33.6k|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ | Branch (4801:9): [True: 0, False: 33.6k] ------------------ 4802| 0| return MP_LT; ------------------ | | 95| 0|#define MP_LT -1 ------------------ 4803| 33.6k| else if (DIGIT(a, 0) > d) ------------------ | | 331| 33.6k|#define DIGIT(MP, N) MP_DIGIT(MP, N) | | ------------------ | | | | 148| 33.6k|#define MP_DIGIT(MP, N) (MP)->dp[(N)] | | ------------------ ------------------ | Branch (4803:14): [True: 19.7k, False: 13.8k] ------------------ 4804| 19.7k| return MP_GT; ------------------ | | 97| 19.7k|#define MP_GT 1 ------------------ 4805| 13.8k| else 4806| 13.8k| return MP_EQ; ------------------ | | 96| 13.8k|#define MP_EQ 0 ------------------ 4807| | 4808| 33.6k|} /* end s_mp_cmp_d() */ s_mp_ispow2d: 4849| 456k|{ 4850| 456k| if ((d != 0) && ((d & (d - 1)) == 0)) { /* d is a power of 2 */ ------------------ | Branch (4850:9): [True: 456k, False: 0] | Branch (4850:21): [True: 456k, False: 0] ------------------ 4851| 456k| int pow = 0; 4852| |#if defined(MP_USE_UINT_DIGIT) 4853| | if (d & 0xffff0000U) 4854| | pow += 16; 4855| | if (d & 0xff00ff00U) 4856| | pow += 8; 4857| | if (d & 0xf0f0f0f0U) 4858| | pow += 4; 4859| | if (d & 0xccccccccU) 4860| | pow += 2; 4861| | if (d & 0xaaaaaaaaU) 4862| | pow += 1; 4863| |#elif defined(MP_USE_LONG_LONG_DIGIT) 4864| | if (d & 0xffffffff00000000ULL) 4865| | pow += 32; 4866| | if (d & 0xffff0000ffff0000ULL) 4867| | pow += 16; 4868| | if (d & 0xff00ff00ff00ff00ULL) 4869| | pow += 8; 4870| | if (d & 0xf0f0f0f0f0f0f0f0ULL) 4871| | pow += 4; 4872| | if (d & 0xccccccccccccccccULL) 4873| | pow += 2; 4874| | if (d & 0xaaaaaaaaaaaaaaaaULL) 4875| | pow += 1; 4876| |#elif defined(MP_USE_LONG_DIGIT) 4877| 456k| if (d & 0xffffffff00000000UL) ------------------ | Branch (4877:13): [True: 0, False: 456k] ------------------ 4878| 0| pow += 32; 4879| 456k| if (d & 0xffff0000ffff0000UL) ------------------ | Branch (4879:13): [True: 0, False: 456k] ------------------ 4880| 0| pow += 16; 4881| 456k| if (d & 0xff00ff00ff00ff00UL) ------------------ | Branch (4881:13): [True: 124k, False: 332k] ------------------ 4882| 124k| pow += 8; 4883| 456k| if (d & 0xf0f0f0f0f0f0f0f0UL) ------------------ | Branch (4883:13): [True: 332k, False: 124k] ------------------ 4884| 332k| pow += 4; 4885| 456k| if (d & 0xccccccccccccccccUL) ------------------ | Branch (4885:13): [True: 0, False: 456k] ------------------ 4886| 0| pow += 2; 4887| 456k| if (d & 0xaaaaaaaaaaaaaaaaUL) ------------------ | Branch (4887:13): [True: 0, False: 456k] ------------------ 4888| 0| pow += 1; 4889| |#else 4890| |#error "unknown type for mp_digit" 4891| |#endif 4892| 456k| return pow; 4893| 456k| } 4894| 0| return -1; 4895| | 4896| 456k|} /* end s_mp_ispow2d() */ s_mp_todigit: 4959| 332k|{ 4960| 332k| char ch; 4961| | 4962| 332k| if (val >= r) ------------------ | Branch (4962:9): [True: 0, False: 332k] ------------------ 4963| 0| return 0; 4964| | 4965| 332k| ch = s_dmap_1[val]; 4966| | 4967| 332k| if (r <= 36 && low) ------------------ | Branch (4967:9): [True: 332k, False: 0] | Branch (4967:20): [True: 0, False: 332k] ------------------ 4968| 0| ch = tolower(ch); 4969| | 4970| 332k| return ch; 4971| | 4972| 332k|} /* end s_mp_todigit() */