crypto/bn/bn_recp.c:124: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_div_recp`.
Showing all 26 steps of the trace


crypto/bn/bn_recp.c:116:11: Call
114.   		{
115.   		if (x == y)
116.   			{ if (!BN_sqr(a,x,ctx)) goto err; }
                 ^
117.   		else
118.   			{ if (!BN_mul(a,x,y,ctx)) goto err; }

crypto/bn/bn_sqr.c:64:1: Parameter `ctx->pool.used`
  62.   /* r must not be a */
  63.   /* I've just gone over this and it is now %20 faster on x86 - eay - 27 Jun 96 */
  64. > int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
  65.   	{
  66.   	int max,al;

crypto/bn/bn_recp.c:124:8: Call
122.   		ca=x; /* Just do the mod */
123.   
124.   	ret = BN_div_recp(NULL,r,ca,recp,ctx);
              ^
125.   err:
126.   	BN_CTX_end(ctx);

crypto/bn/bn_recp.c:131:1: Parameter `ctx->pool.used`
  129.   	}
  130.   
  131. > int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
  132.   	BN_RECP_CTX *recp, BN_CTX *ctx)
  133.   	{

crypto/bn/bn_recp.c:138:4: Call
  136.   
  137.   	BN_CTX_start(ctx);
  138.   	a=BN_CTX_get(ctx);
            ^
  139.   	b=BN_CTX_get(ctx);
  140.   	if (dv != NULL)

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

crypto/bn/bn_recp.c:139:4: Call
  137.   	BN_CTX_start(ctx);
  138.   	a=BN_CTX_get(ctx);
  139.   	b=BN_CTX_get(ctx);
            ^
  140.   	if (dv != NULL)
  141.   		d=dv;

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

crypto/bn/bn_recp.c:171:15: Call
  169.   	/* Nr := round(2^i / N) */
  170.   	if (i != recp->shift)
  171.   		recp->shift=BN_reciprocal(&(recp->Nr),&(recp->N),
                       ^
  172.   			i,ctx); /* BN_reciprocal returns i, or -1 for an error */
  173.   	if (recp->shift == -1) goto err;

crypto/bn/bn_recp.c:218:1: Parameter `ctx->pool.used`
    216.    */
    217.   /* r := 2^len / m */
    218. > int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx)
    219.   	{
    220.   	int ret= -1;

crypto/bn/bn_recp.c:224:10: Call
    222.   
    223.   	BN_CTX_start(ctx);
    224.   	if((t = BN_CTX_get(ctx)) == NULL) goto err;
                    ^
    225.   
    226.   	if (!BN_set_bit(t,len)) goto err;

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

crypto/bn/bn_recp.c:228:7: Call
    226.   	if (!BN_set_bit(t,len)) goto err;
    227.   
    228.   	if (!BN_div(r,NULL,t,m,ctx)) goto err;
                 ^
    229.   
    230.   	ret=len;

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

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

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

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

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

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

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

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

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

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

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

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

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