test/curve448_internal_test.c:649: error: MEMORY_LEAK
  memory dynamically allocated by call to `EVP_MD_CTX_new()` at line 611, column 27 is not reachable after line 649, column 9.
Showing all 105 steps of the trace


test/curve448_internal_test.c:608:1: start of procedure test_ed448()
606.   }
607.   
608. > static int test_ed448(void)
609.   {
610.       uint8_t outsig[114];

test/curve448_internal_test.c:611:5: 
609.   {
610.       uint8_t outsig[114];
611. >     EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
612.   
613.       if (!TEST_ptr(hashctx)

crypto/evp/digest.c:44:1: start of procedure EVP_MD_CTX_new()
  42.   }
  43.   
  44. > EVP_MD_CTX *EVP_MD_CTX_new(void)
  45.   {
  46.       return OPENSSL_zalloc(sizeof(EVP_MD_CTX));

crypto/evp/digest.c:46:5: 
  44.   EVP_MD_CTX *EVP_MD_CTX_new(void)
  45.   {
  46. >     return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
  47.   }
  48.   

crypto/mem.c:228:1: start of procedure CRYPTO_zalloc()
    226.   }
    227.   
    228. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
    229.   {
    230.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:230:5: 
    228.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
    229.   {
    230. >     void *ret = CRYPTO_malloc(num, file, line);
    231.   
    232.       FAILTEST();

crypto/mem.c:192:1: start of procedure CRYPTO_malloc()
      190.   #endif
      191.   
      192. > void *CRYPTO_malloc(size_t num, const char *file, int line)
      193.   {
      194.       void *ret = NULL;

crypto/mem.c:194:5: 
      192.   void *CRYPTO_malloc(size_t num, const char *file, int line)
      193.   {
      194. >     void *ret = NULL;
      195.   
      196.       INCREMENT(malloc_count);

crypto/mem.c:197:9: Taking false branch
      195.   
      196.       INCREMENT(malloc_count);
      197.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                     ^
      198.           return malloc_impl(num, file, line);
      199.   

crypto/mem.c:200:9: Taking false branch
      198.           return malloc_impl(num, file, line);
      199.   
      200.       if (num == 0)
                     ^
      201.           return NULL;
      202.   

crypto/mem.c:204:9: Taking true branch
      202.   
      203.       FAILTEST();
      204.       if (allow_customize) {
                     ^
      205.           /*
      206.            * Disallow customization after the first allocation. We only set this

crypto/mem.c:210:9: 
      208.            * allocation.
      209.            */
      210. >         allow_customize = 0;
      211.       }
      212.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG

crypto/mem.c:221:5: 
      219.       }
      220.   #else
      221. >     (void)(file); (void)(line);
      222.       ret = malloc(num);
      223.   #endif

crypto/mem.c:221:19: 
      219.       }
      220.   #else
      221. >     (void)(file); (void)(line);
      222.       ret = malloc(num);
      223.   #endif

crypto/mem.c:222:5: 
      220.   #else
      221.       (void)(file); (void)(line);
      222. >     ret = malloc(num);
      223.   #endif
      224.   

crypto/mem.c:225:5: 
      223.   #endif
      224.   
      225. >     return ret;
      226.   }
      227.   

crypto/mem.c:226:1: return from a call to CRYPTO_malloc
      224.   
      225.       return ret;
      226. > }
      227.   
      228.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:233:9: Taking true branch
    231.   
    232.       FAILTEST();
    233.       if (ret != NULL)
                   ^
    234.           memset(ret, 0, num);
    235.       return ret;

crypto/mem.c:234:9: 
    232.       FAILTEST();
    233.       if (ret != NULL)
    234. >         memset(ret, 0, num);
    235.       return ret;
    236.   }

crypto/mem.c:235:5: 
    233.       if (ret != NULL)
    234.           memset(ret, 0, num);
    235. >     return ret;
    236.   }
    237.   

crypto/mem.c:236:1: return from a call to CRYPTO_zalloc
    234.           memset(ret, 0, num);
    235.       return ret;
    236. > }
    237.   
    238.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/evp/digest.c:47:1: return from a call to EVP_MD_CTX_new
  45.   {
  46.       return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
  47. > }
  48.   
  49.   void EVP_MD_CTX_free(EVP_MD_CTX *ctx)

test/curve448_internal_test.c:613:10: 
611.       EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
612.   
613. >     if (!TEST_ptr(hashctx)
614.               || !TEST_true(ED448_sign(outsig, NULL, 0, pubkey1, privkey1, NULL,
615.                                        0))

test/testutil/tests.c:228:1: start of procedure test_ptr()
  226.   }
  227.   
  228. > int test_ptr(const char *file, int line, const char *s, const void *p)
  229.   {
  230.       if (p != NULL)

test/testutil/tests.c:230:9: Taking true branch
  228.   int test_ptr(const char *file, int line, const char *s, const void *p)
  229.   {
  230.       if (p != NULL)
                 ^
  231.           return 1;
  232.       test_fail_message(NULL, file, line, "ptr", s, "NULL", "!=", "%p", p);

test/testutil/tests.c:231:9: 
  229.   {
  230.       if (p != NULL)
  231. >         return 1;
  232.       test_fail_message(NULL, file, line, "ptr", s, "NULL", "!=", "%p", p);
  233.       return 0;

test/testutil/tests.c:234:1: return from a call to test_ptr
  232.       test_fail_message(NULL, file, line, "ptr", s, "NULL", "!=", "%p", p);
  233.       return 0;
  234. > }
  235.   
  236.   int test_true(const char *file, int line, const char *s, int b)

test/curve448_internal_test.c:613:10: Taking false branch
611.       EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
612.   
613.       if (!TEST_ptr(hashctx)
                ^
614.               || !TEST_true(ED448_sign(outsig, NULL, 0, pubkey1, privkey1, NULL,
615.                                        0))

test/curve448_internal_test.c:614:17: 
612.   
613.       if (!TEST_ptr(hashctx)
614. >             || !TEST_true(ED448_sign(outsig, NULL, 0, pubkey1, privkey1, NULL,
615.                                        0))
616.               || !TEST_int_eq(memcmp(sig1, outsig, sizeof(sig1)), 0)

crypto/ec/curve448/eddsa.c:314:1: start of procedure ED448_sign()
  312.   }
  313.   
  314. > int ED448_sign(uint8_t *out_sig, const uint8_t *message, size_t message_len,
  315.                  const uint8_t public_key[57], const uint8_t private_key[57],
  316.                  const uint8_t *context, size_t context_len)

crypto/ec/curve448/eddsa.c:318:12: 
  316.                  const uint8_t *context, size_t context_len)
  317.   {
  318. >     return c448_ed448_sign(out_sig, private_key, public_key, message,
  319.                              message_len, 0, context, context_len)
  320.           == C448_SUCCESS;

crypto/ec/curve448/eddsa.c:126:1: start of procedure c448_ed448_sign()
    124.   }
    125.   
    126. > c448_error_t c448_ed448_sign(
    127.                           uint8_t signature[EDDSA_448_SIGNATURE_BYTES],
    128.                           const uint8_t privkey[EDDSA_448_PRIVATE_BYTES],

crypto/ec/curve448/eddsa.c:135:5: 
    133.   {
    134.       curve448_scalar_t secret_scalar;
    135. >     EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
    136.       c448_error_t ret = C448_FAILURE;
    137.       curve448_scalar_t nonce_scalar;

crypto/evp/digest.c:44:1: start of procedure EVP_MD_CTX_new()
      42.   }
      43.   
      44. > EVP_MD_CTX *EVP_MD_CTX_new(void)
      45.   {
      46.       return OPENSSL_zalloc(sizeof(EVP_MD_CTX));

crypto/evp/digest.c:46:5: 
      44.   EVP_MD_CTX *EVP_MD_CTX_new(void)
      45.   {
      46. >     return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
      47.   }
      48.   

crypto/mem.c:228:1: start of procedure CRYPTO_zalloc()
        226.   }
        227.   
        228. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
        229.   {
        230.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:230:5: 
        228.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
        229.   {
        230. >     void *ret = CRYPTO_malloc(num, file, line);
        231.   
        232.       FAILTEST();

crypto/mem.c:192:1: start of procedure CRYPTO_malloc()
          190.   #endif
          191.   
          192. > void *CRYPTO_malloc(size_t num, const char *file, int line)
          193.   {
          194.       void *ret = NULL;

crypto/mem.c:194:5: 
          192.   void *CRYPTO_malloc(size_t num, const char *file, int line)
          193.   {
          194. >     void *ret = NULL;
          195.   
          196.       INCREMENT(malloc_count);

crypto/mem.c:197:9: Taking true branch
          195.   
          196.       INCREMENT(malloc_count);
          197.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                         ^
          198.           return malloc_impl(num, file, line);
          199.   

crypto/mem.c:197:32: Taking true branch
          195.   
          196.       INCREMENT(malloc_count);
          197.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                                                ^
          198.           return malloc_impl(num, file, line);
          199.   

crypto/mem.c:198:9: Skipping __function_pointer__(): unresolved function pointer
          196.       INCREMENT(malloc_count);
          197.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
          198.           return malloc_impl(num, file, line);
                         ^
          199.   
          200.       if (num == 0)

crypto/mem.c:226:1: return from a call to CRYPTO_malloc
          224.   
          225.       return ret;
          226. > }
          227.   
          228.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:233:9: Taking true branch
        231.   
        232.       FAILTEST();
        233.       if (ret != NULL)
                       ^
        234.           memset(ret, 0, num);
        235.       return ret;

crypto/mem.c:234:9: 
        232.       FAILTEST();
        233.       if (ret != NULL)
        234. >         memset(ret, 0, num);
        235.       return ret;
        236.   }

crypto/mem.c:235:5: 
        233.       if (ret != NULL)
        234.           memset(ret, 0, num);
        235. >     return ret;
        236.   }
        237.   

crypto/mem.c:236:1: return from a call to CRYPTO_zalloc
        234.           memset(ret, 0, num);
        235.       return ret;
        236. > }
        237.   
        238.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/evp/digest.c:47:1: return from a call to EVP_MD_CTX_new
      45.   {
      46.       return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
      47. > }
      48.   
      49.   void EVP_MD_CTX_free(EVP_MD_CTX *ctx)

crypto/ec/curve448/eddsa.c:136:5: 
    134.       curve448_scalar_t secret_scalar;
    135.       EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
    136. >     c448_error_t ret = C448_FAILURE;
    137.       curve448_scalar_t nonce_scalar;
    138.       uint8_t nonce_point[EDDSA_448_PUBLIC_BYTES] = { 0 };

crypto/ec/curve448/eddsa.c:138:5: 
    136.       c448_error_t ret = C448_FAILURE;
    137.       curve448_scalar_t nonce_scalar;
    138. >     uint8_t nonce_point[EDDSA_448_PUBLIC_BYTES] = { 0 };
    139.       unsigned int c;
    140.       curve448_scalar_t challenge_scalar;

crypto/ec/curve448/eddsa.c:142:9: Taking false branch
    140.       curve448_scalar_t challenge_scalar;
    141.   
    142.       if (hashctx == NULL)
                   ^
    143.           return C448_FAILURE;
    144.   

crypto/ec/curve448/eddsa.c:152:14: 
    150.           uint8_t expanded[EDDSA_448_PRIVATE_BYTES * 2];
    151.   
    152. >         if (!oneshot_hash(expanded, sizeof(expanded), privkey,
    153.                             EDDSA_448_PRIVATE_BYTES))
    154.               goto err;

crypto/ec/curve448/eddsa.c:22:1: start of procedure oneshot_hash()
      20.   #define COFACTOR 4
      21.   
      22. > static c448_error_t oneshot_hash(uint8_t *out, size_t outlen,
      23.                                    const uint8_t *in, size_t inlen)
      24.   {

crypto/ec/curve448/eddsa.c:25:5: 
      23.                                    const uint8_t *in, size_t inlen)
      24.   {
      25. >     EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
      26.   
      27.       if (hashctx == NULL)

crypto/evp/digest.c:44:1: start of procedure EVP_MD_CTX_new()
        42.   }
        43.   
        44. > EVP_MD_CTX *EVP_MD_CTX_new(void)
        45.   {
        46.       return OPENSSL_zalloc(sizeof(EVP_MD_CTX));

crypto/evp/digest.c:46:5: 
        44.   EVP_MD_CTX *EVP_MD_CTX_new(void)
        45.   {
        46. >     return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
        47.   }
        48.   

crypto/mem.c:228:1: start of procedure CRYPTO_zalloc()
          226.   }
          227.   
          228. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
          229.   {
          230.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:230:5: 
          228.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
          229.   {
          230. >     void *ret = CRYPTO_malloc(num, file, line);
          231.   
          232.       FAILTEST();

crypto/mem.c:192:1: start of procedure CRYPTO_malloc()
            190.   #endif
            191.   
            192. > void *CRYPTO_malloc(size_t num, const char *file, int line)
            193.   {
            194.       void *ret = NULL;

crypto/mem.c:194:5: 
            192.   void *CRYPTO_malloc(size_t num, const char *file, int line)
            193.   {
            194. >     void *ret = NULL;
            195.   
            196.       INCREMENT(malloc_count);

crypto/mem.c:197:9: Taking true branch
            195.   
            196.       INCREMENT(malloc_count);
            197.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                           ^
            198.           return malloc_impl(num, file, line);
            199.   

crypto/mem.c:197:32: Taking true branch
            195.   
            196.       INCREMENT(malloc_count);
            197.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                                                  ^
            198.           return malloc_impl(num, file, line);
            199.   

crypto/mem.c:198:9: Skipping __function_pointer__(): unresolved function pointer
            196.       INCREMENT(malloc_count);
            197.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
            198.           return malloc_impl(num, file, line);
                           ^
            199.   
            200.       if (num == 0)

crypto/mem.c:226:1: return from a call to CRYPTO_malloc
            224.   
            225.       return ret;
            226. > }
            227.   
            228.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:233:9: Taking false branch
          231.   
          232.       FAILTEST();
          233.       if (ret != NULL)
                         ^
          234.           memset(ret, 0, num);
          235.       return ret;

crypto/mem.c:235:5: 
          233.       if (ret != NULL)
          234.           memset(ret, 0, num);
          235. >     return ret;
          236.   }
          237.   

crypto/mem.c:236:1: return from a call to CRYPTO_zalloc
          234.           memset(ret, 0, num);
          235.       return ret;
          236. > }
          237.   
          238.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/evp/digest.c:47:1: return from a call to EVP_MD_CTX_new
        45.   {
        46.       return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
        47. > }
        48.   
        49.   void EVP_MD_CTX_free(EVP_MD_CTX *ctx)

crypto/ec/curve448/eddsa.c:27:9: Taking true branch
      25.       EVP_MD_CTX *hashctx = EVP_MD_CTX_new();
      26.   
      27.       if (hashctx == NULL)
                    ^
      28.           return C448_FAILURE;
      29.   

crypto/ec/curve448/eddsa.c:28:9: 
      26.   
      27.       if (hashctx == NULL)
      28. >         return C448_FAILURE;
      29.   
      30.       if (!EVP_DigestInit_ex(hashctx, EVP_shake256(), NULL)

crypto/ec/curve448/eddsa.c:39:1: return from a call to oneshot_hash
      37.       EVP_MD_CTX_free(hashctx);
      38.       return C448_SUCCESS;
      39. > }
      40.   
      41.   static void clamp(uint8_t secret_scalar_ser[EDDSA_448_PRIVATE_BYTES])

crypto/ec/curve448/eddsa.c:152:14: Taking true branch
    150.           uint8_t expanded[EDDSA_448_PRIVATE_BYTES * 2];
    151.   
    152.           if (!oneshot_hash(expanded, sizeof(expanded), privkey,
                        ^
    153.                             EDDSA_448_PRIVATE_BYTES))
    154.               goto err;

crypto/ec/curve448/eddsa.c:228:2: 
    226.   
    227.       ret = C448_SUCCESS;
    228. >  err:
    229.       EVP_MD_CTX_free(hashctx);
    230.       return ret;

crypto/ec/curve448/eddsa.c:229:5: 
    227.       ret = C448_SUCCESS;
    228.    err:
    229. >     EVP_MD_CTX_free(hashctx);
    230.       return ret;
    231.   }

crypto/evp/digest.c:49:1: start of procedure EVP_MD_CTX_free()
      47.   }
      48.   
      49. > void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
      50.   {
      51.       EVP_MD_CTX_reset(ctx);

crypto/evp/digest.c:51:5: Skipping EVP_MD_CTX_reset(): empty list of specs
      49.   void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
      50.   {
      51.       EVP_MD_CTX_reset(ctx);
                ^
      52.       OPENSSL_free(ctx);
      53.   }

crypto/evp/digest.c:52:5: 
      50.   {
      51.       EVP_MD_CTX_reset(ctx);
      52. >     OPENSSL_free(ctx);
      53.   }
      54.   

crypto/mem.c:295:1: start of procedure CRYPTO_free()
        293.   }
        294.   
        295. > void CRYPTO_free(void *str, const char *file, int line)
        296.   {
        297.       INCREMENT(free_count);

crypto/mem.c:298:9: Taking false branch
        296.   {
        297.       INCREMENT(free_count);
        298.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
                       ^
        299.           free_impl(str, file, line);
        300.           return;

crypto/mem.c:312:5: 
        310.       }
        311.   #else
        312. >     free(str);
        313.   #endif
        314.   }

crypto/mem.c:314:1: return from a call to CRYPTO_free
        312.       free(str);
        313.   #endif
        314. > }
        315.   
        316.   void CRYPTO_clear_free(void *str, size_t num, const char *file, int line)

crypto/evp/digest.c:53:1: return from a call to EVP_MD_CTX_free
      51.       EVP_MD_CTX_reset(ctx);
      52.       OPENSSL_free(ctx);
      53. > }
      54.   
      55.   int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)

crypto/ec/curve448/eddsa.c:230:5: 
    228.    err:
    229.       EVP_MD_CTX_free(hashctx);
    230. >     return ret;
    231.   }
    232.   

crypto/ec/curve448/eddsa.c:231:1: return from a call to c448_ed448_sign
    229.       EVP_MD_CTX_free(hashctx);
    230.       return ret;
    231. > }
    232.   
    233.   c448_error_t c448_ed448_sign_prehash(

crypto/ec/curve448/eddsa.c:318:12: Condition is false
  316.                  const uint8_t *context, size_t context_len)
  317.   {
  318.       return c448_ed448_sign(out_sig, private_key, public_key, message,
                    ^
  319.                              message_len, 0, context, context_len)
  320.           == C448_SUCCESS;

crypto/ec/curve448/eddsa.c:318:5: 
  316.                  const uint8_t *context, size_t context_len)
  317.   {
  318. >     return c448_ed448_sign(out_sig, private_key, public_key, message,
  319.                              message_len, 0, context, context_len)
  320.           == C448_SUCCESS;

crypto/ec/curve448/eddsa.c:321:1: return from a call to ED448_sign
  319.                              message_len, 0, context, context_len)
  320.           == C448_SUCCESS;
  321. > }
  322.   
  323.   int ED448_verify(const uint8_t *message, size_t message_len,

test/curve448_internal_test.c:614:17: Condition is false
612.   
613.       if (!TEST_ptr(hashctx)
614.               || !TEST_true(ED448_sign(outsig, NULL, 0, pubkey1, privkey1, NULL,
                       ^
615.                                        0))
616.               || !TEST_int_eq(memcmp(sig1, outsig, sizeof(sig1)), 0)

test/testutil/tests.c:236:1: start of procedure test_true()
  234.   }
  235.   
  236. > int test_true(const char *file, int line, const char *s, int b)
  237.   {
  238.       if (b)

test/testutil/tests.c:238:9: Taking false branch
  236.   int test_true(const char *file, int line, const char *s, int b)
  237.   {
  238.       if (b)
                 ^
  239.           return 1;
  240.       test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");

test/testutil/tests.c:240:5: Skipping test_fail_message(): empty list of specs
  238.       if (b)
  239.           return 1;
  240.       test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");
             ^
  241.       return 0;
  242.   }

test/testutil/tests.c:241:5: 
  239.           return 1;
  240.       test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");
  241. >     return 0;
  242.   }
  243.   

test/testutil/tests.c:242:1: return from a call to test_true
  240.       test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");
  241.       return 0;
  242. > }
  243.   
  244.   int test_false(const char *file, int line, const char *s, int b)

test/curve448_internal_test.c:614:17: Taking true branch
612.   
613.       if (!TEST_ptr(hashctx)
614.               || !TEST_true(ED448_sign(outsig, NULL, 0, pubkey1, privkey1, NULL,
                       ^
615.                                        0))
616.               || !TEST_int_eq(memcmp(sig1, outsig, sizeof(sig1)), 0)

test/curve448_internal_test.c:649:9: 
647.                                          phcontext2, sizeof(phcontext2)))
648.               || !TEST_int_eq(memcmp(phsig2, outsig, sizeof(phsig2)), 0)) {
649. >         EVP_MD_CTX_free(hashctx);
650.           return 0;
651.       }

crypto/evp/digest.c:49:1: start of procedure EVP_MD_CTX_free()
  47.   }
  48.   
  49. > void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
  50.   {
  51.       EVP_MD_CTX_reset(ctx);

crypto/evp/digest.c:51:5: Skipping EVP_MD_CTX_reset(): empty list of specs
  49.   void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
  50.   {
  51.       EVP_MD_CTX_reset(ctx);
            ^
  52.       OPENSSL_free(ctx);
  53.   }

crypto/evp/digest.c:52:5: 
  50.   {
  51.       EVP_MD_CTX_reset(ctx);
  52. >     OPENSSL_free(ctx);
  53.   }
  54.   

crypto/mem.c:295:1: start of procedure CRYPTO_free()
    293.   }
    294.   
    295. > void CRYPTO_free(void *str, const char *file, int line)
    296.   {
    297.       INCREMENT(free_count);

crypto/mem.c:298:9: Taking true branch
    296.   {
    297.       INCREMENT(free_count);
    298.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
                   ^
    299.           free_impl(str, file, line);
    300.           return;

crypto/mem.c:298:30: Taking true branch
    296.   {
    297.       INCREMENT(free_count);
    298.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
                                        ^
    299.           free_impl(str, file, line);
    300.           return;

crypto/mem.c:299:9: Skipping __function_pointer__(): unresolved function pointer
    297.       INCREMENT(free_count);
    298.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
    299.           free_impl(str, file, line);
                   ^
    300.           return;
    301.       }

crypto/mem.c:300:9: 
    298.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
    299.           free_impl(str, file, line);
    300. >         return;
    301.       }
    302.   

crypto/mem.c:314:1: return from a call to CRYPTO_free
    312.       free(str);
    313.   #endif
    314. > }
    315.   
    316.   void CRYPTO_clear_free(void *str, size_t num, const char *file, int line)

crypto/evp/digest.c:53:1: return from a call to EVP_MD_CTX_free
  51.       EVP_MD_CTX_reset(ctx);
  52.       OPENSSL_free(ctx);
  53. > }
  54.   
  55.   int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
