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


crypto/bn/bntest.c:982:1: Parameter `ctx->stack.depth`
980.   	}
981.   
982. > int test_mod_exp(BIO *bp, BN_CTX *ctx)
983.   	{
984.   	BIGNUM *a,*b,*c,*d,*e;

crypto/bn/bntest.c:999:8: Call
997.   		BN_bntest_rand(b,2+i,0,0);
998.   
999.   		if (!BN_mod_exp(d,a,b,c,ctx))
               ^
1000.   			return(0);
1001.   

crypto/bn/bn_exp.c:194:1: Parameter `ctx->stack.depth`
  192.   
  193.   
  194. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  195.   	       BN_CTX *ctx)
  196.   	{

crypto/bn/bn_exp.c:260:9: Call
  258.   #endif
  259.   #ifdef RECP_MUL_MOD
  260.   		{ ret=BN_mod_exp_recp(r,a,p,m,ctx); }
                 ^
  261.   #else
  262.   		{ ret=BN_mod_exp_simple(r,a,p,m,ctx); }

crypto/bn/bn_exp.c:270:1: Parameter `ctx->stack.depth`
    268.   
    269.   
    270. > int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    271.   		    const BIGNUM *m, BN_CTX *ctx)
    272.   	{

crypto/bn/bn_exp.c:295:2: Call
    293.   		}
    294.   
    295.   	BN_CTX_start(ctx);
            ^
    296.   	aa = BN_CTX_get(ctx);
    297.   	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:313:7: Call
    311.   		}
    312.   
    313.   	if (!BN_nnmod(val[0],a,m,ctx)) goto err;		/* 1 */
                 ^
    314.   	if (BN_is_zero(val[0]))
    315.   		{

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:230:2: Call
        228.   		}
        229.   
        230.   	BN_CTX_start(ctx);
                ^
        231.   	tmp=BN_CTX_get(ctx);
        232.   	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:445:2: Call
        443.   		}
        444.   	if (no_branch)	bn_correct_top(res);
        445.   	BN_CTX_end(ctx);
                ^
        446.   	return(1);
        447.   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` 
            353.   static unsigned int BN_STACK_pop(BN_STACK *st)
            354.   	{
            355.   	return st->indexes[--(st->depth)];
                           ^
            356.   	}
            357.   
