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


crypto/bn/bn_sqrt.c:128:7: Call
126.   
127.   	/* A = a mod p */
128.   	if (!BN_nnmod(A, a, p, ctx)) goto end;
             ^
129.   
130.   	/* now write  |p| - 1  as  2^e*q  where  q  is odd */

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->pool.used`
    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_sqrt.c:148:8: Call
146.   		q->neg = 0;
147.   		if (!BN_add_word(q, 1)) goto end;
148.   		if (!BN_mod_exp(ret, A, q, p, ctx)) goto end;
              ^
149.   		err = 0;
150.   		goto vrfy;

crypto/bn/bn_exp.c:177:1: Parameter `ctx->pool.used`
  175.   
  176.   
  177. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  178.   	       BN_CTX *ctx)
  179.   	{

crypto/bn/bn_exp.c:242:9: Call
  240.   #endif
  241.   #ifdef RECP_MUL_MOD
  242.   		{ ret=BN_mod_exp_recp(r,a,p,m,ctx); }
                 ^
  243.   #else
  244.   		{ ret=BN_mod_exp_simple(r,a,p,m,ctx); }

crypto/bn/bn_exp.c:252:1: Parameter `ctx->pool.used`
    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:278:7: Call
    276.   
    277.   	BN_CTX_start(ctx);
    278.   	aa = BN_CTX_get(ctx);
                 ^
    279.   	val[0] = BN_CTX_get(ctx);
    280.   	if(!aa || !val[0]) goto err;

crypto/bn/bn_ctx.c:290:1: Parameter `ctx->pool.used`
      288.   	}
      289.   
      290. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
      291.   	{
      292.   	BIGNUM *ret;

crypto/bn/bn_exp.c:279:11: Call
    277.   	BN_CTX_start(ctx);
    278.   	aa = BN_CTX_get(ctx);
    279.   	val[0] = BN_CTX_get(ctx);
                     ^
    280.   	if(!aa || !val[0]) goto err;
    281.   

crypto/bn/bn_ctx.c:290:1: Parameter `ctx->pool.used`
      288.   	}
      289.   
      290. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
      291.   	{
      292.   	BIGNUM *ret;

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->pool.used`
      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->pool.used`
        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:229:6: Call
        227.   
        228.   	BN_CTX_start(ctx);
        229.   	tmp=BN_CTX_get(ctx);
                    ^
        230.   	snum=BN_CTX_get(ctx);
        231.   	sdiv=BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:290:1: Parameter `ctx->pool.used`
          288.   	}
          289.   
          290. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
          291.   	{
          292.   	BIGNUM *ret;

crypto/bn/bn_div.c:230:7: Call
        228.   	BN_CTX_start(ctx);
        229.   	tmp=BN_CTX_get(ctx);
        230.   	snum=BN_CTX_get(ctx);
                     ^
        231.   	sdiv=BN_CTX_get(ctx);
        232.   	if (dv == NULL)

crypto/bn/bn_ctx.c:290:1: Parameter `ctx->pool.used`
          288.   	}
          289.   
          290. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
          291.   	{
          292.   	BIGNUM *ret;

crypto/bn/bn_div.c:231:7: Call
        229.   	tmp=BN_CTX_get(ctx);
        230.   	snum=BN_CTX_get(ctx);
        231.   	sdiv=BN_CTX_get(ctx);
                     ^
        232.   	if (dv == NULL)
        233.   		res=BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:290:1: Parameter `ctx->pool.used`
          288.   	}
          289.   
          290. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
          291.   	{
          292.   	BIGNUM *ret;

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->pool.used`
          270.   	}
          271.   
          272. > void BN_CTX_end(BN_CTX *ctx)
          273.   	{
          274.   	CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:282:4: Call
          280.   		/* Does this stack frame have anything to release? */
          281.   		if(fp < ctx->used)
          282.   			BN_POOL_release(&ctx->pool, ctx->used - fp);
                    ^
          283.   		ctx->used = fp;
          284.   		/* Unjam "too_many" in case "get" had failed */

crypto/bn/bn_ctx.c:440:1: <LHS trace>
438.   	}
439.   
440. > static void BN_POOL_release(BN_POOL *p, unsigned int num)
441.   	{
442.   	unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;

crypto/bn/bn_ctx.c:440:1: Parameter `p->used`
            438.   	}
            439.   
            440. > static void BN_POOL_release(BN_POOL *p, unsigned int num)
            441.   	{
            442.   	unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;

crypto/bn/bn_ctx.c:442:2: Binary operation: ([0, +oo] - 1):unsigned32 by call to `BN_mod_exp` 
            440.   static void BN_POOL_release(BN_POOL *p, unsigned int num)
            441.   	{
            442.   	unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;
                    ^
            443.   	p->used -= num;
            444.   	while(num--)
