crypto/objects/obj_dat.c:767: error: MEMORY_LEAK
  memory dynamically allocated by call to `ASN1_OBJECT_create()` at line 762, column 25 is not reachable after line 767, column 5.
Showing all 115 steps of the trace


crypto/objects/obj_dat.c:744:1: start of procedure OBJ_create()
742.   }
743.   
744. > int OBJ_create(const char *oid, const char *sn, const char *ln)
745.   {
746.       int ok = 0;

crypto/objects/obj_dat.c:746:5: 
744.   int OBJ_create(const char *oid, const char *sn, const char *ln)
745.   {
746. >     int ok = 0;
747.       ASN1_OBJECT *op = NULL;
748.       unsigned char *buf;

crypto/objects/obj_dat.c:747:5: 
745.   {
746.       int ok = 0;
747. >     ASN1_OBJECT *op = NULL;
748.       unsigned char *buf;
749.       int i;

crypto/objects/obj_dat.c:751:5: Skipping a2d_ASN1_OBJECT(): empty list of specs
749.       int i;
750.   
751.       i = a2d_ASN1_OBJECT(NULL, 0, oid, -1);
           ^
752.       if (i <= 0)
753.           return (0);

crypto/objects/obj_dat.c:752:9: Taking false branch
750.   
751.       i = a2d_ASN1_OBJECT(NULL, 0, oid, -1);
752.       if (i <= 0)
               ^
753.           return (0);
754.   

crypto/objects/obj_dat.c:755:9: 
753.           return (0);
754.   
755. >     if ((buf = OPENSSL_malloc(i)) == NULL) {
756.           OBJerr(OBJ_F_OBJ_CREATE, ERR_R_MALLOC_FAILURE);
757.           return (0);

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

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

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

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

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

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

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

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

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

crypto/objects/obj_dat.c:755:9: Taking false branch
753.           return (0);
754.   
755.       if ((buf = OPENSSL_malloc(i)) == NULL) {
               ^
756.           OBJerr(OBJ_F_OBJ_CREATE, ERR_R_MALLOC_FAILURE);
757.           return (0);

crypto/objects/obj_dat.c:759:5: Skipping a2d_ASN1_OBJECT(): empty list of specs
757.           return (0);
758.       }
759.       i = a2d_ASN1_OBJECT(buf, i, oid, -1);
           ^
760.       if (i == 0)
761.           goto err;

crypto/objects/obj_dat.c:760:9: Taking false branch
758.       }
759.       i = a2d_ASN1_OBJECT(buf, i, oid, -1);
760.       if (i == 0)
               ^
761.           goto err;
762.       op = (ASN1_OBJECT *)ASN1_OBJECT_create(OBJ_new_nid(1), buf, i, sn, ln);

crypto/objects/obj_dat.c:762:5: 
760.       if (i == 0)
761.           goto err;
762. >     op = (ASN1_OBJECT *)ASN1_OBJECT_create(OBJ_new_nid(1), buf, i, sn, ln);
763.       if (op == NULL)
764.           goto err;

crypto/objects/obj_dat.c:229:1: start of procedure OBJ_new_nid()
  227.   }
  228.   
  229. > int OBJ_new_nid(int num)
  230.   {
  231.       int i;

crypto/objects/obj_dat.c:233:5: 
  231.       int i;
  232.   
  233. >     i = new_nid;
  234.       new_nid += num;
  235.       return (i);

crypto/objects/obj_dat.c:234:5: 
  232.   
  233.       i = new_nid;
  234. >     new_nid += num;
  235.       return (i);
  236.   }

crypto/objects/obj_dat.c:235:5: 
  233.       i = new_nid;
  234.       new_nid += num;
  235. >     return (i);
  236.   }
  237.   

crypto/objects/obj_dat.c:236:1: return from a call to OBJ_new_nid
  234.       new_nid += num;
  235.       return (i);
  236. > }
  237.   
  238.   int OBJ_add_object(const ASN1_OBJECT *obj)

crypto/asn1/a_object.c:401:1: start of procedure ASN1_OBJECT_create()
  399.   }
  400.   
  401. > ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
  402.                                   const char *sn, const char *ln)
  403.   {

crypto/asn1/a_object.c:406:5: 
  404.       ASN1_OBJECT o;
  405.   
  406. >     o.sn = sn;
  407.       o.ln = ln;
  408.       o.data = data;

crypto/asn1/a_object.c:407:5: 
  405.   
  406.       o.sn = sn;
  407. >     o.ln = ln;
  408.       o.data = data;
  409.       o.nid = nid;

crypto/asn1/a_object.c:408:5: 
  406.       o.sn = sn;
  407.       o.ln = ln;
  408. >     o.data = data;
  409.       o.nid = nid;
  410.       o.length = len;

crypto/asn1/a_object.c:409:5: 
  407.       o.ln = ln;
  408.       o.data = data;
  409. >     o.nid = nid;
  410.       o.length = len;
  411.       o.flags = ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |

crypto/asn1/a_object.c:410:5: 
  408.       o.data = data;
  409.       o.nid = nid;
  410. >     o.length = len;
  411.       o.flags = ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
  412.           ASN1_OBJECT_FLAG_DYNAMIC_DATA;

crypto/asn1/a_object.c:411:5: 
  409.       o.nid = nid;
  410.       o.length = len;
  411. >     o.flags = ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
  412.           ASN1_OBJECT_FLAG_DYNAMIC_DATA;
  413.       return (OBJ_dup(&o));

crypto/asn1/a_object.c:413:5: 
  411.       o.flags = ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
  412.           ASN1_OBJECT_FLAG_DYNAMIC_DATA;
  413. >     return (OBJ_dup(&o));
  414.   }

crypto/objects/obj_lib.c:65:1: start of procedure OBJ_dup()
    63.   #include "internal/asn1_int.h"
    64.   
    65. > ASN1_OBJECT *OBJ_dup(const ASN1_OBJECT *o)
    66.   {
    67.       ASN1_OBJECT *r;

crypto/objects/obj_lib.c:69:5: 
    67.       ASN1_OBJECT *r;
    68.       int i;
    69. >     char *ln = NULL, *sn = NULL;
    70.       unsigned char *data = NULL;
    71.   

crypto/objects/obj_lib.c:70:5: 
    68.       int i;
    69.       char *ln = NULL, *sn = NULL;
    70. >     unsigned char *data = NULL;
    71.   
    72.       if (o == NULL)

crypto/objects/obj_lib.c:72:9: Taking false branch
    70.       unsigned char *data = NULL;
    71.   
    72.       if (o == NULL)
                  ^
    73.           return (NULL);
    74.       if (!(o->flags & ASN1_OBJECT_FLAG_DYNAMIC))

crypto/objects/obj_lib.c:74:11: Taking false branch
    72.       if (o == NULL)
    73.           return (NULL);
    74.       if (!(o->flags & ASN1_OBJECT_FLAG_DYNAMIC))
                    ^
    75.           return ((ASN1_OBJECT *)o); /* XXX: ugh! Why? What kind of duplication
    76.                                       * is this??? */

crypto/objects/obj_lib.c:78:5: 
    76.                                       * is this??? */
    77.   
    78. >     r = ASN1_OBJECT_new();
    79.       if (r == NULL) {
    80.           OBJerr(OBJ_F_OBJ_DUP, ERR_R_ASN1_LIB);

crypto/asn1/a_object.c:366:1: start of procedure ASN1_OBJECT_new()
      364.   }
      365.   
      366. > ASN1_OBJECT *ASN1_OBJECT_new(void)
      367.   {
      368.       ASN1_OBJECT *ret;

crypto/asn1/a_object.c:370:5: 
      368.       ASN1_OBJECT *ret;
      369.   
      370. >     ret = OPENSSL_zalloc(sizeof(*ret));
      371.       if (ret == NULL) {
      372.           ASN1err(ASN1_F_ASN1_OBJECT_NEW, ERR_R_MALLOC_FAILURE);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

crypto/asn1/a_object.c:371:9: Taking false branch
      369.   
      370.       ret = OPENSSL_zalloc(sizeof(*ret));
      371.       if (ret == NULL) {
                     ^
      372.           ASN1err(ASN1_F_ASN1_OBJECT_NEW, ERR_R_MALLOC_FAILURE);
      373.           return (NULL);

crypto/asn1/a_object.c:375:5: 
      373.           return (NULL);
      374.       }
      375. >     ret->flags = ASN1_OBJECT_FLAG_DYNAMIC;
      376.       return (ret);
      377.   }

crypto/asn1/a_object.c:376:5: 
      374.       }
      375.       ret->flags = ASN1_OBJECT_FLAG_DYNAMIC;
      376. >     return (ret);
      377.   }
      378.   

crypto/asn1/a_object.c:377:1: return from a call to ASN1_OBJECT_new
      375.       ret->flags = ASN1_OBJECT_FLAG_DYNAMIC;
      376.       return (ret);
      377. > }
      378.   
      379.   void ASN1_OBJECT_free(ASN1_OBJECT *a)

crypto/objects/obj_lib.c:79:9: Taking false branch
    77.   
    78.       r = ASN1_OBJECT_new();
    79.       if (r == NULL) {
                  ^
    80.           OBJerr(OBJ_F_OBJ_DUP, ERR_R_ASN1_LIB);
    81.           return (NULL);

crypto/objects/obj_lib.c:83:5: 
    81.           return (NULL);
    82.       }
    83. >     data = OPENSSL_malloc(o->length);
    84.       if (data == NULL)
    85.           goto err;

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

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

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

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

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

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

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

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

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

crypto/objects/obj_lib.c:84:9: Taking false branch
    82.       }
    83.       data = OPENSSL_malloc(o->length);
    84.       if (data == NULL)
                  ^
    85.           goto err;
    86.       if (o->data != NULL)

crypto/objects/obj_lib.c:86:9: Taking true branch
    84.       if (data == NULL)
    85.           goto err;
    86.       if (o->data != NULL)
                  ^
    87.           memcpy(data, o->data, o->length);
    88.       /* once data attached to object it remains const */

crypto/objects/obj_lib.c:87:9: 
    85.           goto err;
    86.       if (o->data != NULL)
    87. >         memcpy(data, o->data, o->length);
    88.       /* once data attached to object it remains const */
    89.       r->data = data;

crypto/objects/obj_lib.c:89:5: 
    87.           memcpy(data, o->data, o->length);
    88.       /* once data attached to object it remains const */
    89. >     r->data = data;
    90.       r->length = o->length;
    91.       r->nid = o->nid;

crypto/objects/obj_lib.c:90:5: 
    88.       /* once data attached to object it remains const */
    89.       r->data = data;
    90. >     r->length = o->length;
    91.       r->nid = o->nid;
    92.       r->ln = r->sn = NULL;

crypto/objects/obj_lib.c:91:5: 
    89.       r->data = data;
    90.       r->length = o->length;
    91. >     r->nid = o->nid;
    92.       r->ln = r->sn = NULL;
    93.       if (o->ln != NULL) {

crypto/objects/obj_lib.c:92:5: 
    90.       r->length = o->length;
    91.       r->nid = o->nid;
    92. >     r->ln = r->sn = NULL;
    93.       if (o->ln != NULL) {
    94.           i = strlen(o->ln) + 1;

crypto/objects/obj_lib.c:93:9: Taking true branch
    91.       r->nid = o->nid;
    92.       r->ln = r->sn = NULL;
    93.       if (o->ln != NULL) {
                  ^
    94.           i = strlen(o->ln) + 1;
    95.           ln = OPENSSL_malloc(i);

crypto/objects/obj_lib.c:94:9: 
    92.       r->ln = r->sn = NULL;
    93.       if (o->ln != NULL) {
    94. >         i = strlen(o->ln) + 1;
    95.           ln = OPENSSL_malloc(i);
    96.           if (ln == NULL)

crypto/objects/obj_lib.c:95:9: 
    93.       if (o->ln != NULL) {
    94.           i = strlen(o->ln) + 1;
    95. >         ln = OPENSSL_malloc(i);
    96.           if (ln == NULL)
    97.               goto err;

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

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

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

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

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

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

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

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

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

crypto/objects/obj_lib.c:96:13: Taking false branch
    94.           i = strlen(o->ln) + 1;
    95.           ln = OPENSSL_malloc(i);
    96.           if (ln == NULL)
                      ^
    97.               goto err;
    98.           memcpy(ln, o->ln, i);

crypto/objects/obj_lib.c:98:9: 
    96.           if (ln == NULL)
    97.               goto err;
    98. >         memcpy(ln, o->ln, i);
    99.           r->ln = ln;
    100.       }

crypto/objects/obj_lib.c:99:9: 
    97.               goto err;
    98.           memcpy(ln, o->ln, i);
    99. >         r->ln = ln;
    100.       }
    101.   

crypto/objects/obj_lib.c:102:9: Taking true branch
    100.       }
    101.   
    102.       if (o->sn != NULL) {
                   ^
    103.           i = strlen(o->sn) + 1;
    104.           sn = OPENSSL_malloc(i);

crypto/objects/obj_lib.c:103:9: 
    101.   
    102.       if (o->sn != NULL) {
    103. >         i = strlen(o->sn) + 1;
    104.           sn = OPENSSL_malloc(i);
    105.           if (sn == NULL)

crypto/objects/obj_lib.c:104:9: 
    102.       if (o->sn != NULL) {
    103.           i = strlen(o->sn) + 1;
    104. >         sn = OPENSSL_malloc(i);
    105.           if (sn == NULL)
    106.               goto err;

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

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

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

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

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

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

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

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

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

crypto/objects/obj_lib.c:105:13: Taking false branch
    103.           i = strlen(o->sn) + 1;
    104.           sn = OPENSSL_malloc(i);
    105.           if (sn == NULL)
                       ^
    106.               goto err;
    107.           memcpy(sn, o->sn, i);

crypto/objects/obj_lib.c:107:9: 
    105.           if (sn == NULL)
    106.               goto err;
    107. >         memcpy(sn, o->sn, i);
    108.           r->sn = sn;
    109.       }

crypto/objects/obj_lib.c:108:9: 
    106.               goto err;
    107.           memcpy(sn, o->sn, i);
    108. >         r->sn = sn;
    109.       }
    110.       r->flags = o->flags | (ASN1_OBJECT_FLAG_DYNAMIC |

crypto/objects/obj_lib.c:110:5: 
    108.           r->sn = sn;
    109.       }
    110. >     r->flags = o->flags | (ASN1_OBJECT_FLAG_DYNAMIC |
    111.                              ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
    112.                              ASN1_OBJECT_FLAG_DYNAMIC_DATA);

crypto/objects/obj_lib.c:113:5: 
    111.                              ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
    112.                              ASN1_OBJECT_FLAG_DYNAMIC_DATA);
    113. >     return (r);
    114.    err:
    115.       OBJerr(OBJ_F_OBJ_DUP, ERR_R_MALLOC_FAILURE);

crypto/objects/obj_lib.c:121:1: return from a call to OBJ_dup
    119.       OPENSSL_free(r);
    120.       return (NULL);
    121. > }
    122.   
    123.   int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b)

crypto/asn1/a_object.c:414:1: return from a call to ASN1_OBJECT_create
  412.           ASN1_OBJECT_FLAG_DYNAMIC_DATA;
  413.       return (OBJ_dup(&o));
  414. > }

crypto/objects/obj_dat.c:763:9: Taking false branch
761.           goto err;
762.       op = (ASN1_OBJECT *)ASN1_OBJECT_create(OBJ_new_nid(1), buf, i, sn, ln);
763.       if (op == NULL)
               ^
764.           goto err;
765.       ok = OBJ_add_object(op);

crypto/objects/obj_dat.c:765:5: Skipping OBJ_add_object(): empty list of specs
763.       if (op == NULL)
764.           goto err;
765.       ok = OBJ_add_object(op);
           ^
766.    err:
767.       ASN1_OBJECT_free(op);

crypto/objects/obj_dat.c:766:2: 
764.           goto err;
765.       ok = OBJ_add_object(op);
766. >  err:
767.       ASN1_OBJECT_free(op);
768.       OPENSSL_free(buf);

crypto/objects/obj_dat.c:767:5: Skipping ASN1_OBJECT_free(): empty list of specs
765.       ok = OBJ_add_object(op);
766.    err:
767.       ASN1_OBJECT_free(op);
           ^
768.       OPENSSL_free(buf);
769.       return (ok);
