crypto/bn/bntest.c:1695: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_mod_exp_recp`.
Showing all 17 steps of the trace


crypto/bn/bntest.c:1653:1: Parameter `ctx->stack.depth`
1651.   	}
1652.   
1653. > int test_kron(BIO *bp, BN_CTX *ctx)
1654.   	{
1655.   	BN_GENCB cb;

crypto/bn/bntest.c:1695:8: Call
1693.   		b->neg=0;
1694.   		
1695.   		if (!BN_mod_exp_recp(r, a, t, b, ctx)) goto err;
               ^
1696.   		b->neg=1;
1697.   

crypto/bn/bn_exp.c:252:1: Parameter `ctx->stack.depth`
  250.   
  251.   
  252. > int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
  253.   		    const BIGNUM *m, BN_CTX *ctx)
  254.   	{

crypto/bn/bn_exp.c:277:2: Call
  275.   		}
  276.   
  277.   	BN_CTX_start(ctx);
          ^
  278.   	aa = BN_CTX_get(ctx);
  279.   	val[0] = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:257:1: Parameter `ctx->stack.depth`
    255.   	}
    256.   
    257. > void BN_CTX_start(BN_CTX *ctx)
    258.   	{
    259.   	CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_exp.c:295:7: Call
  293.   		}
  294.   
  295.   	if (!BN_nnmod(val[0],a,m,ctx)) goto err;		/* 1 */
               ^
  296.   	if (BN_is_zero(val[0]))
  297.   		{

crypto/bn/bn_mod.c:129:1: Parameter `ctx->stack.depth`
    127.   
    128.   
    129. > int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
    130.   	{
    131.   	/* like BN_mod, but returns non-negative remainder

crypto/bn/bn_mod.c:134:8: Call
    132.   	 * (i.e.,  0 <= r < |d|  always holds) */
    133.   
    134.   	if (!(BN_mod(r,m,d,ctx)))
                  ^
    135.   		return 0;
    136.   	if (!r->neg)

crypto/bn/bn_div.c:183:1: Parameter `ctx->stack.depth`
      181.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
      182.    */
      183. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
      184.   	   BN_CTX *ctx)
      185.   	{

crypto/bn/bn_div.c:228:2: Call
      226.   		}
      227.   
      228.   	BN_CTX_start(ctx);
              ^
      229.   	tmp=BN_CTX_get(ctx);
      230.   	snum=BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:257:1: Parameter `ctx->stack.depth`
        255.   	}
        256.   
        257. > void BN_CTX_start(BN_CTX *ctx)
        258.   	{
        259.   	CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_div.c:443:2: Call
      441.   		}
      442.   	if (no_branch)	bn_correct_top(res);
      443.   	BN_CTX_end(ctx);
              ^
      444.   	return(1);
      445.   err:

crypto/bn/bn_ctx.c:272:1: Parameter `ctx->stack.depth`
        270.   	}
        271.   
        272. > void BN_CTX_end(BN_CTX *ctx)
        273.   	{
        274.   	CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:279:21: Call
        277.   	else
        278.   		{
        279.   		unsigned int fp = BN_STACK_pop(&ctx->stack);
                                   ^
        280.   		/* Does this stack frame have anything to release? */
        281.   		if(fp < ctx->used)

crypto/bn/bn_ctx.c:353:1: <LHS trace>
351.   	}
352.   
353. > static unsigned int BN_STACK_pop(BN_STACK *st)
354.   	{
355.   	return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:353:1: Parameter `st->depth`
          351.   	}
          352.   
          353. > static unsigned int BN_STACK_pop(BN_STACK *st)
          354.   	{
          355.   	return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:355:9: Binary operation: ([0, +oo] - 1):unsigned32 by call to `BN_mod_exp_recp` 
          353.   static unsigned int BN_STACK_pop(BN_STACK *st)
          354.   	{
          355.   	return st->indexes[--(st->depth)];
                         ^
          356.   	}
          357.   
