crypto/bn/bn_recp.c:76: 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:66:18: Call
64.       if (y != NULL) {
65.           if (x == y) {
66.               if (!BN_sqr(a, x, ctx))
                       ^
67.                   goto err;
68.           } else {

crypto/bn/bn_sqr.c:17:1: Parameter `ctx->pool.used`
  15.    * I've just gone over this and it is now %20 faster on x86 - eay - 27 Jun 96
  16.    */
  17. > int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
  18.   {
  19.       int max, al;

crypto/bn/bn_recp.c:76:11: Call
74.           ca = x;                 /* Just do the mod */
75.   
76.       ret = BN_div_recp(NULL, r, ca, recp, ctx);
                ^
77.    err:
78.       BN_CTX_end(ctx);

crypto/bn/bn_recp.c:83:1: Parameter `ctx->pool.used`
  81.   }
  82.   
  83. > int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
  84.                   BN_RECP_CTX *recp, BN_CTX *ctx)
  85.   {

crypto/bn/bn_recp.c:92:9: Call
  90.       d = (dv != NULL) ? dv : BN_CTX_get(ctx);
  91.       r = (rem != NULL) ? rem : BN_CTX_get(ctx);
  92.       a = BN_CTX_get(ctx);
                ^
  93.       b = BN_CTX_get(ctx);
  94.       if (b == NULL)

crypto/bn/bn_ctx.c:212:1: Parameter `ctx->pool.used`
    210.   }
    211.   
    212. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
    213.   {
    214.       BIGNUM *ret;

crypto/bn/bn_recp.c:93:9: Call
  91.       r = (rem != NULL) ? rem : BN_CTX_get(ctx);
  92.       a = BN_CTX_get(ctx);
  93.       b = BN_CTX_get(ctx);
                ^
  94.       if (b == NULL)
  95.           goto err;

crypto/bn/bn_ctx.c:212:1: Parameter `ctx->pool.used`
    210.   }
    211.   
    212. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
    213.   {
    214.       BIGNUM *ret;

crypto/bn/bn_recp.c:120:23: Call
  118.       /* Nr := round(2^i / N) */
  119.       if (i != recp->shift)
  120.           recp->shift = BN_reciprocal(&(recp->Nr), &(recp->N), i, ctx);
                               ^
  121.       /* BN_reciprocal could have returned -1 for an error */
  122.       if (recp->shift == -1)

crypto/bn/bn_recp.c:173:1: Parameter `ctx->pool.used`
    171.    */
    172.   /* r := 2^len / m */
    173. > int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx)
    174.   {
    175.       int ret = -1;

crypto/bn/bn_recp.c:179:14: Call
    177.   
    178.       BN_CTX_start(ctx);
    179.       if ((t = BN_CTX_get(ctx)) == NULL)
                        ^
    180.           goto err;
    181.   

crypto/bn/bn_ctx.c:212:1: Parameter `ctx->pool.used`
      210.   }
      211.   
      212. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
      213.   {
      214.       BIGNUM *ret;

crypto/bn/bn_recp.c:185:10: Call
    183.           goto err;
    184.   
    185.       if (!BN_div(r, NULL, t, m, ctx))
                    ^
    186.           goto err;
    187.   

crypto/bn/bn_div.c:137:1: Parameter `ctx->pool.used`
      135.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
      136.    */
      137. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
      138.              BN_CTX *ctx)
      139.   {

crypto/bn/bn_div.c:192:11: Call
      190.       BN_CTX_start(ctx);
      191.       res = (dv == NULL) ? BN_CTX_get(ctx) : dv;
      192.       tmp = BN_CTX_get(ctx);
                       ^
      193.       snum = BN_CTX_get(ctx);
      194.       sdiv = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:212:1: Parameter `ctx->pool.used`
        210.   }
        211.   
        212. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
        213.   {
        214.       BIGNUM *ret;

crypto/bn/bn_div.c:193:12: Call
      191.       res = (dv == NULL) ? BN_CTX_get(ctx) : dv;
      192.       tmp = BN_CTX_get(ctx);
      193.       snum = BN_CTX_get(ctx);
                        ^
      194.       sdiv = BN_CTX_get(ctx);
      195.       if (sdiv == NULL)

crypto/bn/bn_ctx.c:212:1: Parameter `ctx->pool.used`
        210.   }
        211.   
        212. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
        213.   {
        214.       BIGNUM *ret;

crypto/bn/bn_div.c:194:12: Call
      192.       tmp = BN_CTX_get(ctx);
      193.       snum = BN_CTX_get(ctx);
      194.       sdiv = BN_CTX_get(ctx);
                        ^
      195.       if (sdiv == NULL)
      196.           goto err;

crypto/bn/bn_ctx.c:212:1: Parameter `ctx->pool.used`
        210.   }
        211.   
        212. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
        213.   {
        214.       BIGNUM *ret;

crypto/bn/bn_div.c:410:5: Call
      408.       if (no_branch)
      409.           bn_correct_top(res);
      410.       BN_CTX_end(ctx);
                 ^
      411.       return 1;
      412.    err:

crypto/bn/bn_ctx.c:195:1: Parameter `ctx->pool.used`
        193.   }
        194.   
        195. > void BN_CTX_end(BN_CTX *ctx)
        196.   {
        197.       CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:204:13: Call
        202.           /* Does this stack frame have anything to release? */
        203.           if (fp < ctx->used)
        204.               BN_POOL_release(&ctx->pool, ctx->used - fp);
                           ^
        205.           ctx->used = fp;
        206.           /* Unjam "too_many" in case "get" had failed */

crypto/bn/bn_ctx.c:340:1: <LHS trace>
338.   }
339.   
340. > static void BN_POOL_release(BN_POOL *p, unsigned int num)
341.   {
342.       unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;

crypto/bn/bn_ctx.c:340:1: Parameter `p->used`
          338.   }
          339.   
          340. > static void BN_POOL_release(BN_POOL *p, unsigned int num)
          341.   {
          342.       unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;

crypto/bn/bn_ctx.c:342:5: Binary operation: ([0, +oo] - 1):unsigned32 by call to `BN_div_recp` 
          340.   static void BN_POOL_release(BN_POOL *p, unsigned int num)
          341.   {
          342.       unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;
                     ^
          343.   
          344.       p->used -= num;
