test/ectest.c:914: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `EC_POINTs_mul`.
Showing all 20 steps of the trace


test/ectest.c:914:14: Call
912.   
913.           /* z is still the group order */
914.           if (!TEST_true(EC_POINTs_mul(group, P, NULL, 2, points, scalars, ctx))
                    ^
915.               || !TEST_true(EC_POINTs_mul(group, R, z, 2, points, scalars, ctx))
916.               || !TEST_int_eq(0, EC_POINT_cmp(group, P, R, ctx))

crypto/ec/ec_lib.c:947:1: Parameter `ctx->stack.depth`
  945.    */
  946.   
  947. > int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
  948.                     size_t num, const EC_POINT *points[],
  949.                     const BIGNUM *scalars[], BN_CTX *ctx)

crypto/ec/ec_lib.c:983:15: Call
  981.       else
  982.           /* use default */
  983.           ret = ec_wNAF_mul(group, r, scalar, num, points, scalars, ctx);
                       ^
  984.   
  985.   #ifndef FIPS_MODE

crypto/ec/ec_mult.c:410:1: Parameter `ctx->stack.depth`
    408.    * in the addition if scalar != NULL
    409.    */
    410. > int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
    411.                   size_t num, const EC_POINT *points[], const BIGNUM *scalars[],
    412.                   BN_CTX *ctx)

crypto/ec/ec_mult.c:453:20: Call
    451.                * always call the ladder version.
    452.                */
    453.               return ec_scalar_mul_ladder(group, r, scalar, NULL, ctx);
                              ^
    454.           }
    455.           if ((scalar == NULL) && (num == 1) && (scalars[0] != group->order)) {

crypto/ec/ec_mult.c:139:1: Parameter `ctx->stack.depth`
      137.    * Returns 1 on success, 0 otherwise.
      138.    */
      139. > int ec_scalar_mul_ladder(const EC_GROUP *group, EC_POINT *r,
      140.                            const BIGNUM *scalar, const EC_POINT *point,
      141.                            BN_CTX *ctx)

crypto/ec/ec_mult.c:164:5: Call
      162.       }
      163.   
      164.       BN_CTX_start(ctx);
                 ^
      165.   
      166.       if (((p = EC_POINT_new(group)) == NULL)

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
        192.   }
        193.   
        194. > void BN_CTX_start(BN_CTX *ctx)
        195.   {
        196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/ec/ec_mult.c:196:10: Call
      194.       }
      195.   
      196.       if (!BN_mul(cardinality, group->order, group->cofactor, ctx)) {
                      ^
      197.           ECerr(EC_F_EC_SCALAR_MUL_LADDER, ERR_R_BN_LIB);
      198.           goto err;

crypto/bn/bn_mul.c:497:1: Parameter `ctx->stack.depth`
        495.   #endif                          /* BN_RECURSION */
        496.   
        497. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
        498.   {
        499.       int ret = bn_mul_fixed_top(r, a, b, ctx);

crypto/bn/bn_mul.c:499:15: Call
        497.   int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
        498.   {
        499.       int ret = bn_mul_fixed_top(r, a, b, ctx);
                             ^
        500.   
        501.       bn_correct_top(r);

crypto/bn/bn_mul.c:507:1: Parameter `ctx->stack.depth`
          505.   }
          506.   
          507. > int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
          508.   {
          509.       int ret = 0;

crypto/bn/bn_mul.c:533:5: Call
          531.       top = al + bl;
          532.   
          533.       BN_CTX_start(ctx);
                     ^
          534.       if ((r == a) || (r == b)) {
          535.           if ((rr = BN_CTX_get(ctx)) == NULL)

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
            192.   }
            193.   
            194. > void BN_CTX_start(BN_CTX *ctx)
            195.   {
            196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_mul.c:618:5: Call
          616.    err:
          617.       bn_check_top(r);
          618.       BN_CTX_end(ctx);
                     ^
          619.       return ret;
          620.   }

crypto/bn/bn_ctx.c:208:1: Parameter `ctx->stack.depth`
            206.   }
            207.   
            208. > void BN_CTX_end(BN_CTX *ctx)
            209.   {
            210.       if (ctx == NULL)

crypto/bn/bn_ctx.c:216:27: Call
            214.           ctx->err_stack--;
            215.       else {
            216.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                             ^
            217.           /* Does this stack frame have anything to release? */
            218.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:298:1: <LHS trace>
296.   }
297.   
298. > static unsigned int BN_STACK_pop(BN_STACK *st)
299.   {
300.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:298:1: Parameter `st->depth`
              296.   }
              297.   
              298. > static unsigned int BN_STACK_pop(BN_STACK *st)
              299.   {
              300.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:300:12: Binary operation: ([0, +oo] - 1):unsigned32 by call to `EC_POINTs_mul` 
              298.   static unsigned int BN_STACK_pop(BN_STACK *st)
              299.   {
              300.       return st->indexes[--(st->depth)];
                                ^
              301.   }
              302.   
