crypto/bn/bn_exp.c:501: error: INTEGER_OVERFLOW_L2
  (0 - [0, 1]):unsigned64 by call to `BN_to_montgomery`.
Showing all 17 steps of the trace


crypto/bn/bn_exp.c:501:30: Call
499.       } else
500.   #endif
501.       if (!BN_to_montgomery(r, BN_value_one(), mont, ctx))
                                    ^
502.           goto err;
503.       for (;;) {

crypto/bn/bn_lib.c:137:5: Assignment
  135.   const BIGNUM *BN_value_one(void)
  136.   {
  137.       static const BN_ULONG data_one = 1L;
             ^
  138.       static const BIGNUM const_one =
  139.           { (BN_ULONG *)&data_one, 1, 1, 0, BN_FLG_STATIC_DATA };

crypto/bn/bn_exp.c:501:10: Call
499.       } else
500.   #endif
501.       if (!BN_to_montgomery(r, BN_value_one(), mont, ctx))
                ^
502.           goto err;
503.       for (;;) {

crypto/bn/bn_lib.c:926:1: Parameter `*a->d`
  924.   }
  925.   
  926. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
  927.                        BN_CTX *ctx)
  928.   {

crypto/bn/bn_lib.c:929:12: Call
  927.                        BN_CTX *ctx)
  928.   {
  929.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                    ^
  930.   }
  931.   

crypto/bn/bn_mont.c:128:1: Parameter `*a->d`
    126.   #endif
    127.   
    128. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
    129.                             BN_MONT_CTX *mont, BN_CTX *ctx)
    130.   {

crypto/bn/bn_mont.c:158:14: Call
    156.               goto err;
    157.       } else {
    158.           if (!BN_mul(tmp, a, b, ctx))
                        ^
    159.               goto err;
    160.       }

crypto/bn/bn_mul.c:883:1: Parameter `*a->d`
      881.   #endif                          /* BN_RECURSION */
      882.   
      883. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
      884.   {
      885.       int ret = 0;

crypto/bn/bn_mul.c:964:17: Call
      962.                   if (bn_wexpand(rr, k * 4) == NULL)
      963.                       goto err;
      964.                   bn_mul_part_recursive(rr->d, a->d, b->d,
                             ^
      965.                                         j, al - j, bl - j, t->d);
      966.               } else {            /* al <= j || bl <= j */

crypto/bn/bn_mul.c:534:1: Parameter `*a`
        532.    */
        533.   /* tnX may not be negative but less than n */
        534. > void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n,
        535.                              int tna, int tnb, BN_ULONG *t)
        536.   {

crypto/bn/bn_mul.c:547:10: Call
        545.   
        546.       /* r=(a[0]-a[1])*(b[1]-b[0]) */
        547.       c1 = bn_cmp_part_words(a, &(a[n]), tna, n - tna);
                        ^
        548.       c2 = bn_cmp_part_words(&(b[n]), b, tnb, tnb - n);
        549.       neg = 0;

crypto/bn/bn_lib.c:784:1: Parameter `*b`
          782.    */
          783.   
          784. > int bn_cmp_part_words(const BN_ULONG *a, const BN_ULONG *b, int cl, int dl)
          785.   {
          786.       int n, i;

crypto/bn/bn_mul.c:552:9: Call
        550.       switch (c1 * 3 + c2) {
        551.       case -4:
        552.           bn_sub_part_words(t, &(a[n]), a, tna, tna - n); /* - */
                       ^
        553.           bn_sub_part_words(&(t[n]), b, &(b[n]), tnb, n - tnb); /* - */
        554.           break;

crypto/bn/bn_mul.c:81:1: <RHS trace>
79.    */
80.   
81. > BN_ULONG bn_sub_part_words(BN_ULONG *r,
82.                              const BN_ULONG *a, const BN_ULONG *b,
83.                              int cl, int dl)

crypto/bn/bn_mul.c:81:1: Parameter `*b`
          79.    */
          80.   
          81. > BN_ULONG bn_sub_part_words(BN_ULONG *r,
          82.                              const BN_ULONG *a, const BN_ULONG *b,
          83.                              int cl, int dl)

crypto/bn/bn_mul.c:99:13: Assignment
          97.       if (dl < 0) {
          98.           for (;;) {
          99.               t = b[0];
                             ^
          100.               r[0] = (0 - t - c) & BN_MASK2;
          101.               if (t != 0)

crypto/bn/bn_mul.c:100:13: Binary operation: (0 - [0, 1]):unsigned64 by call to `BN_to_montgomery` 
          98.           for (;;) {
          99.               t = b[0];
          100.               r[0] = (0 - t - c) & BN_MASK2;
                             ^
          101.               if (t != 0)
          102.                   c = 1;
