test/bntest.c:802: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_GF2m_mod_div`.
Showing all 34 steps of the trace


test/bntest.c:802:13: Call
800.           BN_bntest_rand(c, 512, 0, 0);
801.           for (j = 0; j < 2; j++) {
802.               BN_GF2m_mod_div(d, a, c, b[j], ctx);
                   ^
803.               BN_GF2m_mod_mul(e, d, c, b[j], ctx);
804.               BN_GF2m_mod_div(f, a, e, b[j], ctx);

crypto/bn/bn_gf2m.c:790:1: Parameter `ctx->stack.depth`
  788.    * or y, x could equal y.
  789.    */
  790. > int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *y, const BIGNUM *x,
  791.                       const BIGNUM *p, BN_CTX *ctx)
  792.   {

crypto/bn/bn_gf2m.c:800:5: Call
  798.       bn_check_top(p);
  799.   
  800.       BN_CTX_start(ctx);
             ^
  801.       xinv = BN_CTX_get(ctx);
  802.       if (xinv == NULL)

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
    169.   }
    170.   
    171. > void BN_CTX_start(BN_CTX *ctx)
    172.   {
    173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_gf2m.c:813:5: Call
  811.   
  812.    err:
  813.       BN_CTX_end(ctx);
             ^
  814.       return ret;
  815.   }

crypto/bn/bn_ctx.c:185:1: Parameter `ctx->stack.depth`
    183.   }
    184.   
    185. > void BN_CTX_end(BN_CTX *ctx)
    186.   {
    187.       CTXDBG("ENTER BN_CTX_end()", ctx);

test/bntest.c:803:13: Call
801.           for (j = 0; j < 2; j++) {
802.               BN_GF2m_mod_div(d, a, c, b[j], ctx);
803.               BN_GF2m_mod_mul(e, d, c, b[j], ctx);
                   ^
804.               BN_GF2m_mod_div(f, a, e, b[j], ctx);
805.               /* Test that ((a/c)*c)/a = 1. */

crypto/bn/bn_gf2m.c:465:1: Parameter `ctx->stack.depth`
  463.    * BN_GF2m_mod_mul_arr function.
  464.    */
  465. > int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
  466.                       const BIGNUM *p, BN_CTX *ctx)
  467.   {

test/bntest.c:804:13: Call
802.               BN_GF2m_mod_div(d, a, c, b[j], ctx);
803.               BN_GF2m_mod_mul(e, d, c, b[j], ctx);
804.               BN_GF2m_mod_div(f, a, e, b[j], ctx);
                   ^
805.               /* Test that ((a/c)*c)/a = 1. */
806.               if (!TEST_BN_eq_one(f))

crypto/bn/bn_gf2m.c:790:1: Parameter `ctx->stack.depth`
  788.    * or y, x could equal y.
  789.    */
  790. > int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *y, const BIGNUM *x,
  791.                       const BIGNUM *p, BN_CTX *ctx)
  792.   {

crypto/bn/bn_gf2m.c:800:5: Call
  798.       bn_check_top(p);
  799.   
  800.       BN_CTX_start(ctx);
             ^
  801.       xinv = BN_CTX_get(ctx);
  802.       if (xinv == NULL)

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
    169.   }
    170.   
    171. > void BN_CTX_start(BN_CTX *ctx)
    172.   {
    173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_gf2m.c:813:5: Call
  811.   
  812.    err:
  813.       BN_CTX_end(ctx);
             ^
  814.       return ret;
  815.   }

crypto/bn/bn_ctx.c:185:1: Parameter `ctx->stack.depth`
    183.   }
    184.   
    185. > void BN_CTX_end(BN_CTX *ctx)
    186.   {
    187.       CTXDBG("ENTER BN_CTX_end()", ctx);

test/bntest.c:802:13: Call
800.           BN_bntest_rand(c, 512, 0, 0);
801.           for (j = 0; j < 2; j++) {
802.               BN_GF2m_mod_div(d, a, c, b[j], ctx);
                   ^
803.               BN_GF2m_mod_mul(e, d, c, b[j], ctx);
804.               BN_GF2m_mod_div(f, a, e, b[j], ctx);

crypto/bn/bn_gf2m.c:790:1: Parameter `ctx->stack.depth`
  788.    * or y, x could equal y.
  789.    */
  790. > int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *y, const BIGNUM *x,
  791.                       const BIGNUM *p, BN_CTX *ctx)
  792.   {

crypto/bn/bn_gf2m.c:800:5: Call
  798.       bn_check_top(p);
  799.   
  800.       BN_CTX_start(ctx);
             ^
  801.       xinv = BN_CTX_get(ctx);
  802.       if (xinv == NULL)

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
    169.   }
    170.   
    171. > void BN_CTX_start(BN_CTX *ctx)
    172.   {
    173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_gf2m.c:805:10: Call
  803.           goto err;
  804.   
  805.       if (!BN_GF2m_mod_inv(xinv, x, p, ctx))
                  ^
  806.           goto err;
  807.       if (!BN_GF2m_mod_mul(r, y, xinv, p, ctx))

crypto/bn/bn_gf2m.c:724:1: Parameter `ctx->stack.depth`
    722.    * But it does eliminate first order deduction on the input.
    723.    */
    724. > int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx)
    725.   {
    726.       BIGNUM *b = NULL;

crypto/bn/bn_gf2m.c:729:5: Call
    727.       int ret = 0;
    728.   
    729.       BN_CTX_start(ctx);
               ^
    730.       if ((b = BN_CTX_get(ctx)) == NULL)
    731.           goto err;

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
      169.   }
      170.   
      171. > void BN_CTX_start(BN_CTX *ctx)
      172.   {
      173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_gf2m.c:741:10: Call
    739.   
    740.       /* r := a * b */
    741.       if (!BN_GF2m_mod_mul(r, a, b, p, ctx))
                    ^
    742.           goto err;
    743.   

crypto/bn/bn_gf2m.c:465:1: Parameter `ctx->stack.depth`
      463.    * BN_GF2m_mod_mul_arr function.
      464.    */
      465. > int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
      466.                       const BIGNUM *p, BN_CTX *ctx)
      467.   {

crypto/bn/bn_gf2m.c:481:11: Call
      479.           goto err;
      480.       }
      481.       ret = BN_GF2m_mod_mul_arr(r, a, b, arr, ctx);
                       ^
      482.       bn_check_top(r);
      483.    err:

crypto/bn/bn_gf2m.c:410:1: Parameter `ctx->stack.depth`
        408.    * the result in r.  r could be a or b; a could be b.
        409.    */
        410. > int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
        411.                           const int p[], BN_CTX *ctx)
        412.   {

crypto/bn/bn_gf2m.c:424:5: Call
        422.       }
        423.   
        424.       BN_CTX_start(ctx);
                   ^
        425.       if ((s = BN_CTX_get(ctx)) == NULL)
        426.           goto err;

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
          169.   }
          170.   
          171. > void BN_CTX_start(BN_CTX *ctx)
          172.   {
          173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_gf2m.c:454:5: Call
        452.   
        453.    err:
        454.       BN_CTX_end(ctx);
                   ^
        455.       return ret;
        456.   }

crypto/bn/bn_ctx.c:185:1: Parameter `ctx->stack.depth`
          183.   }
          184.   
          185. > void BN_CTX_end(BN_CTX *ctx)
          186.   {
          187.       CTXDBG("ENTER BN_CTX_end()", ctx);

crypto/bn/bn_ctx.c:191:27: Call
          189.           ctx->err_stack--;
          190.       else {
          191.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                           ^
          192.           /* Does this stack frame have anything to release? */
          193.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:266:1: <LHS trace>
264.   }
265.   
266. > static unsigned int BN_STACK_pop(BN_STACK *st)
267.   {
268.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:266:1: Parameter `st->depth`
            264.   }
            265.   
            266. > static unsigned int BN_STACK_pop(BN_STACK *st)
            267.   {
            268.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:268:12: Binary operation: ([0, +oo] - 1):unsigned32 by call to `BN_GF2m_mod_div` 
            266.   static unsigned int BN_STACK_pop(BN_STACK *st)
            267.   {
            268.       return st->indexes[--(st->depth)];
                              ^
            269.   }
            270.   
