test/bntest.c:1882: error: INTEGER_OVERFLOW_L2
  (0 - [0, 1]):unsigned64 by call to `BN_mod_mul`.
Showing all 15 steps of the trace


test/bntest.c:1882:39: Call
1880.       ERR_clear_error();
1881.   
1882.       if (BN_mod_mul(a, BN_value_one(), BN_value_one(), zero, ctx)) {
                                              ^
1883.           fprintf(stderr, "BN_mod_mul with zero modulus succeeded!\n");
1884.           goto err;

crypto/bn/bn_lib.c:82:5: Assignment
  80.   const BIGNUM *BN_value_one(void)
  81.   {
  82.       static const BN_ULONG data_one = 1L;
            ^
  83.       static const BIGNUM const_one =
  84.           { (BN_ULONG *)&data_one, 1, 1, 0, BN_FLG_STATIC_DATA };

test/bntest.c:1882:9: Call
1880.       ERR_clear_error();
1881.   
1882.       if (BN_mod_mul(a, BN_value_one(), BN_value_one(), zero, ctx)) {
                ^
1883.           fprintf(stderr, "BN_mod_mul with zero modulus succeeded!\n");
1884.           goto err;

crypto/bn/bn_mod.c:73:1: Parameter `*b->d`
  71.   
  72.   /* slow but works */
  73. > int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
  74.                  BN_CTX *ctx)
  75.   {

crypto/bn/bn_mod.c:90:14: Call
  88.               goto err;
  89.       } else {
  90.           if (!BN_mul(t, a, b, ctx))
                     ^
  91.               goto err;
  92.       }

crypto/bn/bn_mul.c:828:1: Parameter `*b->d`
    826.   #endif                          /* BN_RECURSION */
    827.   
    828. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    829.   {
    830.       int ret = 0;

crypto/bn/bn_mul.c:909:17: Call
    907.                   if (bn_wexpand(rr, k * 4) == NULL)
    908.                       goto err;
    909.                   bn_mul_part_recursive(rr->d, a->d, b->d,
                           ^
    910.                                         j, al - j, bl - j, t->d);
    911.               } else {            /* al <= j || bl <= j */

crypto/bn/bn_mul.c:480:1: Parameter `*b`
      478.    */
      479.   /* tnX may not be negative but less than n */
      480. > void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n,
      481.                              int tna, int tnb, BN_ULONG *t)
      482.   {

crypto/bn/bn_mul.c:494:10: Call
      492.       /* r=(a[0]-a[1])*(b[1]-b[0]) */
      493.       c1 = bn_cmp_part_words(a, &(a[n]), tna, n - tna);
      494.       c2 = bn_cmp_part_words(&(b[n]), b, tnb, tnb - n);
                      ^
      495.       neg = 0;
      496.       switch (c1 * 3 + c2) {

crypto/bn/bn_lib.c:803:1: Parameter `*b`
        801.    */
        802.   
        803. > int bn_cmp_part_words(const BN_ULONG *a, const BN_ULONG *b, int cl, int dl)
        804.   {
        805.       int n, i;

crypto/bn/bn_mul.c:499:9: Call
      497.       case -4:
      498.           bn_sub_part_words(t, &(a[n]), a, tna, tna - n); /* - */
      499.           bn_sub_part_words(&(t[n]), b, &(b[n]), tnb, n - tnb); /* - */
                     ^
      500.           break;
      501.       case -3:

crypto/bn/bn_mul.c:27:1: <RHS trace>
25.    */
26.   
27. > BN_ULONG bn_sub_part_words(BN_ULONG *r,
28.                              const BN_ULONG *a, const BN_ULONG *b,
29.                              int cl, int dl)

crypto/bn/bn_mul.c:27:1: Parameter `*b`
        25.    */
        26.   
        27. > BN_ULONG bn_sub_part_words(BN_ULONG *r,
        28.                              const BN_ULONG *a, const BN_ULONG *b,
        29.                              int cl, int dl)

crypto/bn/bn_mul.c:45:13: Assignment
        43.       if (dl < 0) {
        44.           for (;;) {
        45.               t = b[0];
                          ^
        46.               r[0] = (0 - t - c) & BN_MASK2;
        47.               if (t != 0)

crypto/bn/bn_mul.c:46:13: Binary operation: (0 - [0, 1]):unsigned64 by call to `BN_mod_mul` 
        44.           for (;;) {
        45.               t = b[0];
        46.               r[0] = (0 - t - c) & BN_MASK2;
                          ^
        47.               if (t != 0)
        48.                   c = 1;
