crypto/dh/dh_pmeth.c:367: error: MEMORY_LEAK
  memory dynamically allocated by call to `DH_get_2048_256()` at line 361, column 18 is not reachable after line 367, column 9.
Showing all 126 steps of the trace


crypto/dh/dh_pmeth.c:344:1: start of procedure pkey_dh_paramgen()
342.   #endif
343.   
344. > static int pkey_dh_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
345.   {
346.       DH *dh = NULL;

crypto/dh/dh_pmeth.c:346:5: 
344.   static int pkey_dh_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
345.   {
346. >     DH *dh = NULL;
347.       DH_PKEY_CTX *dctx = ctx->data;
348.       BN_GENCB *pcb;

crypto/dh/dh_pmeth.c:347:5: 
345.   {
346.       DH *dh = NULL;
347. >     DH_PKEY_CTX *dctx = ctx->data;
348.       BN_GENCB *pcb;
349.       int ret;

crypto/dh/dh_pmeth.c:350:9: Taking true branch
348.       BN_GENCB *pcb;
349.       int ret;
350.       if (dctx->rfc5114_param) {
               ^
351.           switch (dctx->rfc5114_param) {
352.           case 1:

crypto/dh/dh_pmeth.c:351:9: 
349.       int ret;
350.       if (dctx->rfc5114_param) {
351. >         switch (dctx->rfc5114_param) {
352.           case 1:
353.               dh = DH_get_1024_160();

crypto/dh/dh_pmeth.c:352:9: Switch condition is false. Skipping switch case
350.       if (dctx->rfc5114_param) {
351.           switch (dctx->rfc5114_param) {
352.           case 1:
               ^
353.               dh = DH_get_1024_160();
354.               break;

crypto/dh/dh_pmeth.c:356:9: Switch condition is false. Skipping switch case
354.               break;
355.   
356.           case 2:
               ^
357.               dh = DH_get_2048_224();
358.               break;

crypto/dh/dh_pmeth.c:360:9: Switch condition is true. Entering switch case
358.               break;
359.   
360.           case 3:
               ^
361.               dh = DH_get_2048_256();
362.               break;

crypto/dh/dh_pmeth.c:361:13: 
359.   
360.           case 3:
361. >             dh = DH_get_2048_256();
362.               break;
363.   

crypto/dh/dh_rfc5114.c:90:1: start of procedure DH_get_2048_256()
  88.   make_dh(1024_160)
  89.   make_dh(2048_224)
  90. > make_dh(2048_256)

crypto/dh/dh_rfc5114.c:90:1: Taking false branch
  88.   make_dh(1024_160)
  89.   make_dh(2048_224)
  90. > make_dh(2048_256)

crypto/bn/bn_lib.c:410:1: start of procedure BN_dup()
    408.   }
    409.   
    410. > BIGNUM *BN_dup(const BIGNUM *a)
    411.   {
    412.       BIGNUM *t;

crypto/bn/bn_lib.c:414:9: Taking false branch
    412.       BIGNUM *t;
    413.   
    414.       if (a == NULL)
                   ^
    415.           return NULL;
    416.       bn_check_top(a);

crypto/bn/bn_lib.c:418:9: 
    416.       bn_check_top(a);
    417.   
    418. >     t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:965:1: start of procedure BN_get_flags()
      963.   }
      964.   
      965. > int BN_get_flags(const BIGNUM *b, int n)
      966.   {
      967.       return b->flags & n;

crypto/bn/bn_lib.c:967:5: 
      965.   int BN_get_flags(const BIGNUM *b, int n)
      966.   {
      967. >     return b->flags & n;
      968.   }
      969.   

crypto/bn/bn_lib.c:968:1: return from a call to BN_get_flags
      966.   {
      967.       return b->flags & n;
      968. > }
      969.   
      970.   /* Populate a BN_GENCB structure with an "old"-style callback */

crypto/bn/bn_lib.c:418:9: Condition is false
    416.       bn_check_top(a);
    417.   
    418.       t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
                   ^
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:277:1: start of procedure BN_new()
      275.   }
      276.   
      277. > BIGNUM *BN_new(void)
      278.   {
      279.       BIGNUM *ret;

crypto/bn/bn_lib.c:281:9: 
      279.       BIGNUM *ret;
      280.   
      281. >     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
      282.           BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);
      283.           return (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/bn/bn_lib.c:281:9: Taking false branch
      279.       BIGNUM *ret;
      280.   
      281.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
                     ^
      282.           BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);
      283.           return (NULL);

crypto/bn/bn_lib.c:285:5: 
      283.           return (NULL);
      284.       }
      285. >     ret->flags = BN_FLG_MALLOCED;
      286.       bn_check_top(ret);
      287.       return (ret);

crypto/bn/bn_lib.c:287:5: 
      285.       ret->flags = BN_FLG_MALLOCED;
      286.       bn_check_top(ret);
      287. >     return (ret);
      288.   }
      289.   

crypto/bn/bn_lib.c:288:1: return from a call to BN_new
      286.       bn_check_top(ret);
      287.       return (ret);
      288. > }
      289.   
      290.    BIGNUM *BN_secure_new(void)

crypto/bn/bn_lib.c:418:5: 
    416.       bn_check_top(a);
    417.   
    418. >     t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:419:9: Taking false branch
    417.   
    418.       t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
                   ^
    420.           return NULL;
    421.       if (!BN_copy(t, a)) {

crypto/bn/bn_lib.c:421:10: Taking false branch
    419.       if (t == NULL)
    420.           return NULL;
    421.       if (!BN_copy(t, a)) {
                    ^
    422.           BN_free(t);
    423.           return NULL;

crypto/bn/bn_lib.c:426:5: 
    424.       }
    425.       bn_check_top(t);
    426. >     return t;
    427.   }
    428.   

crypto/bn/bn_lib.c:427:1: return from a call to BN_dup
    425.       bn_check_top(t);
    426.       return t;
    427. > }
    428.   
    429.   BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)

crypto/dh/dh_rfc5114.c:90:1: 
  88.   make_dh(1024_160)
  89.   make_dh(2048_224)
  90. > make_dh(2048_256)

crypto/bn/bn_lib.c:410:1: start of procedure BN_dup()
    408.   }
    409.   
    410. > BIGNUM *BN_dup(const BIGNUM *a)
    411.   {
    412.       BIGNUM *t;

crypto/bn/bn_lib.c:414:9: Taking false branch
    412.       BIGNUM *t;
    413.   
    414.       if (a == NULL)
                   ^
    415.           return NULL;
    416.       bn_check_top(a);

crypto/bn/bn_lib.c:418:9: 
    416.       bn_check_top(a);
    417.   
    418. >     t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:965:1: start of procedure BN_get_flags()
      963.   }
      964.   
      965. > int BN_get_flags(const BIGNUM *b, int n)
      966.   {
      967.       return b->flags & n;

crypto/bn/bn_lib.c:967:5: 
      965.   int BN_get_flags(const BIGNUM *b, int n)
      966.   {
      967. >     return b->flags & n;
      968.   }
      969.   

crypto/bn/bn_lib.c:968:1: return from a call to BN_get_flags
      966.   {
      967.       return b->flags & n;
      968. > }
      969.   
      970.   /* Populate a BN_GENCB structure with an "old"-style callback */

crypto/bn/bn_lib.c:418:9: Condition is false
    416.       bn_check_top(a);
    417.   
    418.       t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
                   ^
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:277:1: start of procedure BN_new()
      275.   }
      276.   
      277. > BIGNUM *BN_new(void)
      278.   {
      279.       BIGNUM *ret;

crypto/bn/bn_lib.c:281:9: 
      279.       BIGNUM *ret;
      280.   
      281. >     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
      282.           BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);
      283.           return (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/bn/bn_lib.c:281:9: Taking false branch
      279.       BIGNUM *ret;
      280.   
      281.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
                     ^
      282.           BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);
      283.           return (NULL);

crypto/bn/bn_lib.c:285:5: 
      283.           return (NULL);
      284.       }
      285. >     ret->flags = BN_FLG_MALLOCED;
      286.       bn_check_top(ret);
      287.       return (ret);

crypto/bn/bn_lib.c:287:5: 
      285.       ret->flags = BN_FLG_MALLOCED;
      286.       bn_check_top(ret);
      287. >     return (ret);
      288.   }
      289.   

crypto/bn/bn_lib.c:288:1: return from a call to BN_new
      286.       bn_check_top(ret);
      287.       return (ret);
      288. > }
      289.   
      290.    BIGNUM *BN_secure_new(void)

crypto/bn/bn_lib.c:418:5: 
    416.       bn_check_top(a);
    417.   
    418. >     t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:419:9: Taking false branch
    417.   
    418.       t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
                   ^
    420.           return NULL;
    421.       if (!BN_copy(t, a)) {

crypto/bn/bn_lib.c:421:10: Taking false branch
    419.       if (t == NULL)
    420.           return NULL;
    421.       if (!BN_copy(t, a)) {
                    ^
    422.           BN_free(t);
    423.           return NULL;

crypto/bn/bn_lib.c:426:5: 
    424.       }
    425.       bn_check_top(t);
    426. >     return t;
    427.   }
    428.   

crypto/bn/bn_lib.c:427:1: return from a call to BN_dup
    425.       bn_check_top(t);
    426.       return t;
    427. > }
    428.   
    429.   BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)

crypto/dh/dh_rfc5114.c:90:1: 
  88.   make_dh(1024_160)
  89.   make_dh(2048_224)
  90. > make_dh(2048_256)

crypto/bn/bn_lib.c:410:1: start of procedure BN_dup()
    408.   }
    409.   
    410. > BIGNUM *BN_dup(const BIGNUM *a)
    411.   {
    412.       BIGNUM *t;

crypto/bn/bn_lib.c:414:9: Taking false branch
    412.       BIGNUM *t;
    413.   
    414.       if (a == NULL)
                   ^
    415.           return NULL;
    416.       bn_check_top(a);

crypto/bn/bn_lib.c:418:9: 
    416.       bn_check_top(a);
    417.   
    418. >     t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:965:1: start of procedure BN_get_flags()
      963.   }
      964.   
      965. > int BN_get_flags(const BIGNUM *b, int n)
      966.   {
      967.       return b->flags & n;

crypto/bn/bn_lib.c:967:5: 
      965.   int BN_get_flags(const BIGNUM *b, int n)
      966.   {
      967. >     return b->flags & n;
      968.   }
      969.   

crypto/bn/bn_lib.c:968:1: return from a call to BN_get_flags
      966.   {
      967.       return b->flags & n;
      968. > }
      969.   
      970.   /* Populate a BN_GENCB structure with an "old"-style callback */

crypto/bn/bn_lib.c:418:9: Condition is false
    416.       bn_check_top(a);
    417.   
    418.       t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
                   ^
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:277:1: start of procedure BN_new()
      275.   }
      276.   
      277. > BIGNUM *BN_new(void)
      278.   {
      279.       BIGNUM *ret;

crypto/bn/bn_lib.c:281:9: 
      279.       BIGNUM *ret;
      280.   
      281. >     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
      282.           BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);
      283.           return (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/bn/bn_lib.c:281:9: Taking false branch
      279.       BIGNUM *ret;
      280.   
      281.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
                     ^
      282.           BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);
      283.           return (NULL);

crypto/bn/bn_lib.c:285:5: 
      283.           return (NULL);
      284.       }
      285. >     ret->flags = BN_FLG_MALLOCED;
      286.       bn_check_top(ret);
      287.       return (ret);

crypto/bn/bn_lib.c:287:5: 
      285.       ret->flags = BN_FLG_MALLOCED;
      286.       bn_check_top(ret);
      287. >     return (ret);
      288.   }
      289.   

crypto/bn/bn_lib.c:288:1: return from a call to BN_new
      286.       bn_check_top(ret);
      287.       return (ret);
      288. > }
      289.   
      290.    BIGNUM *BN_secure_new(void)

crypto/bn/bn_lib.c:418:5: 
    416.       bn_check_top(a);
    417.   
    418. >     t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
    420.           return NULL;

crypto/bn/bn_lib.c:419:9: Taking false branch
    417.   
    418.       t = BN_get_flags(a, BN_FLG_SECURE) ? BN_secure_new() : BN_new();
    419.       if (t == NULL)
                   ^
    420.           return NULL;
    421.       if (!BN_copy(t, a)) {

crypto/bn/bn_lib.c:421:10: Taking false branch
    419.       if (t == NULL)
    420.           return NULL;
    421.       if (!BN_copy(t, a)) {
                    ^
    422.           BN_free(t);
    423.           return NULL;

crypto/bn/bn_lib.c:426:5: 
    424.       }
    425.       bn_check_top(t);
    426. >     return t;
    427.   }
    428.   

crypto/bn/bn_lib.c:427:1: return from a call to BN_dup
    425.       bn_check_top(t);
    426.       return t;
    427. > }
    428.   
    429.   BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)

crypto/dh/dh_rfc5114.c:90:1: Taking false branch
  88.   make_dh(1024_160)
  89.   make_dh(2048_224)
  90. > make_dh(2048_256)

crypto/dh/dh_rfc5114.c:90:1: Taking false branch
  88.   make_dh(1024_160)
  89.   make_dh(2048_224)
  90. > make_dh(2048_256)

crypto/dh/dh_rfc5114.c:90:1: Taking false branch
  88.   make_dh(1024_160)
  89.   make_dh(2048_224)
  90. > make_dh(2048_256)

crypto/dh/dh_rfc5114.c:90:1: return from a call to DH_get_2048_256
  88.   make_dh(1024_160)
  89.   make_dh(2048_224)
  90. > make_dh(2048_256)

crypto/dh/dh_pmeth.c:367:9: 
365.               return -2;
366.           }
367. >         EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);
368.           return 1;
369.       }

crypto/evp/p_lib.c:270:1: start of procedure EVP_PKEY_assign()
  268.   }
  269.   
  270. > int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key)
  271.   {
  272.       if (pkey == NULL || !EVP_PKEY_set_type(pkey, type))

crypto/evp/p_lib.c:272:9: Taking false branch
  270.   int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key)
  271.   {
  272.       if (pkey == NULL || !EVP_PKEY_set_type(pkey, type))
                 ^
  273.           return 0;
  274.       pkey->pkey.ptr = key;

crypto/evp/p_lib.c:272:26: 
  270.   int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key)
  271.   {
  272. >     if (pkey == NULL || !EVP_PKEY_set_type(pkey, type))
  273.           return 0;
  274.       pkey->pkey.ptr = key;

crypto/evp/p_lib.c:260:1: start of procedure EVP_PKEY_set_type()
    258.   }
    259.   
    260. > int EVP_PKEY_set_type(EVP_PKEY *pkey, int type)
    261.   {
    262.       return pkey_set_type(pkey, type, NULL, -1);

crypto/evp/p_lib.c:262:5: Skipping pkey_set_type(): empty list of specs
    260.   int EVP_PKEY_set_type(EVP_PKEY *pkey, int type)
    261.   {
    262.       return pkey_set_type(pkey, type, NULL, -1);
               ^
    263.   }
    264.   

crypto/evp/p_lib.c:263:1: return from a call to EVP_PKEY_set_type
    261.   {
    262.       return pkey_set_type(pkey, type, NULL, -1);
    263. > }
    264.   
    265.   int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len)

crypto/evp/p_lib.c:272:26: Taking true branch
  270.   int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key)
  271.   {
  272.       if (pkey == NULL || !EVP_PKEY_set_type(pkey, type))
                                  ^
  273.           return 0;
  274.       pkey->pkey.ptr = key;

crypto/evp/p_lib.c:273:9: 
  271.   {
  272.       if (pkey == NULL || !EVP_PKEY_set_type(pkey, type))
  273. >         return 0;
  274.       pkey->pkey.ptr = key;
  275.       return (key != NULL);

crypto/evp/p_lib.c:276:1: return from a call to EVP_PKEY_assign
  274.       pkey->pkey.ptr = key;
  275.       return (key != NULL);
  276. > }
  277.   
  278.   void *EVP_PKEY_get0(EVP_PKEY *pkey)
