test/ssl_test.c:462: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned64 by call to `do_handshake`.
Showing all 22 steps of the trace


test/ssl_test.c:462:14: Call
460.           goto err;
461.   
462.       result = do_handshake(server_ctx, server2_ctx, client_ctx,
                    ^
463.                             resume_server_ctx, resume_client_ctx, test_ctx);
464.   

test/handshake_helper.c:1674:1: Parameter `client_ctx->sessions->num_items`
  1672.   }
  1673.   
  1674. > HANDSHAKE_RESULT *do_handshake(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
  1675.                                  SSL_CTX *client_ctx, SSL_CTX *resume_server_ctx,
  1676.                                  SSL_CTX *resume_client_ctx,

test/handshake_helper.c:1682:14: Call
  1680.       SSL_SESSION *session = NULL;
  1681.   
  1682.       result = do_handshake_internal(server_ctx, server2_ctx, client_ctx,
                       ^
  1683.                                      test_ctx, &test_ctx->extra,
  1684.                                      NULL, &session);

test/handshake_helper.c:1384:1: Parameter `client_ctx->sessions->num_items`
    1382.    * parsing.)
    1383.    */
    1384. > static HANDSHAKE_RESULT *do_handshake_internal(
    1385.       SSL_CTX *server_ctx, SSL_CTX *server2_ctx, SSL_CTX *client_ctx,
    1386.       const SSL_TEST_CTX *test_ctx, const SSL_TEST_EXTRA_CONF *extra,

test/handshake_helper.c:1433:10: Call
    1431.           goto err;
    1432.       }
    1433.       if (!create_peer(&client, client_ctx)) {
                     ^
    1434.           TEST_note("creating client context");
    1435.           goto err;

test/handshake_helper.c:743:1: Parameter `ctx->sessions->num_items`
      741.   } PEER;
      742.   
      743. > static int create_peer(PEER *peer, SSL_CTX *ctx)
      744.   {
      745.       static const int peer_buffer_size = 64 * 1024;

test/handshake_helper.c:749:10: Call
      747.       unsigned char *read_buf = NULL, *write_buf = NULL;
      748.   
      749.       if (!TEST_ptr(ssl = SSL_new(ctx))
                      ^
      750.               || !TEST_ptr(write_buf = OPENSSL_zalloc(peer_buffer_size))
      751.               || !TEST_ptr(read_buf = OPENSSL_zalloc(peer_buffer_size)))

ssl/ssl_lib.c:668:1: Parameter `ctx->sessions->num_items`
        666.   }
        667.   
        668. > SSL *SSL_new(SSL_CTX *ctx)
        669.   {
        670.       SSL *s;

ssl/ssl_lib.c:825:10: Call
        823.       s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
        824.   
        825.       if (!SSL_clear(s))
                        ^
        826.           goto err;
        827.   

ssl/ssl_lib.c:577:1: Parameter `s->session_ctx->sessions->num_items`
          575.   }
          576.   
          577. > int SSL_clear(SSL *s)
          578.   {
          579.       if (s->method == NULL) {

ssl/ssl_lib.c:584:9: Call
          582.       }
          583.   
          584.       if (ssl_clear_bad_session(s)) {
                         ^
          585.           SSL_SESSION_free(s->session);
          586.           s->session = NULL;

ssl/ssl_sess.c:1135:1: Parameter `s->session_ctx->sessions->num_items`
            1133.   }
            1134.   
            1135. > int ssl_clear_bad_session(SSL *s)
            1136.   {
            1137.       if ((s->session != NULL) &&

ssl/ssl_sess.c:1140:9: Call
            1138.           !(s->shutdown & SSL_SENT_SHUTDOWN) &&
            1139.           !(SSL_in_init(s) || SSL_in_before(s))) {
            1140.           SSL_CTX_remove_session(s->session_ctx, s->session);
                            ^
            1141.           return 1;
            1142.       } else

ssl/ssl_sess.c:751:1: Parameter `ctx->sessions->num_items`
              749.   }
              750.   
              751. > int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
              752.   {
              753.       return remove_session_lock(ctx, c, 1);

ssl/ssl_sess.c:753:12: Call
              751.   int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
              752.   {
              753.       return remove_session_lock(ctx, c, 1);
                                ^
              754.   }
              755.   

ssl/ssl_sess.c:756:1: Parameter `ctx->sessions->num_items`
                754.   }
                755.   
                756. > static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
                757.   {
                758.       SSL_SESSION *r;

ssl/ssl_sess.c:766:17: Call
                764.           if ((r = lh_SSL_SESSION_retrieve(ctx->sessions, c)) != NULL) {
                765.               ret = 1;
                766.               r = lh_SSL_SESSION_delete(ctx->sessions, r);
                                       ^
                767.               SSL_SESSION_list_remove(ctx, r);
                768.           }

ssl/ssl_locl.h:732:1: Parameter `lh->num_items`
                  730.   } TLSEXT_INDEX;
                  731.   
                  732. > DEFINE_LHASH_OF(SSL_SESSION);
                  733.   /* Needed in ssl_cert.c */
                  734.   DEFINE_LHASH_OF(X509_NAME);

ssl/ssl_locl.h:732:1: Call
                  730.   } TLSEXT_INDEX;
                  731.   
                  732. > DEFINE_LHASH_OF(SSL_SESSION);
                  733.   /* Needed in ssl_cert.c */
                  734.   DEFINE_LHASH_OF(X509_NAME);

crypto/lhash/lhash.c:119:1: <LHS trace>
117.   }
118.   
119. > void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data)
120.   {
121.       unsigned long hash;

crypto/lhash/lhash.c:119:1: Parameter `lh->num_items`
                    117.   }
                    118.   
                    119. > void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data)
                    120.   {
                    121.       unsigned long hash;

crypto/lhash/lhash.c:139:5: Binary operation: ([0, +oo] - 1):unsigned64 by call to `do_handshake` 
                    137.       }
                    138.   
                    139.       lh->num_items--;
                               ^
                    140.       if ((lh->num_nodes > MIN_NODES) &&
                    141.           (lh->down_load >= (lh->num_items * LH_LOAD_MULT / lh->num_nodes)))
