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


crypto/bn/bn_gf2m.c:691:7: Call
689.   	if (xinv == NULL) goto err;
690.   	
691.   	if (!BN_GF2m_mod_inv(xinv, x, p, ctx)) goto err;
             ^
692.   	if (!BN_GF2m_mod_mul(r, y, xinv, p, ctx)) goto err;
693.   	bn_check_top(r);

crypto/bn/bn_gf2m.c:645:4: Call
  643.   
  644.   err:
  645.     	BN_CTX_end(ctx);
            ^
  646.   	return ret;
  647.   	}

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_gf2m.c:692:7: Call
690.   	
691.   	if (!BN_GF2m_mod_inv(xinv, x, p, ctx)) goto err;
692.   	if (!BN_GF2m_mod_mul(r, y, xinv, p, ctx)) goto err;
             ^
693.   	bn_check_top(r);
694.   	ret = 1;

crypto/bn/bn_gf2m.c:441:1: Parameter `ctx->pool.used`
  439.    * BN_GF2m_mod_mul_arr function.
  440.    */
  441. > int	BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx)
  442.   	{
  443.   	int ret = 0;

crypto/bn/bn_gf2m.c:456:8: Call
  454.   		goto err;
  455.   		}
  456.   	ret = BN_GF2m_mod_mul_arr(r, a, b, arr, ctx);
                ^
  457.   	bn_check_top(r);
  458.   err:

crypto/bn/bn_gf2m.c:388:1: Parameter `ctx->pool.used`
    386.    * the result in r.  r could be a or b; a could be b.
    387.    */
    388. > int	BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const int p[], BN_CTX *ctx)
    389.   	{
    390.   	int zlen, i, j, k, ret = 0;

crypto/bn/bn_gf2m.c:399:10: Call
    397.   	if (a == b)
    398.   		{
    399.   		return BN_GF2m_mod_sqr_arr(r, a, p, ctx);
                    ^
    400.   		}
    401.   

crypto/bn/bn_gf2m.c:465:1: Parameter `ctx->pool.used`
      463.   
      464.   /* Square a, reduce the result mod p, and store it in a.  r could be a. */
      465. > int	BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], BN_CTX *ctx)
      466.   	{
      467.   	int i, ret = 0;

crypto/bn/bn_gf2m.c:472:11: Call
      470.   	bn_check_top(a);
      471.   	BN_CTX_start(ctx);
      472.   	if ((s = BN_CTX_get(ctx)) == NULL) return 0;
                       ^
      473.   	if (!bn_wexpand(s, 2 * a->top)) goto err;
      474.   

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_gf2m.c:487:2: Call
      485.   	ret = 1;
      486.   err:
      487.   	BN_CTX_end(ctx);
              ^
      488.   	return ret;
      489.   	}

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_GF2m_mod_mul` 
          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--)
