crypto/x509/x509_lu.c:501: error: NULL_DEREFERENCE
  pointer `obj` last assigned on line 500 could be null and is dereferenced at line 501, column 13.
Showing all 112 steps of the trace


crypto/x509/x509_lu.c:470:1: start of procedure X509_STORE_get1_certs()
468.   }
469.   
470. > STACK_OF(X509) *X509_STORE_get1_certs(X509_STORE_CTX *ctx, X509_NAME *nm)
471.   {
472.       int i, idx, cnt;

crypto/x509/x509_lu.c:476:5: 
474.       X509 *x;
475.       X509_OBJECT *obj;
476. >     sk = sk_X509_new_null();
477.       CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
478.       idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);

include/openssl/x509.h:169:1: start of procedure sk_X509_new_null()
  167.   typedef struct x509_cinf_st X509_CINF;
  168.   
  169. > DEFINE_STACK_OF(X509)
  170.   
  171.   /* This is used for a table of trust checking functions */

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

crypto/stack/stack.c:146:5: Skipping sk_new(): empty list of specs
    144.   _STACK *sk_new_null(void)
    145.   {
    146.       return sk_new((int (*)(const void *, const void *))0);
               ^
    147.   }
    148.   

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

include/openssl/x509.h:169:1: return from a call to sk_X509_new_null
  167.   typedef struct x509_cinf_st X509_CINF;
  168.   
  169. > DEFINE_STACK_OF(X509)
  170.   
  171.   /* This is used for a table of trust checking functions */

crypto/x509/x509_lu.c:477:5: 
475.       X509_OBJECT *obj;
476.       sk = sk_X509_new_null();
477. >     CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
478.       idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);
479.       if (idx < 0) {

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
  412.   }
  413.   
  414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
  415.   {
  416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
  439.       }
  440.   #endif
  441.       if (type < 0) {
                 ^
  442.           if (dynlock_lock_callback != NULL) {
  443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking true branch
  450.               CRYPTO_destroy_dynlockid(type);
  451.           }
  452.       } else if (locking_callback != NULL)
                        ^
  453.           locking_callback(mode, type, file, line);
  454.   }

crypto/lock.c:453:9: Skipping __function_pointer__(): unresolved function pointer
  451.           }
  452.       } else if (locking_callback != NULL)
  453.           locking_callback(mode, type, file, line);
                 ^
  454.   }
  455.   

crypto/lock.c:441:5: 
  439.       }
  440.   #endif
  441. >     if (type < 0) {
  442.           if (dynlock_lock_callback != NULL) {
  443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
  452.       } else if (locking_callback != NULL)
  453.           locking_callback(mode, type, file, line);
  454. > }
  455.   
  456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/x509/x509_lu.c:478:5: Skipping x509_object_idx_cnt(): empty list of specs
476.       sk = sk_X509_new_null();
477.       CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
478.       idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);
           ^
479.       if (idx < 0) {
480.           /*

crypto/x509/x509_lu.c:479:9: Taking true branch
477.       CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
478.       idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);
479.       if (idx < 0) {
               ^
480.           /*
481.            * Nothing found in cache: do lookup to possibly add new objects to

crypto/x509/x509_lu.c:485:9: 
483.            */
484.           X509_OBJECT xobj;
485. >         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
486.           if (!X509_STORE_get_by_subject(ctx, X509_LU_X509, nm, &xobj)) {
487.               sk_X509_free(sk);

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
  412.   }
  413.   
  414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
  415.   {
  416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
  439.       }
  440.   #endif
  441.       if (type < 0) {
                 ^
  442.           if (dynlock_lock_callback != NULL) {
  443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking true branch
  450.               CRYPTO_destroy_dynlockid(type);
  451.           }
  452.       } else if (locking_callback != NULL)
                        ^
  453.           locking_callback(mode, type, file, line);
  454.   }

crypto/lock.c:453:9: Skipping __function_pointer__(): unresolved function pointer
  451.           }
  452.       } else if (locking_callback != NULL)
  453.           locking_callback(mode, type, file, line);
                 ^
  454.   }
  455.   

crypto/lock.c:441:5: 
  439.       }
  440.   #endif
  441. >     if (type < 0) {
  442.           if (dynlock_lock_callback != NULL) {
  443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
  452.       } else if (locking_callback != NULL)
  453.           locking_callback(mode, type, file, line);
  454. > }
  455.   
  456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/x509/x509_lu.c:486:14: 
484.           X509_OBJECT xobj;
485.           CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
486. >         if (!X509_STORE_get_by_subject(ctx, X509_LU_X509, nm, &xobj)) {
487.               sk_X509_free(sk);
488.               return NULL;

crypto/x509/x509_lu.c:279:1: start of procedure X509_STORE_get_by_subject()
  277.   }
  278.   
  279. > int X509_STORE_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
  280.                                 X509_NAME *name, X509_OBJECT *ret)
  281.   {

crypto/x509/x509_lu.c:282:5: 
  280.                                 X509_NAME *name, X509_OBJECT *ret)
  281.   {
  282. >     X509_STORE *ctx = vs->ctx;
  283.       X509_LOOKUP *lu;
  284.       X509_OBJECT stmp, *tmp;

crypto/x509/x509_lu.c:287:5: 
  285.       int i, j;
  286.   
  287. >     CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
  288.       tmp = X509_OBJECT_retrieve_by_subject(ctx->objs, type, name);
  289.       CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
    412.   }
    413.   
    414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
    415.   {
    416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
    439.       }
    440.   #endif
    441.       if (type < 0) {
                   ^
    442.           if (dynlock_lock_callback != NULL) {
    443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking true branch
    450.               CRYPTO_destroy_dynlockid(type);
    451.           }
    452.       } else if (locking_callback != NULL)
                          ^
    453.           locking_callback(mode, type, file, line);
    454.   }

crypto/lock.c:453:9: Skipping __function_pointer__(): unresolved function pointer
    451.           }
    452.       } else if (locking_callback != NULL)
    453.           locking_callback(mode, type, file, line);
                   ^
    454.   }
    455.   

crypto/lock.c:441:5: 
    439.       }
    440.   #endif
    441. >     if (type < 0) {
    442.           if (dynlock_lock_callback != NULL) {
    443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
    452.       } else if (locking_callback != NULL)
    453.           locking_callback(mode, type, file, line);
    454. > }
    455.   
    456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/x509/x509_lu.c:288:5: 
  286.   
  287.       CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
  288. >     tmp = X509_OBJECT_retrieve_by_subject(ctx->objs, type, name);
  289.       CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
  290.   

crypto/x509/x509_lu.c:460:1: start of procedure X509_OBJECT_retrieve_by_subject()
    458.   }
    459.   
    460. > X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h,
    461.                                                int type, X509_NAME *name)
    462.   {

crypto/x509/x509_lu.c:464:5: 
    462.   {
    463.       int idx;
    464. >     idx = X509_OBJECT_idx_by_subject(h, type, name);
    465.       if (idx == -1)
    466.           return NULL;

crypto/x509/x509_lu.c:454:1: start of procedure X509_OBJECT_idx_by_subject()
      452.   }
      453.   
      454. > int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, int type,
      455.                                  X509_NAME *name)
      456.   {

crypto/x509/x509_lu.c:457:5: Skipping x509_object_idx_cnt(): empty list of specs
      455.                                  X509_NAME *name)
      456.   {
      457.       return x509_object_idx_cnt(h, type, name, NULL);
                 ^
      458.   }
      459.   

crypto/x509/x509_lu.c:458:1: return from a call to X509_OBJECT_idx_by_subject
      456.   {
      457.       return x509_object_idx_cnt(h, type, name, NULL);
      458. > }
      459.   
      460.   X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h,

crypto/x509/x509_lu.c:465:9: Taking false branch
    463.       int idx;
    464.       idx = X509_OBJECT_idx_by_subject(h, type, name);
    465.       if (idx == -1)
                   ^
    466.           return NULL;
    467.       return sk_X509_OBJECT_value(h, idx);

crypto/x509/x509_lu.c:467:5: 
    465.       if (idx == -1)
    466.           return NULL;
    467. >     return sk_X509_OBJECT_value(h, idx);
    468.   }
    469.   

include/openssl/x509_vfy.h:122:1: start of procedure sk_X509_OBJECT_value()
      120.   
      121.   DEFINE_STACK_OF(X509_LOOKUP)
      122. > DEFINE_STACK_OF(X509_OBJECT)
      123.   
      124.   /* This is a static that defines the function interface */

crypto/stack/stack.c:323:1: start of procedure sk_value()
        321.   }
        322.   
        323. > void *sk_value(const _STACK *st, int i)
        324.   {
        325.       if (!st || (i < 0) || (i >= st->num))

crypto/stack/stack.c:325:10: Taking false branch
        323.   void *sk_value(const _STACK *st, int i)
        324.   {
        325.       if (!st || (i < 0) || (i >= st->num))
                        ^
        326.           return NULL;
        327.       return st->data[i];

crypto/stack/stack.c:325:17: Taking false branch
        323.   void *sk_value(const _STACK *st, int i)
        324.   {
        325.       if (!st || (i < 0) || (i >= st->num))
                               ^
        326.           return NULL;
        327.       return st->data[i];

crypto/stack/stack.c:325:28: Taking false branch
        323.   void *sk_value(const _STACK *st, int i)
        324.   {
        325.       if (!st || (i < 0) || (i >= st->num))
                                          ^
        326.           return NULL;
        327.       return st->data[i];

crypto/stack/stack.c:327:5: 
        325.       if (!st || (i < 0) || (i >= st->num))
        326.           return NULL;
        327. >     return st->data[i];
        328.   }
        329.   

crypto/stack/stack.c:328:1: return from a call to sk_value
        326.           return NULL;
        327.       return st->data[i];
        328. > }
        329.   
        330.   void *sk_set(_STACK *st, int i, void *value)

include/openssl/x509_vfy.h:122:1: return from a call to sk_X509_OBJECT_value
      120.   
      121.   DEFINE_STACK_OF(X509_LOOKUP)
      122. > DEFINE_STACK_OF(X509_OBJECT)
      123.   
      124.   /* This is a static that defines the function interface */

crypto/x509/x509_lu.c:468:1: return from a call to X509_OBJECT_retrieve_by_subject
    466.           return NULL;
    467.       return sk_X509_OBJECT_value(h, idx);
    468. > }
    469.   
    470.   STACK_OF(X509) *X509_STORE_get1_certs(X509_STORE_CTX *ctx, X509_NAME *nm)

crypto/x509/x509_lu.c:289:5: 
  287.       CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
  288.       tmp = X509_OBJECT_retrieve_by_subject(ctx->objs, type, name);
  289. >     CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
  290.   
  291.       if (tmp == NULL || type == X509_LU_CRL) {

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
    412.   }
    413.   
    414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
    415.   {
    416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
    439.       }
    440.   #endif
    441.       if (type < 0) {
                   ^
    442.           if (dynlock_lock_callback != NULL) {
    443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking true branch
    450.               CRYPTO_destroy_dynlockid(type);
    451.           }
    452.       } else if (locking_callback != NULL)
                          ^
    453.           locking_callback(mode, type, file, line);
    454.   }

crypto/lock.c:453:9: Skipping __function_pointer__(): unresolved function pointer
    451.           }
    452.       } else if (locking_callback != NULL)
    453.           locking_callback(mode, type, file, line);
                   ^
    454.   }
    455.   

crypto/lock.c:441:5: 
    439.       }
    440.   #endif
    441. >     if (type < 0) {
    442.           if (dynlock_lock_callback != NULL) {
    443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
    452.       } else if (locking_callback != NULL)
    453.           locking_callback(mode, type, file, line);
    454. > }
    455.   
    456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/x509/x509_lu.c:291:9: Taking false branch
  289.       CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
  290.   
  291.       if (tmp == NULL || type == X509_LU_CRL) {
                 ^
  292.           for (i = vs->current_method;
  293.                i < sk_X509_LOOKUP_num(ctx->get_cert_methods); i++) {

crypto/x509/x509_lu.c:291:24: Taking false branch
  289.       CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
  290.   
  291.       if (tmp == NULL || type == X509_LU_CRL) {
                                ^
  292.           for (i = vs->current_method;
  293.                i < sk_X509_LOOKUP_num(ctx->get_cert_methods); i++) {

crypto/x509/x509_lu.c:312:5: 
  310.               X509_OBJECT_free_contents(ret); */
  311.   
  312. >     ret->type = tmp->type;
  313.       ret->data.ptr = tmp->data.ptr;
  314.   

crypto/x509/x509_lu.c:313:5: 
  311.   
  312.       ret->type = tmp->type;
  313. >     ret->data.ptr = tmp->data.ptr;
  314.   
  315.       X509_OBJECT_up_ref_count(ret);

crypto/x509/x509_lu.c:315:5: 
  313.       ret->data.ptr = tmp->data.ptr;
  314.   
  315. >     X509_OBJECT_up_ref_count(ret);
  316.   
  317.       return 1;

crypto/x509/x509_lu.c:385:1: start of procedure X509_OBJECT_up_ref_count()
    383.   }
    384.   
    385. > void X509_OBJECT_up_ref_count(X509_OBJECT *a)
    386.   {
    387.       switch (a->type) {

crypto/x509/x509_lu.c:387:5: 
    385.   void X509_OBJECT_up_ref_count(X509_OBJECT *a)
    386.   {
    387. >     switch (a->type) {
    388.       default:
    389.           break;

crypto/x509/x509_lu.c:390:5: Switch condition is true. Entering switch case
    388.       default:
    389.           break;
    390.       case X509_LU_X509:
               ^
    391.           X509_up_ref(a->data.x509);
    392.           break;

crypto/x509/x509_lu.c:391:9: 
    389.           break;
    390.       case X509_LU_X509:
    391. >         X509_up_ref(a->data.x509);
    392.           break;
    393.       case X509_LU_CRL:

crypto/x509/x509_set.c:149:1: start of procedure X509_up_ref()
      147.   }
      148.   
      149. > void X509_up_ref(X509 *x)
      150.   {
      151.       CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);

crypto/x509/x509_set.c:151:5: 
      149.   void X509_up_ref(X509 *x)
      150.   {
      151. >     CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
      152.   }
      153.   

crypto/lock.c:456:1: start of procedure CRYPTO_add_lock()
        454.   }
        455.   
        456. > int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
        457.                       int line)
        458.   {

crypto/lock.c:459:5: 
        457.                       int line)
        458.   {
        459. >     int ret = 0;
        460.   
        461.       if (add_lock_callback != NULL) {

crypto/lock.c:461:9: Taking true branch
        459.       int ret = 0;
        460.   
        461.       if (add_lock_callback != NULL) {
                       ^
        462.   #ifdef LOCK_DEBUG
        463.           int before = *pointer;

crypto/lock.c:466:9: Skipping __function_pointer__(): unresolved function pointer
        464.   #endif
        465.   
        466.           ret = add_lock_callback(pointer, amount, type, file, line);
                       ^
        467.   #ifdef LOCK_DEBUG
        468.           {

crypto/lock.c:493:5: 
        491.           CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);
        492.       }
        493. >     return (ret);
        494.   }
        495.   

crypto/lock.c:494:1: return from a call to CRYPTO_add_lock
        492.       }
        493.       return (ret);
        494. > }
        495.   
        496.   const char *CRYPTO_get_lock_name(int type)

crypto/x509/x509_set.c:152:1: return from a call to X509_up_ref
      150.   {
      151.       CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
      152. > }
      153.   
      154.   long X509_get_version(X509 *x)

crypto/x509/x509_lu.c:397:1: return from a call to X509_OBJECT_up_ref_count
    395.           break;
    396.       }
    397. > }
    398.   
    399.   void X509_OBJECT_free_contents(X509_OBJECT *a)

crypto/x509/x509_lu.c:317:5: 
  315.       X509_OBJECT_up_ref_count(ret);
  316.   
  317. >     return 1;
  318.   }
  319.   

crypto/x509/x509_lu.c:318:1: return from a call to X509_STORE_get_by_subject
  316.   
  317.       return 1;
  318. > }
  319.   
  320.   int X509_STORE_add_cert(X509_STORE *ctx, X509 *x)

crypto/x509/x509_lu.c:486:14: Taking false branch
484.           X509_OBJECT xobj;
485.           CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
486.           if (!X509_STORE_get_by_subject(ctx, X509_LU_X509, nm, &xobj)) {
                    ^
487.               sk_X509_free(sk);
488.               return NULL;

crypto/x509/x509_lu.c:490:9: 
488.               return NULL;
489.           }
490. >         X509_OBJECT_free_contents(&xobj);
491.           CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
492.           idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);

crypto/x509/x509_lu.c:399:1: start of procedure X509_OBJECT_free_contents()
  397.   }
  398.   
  399. > void X509_OBJECT_free_contents(X509_OBJECT *a)
  400.   {
  401.       if (!a)

crypto/x509/x509_lu.c:401:10: Taking false branch
  399.   void X509_OBJECT_free_contents(X509_OBJECT *a)
  400.   {
  401.       if (!a)
                  ^
  402.           return;
  403.       switch (a->type) {

crypto/x509/x509_lu.c:403:5: 
  401.       if (!a)
  402.           return;
  403. >     switch (a->type) {
  404.       default:
  405.           break;

crypto/x509/x509_lu.c:406:5: Switch condition is true. Entering switch case
  404.       default:
  405.           break;
  406.       case X509_LU_X509:
             ^
  407.           X509_free(a->data.x509);
  408.           break;

crypto/x509/x509_lu.c:407:9: 
  405.           break;
  406.       case X509_LU_X509:
  407. >         X509_free(a->data.x509);
  408.           break;
  409.       case X509_LU_CRL:

crypto/x509/x_x509.c:139:1: start of procedure X509_free()
    137.   } ASN1_SEQUENCE_END_ref(X509, X509)
    138.   
    139. > IMPLEMENT_ASN1_FUNCTIONS(X509)
    140.   
    141.   IMPLEMENT_ASN1_DUP_FUNCTION(X509)

crypto/asn1/tasn_fre.c:70:1: start of procedure ASN1_item_free()
      68.   /* Free up an ASN1 structure */
      69.   
      70. > void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it)
      71.   {
      72.       asn1_item_embed_free(&val, it, 0);

crypto/asn1/tasn_fre.c:72:5: Skipping asn1_item_embed_free(): empty list of specs
      70.   void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it)
      71.   {
      72.       asn1_item_embed_free(&val, it, 0);
                ^
      73.   }
      74.   

crypto/asn1/tasn_fre.c:73:1: return from a call to ASN1_item_free
      71.   {
      72.       asn1_item_embed_free(&val, it, 0);
      73. > }
      74.   
      75.   void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it)

crypto/x509/x_x509.c:139:1: return from a call to X509_free
    137.   } ASN1_SEQUENCE_END_ref(X509, X509)
    138.   
    139. > IMPLEMENT_ASN1_FUNCTIONS(X509)
    140.   
    141.   IMPLEMENT_ASN1_DUP_FUNCTION(X509)

crypto/x509/x509_lu.c:413:1: return from a call to X509_OBJECT_free_contents
  411.           break;
  412.       }
  413. > }
  414.   
  415.   static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, int type,

crypto/x509/x509_lu.c:491:9: 
489.           }
490.           X509_OBJECT_free_contents(&xobj);
491. >         CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
492.           idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);
493.           if (idx < 0) {

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
  412.   }
  413.   
  414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
  415.   {
  416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
  439.       }
  440.   #endif
  441.       if (type < 0) {
                 ^
  442.           if (dynlock_lock_callback != NULL) {
  443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking true branch
  450.               CRYPTO_destroy_dynlockid(type);
  451.           }
  452.       } else if (locking_callback != NULL)
                        ^
  453.           locking_callback(mode, type, file, line);
  454.   }

crypto/lock.c:453:9: Skipping __function_pointer__(): unresolved function pointer
  451.           }
  452.       } else if (locking_callback != NULL)
  453.           locking_callback(mode, type, file, line);
                 ^
  454.   }
  455.   

crypto/lock.c:441:5: 
  439.       }
  440.   #endif
  441. >     if (type < 0) {
  442.           if (dynlock_lock_callback != NULL) {
  443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
  452.       } else if (locking_callback != NULL)
  453.           locking_callback(mode, type, file, line);
  454. > }
  455.   
  456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/x509/x509_lu.c:492:9: Skipping x509_object_idx_cnt(): empty list of specs
490.           X509_OBJECT_free_contents(&xobj);
491.           CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
492.           idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);
               ^
493.           if (idx < 0) {
494.               CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);

crypto/x509/x509_lu.c:493:13: Taking false branch
491.           CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
492.           idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);
493.           if (idx < 0) {
                   ^
494.               CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
495.               sk_X509_free(sk);

crypto/x509/x509_lu.c:499:10: 
497.           }
498.       }
499. >     for (i = 0; i < cnt; i++, idx++) {
500.           obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
501.           x = obj->data.x509;

crypto/x509/x509_lu.c:499:17: Loop condition is true. Entering loop body
497.           }
498.       }
499.       for (i = 0; i < cnt; i++, idx++) {
                       ^
500.           obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
501.           x = obj->data.x509;

crypto/x509/x509_lu.c:500:9: 
498.       }
499.       for (i = 0; i < cnt; i++, idx++) {
500. >         obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
501.           x = obj->data.x509;
502.           X509_up_ref(x);

include/openssl/x509_vfy.h:122:1: start of procedure sk_X509_OBJECT_value()
  120.   
  121.   DEFINE_STACK_OF(X509_LOOKUP)
  122. > DEFINE_STACK_OF(X509_OBJECT)
  123.   
  124.   /* This is a static that defines the function interface */

crypto/stack/stack.c:323:1: start of procedure sk_value()
    321.   }
    322.   
    323. > void *sk_value(const _STACK *st, int i)
    324.   {
    325.       if (!st || (i < 0) || (i >= st->num))

crypto/stack/stack.c:325:10: Taking false branch
    323.   void *sk_value(const _STACK *st, int i)
    324.   {
    325.       if (!st || (i < 0) || (i >= st->num))
                    ^
    326.           return NULL;
    327.       return st->data[i];

crypto/stack/stack.c:325:17: Taking false branch
    323.   void *sk_value(const _STACK *st, int i)
    324.   {
    325.       if (!st || (i < 0) || (i >= st->num))
                           ^
    326.           return NULL;
    327.       return st->data[i];

crypto/stack/stack.c:325:28: Taking true branch
    323.   void *sk_value(const _STACK *st, int i)
    324.   {
    325.       if (!st || (i < 0) || (i >= st->num))
                                      ^
    326.           return NULL;
    327.       return st->data[i];

crypto/stack/stack.c:326:9: 
    324.   {
    325.       if (!st || (i < 0) || (i >= st->num))
    326. >         return NULL;
    327.       return st->data[i];
    328.   }

crypto/stack/stack.c:328:1: return from a call to sk_value
    326.           return NULL;
    327.       return st->data[i];
    328. > }
    329.   
    330.   void *sk_set(_STACK *st, int i, void *value)

include/openssl/x509_vfy.h:122:1: return from a call to sk_X509_OBJECT_value
  120.   
  121.   DEFINE_STACK_OF(X509_LOOKUP)
  122. > DEFINE_STACK_OF(X509_OBJECT)
  123.   
  124.   /* This is a static that defines the function interface */

crypto/x509/x509_lu.c:501:9: 
499.       for (i = 0; i < cnt; i++, idx++) {
500.           obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
501. >         x = obj->data.x509;
502.           X509_up_ref(x);
503.           if (!sk_X509_push(sk, x)) {
