crypto/async/async.c:388: error: MEMORY_LEAK
  memory dynamically allocated by call to `async_job_new()` at line 378, column 15 is not reachable after line 388, column 9.
Showing all 207 steps of the trace


crypto/async/async.c:346:1: start of procedure ASYNC_init_thread()
344.   }
345.   
346. > int ASYNC_init_thread(size_t max_size, size_t init_size)
347.   {
348.       async_pool *pool;

crypto/async/async.c:349:5: 
347.   {
348.       async_pool *pool;
349. >     size_t curr_size = 0;
350.   
351.       if (init_size > max_size) {

crypto/async/async.c:351:9: Taking false branch
349.       size_t curr_size = 0;
350.   
351.       if (init_size > max_size) {
               ^
352.           ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INVALID_POOL_SIZE);
353.           return 0;

crypto/async/async.c:356:10: 
354.       }
355.   
356. >     if (!async_local_init()) {
357.           ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INIT_FAILED);
358.           return 0;

crypto/async/arch/async_posix.c:76:1: start of procedure async_local_init()
  74.   }
  75.   
  76. > int async_local_init(void)
  77.   {
  78.       if (!async_set_ctx(NULL) || ! async_set_pool(NULL))

crypto/async/arch/async_posix.c:78:10: Taking false branch
  76.   int async_local_init(void)
  77.   {
  78.       if (!async_set_ctx(NULL) || ! async_set_pool(NULL))
                 ^
  79.           return 0;
  80.   

crypto/async/arch/async_posix.c:78:35: Taking false branch
  76.   int async_local_init(void)
  77.   {
  78.       if (!async_set_ctx(NULL) || ! async_set_pool(NULL))
                                          ^
  79.           return 0;
  80.   

crypto/async/arch/async_posix.c:81:5: 
  79.           return 0;
  80.   
  81. >     return 1;
  82.   }
  83.   

crypto/async/arch/async_posix.c:82:1: return from a call to async_local_init
  80.   
  81.       return 1;
  82. > }
  83.   
  84.   void async_local_cleanup(void)

crypto/async/async.c:356:10: Taking false branch
354.       }
355.   
356.       if (!async_local_init()) {
                ^
357.           ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INIT_FAILED);
358.           return 0;

crypto/async/async.c:360:5: 
358.           return 0;
359.       }
360. >     pool = OPENSSL_zalloc(sizeof *pool);
361.       if (pool == NULL) {
362.           ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);

crypto/mem.c:157:1: start of procedure CRYPTO_zalloc()
  155.   }
  156.   
  157. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
  158.   {
  159.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:159:5: 
  157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
  158.   {
  159. >     void *ret = CRYPTO_malloc(num, file, line);
  160.   
  161.       if (ret != NULL)

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
    118.   }
    119.   
    120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122.       void *ret = NULL;

crypto/mem.c:122:5: 
    120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122. >     void *ret = NULL;
    123.   
    124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
    122.       void *ret = NULL;
    123.   
    124.       if (num <= 0)
                   ^
    125.           return NULL;
    126.   

crypto/mem.c:127:5: 
    125.           return NULL;
    126.   
    127. >     allow_customize = 0;
    128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
    129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
    135.       }
    136.   #else
    137. >     (void)file;
    138.       (void)line;
    139.       ret = malloc(num);

crypto/mem.c:138:5: 
    136.   #else
    137.       (void)file;
    138. >     (void)line;
    139.       ret = malloc(num);
    140.   #endif

crypto/mem.c:139:5: 
    137.       (void)file;
    138.       (void)line;
    139. >     ret = malloc(num);
    140.   #endif
    141.   

crypto/mem.c:154:5: 
    152.   #endif
    153.   
    154. >     return ret;
    155.   }
    156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
    153.   
    154.       return ret;
    155. > }
    156.   
    157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:161:9: Taking true branch
  159.       void *ret = CRYPTO_malloc(num, file, line);
  160.   
  161.       if (ret != NULL)
                 ^
  162.           memset(ret, 0, num);
  163.       return ret;

crypto/mem.c:162:9: 
  160.   
  161.       if (ret != NULL)
  162. >         memset(ret, 0, num);
  163.       return ret;
  164.   }

crypto/mem.c:163:5: 
  161.       if (ret != NULL)
  162.           memset(ret, 0, num);
  163. >     return ret;
  164.   }
  165.   

crypto/mem.c:164:1: return from a call to CRYPTO_zalloc
  162.           memset(ret, 0, num);
  163.       return ret;
  164. > }
  165.   
  166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/async/async.c:361:9: Taking false branch
359.       }
360.       pool = OPENSSL_zalloc(sizeof *pool);
361.       if (pool == NULL) {
               ^
362.           ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);
363.           return 0;

crypto/async/async.c:366:5: 
364.       }
365.   
366. >     pool->jobs = sk_ASYNC_JOB_new_null();
367.       if (pool->jobs == NULL) {
368.           ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);

crypto/async/async_locl.h:90:1: start of procedure sk_ASYNC_JOB_new_null()
  88.   };
  89.   
  90. > DEFINE_STACK_OF(ASYNC_JOB)
  91.   
  92.   struct async_pool_st {

crypto/stack/stack.c:145:1: start of procedure sk_new_null()
    143.   }
    144.   
    145. > _STACK *sk_new_null(void)
    146.   {
    147.       return sk_new((int (*)(const void *, const void *))0);

crypto/stack/stack.c:147:5: 
    145.   _STACK *sk_new_null(void)
    146.   {
    147. >     return sk_new((int (*)(const void *, const void *))0);
    148.   }
    149.   

crypto/stack/stack.c:150:1: start of procedure sk_new()
      148.   }
      149.   
      150. > _STACK *sk_new(int (*c) (const void *, const void *))
      151.   {
      152.       _STACK *ret;

crypto/stack/stack.c:154:9: 
      152.       _STACK *ret;
      153.   
      154. >     if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
      155.           goto err;
      156.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)

crypto/mem.c:157:1: start of procedure CRYPTO_zalloc()
        155.   }
        156.   
        157. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
        158.   {
        159.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:159:5: 
        157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
        158.   {
        159. >     void *ret = CRYPTO_malloc(num, file, line);
        160.   
        161.       if (ret != NULL)

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
          118.   }
          119.   
          120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
          121.   {
          122.       void *ret = NULL;

crypto/mem.c:122:5: 
          120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
          121.   {
          122. >     void *ret = NULL;
          123.   
          124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
          122.       void *ret = NULL;
          123.   
          124.       if (num <= 0)
                         ^
          125.           return NULL;
          126.   

crypto/mem.c:127:5: 
          125.           return NULL;
          126.   
          127. >     allow_customize = 0;
          128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
          129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
          135.       }
          136.   #else
          137. >     (void)file;
          138.       (void)line;
          139.       ret = malloc(num);

crypto/mem.c:138:5: 
          136.   #else
          137.       (void)file;
          138. >     (void)line;
          139.       ret = malloc(num);
          140.   #endif

crypto/mem.c:139:5: 
          137.       (void)file;
          138.       (void)line;
          139. >     ret = malloc(num);
          140.   #endif
          141.   

crypto/mem.c:154:5: 
          152.   #endif
          153.   
          154. >     return ret;
          155.   }
          156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
          153.   
          154.       return ret;
          155. > }
          156.   
          157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:161:9: Taking true branch
        159.       void *ret = CRYPTO_malloc(num, file, line);
        160.   
        161.       if (ret != NULL)
                       ^
        162.           memset(ret, 0, num);
        163.       return ret;

crypto/mem.c:162:9: 
        160.   
        161.       if (ret != NULL)
        162. >         memset(ret, 0, num);
        163.       return ret;
        164.   }

crypto/mem.c:163:5: 
        161.       if (ret != NULL)
        162.           memset(ret, 0, num);
        163. >     return ret;
        164.   }
        165.   

crypto/mem.c:164:1: return from a call to CRYPTO_zalloc
        162.           memset(ret, 0, num);
        163.       return ret;
        164. > }
        165.   
        166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/stack/stack.c:154:9: Taking false branch
      152.       _STACK *ret;
      153.   
      154.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
                     ^
      155.           goto err;
      156.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)

crypto/stack/stack.c:156:9: 
      154.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
      155.           goto err;
      156. >     if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
      157.           goto err;
      158.       ret->comp = c;

crypto/mem.c:157:1: start of procedure CRYPTO_zalloc()
        155.   }
        156.   
        157. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
        158.   {
        159.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:159:5: 
        157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
        158.   {
        159. >     void *ret = CRYPTO_malloc(num, file, line);
        160.   
        161.       if (ret != NULL)

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
          118.   }
          119.   
          120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
          121.   {
          122.       void *ret = NULL;

crypto/mem.c:122:5: 
          120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
          121.   {
          122. >     void *ret = NULL;
          123.   
          124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
          122.       void *ret = NULL;
          123.   
          124.       if (num <= 0)
                         ^
          125.           return NULL;
          126.   

crypto/mem.c:127:5: 
          125.           return NULL;
          126.   
          127. >     allow_customize = 0;
          128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
          129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
          135.       }
          136.   #else
          137. >     (void)file;
          138.       (void)line;
          139.       ret = malloc(num);

crypto/mem.c:138:5: 
          136.   #else
          137.       (void)file;
          138. >     (void)line;
          139.       ret = malloc(num);
          140.   #endif

crypto/mem.c:139:5: 
          137.       (void)file;
          138.       (void)line;
          139. >     ret = malloc(num);
          140.   #endif
          141.   

crypto/mem.c:154:5: 
          152.   #endif
          153.   
          154. >     return ret;
          155.   }
          156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
          153.   
          154.       return ret;
          155. > }
          156.   
          157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:161:9: Taking true branch
        159.       void *ret = CRYPTO_malloc(num, file, line);
        160.   
        161.       if (ret != NULL)
                       ^
        162.           memset(ret, 0, num);
        163.       return ret;

crypto/mem.c:162:9: 
        160.   
        161.       if (ret != NULL)
        162. >         memset(ret, 0, num);
        163.       return ret;
        164.   }

crypto/mem.c:163:5: 
        161.       if (ret != NULL)
        162.           memset(ret, 0, num);
        163. >     return ret;
        164.   }
        165.   

crypto/mem.c:164:1: return from a call to CRYPTO_zalloc
        162.           memset(ret, 0, num);
        163.       return ret;
        164. > }
        165.   
        166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/stack/stack.c:156:9: Taking false branch
      154.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
      155.           goto err;
      156.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
                     ^
      157.           goto err;
      158.       ret->comp = c;

crypto/stack/stack.c:158:5: 
      156.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
      157.           goto err;
      158. >     ret->comp = c;
      159.       ret->num_alloc = MIN_NODES;
      160.       return (ret);

crypto/stack/stack.c:159:5: 
      157.           goto err;
      158.       ret->comp = c;
      159. >     ret->num_alloc = MIN_NODES;
      160.       return (ret);
      161.   

crypto/stack/stack.c:160:5: 
      158.       ret->comp = c;
      159.       ret->num_alloc = MIN_NODES;
      160. >     return (ret);
      161.   
      162.    err:

crypto/stack/stack.c:165:1: return from a call to sk_new
      163.       OPENSSL_free(ret);
      164.       return (NULL);
      165. > }
      166.   
      167.   int sk_insert(_STACK *st, void *data, int loc)

crypto/stack/stack.c:148:1: return from a call to sk_new_null
    146.   {
    147.       return sk_new((int (*)(const void *, const void *))0);
    148. > }
    149.   
    150.   _STACK *sk_new(int (*c) (const void *, const void *))

crypto/async/async_locl.h:90:1: return from a call to sk_ASYNC_JOB_new_null
  88.   };
  89.   
  90. > DEFINE_STACK_OF(ASYNC_JOB)
  91.   
  92.   struct async_pool_st {

crypto/async/async.c:367:9: Taking false branch
365.   
366.       pool->jobs = sk_ASYNC_JOB_new_null();
367.       if (pool->jobs == NULL) {
               ^
368.           ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);
369.           OPENSSL_free(pool);

crypto/async/async.c:373:5: 
371.       }
372.   
373. >     pool->max_size = max_size;
374.   
375.       /* Pre-create jobs as required */

crypto/async/async.c:376:12: Loop condition is true. Entering loop body
374.   
375.       /* Pre-create jobs as required */
376.       while (init_size--) {
                  ^
377.           ASYNC_JOB *job;
378.           job = async_job_new();

crypto/async/async.c:378:9: 
376.       while (init_size--) {
377.           ASYNC_JOB *job;
378. >         job = async_job_new();
379.           if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
380.               /*

crypto/async/async.c:112:1: start of procedure async_job_new()
  110.   }
  111.   
  112. > static ASYNC_JOB *async_job_new(void)
  113.   {
  114.       ASYNC_JOB *job = NULL;

crypto/async/async.c:114:5: 
  112.   static ASYNC_JOB *async_job_new(void)
  113.   {
  114. >     ASYNC_JOB *job = NULL;
  115.       OSSL_ASYNC_FD pipefds[2];
  116.   

crypto/async/async.c:117:5: 
  115.       OSSL_ASYNC_FD pipefds[2];
  116.   
  117. >     job = OPENSSL_malloc(sizeof (ASYNC_JOB));
  118.       if (job == NULL) {
  119.           ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
    118.   }
    119.   
    120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122.       void *ret = NULL;

crypto/mem.c:122:5: 
    120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122. >     void *ret = NULL;
    123.   
    124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
    122.       void *ret = NULL;
    123.   
    124.       if (num <= 0)
                   ^
    125.           return NULL;
    126.   

crypto/mem.c:127:5: 
    125.           return NULL;
    126.   
    127. >     allow_customize = 0;
    128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
    129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
    135.       }
    136.   #else
    137. >     (void)file;
    138.       (void)line;
    139.       ret = malloc(num);

crypto/mem.c:138:5: 
    136.   #else
    137.       (void)file;
    138. >     (void)line;
    139.       ret = malloc(num);
    140.   #endif

crypto/mem.c:139:5: 
    137.       (void)file;
    138.       (void)line;
    139. >     ret = malloc(num);
    140.   #endif
    141.   

crypto/mem.c:154:5: 
    152.   #endif
    153.   
    154. >     return ret;
    155.   }
    156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
    153.   
    154.       return ret;
    155. > }
    156.   
    157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/async/async.c:118:9: Taking false branch
  116.   
  117.       job = OPENSSL_malloc(sizeof (ASYNC_JOB));
  118.       if (job == NULL) {
                 ^
  119.           ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);
  120.           return NULL;

crypto/async/async.c:123:10: 
  121.       }
  122.   
  123. >     if (!async_pipe(pipefds)) {
  124.           OPENSSL_free(job);
  125.           ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);

crypto/async/arch/async_posix.c:115:1: start of procedure async_pipe()
    113.   }
    114.   
    115. > int async_pipe(OSSL_ASYNC_FD *pipefds)
    116.   {
    117.       if (pipe(pipefds) == 0)

crypto/async/arch/async_posix.c:117:9: Taking true branch
    115.   int async_pipe(OSSL_ASYNC_FD *pipefds)
    116.   {
    117.       if (pipe(pipefds) == 0)
                   ^
    118.           return 1;
    119.   

crypto/async/arch/async_posix.c:118:9: 
    116.   {
    117.       if (pipe(pipefds) == 0)
    118. >         return 1;
    119.   
    120.       return 0;

crypto/async/arch/async_posix.c:121:1: return from a call to async_pipe
    119.   
    120.       return 0;
    121. > }
    122.   
    123.   int async_close_fd(OSSL_ASYNC_FD fd)

crypto/async/async.c:123:10: Taking false branch
  121.       }
  122.   
  123.       if (!async_pipe(pipefds)) {
                  ^
  124.           OPENSSL_free(job);
  125.           ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);

crypto/async/async.c:129:5: 
  127.       }
  128.   
  129. >     job->wake_set = 0;
  130.       job->wait_fd = pipefds[0];
  131.       job->wake_fd = pipefds[1];

crypto/async/async.c:130:5: 
  128.   
  129.       job->wake_set = 0;
  130. >     job->wait_fd = pipefds[0];
  131.       job->wake_fd = pipefds[1];
  132.   

crypto/async/async.c:131:5: 
  129.       job->wake_set = 0;
  130.       job->wait_fd = pipefds[0];
  131. >     job->wake_fd = pipefds[1];
  132.   
  133.       job->status = ASYNC_JOB_RUNNING;

crypto/async/async.c:133:5: 
  131.       job->wake_fd = pipefds[1];
  132.   
  133. >     job->status = ASYNC_JOB_RUNNING;
  134.       job->funcargs = NULL;
  135.   

crypto/async/async.c:134:5: 
  132.   
  133.       job->status = ASYNC_JOB_RUNNING;
  134. >     job->funcargs = NULL;
  135.   
  136.       return job;

crypto/async/async.c:136:5: 
  134.       job->funcargs = NULL;
  135.   
  136. >     return job;
  137.   }
  138.   

crypto/async/async.c:137:1: return from a call to async_job_new
  135.   
  136.       return job;
  137. > }
  138.   
  139.   static void async_job_free(ASYNC_JOB *job)

crypto/async/async.c:379:13: Taking false branch
377.           ASYNC_JOB *job;
378.           job = async_job_new();
379.           if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
                   ^
380.               /*
381.                * Not actually fatal because we already created the pool, just

crypto/async/async.c:379:29: 
377.           ASYNC_JOB *job;
378.           job = async_job_new();
379. >         if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
380.               /*
381.                * Not actually fatal because we already created the pool, just

crypto/async/arch/async_posix.c:92:1: start of procedure async_fibre_makecontext()
  90.   }
  91.   
  92. > int async_fibre_makecontext(async_fibre *fibre)
  93.   {
  94.       fibre->env_init = 0;

crypto/async/arch/async_posix.c:94:5: 
  92.   int async_fibre_makecontext(async_fibre *fibre)
  93.   {
  94. >     fibre->env_init = 0;
  95.       if (getcontext(&fibre->fibre) == 0) {
  96.           fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);

crypto/async/arch/async_posix.c:95:9: Taking true branch
  93.   {
  94.       fibre->env_init = 0;
  95.       if (getcontext(&fibre->fibre) == 0) {
                ^
  96.           fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {

crypto/async/arch/async_posix.c:96:9: 
  94.       fibre->env_init = 0;
  95.       if (getcontext(&fibre->fibre) == 0) {
  96. >         fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {
  98.               fibre->fibre.uc_stack.ss_size = STACKSIZE;

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
    118.   }
    119.   
    120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122.       void *ret = NULL;

crypto/mem.c:122:5: 
    120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122. >     void *ret = NULL;
    123.   
    124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
    122.       void *ret = NULL;
    123.   
    124.       if (num <= 0)
                   ^
    125.           return NULL;
    126.   

crypto/mem.c:127:5: 
    125.           return NULL;
    126.   
    127. >     allow_customize = 0;
    128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
    129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
    135.       }
    136.   #else
    137. >     (void)file;
    138.       (void)line;
    139.       ret = malloc(num);

crypto/mem.c:138:5: 
    136.   #else
    137.       (void)file;
    138. >     (void)line;
    139.       ret = malloc(num);
    140.   #endif

crypto/mem.c:139:5: 
    137.       (void)file;
    138.       (void)line;
    139. >     ret = malloc(num);
    140.   #endif
    141.   

crypto/mem.c:154:5: 
    152.   #endif
    153.   
    154. >     return ret;
    155.   }
    156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
    153.   
    154.       return ret;
    155. > }
    156.   
    157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/async/arch/async_posix.c:97:13: Taking true branch
  95.       if (getcontext(&fibre->fibre) == 0) {
  96.           fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {
                     ^
  98.               fibre->fibre.uc_stack.ss_size = STACKSIZE;
  99.               fibre->fibre.uc_link = NULL;

crypto/async/arch/async_posix.c:98:13: 
  96.           fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {
  98. >             fibre->fibre.uc_stack.ss_size = STACKSIZE;
  99.               fibre->fibre.uc_link = NULL;
  100.               makecontext(&fibre->fibre, async_start_func, 0);

crypto/async/arch/async_posix.c:99:13: 
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {
  98.               fibre->fibre.uc_stack.ss_size = STACKSIZE;
  99. >             fibre->fibre.uc_link = NULL;
  100.               makecontext(&fibre->fibre, async_start_func, 0);
  101.               return 1;

crypto/async/arch/async_posix.c:100:13: Skipping makecontext(): method has no implementation
  98.               fibre->fibre.uc_stack.ss_size = STACKSIZE;
  99.               fibre->fibre.uc_link = NULL;
  100.               makecontext(&fibre->fibre, async_start_func, 0);
                     ^
  101.               return 1;
  102.           }

crypto/async/arch/async_posix.c:101:13: 
  99.               fibre->fibre.uc_link = NULL;
  100.               makecontext(&fibre->fibre, async_start_func, 0);
  101. >             return 1;
  102.           }
  103.       } else {

crypto/async/arch/async_posix.c:107:1: return from a call to async_fibre_makecontext
  105.       }
  106.       return 0;
  107. > }
  108.   
  109.   void async_fibre_free(async_fibre *fibre)

crypto/async/async.c:379:29: Taking false branch
377.           ASYNC_JOB *job;
378.           job = async_job_new();
379.           if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
                                   ^
380.               /*
381.                * Not actually fatal because we already created the pool, just

crypto/async/async.c:387:9: 
385.               break;
386.           }
387. >         job->funcargs = NULL;
388.           sk_ASYNC_JOB_push(pool->jobs, job);
389.           curr_size++;

crypto/async/async.c:388:9: 
386.           }
387.           job->funcargs = NULL;
388. >         sk_ASYNC_JOB_push(pool->jobs, job);
389.           curr_size++;
390.       }

crypto/async/async_locl.h:90:1: start of procedure sk_ASYNC_JOB_push()
  88.   };
  89.   
  90. > DEFINE_STACK_OF(ASYNC_JOB)
  91.   
  92.   struct async_pool_st {

crypto/stack/stack.c:259:1: start of procedure sk_push()
    257.   }
    258.   
    259. > int sk_push(_STACK *st, void *data)
    260.   {
    261.       return (sk_insert(st, data, st->num));

crypto/stack/stack.c:261:5: 
    259.   int sk_push(_STACK *st, void *data)
    260.   {
    261. >     return (sk_insert(st, data, st->num));
    262.   }
    263.   

crypto/stack/stack.c:167:1: start of procedure sk_insert()
      165.   }
      166.   
      167. > int sk_insert(_STACK *st, void *data, int loc)
      168.   {
      169.       char **s;

crypto/stack/stack.c:171:9: Taking false branch
      169.       char **s;
      170.   
      171.       if (st == NULL)
                     ^
      172.           return 0;
      173.       if (st->num_alloc <= st->num + 1) {

crypto/stack/stack.c:173:9: Taking false branch
      171.       if (st == NULL)
      172.           return 0;
      173.       if (st->num_alloc <= st->num + 1) {
                     ^
      174.           s = OPENSSL_realloc((char *)st->data,
      175.                               (unsigned int)sizeof(char *) * st->num_alloc * 2);

crypto/stack/stack.c:181:10: Taking true branch
      179.           st->num_alloc *= 2;
      180.       }
      181.       if ((loc >= (int)st->num) || (loc < 0))
                      ^
      182.           st->data[st->num] = data;
      183.       else {

crypto/stack/stack.c:182:9: 
      180.       }
      181.       if ((loc >= (int)st->num) || (loc < 0))
      182. >         st->data[st->num] = data;
      183.       else {
      184.           memmove(&(st->data[loc + 1]),

crypto/stack/stack.c:188:5: 
      186.           st->data[loc] = data;
      187.       }
      188. >     st->num++;
      189.       st->sorted = 0;
      190.       return (st->num);

crypto/stack/stack.c:189:5: 
      187.       }
      188.       st->num++;
      189. >     st->sorted = 0;
      190.       return (st->num);
      191.   }

crypto/stack/stack.c:190:5: 
      188.       st->num++;
      189.       st->sorted = 0;
      190. >     return (st->num);
      191.   }
      192.   

crypto/stack/stack.c:191:1: return from a call to sk_insert
      189.       st->sorted = 0;
      190.       return (st->num);
      191. > }
      192.   
      193.   void *sk_delete_ptr(_STACK *st, void *p)

crypto/stack/stack.c:262:1: return from a call to sk_push
    260.   {
    261.       return (sk_insert(st, data, st->num));
    262. > }
    263.   
    264.   int sk_unshift(_STACK *st, void *data)

crypto/async/async_locl.h:90:1: return from a call to sk_ASYNC_JOB_push
  88.   };
  89.   
  90. > DEFINE_STACK_OF(ASYNC_JOB)
  91.   
  92.   struct async_pool_st {

crypto/async/async.c:389:9: 
387.           job->funcargs = NULL;
388.           sk_ASYNC_JOB_push(pool->jobs, job);
389. >         curr_size++;
390.       }
391.       pool->curr_size = curr_size;

crypto/async/async.c:376:12: Loop condition is true. Entering loop body
374.   
375.       /* Pre-create jobs as required */
376.       while (init_size--) {
                  ^
377.           ASYNC_JOB *job;
378.           job = async_job_new();

crypto/async/async.c:378:9: 
376.       while (init_size--) {
377.           ASYNC_JOB *job;
378. >         job = async_job_new();
379.           if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
380.               /*

crypto/async/async.c:112:1: start of procedure async_job_new()
  110.   }
  111.   
  112. > static ASYNC_JOB *async_job_new(void)
  113.   {
  114.       ASYNC_JOB *job = NULL;

crypto/async/async.c:114:5: 
  112.   static ASYNC_JOB *async_job_new(void)
  113.   {
  114. >     ASYNC_JOB *job = NULL;
  115.       OSSL_ASYNC_FD pipefds[2];
  116.   

crypto/async/async.c:117:5: 
  115.       OSSL_ASYNC_FD pipefds[2];
  116.   
  117. >     job = OPENSSL_malloc(sizeof (ASYNC_JOB));
  118.       if (job == NULL) {
  119.           ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
    118.   }
    119.   
    120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122.       void *ret = NULL;

crypto/mem.c:122:5: 
    120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122. >     void *ret = NULL;
    123.   
    124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
    122.       void *ret = NULL;
    123.   
    124.       if (num <= 0)
                   ^
    125.           return NULL;
    126.   

crypto/mem.c:127:5: 
    125.           return NULL;
    126.   
    127. >     allow_customize = 0;
    128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
    129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
    135.       }
    136.   #else
    137. >     (void)file;
    138.       (void)line;
    139.       ret = malloc(num);

crypto/mem.c:138:5: 
    136.   #else
    137.       (void)file;
    138. >     (void)line;
    139.       ret = malloc(num);
    140.   #endif

crypto/mem.c:139:5: 
    137.       (void)file;
    138.       (void)line;
    139. >     ret = malloc(num);
    140.   #endif
    141.   

crypto/mem.c:154:5: 
    152.   #endif
    153.   
    154. >     return ret;
    155.   }
    156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
    153.   
    154.       return ret;
    155. > }
    156.   
    157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/async/async.c:118:9: Taking false branch
  116.   
  117.       job = OPENSSL_malloc(sizeof (ASYNC_JOB));
  118.       if (job == NULL) {
                 ^
  119.           ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);
  120.           return NULL;

crypto/async/async.c:123:10: 
  121.       }
  122.   
  123. >     if (!async_pipe(pipefds)) {
  124.           OPENSSL_free(job);
  125.           ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);

crypto/async/arch/async_posix.c:115:1: start of procedure async_pipe()
    113.   }
    114.   
    115. > int async_pipe(OSSL_ASYNC_FD *pipefds)
    116.   {
    117.       if (pipe(pipefds) == 0)

crypto/async/arch/async_posix.c:117:9: Taking true branch
    115.   int async_pipe(OSSL_ASYNC_FD *pipefds)
    116.   {
    117.       if (pipe(pipefds) == 0)
                   ^
    118.           return 1;
    119.   

crypto/async/arch/async_posix.c:118:9: 
    116.   {
    117.       if (pipe(pipefds) == 0)
    118. >         return 1;
    119.   
    120.       return 0;

crypto/async/arch/async_posix.c:121:1: return from a call to async_pipe
    119.   
    120.       return 0;
    121. > }
    122.   
    123.   int async_close_fd(OSSL_ASYNC_FD fd)

crypto/async/async.c:123:10: Taking false branch
  121.       }
  122.   
  123.       if (!async_pipe(pipefds)) {
                  ^
  124.           OPENSSL_free(job);
  125.           ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);

crypto/async/async.c:129:5: 
  127.       }
  128.   
  129. >     job->wake_set = 0;
  130.       job->wait_fd = pipefds[0];
  131.       job->wake_fd = pipefds[1];

crypto/async/async.c:130:5: 
  128.   
  129.       job->wake_set = 0;
  130. >     job->wait_fd = pipefds[0];
  131.       job->wake_fd = pipefds[1];
  132.   

crypto/async/async.c:131:5: 
  129.       job->wake_set = 0;
  130.       job->wait_fd = pipefds[0];
  131. >     job->wake_fd = pipefds[1];
  132.   
  133.       job->status = ASYNC_JOB_RUNNING;

crypto/async/async.c:133:5: 
  131.       job->wake_fd = pipefds[1];
  132.   
  133. >     job->status = ASYNC_JOB_RUNNING;
  134.       job->funcargs = NULL;
  135.   

crypto/async/async.c:134:5: 
  132.   
  133.       job->status = ASYNC_JOB_RUNNING;
  134. >     job->funcargs = NULL;
  135.   
  136.       return job;

crypto/async/async.c:136:5: 
  134.       job->funcargs = NULL;
  135.   
  136. >     return job;
  137.   }
  138.   

crypto/async/async.c:137:1: return from a call to async_job_new
  135.   
  136.       return job;
  137. > }
  138.   
  139.   static void async_job_free(ASYNC_JOB *job)

crypto/async/async.c:379:13: Taking false branch
377.           ASYNC_JOB *job;
378.           job = async_job_new();
379.           if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
                   ^
380.               /*
381.                * Not actually fatal because we already created the pool, just

crypto/async/async.c:379:29: 
377.           ASYNC_JOB *job;
378.           job = async_job_new();
379. >         if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
380.               /*
381.                * Not actually fatal because we already created the pool, just

crypto/async/arch/async_posix.c:92:1: start of procedure async_fibre_makecontext()
  90.   }
  91.   
  92. > int async_fibre_makecontext(async_fibre *fibre)
  93.   {
  94.       fibre->env_init = 0;

crypto/async/arch/async_posix.c:94:5: 
  92.   int async_fibre_makecontext(async_fibre *fibre)
  93.   {
  94. >     fibre->env_init = 0;
  95.       if (getcontext(&fibre->fibre) == 0) {
  96.           fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);

crypto/async/arch/async_posix.c:95:9: Taking true branch
  93.   {
  94.       fibre->env_init = 0;
  95.       if (getcontext(&fibre->fibre) == 0) {
                ^
  96.           fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {

crypto/async/arch/async_posix.c:96:9: 
  94.       fibre->env_init = 0;
  95.       if (getcontext(&fibre->fibre) == 0) {
  96. >         fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {
  98.               fibre->fibre.uc_stack.ss_size = STACKSIZE;

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
    118.   }
    119.   
    120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122.       void *ret = NULL;

crypto/mem.c:122:5: 
    120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
    121.   {
    122. >     void *ret = NULL;
    123.   
    124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
    122.       void *ret = NULL;
    123.   
    124.       if (num <= 0)
                   ^
    125.           return NULL;
    126.   

crypto/mem.c:127:5: 
    125.           return NULL;
    126.   
    127. >     allow_customize = 0;
    128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
    129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
    135.       }
    136.   #else
    137. >     (void)file;
    138.       (void)line;
    139.       ret = malloc(num);

crypto/mem.c:138:5: 
    136.   #else
    137.       (void)file;
    138. >     (void)line;
    139.       ret = malloc(num);
    140.   #endif

crypto/mem.c:139:5: 
    137.       (void)file;
    138.       (void)line;
    139. >     ret = malloc(num);
    140.   #endif
    141.   

crypto/mem.c:154:5: 
    152.   #endif
    153.   
    154. >     return ret;
    155.   }
    156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
    153.   
    154.       return ret;
    155. > }
    156.   
    157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/async/arch/async_posix.c:97:13: Taking true branch
  95.       if (getcontext(&fibre->fibre) == 0) {
  96.           fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {
                     ^
  98.               fibre->fibre.uc_stack.ss_size = STACKSIZE;
  99.               fibre->fibre.uc_link = NULL;

crypto/async/arch/async_posix.c:98:13: 
  96.           fibre->fibre.uc_stack.ss_sp = OPENSSL_malloc(STACKSIZE);
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {
  98. >             fibre->fibre.uc_stack.ss_size = STACKSIZE;
  99.               fibre->fibre.uc_link = NULL;
  100.               makecontext(&fibre->fibre, async_start_func, 0);

crypto/async/arch/async_posix.c:99:13: 
  97.           if (fibre->fibre.uc_stack.ss_sp != NULL) {
  98.               fibre->fibre.uc_stack.ss_size = STACKSIZE;
  99. >             fibre->fibre.uc_link = NULL;
  100.               makecontext(&fibre->fibre, async_start_func, 0);
  101.               return 1;

crypto/async/arch/async_posix.c:100:13: Skipping makecontext(): method has no implementation
  98.               fibre->fibre.uc_stack.ss_size = STACKSIZE;
  99.               fibre->fibre.uc_link = NULL;
  100.               makecontext(&fibre->fibre, async_start_func, 0);
                     ^
  101.               return 1;
  102.           }

crypto/async/arch/async_posix.c:101:13: 
  99.               fibre->fibre.uc_link = NULL;
  100.               makecontext(&fibre->fibre, async_start_func, 0);
  101. >             return 1;
  102.           }
  103.       } else {

crypto/async/arch/async_posix.c:107:1: return from a call to async_fibre_makecontext
  105.       }
  106.       return 0;
  107. > }
  108.   
  109.   void async_fibre_free(async_fibre *fibre)

crypto/async/async.c:379:29: Taking false branch
377.           ASYNC_JOB *job;
378.           job = async_job_new();
379.           if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
                                   ^
380.               /*
381.                * Not actually fatal because we already created the pool, just

crypto/async/async.c:387:9: 
385.               break;
386.           }
387. >         job->funcargs = NULL;
388.           sk_ASYNC_JOB_push(pool->jobs, job);
389.           curr_size++;

crypto/async/async.c:388:9: 
386.           }
387.           job->funcargs = NULL;
388. >         sk_ASYNC_JOB_push(pool->jobs, job);
389.           curr_size++;
390.       }

crypto/async/async_locl.h:90:1: start of procedure sk_ASYNC_JOB_push()
  88.   };
  89.   
  90. > DEFINE_STACK_OF(ASYNC_JOB)
  91.   
  92.   struct async_pool_st {

crypto/stack/stack.c:259:1: start of procedure sk_push()
    257.   }
    258.   
    259. > int sk_push(_STACK *st, void *data)
    260.   {
    261.       return (sk_insert(st, data, st->num));

crypto/stack/stack.c:261:5: 
    259.   int sk_push(_STACK *st, void *data)
    260.   {
    261. >     return (sk_insert(st, data, st->num));
    262.   }
    263.   

crypto/stack/stack.c:167:1: start of procedure sk_insert()
      165.   }
      166.   
      167. > int sk_insert(_STACK *st, void *data, int loc)
      168.   {
      169.       char **s;

crypto/stack/stack.c:171:9: Taking false branch
      169.       char **s;
      170.   
      171.       if (st == NULL)
                     ^
      172.           return 0;
      173.       if (st->num_alloc <= st->num + 1) {

crypto/stack/stack.c:173:9: Taking false branch
      171.       if (st == NULL)
      172.           return 0;
      173.       if (st->num_alloc <= st->num + 1) {
                     ^
      174.           s = OPENSSL_realloc((char *)st->data,
      175.                               (unsigned int)sizeof(char *) * st->num_alloc * 2);

crypto/stack/stack.c:181:10: Taking true branch
      179.           st->num_alloc *= 2;
      180.       }
      181.       if ((loc >= (int)st->num) || (loc < 0))
                      ^
      182.           st->data[st->num] = data;
      183.       else {

crypto/stack/stack.c:182:9: 
      180.       }
      181.       if ((loc >= (int)st->num) || (loc < 0))
      182. >         st->data[st->num] = data;
      183.       else {
      184.           memmove(&(st->data[loc + 1]),

crypto/stack/stack.c:188:5: 
      186.           st->data[loc] = data;
      187.       }
      188. >     st->num++;
      189.       st->sorted = 0;
      190.       return (st->num);

crypto/stack/stack.c:189:5: 
      187.       }
      188.       st->num++;
      189. >     st->sorted = 0;
      190.       return (st->num);
      191.   }

crypto/stack/stack.c:190:5: 
      188.       st->num++;
      189.       st->sorted = 0;
      190. >     return (st->num);
      191.   }
      192.   

crypto/stack/stack.c:191:1: return from a call to sk_insert
      189.       st->sorted = 0;
      190.       return (st->num);
      191. > }
      192.   
      193.   void *sk_delete_ptr(_STACK *st, void *p)

crypto/stack/stack.c:262:1: return from a call to sk_push
    260.   {
    261.       return (sk_insert(st, data, st->num));
    262. > }
    263.   
    264.   int sk_unshift(_STACK *st, void *data)

crypto/async/async_locl.h:90:1: return from a call to sk_ASYNC_JOB_push
  88.   };
  89.   
  90. > DEFINE_STACK_OF(ASYNC_JOB)
  91.   
  92.   struct async_pool_st {
