crypto/pem/pem_all.c:236: error: NULL_DEREFERENCE
  pointer `pktmp` last assigned on line 235 could be null and is dereferenced by call to `pkey_get_dsa()` at line 236, column 9.
Showing all 103 steps of the trace


crypto/pem/pem_all.c:231:1: start of procedure PEM_read_DSAPrivateKey()
229.   #ifndef OPENSSL_NO_FP_API
230.   
231. > DSA *PEM_read_DSAPrivateKey(FILE *fp, DSA **dsa, pem_password_cb *cb,
232.   								void *u)
233.   {

crypto/pem/pem_all.c:235:2: 
233.   {
234.   	EVP_PKEY *pktmp;
235. > 	pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
236.   	return pkey_get_dsa(pktmp, dsa);	/* will free pktmp */
237.   }

crypto/pem/pem_pkey.c:209:1: start of procedure PEM_read_PrivateKey()
  207.   
  208.   #ifndef OPENSSL_NO_FP_API
  209. > EVP_PKEY *PEM_read_PrivateKey(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u)
  210.   	{
  211.           BIO *b;

crypto/pem/pem_pkey.c:214:13: 
  212.           EVP_PKEY *ret;
  213.   
  214. >         if ((b=BIO_new(BIO_s_file())) == NULL)
  215.   		{
  216.   		PEMerr(PEM_F_PEM_READ_PRIVATEKEY,ERR_R_BUF_LIB);

crypto/bio/bss_file.c:153:1: start of procedure BIO_s_file()
    151.   	}
    152.   
    153. > BIO_METHOD *BIO_s_file(void)
    154.   	{
    155.   	return(&methods_filep);

crypto/bio/bss_file.c:155:2: 
    153.   BIO_METHOD *BIO_s_file(void)
    154.   	{
    155. > 	return(&methods_filep);
    156.   	}
    157.   

crypto/bio/bss_file.c:156:2: return from a call to BIO_s_file
    154.   	{
    155.   	return(&methods_filep);
    156.   	}
            ^
    157.   
    158.   static int MS_CALLBACK file_new(BIO *bi)

crypto/bio/bio_lib.c:66:1: start of procedure BIO_new()
    64.   #include <openssl/stack.h>
    65.   
    66. > BIO *BIO_new(BIO_METHOD *method)
    67.   	{
    68.   	BIO *ret=NULL;

crypto/bio/bio_lib.c:68:2: 
    66.   BIO *BIO_new(BIO_METHOD *method)
    67.   	{
    68. > 	BIO *ret=NULL;
    69.   
    70.   	ret=(BIO *)OPENSSL_malloc(sizeof(BIO));

crypto/bio/bio_lib.c:70:2: 
    68.   	BIO *ret=NULL;
    69.   
    70. > 	ret=(BIO *)OPENSSL_malloc(sizeof(BIO));
    71.   	if (ret == NULL)
    72.   		{

crypto/mem.c:294:1: start of procedure CRYPTO_malloc()
      292.   	}
      293.   
      294. > void *CRYPTO_malloc(int num, const char *file, int line)
      295.   	{
      296.   	void *ret = NULL;

crypto/mem.c:296:2: 
      294.   void *CRYPTO_malloc(int num, const char *file, int line)
      295.   	{
      296. > 	void *ret = NULL;
      297.   
      298.   	if (num <= 0) return NULL;

crypto/mem.c:298:6: Taking false branch
      296.   	void *ret = NULL;
      297.   
      298.   	if (num <= 0) return NULL;
                  ^
      299.   
      300.   	allow_customize = 0;

crypto/mem.c:300:2: 
      298.   	if (num <= 0) return NULL;
      299.   
      300. > 	allow_customize = 0;
      301.   	if (malloc_debug_func != NULL)
      302.   		{

crypto/mem.c:301:6: Taking true branch
      299.   
      300.   	allow_customize = 0;
      301.   	if (malloc_debug_func != NULL)
                  ^
      302.   		{
      303.   		allow_customize_debug = 0;

crypto/mem.c:303:3: 
      301.   	if (malloc_debug_func != NULL)
      302.   		{
      303. > 		allow_customize_debug = 0;
      304.   		malloc_debug_func(NULL, num, file, line, 0);
      305.   		}

crypto/mem.c:304:3: Skipping __function_pointer__(): unresolved function pointer
      302.   		{
      303.   		allow_customize_debug = 0;
      304.   		malloc_debug_func(NULL, num, file, line, 0);
               ^
      305.   		}
      306.   	ret = malloc_ex_func(num,file,line);

crypto/mem.c:306:2: Skipping __function_pointer__(): unresolved function pointer
      304.   		malloc_debug_func(NULL, num, file, line, 0);
      305.   		}
      306.   	ret = malloc_ex_func(num,file,line);
              ^
      307.   #ifdef LEVITTE_DEBUG_MEM
      308.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);

crypto/mem.c:310:6: Taking true branch
      308.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
      309.   #endif
      310.   	if (malloc_debug_func != NULL)
                  ^
      311.   		malloc_debug_func(ret, num, file, line, 1);
      312.   

crypto/mem.c:311:3: Skipping __function_pointer__(): unresolved function pointer
      309.   #endif
      310.   	if (malloc_debug_func != NULL)
      311.   		malloc_debug_func(ret, num, file, line, 1);
               ^
      312.   
      313.   #ifndef OPENSSL_CPUID_OBJ

crypto/mem.c:317:12: Taking false branch
      315.            * sanitisation function can't be optimised out. NB: We only do
      316.            * this for >2Kb so the overhead doesn't bother us. */
      317.           if(ret && (num > 2048))
                        ^
      318.   	{	extern unsigned char cleanse_ctr;
      319.                   ((unsigned char *)ret)[0] = cleanse_ctr;

crypto/mem.c:323:2: 
      321.   #endif
      322.   
      323. > 	return ret;
      324.   	}
      325.   

crypto/mem.c:324:2: return from a call to CRYPTO_malloc
      322.   
      323.   	return ret;
      324.   	}
              ^
      325.   
      326.   void *CRYPTO_realloc(void *str, int num, const char *file, int line)

crypto/bio/bio_lib.c:71:6: Taking true branch
    69.   
    70.   	ret=(BIO *)OPENSSL_malloc(sizeof(BIO));
    71.   	if (ret == NULL)
               ^
    72.   		{
    73.   		BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);

crypto/bio/bio_lib.c:73:3: 
    71.   	if (ret == NULL)
    72.   		{
    73. > 		BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
    74.   		return(NULL);
    75.   		}

crypto/err/err.c:680:1: start of procedure ERR_put_error()
      678.   /********************************************************/
      679.   
      680. > void ERR_put_error(int lib, int func, int reason, const char *file,
      681.   	     int line)
      682.   	{

crypto/err/err.c:704:2: Skipping ERR_get_state(): empty list of specs
      702.   	}
      703.   #endif
      704.   	es=ERR_get_state();
              ^
      705.   
      706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:706:2: 
      704.   	es=ERR_get_state();
      705.   
      706. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
      707.   	if (es->top == es->bottom)
      708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:707:6: Taking false branch
      705.   
      706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
      707.   	if (es->top == es->bottom)
                  ^
      708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
      709.   	es->err_flags[es->top]=0;

crypto/err/err.c:709:2: 
      707.   	if (es->top == es->bottom)
      708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
      709. > 	es->err_flags[es->top]=0;
      710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
      711.   	es->err_file[es->top]=file;

crypto/err/err.c:710:2: 
      708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
      709.   	es->err_flags[es->top]=0;
      710. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
      711.   	es->err_file[es->top]=file;
      712.   	es->err_line[es->top]=line;

crypto/err/err.c:711:2: 
      709.   	es->err_flags[es->top]=0;
      710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
      711. > 	es->err_file[es->top]=file;
      712.   	es->err_line[es->top]=line;
      713.   	err_clear_data(es,es->top);

crypto/err/err.c:712:2: 
      710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
      711.   	es->err_file[es->top]=file;
      712. > 	es->err_line[es->top]=line;
      713.   	err_clear_data(es,es->top);
      714.   	}

crypto/err/err.c:713:2: Taking true branch
      711.   	es->err_file[es->top]=file;
      712.   	es->err_line[es->top]=line;
      713.   	err_clear_data(es,es->top);
              ^
      714.   	}
      715.   

crypto/err/err.c:713:2: Taking false branch
      711.   	es->err_file[es->top]=file;
      712.   	es->err_line[es->top]=line;
      713.   	err_clear_data(es,es->top);
              ^
      714.   	}
      715.   

crypto/err/err.c:713:2: Loop condition is false. Leaving loop
      711.   	es->err_file[es->top]=file;
      712.   	es->err_line[es->top]=line;
      713.   	err_clear_data(es,es->top);
              ^
      714.   	}
      715.   

crypto/err/err.c:714:2: return from a call to ERR_put_error
      712.   	es->err_line[es->top]=line;
      713.   	err_clear_data(es,es->top);
      714.   	}
              ^
      715.   
      716.   void ERR_clear_error(void)

crypto/bio/bio_lib.c:74:3: 
    72.   		{
    73.   		BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
    74. > 		return(NULL);
    75.   		}
    76.   	if (!BIO_set(ret,method))

crypto/bio/bio_lib.c:82:2: return from a call to BIO_new
    80.   		}
    81.   	return(ret);
    82.   	}
           ^
    83.   
    84.   int BIO_set(BIO *bio, BIO_METHOD *method)

crypto/pem/pem_pkey.c:214:13: Taking true branch
  212.           EVP_PKEY *ret;
  213.   
  214.           if ((b=BIO_new(BIO_s_file())) == NULL)
                     ^
  215.   		{
  216.   		PEMerr(PEM_F_PEM_READ_PRIVATEKEY,ERR_R_BUF_LIB);

crypto/pem/pem_pkey.c:216:3: 
  214.           if ((b=BIO_new(BIO_s_file())) == NULL)
  215.   		{
  216. > 		PEMerr(PEM_F_PEM_READ_PRIVATEKEY,ERR_R_BUF_LIB);
  217.                   return(0);
  218.   		}

crypto/err/err.c:680:1: start of procedure ERR_put_error()
    678.   /********************************************************/
    679.   
    680. > void ERR_put_error(int lib, int func, int reason, const char *file,
    681.   	     int line)
    682.   	{

crypto/err/err.c:704:2: Skipping ERR_get_state(): empty list of specs
    702.   	}
    703.   #endif
    704.   	es=ERR_get_state();
            ^
    705.   
    706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:706:2: 
    704.   	es=ERR_get_state();
    705.   
    706. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
    707.   	if (es->top == es->bottom)
    708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:707:6: Taking false branch
    705.   
    706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
    707.   	if (es->top == es->bottom)
                ^
    708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    709.   	es->err_flags[es->top]=0;

crypto/err/err.c:709:2: 
    707.   	if (es->top == es->bottom)
    708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    709. > 	es->err_flags[es->top]=0;
    710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    711.   	es->err_file[es->top]=file;

crypto/err/err.c:710:2: 
    708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    709.   	es->err_flags[es->top]=0;
    710. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    711.   	es->err_file[es->top]=file;
    712.   	es->err_line[es->top]=line;

crypto/err/err.c:711:2: 
    709.   	es->err_flags[es->top]=0;
    710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    711. > 	es->err_file[es->top]=file;
    712.   	es->err_line[es->top]=line;
    713.   	err_clear_data(es,es->top);

crypto/err/err.c:712:2: 
    710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    711.   	es->err_file[es->top]=file;
    712. > 	es->err_line[es->top]=line;
    713.   	err_clear_data(es,es->top);
    714.   	}

crypto/err/err.c:713:2: Taking true branch
    711.   	es->err_file[es->top]=file;
    712.   	es->err_line[es->top]=line;
    713.   	err_clear_data(es,es->top);
            ^
    714.   	}
    715.   

crypto/err/err.c:713:2: Taking false branch
    711.   	es->err_file[es->top]=file;
    712.   	es->err_line[es->top]=line;
    713.   	err_clear_data(es,es->top);
            ^
    714.   	}
    715.   

crypto/err/err.c:713:2: Loop condition is false. Leaving loop
    711.   	es->err_file[es->top]=file;
    712.   	es->err_line[es->top]=line;
    713.   	err_clear_data(es,es->top);
            ^
    714.   	}
    715.   

crypto/err/err.c:714:2: return from a call to ERR_put_error
    712.   	es->err_line[es->top]=line;
    713.   	err_clear_data(es,es->top);
    714.   	}
            ^
    715.   
    716.   void ERR_clear_error(void)

crypto/pem/pem_pkey.c:217:17: 
  215.   		{
  216.   		PEMerr(PEM_F_PEM_READ_PRIVATEKEY,ERR_R_BUF_LIB);
  217. >                 return(0);
  218.   		}
  219.           BIO_set_fp(b,fp,BIO_NOCLOSE);

crypto/pem/pem_pkey.c:223:2: return from a call to PEM_read_PrivateKey
  221.           BIO_free(b);
  222.           return(ret);
  223.   	}
          ^
  224.   
  225.   int PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,

crypto/pem/pem_all.c:236:2: 
234.   	EVP_PKEY *pktmp;
235.   	pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
236. > 	return pkey_get_dsa(pktmp, dsa);	/* will free pktmp */
237.   }
238.   

crypto/pem/pem_all.c:204:1: start of procedure pkey_get_dsa()
  202.   #ifndef OPENSSL_NO_DSA
  203.   
  204. > static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa)
  205.   {
  206.   	DSA *dtmp;

crypto/pem/pem_all.c:207:6: Taking false branch
  205.   {
  206.   	DSA *dtmp;
  207.   	if(!key) return NULL;
              ^
  208.   	dtmp = EVP_PKEY_get1_DSA(key);
  209.   	EVP_PKEY_free(key);

crypto/pem/pem_all.c:208:2: 
  206.   	DSA *dtmp;
  207.   	if(!key) return NULL;
  208. > 	dtmp = EVP_PKEY_get1_DSA(key);
  209.   	EVP_PKEY_free(key);
  210.   	if(!dtmp) return NULL;

crypto/evp/p_lib.c:302:1: start of procedure EVP_PKEY_get1_DSA()
    300.   }
    301.   
    302. > DSA *EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
    303.   	{
    304.   	if(pkey->type != EVP_PKEY_DSA) {

crypto/evp/p_lib.c:304:5: Taking false branch
    302.   DSA *EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
    303.   	{
    304.   	if(pkey->type != EVP_PKEY_DSA) {
               ^
    305.   		EVPerr(EVP_F_EVP_PKEY_GET1_DSA, EVP_R_EXPECTING_A_DSA_KEY);
    306.   		return NULL;

crypto/evp/p_lib.c:308:2: 
    306.   		return NULL;
    307.   	}
    308. > 	DSA_up_ref(pkey->pkey.dsa);
    309.   	return pkey->pkey.dsa;
    310.   }

crypto/dsa/dsa_lib.c:220:1: start of procedure DSA_up_ref()
      218.   	}
      219.   
      220. > int DSA_up_ref(DSA *r)
      221.   	{
      222.   	int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_DSA);

crypto/dsa/dsa_lib.c:222:2: 
      220.   int DSA_up_ref(DSA *r)
      221.   	{
      222. > 	int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_DSA);
      223.   #ifdef REF_PRINT
      224.   	REF_PRINT("DSA",r);

crypto/cryptlib.c:517:1: start of procedure CRYPTO_add_lock()
        515.   	}
        516.   
        517. > int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
        518.   	     int line)
        519.   	{

crypto/cryptlib.c:520:2: 
        518.   	     int line)
        519.   	{
        520. > 	int ret = 0;
        521.   
        522.   	if (add_lock_callback != NULL)

crypto/cryptlib.c:522:6: Taking false branch
        520.   	int ret = 0;
        521.   
        522.   	if (add_lock_callback != NULL)
                    ^
        523.   		{
        524.   #ifdef LOCK_DEBUG

crypto/cryptlib.c:539:3: 
        537.   	else
        538.   		{
        539. > 		CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);
        540.   
        541.   		ret= *pointer+amount;

crypto/cryptlib.c:473:1: start of procedure CRYPTO_lock()
          471.   	}
          472.   
          473. > void CRYPTO_lock(int mode, int type, const char *file, int line)
          474.   	{
          475.   #ifdef LOCK_DEBUG

crypto/cryptlib.c:498:6: Taking false branch
          496.   		}
          497.   #endif
          498.   	if (type < 0)
                      ^
          499.   		{
          500.   		if (dynlock_lock_callback != NULL)

crypto/cryptlib.c:513:7: Taking false branch
          511.   		}
          512.   	else
          513.   		if (locking_callback != NULL)
                       ^
          514.   			locking_callback(mode,type,file,line);
          515.   	}

crypto/cryptlib.c:498:2: 
          496.   		}
          497.   #endif
          498. > 	if (type < 0)
          499.   		{
          500.   		if (dynlock_lock_callback != NULL)

crypto/cryptlib.c:515:2: return from a call to CRYPTO_lock
          513.   		if (locking_callback != NULL)
          514.   			locking_callback(mode,type,file,line);
          515.   	}
                  ^
          516.   
          517.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/cryptlib.c:541:3: 
        539.   		CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);
        540.   
        541. > 		ret= *pointer+amount;
        542.   #ifdef LOCK_DEBUG
        543.   		fprintf(stderr,"ladd:%08lx/%0xp:%2d+%2d->%2d %-18s %s:%d\n",

crypto/cryptlib.c:549:3: 
        547.   			file,line);
        548.   #endif
        549. > 		*pointer=ret;
        550.   		CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,file,line);
        551.   		}

crypto/cryptlib.c:550:3: 
        548.   #endif
        549.   		*pointer=ret;
        550. > 		CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,file,line);
        551.   		}
        552.   	return(ret);

crypto/cryptlib.c:473:1: start of procedure CRYPTO_lock()
          471.   	}
          472.   
          473. > void CRYPTO_lock(int mode, int type, const char *file, int line)
          474.   	{
          475.   #ifdef LOCK_DEBUG

crypto/cryptlib.c:498:6: Taking false branch
          496.   		}
          497.   #endif
          498.   	if (type < 0)
                      ^
          499.   		{
          500.   		if (dynlock_lock_callback != NULL)

crypto/cryptlib.c:513:7: Taking false branch
          511.   		}
          512.   	else
          513.   		if (locking_callback != NULL)
                       ^
          514.   			locking_callback(mode,type,file,line);
          515.   	}

crypto/cryptlib.c:498:2: 
          496.   		}
          497.   #endif
          498. > 	if (type < 0)
          499.   		{
          500.   		if (dynlock_lock_callback != NULL)

crypto/cryptlib.c:515:2: return from a call to CRYPTO_lock
          513.   		if (locking_callback != NULL)
          514.   			locking_callback(mode,type,file,line);
          515.   	}
                  ^
          516.   
          517.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/cryptlib.c:552:2: 
        550.   		CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,file,line);
        551.   		}
        552. > 	return(ret);
        553.   	}
        554.   

crypto/cryptlib.c:553:2: return from a call to CRYPTO_add_lock
        551.   		}
        552.   	return(ret);
        553.   	}
                ^
        554.   
        555.   const char *CRYPTO_get_lock_name(int type)

crypto/dsa/dsa_lib.c:233:11: Condition is false
      231.   		}
      232.   #endif
      233.   	return ((i > 1) ? 1 : 0);
                       ^
      234.   	}
      235.   

crypto/dsa/dsa_lib.c:233:10: 
      231.   		}
      232.   #endif
      233. > 	return ((i > 1) ? 1 : 0);
      234.   	}
      235.   

crypto/dsa/dsa_lib.c:233:2: 
      231.   		}
      232.   #endif
      233. > 	return ((i > 1) ? 1 : 0);
      234.   	}
      235.   

crypto/dsa/dsa_lib.c:234:2: return from a call to DSA_up_ref
      232.   #endif
      233.   	return ((i > 1) ? 1 : 0);
      234.   	}
              ^
      235.   
      236.   int DSA_size(const DSA *r)

crypto/evp/p_lib.c:309:2: 
    307.   	}
    308.   	DSA_up_ref(pkey->pkey.dsa);
    309. > 	return pkey->pkey.dsa;
    310.   }
    311.   #endif

crypto/evp/p_lib.c:310:1: return from a call to EVP_PKEY_get1_DSA
    308.   	DSA_up_ref(pkey->pkey.dsa);
    309.   	return pkey->pkey.dsa;
    310. > }
    311.   #endif
    312.   

crypto/pem/pem_all.c:209:2: 
  207.   	if(!key) return NULL;
  208.   	dtmp = EVP_PKEY_get1_DSA(key);
  209. > 	EVP_PKEY_free(key);
  210.   	if(!dtmp) return NULL;
  211.   	if(dsa) {

crypto/evp/p_lib.c:384:1: start of procedure EVP_PKEY_free()
    382.   	}
    383.   
    384. > void EVP_PKEY_free(EVP_PKEY *x)
    385.   	{
    386.   	int i;

crypto/evp/p_lib.c:388:6: Taking false branch
    386.   	int i;
    387.   
    388.   	if (x == NULL) return;
                ^
    389.   
    390.   	i=CRYPTO_add(&x->references,-1,CRYPTO_LOCK_EVP_PKEY);

crypto/evp/p_lib.c:390:2: 
    388.   	if (x == NULL) return;
    389.   
    390. > 	i=CRYPTO_add(&x->references,-1,CRYPTO_LOCK_EVP_PKEY);
    391.   #ifdef REF_PRINT
    392.   	REF_PRINT("EVP_PKEY",x);

crypto/cryptlib.c:517:1: start of procedure CRYPTO_add_lock()
      515.   	}
      516.   
      517. > int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
      518.   	     int line)
      519.   	{

crypto/cryptlib.c:520:2: 
      518.   	     int line)
      519.   	{
      520. > 	int ret = 0;
      521.   
      522.   	if (add_lock_callback != NULL)

crypto/cryptlib.c:522:6: Taking false branch
      520.   	int ret = 0;
      521.   
      522.   	if (add_lock_callback != NULL)
                  ^
      523.   		{
      524.   #ifdef LOCK_DEBUG

crypto/cryptlib.c:539:3: 
      537.   	else
      538.   		{
      539. > 		CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);
      540.   
      541.   		ret= *pointer+amount;

crypto/cryptlib.c:473:1: start of procedure CRYPTO_lock()
        471.   	}
        472.   
        473. > void CRYPTO_lock(int mode, int type, const char *file, int line)
        474.   	{
        475.   #ifdef LOCK_DEBUG

crypto/cryptlib.c:498:6: Taking false branch
        496.   		}
        497.   #endif
        498.   	if (type < 0)
                    ^
        499.   		{
        500.   		if (dynlock_lock_callback != NULL)

crypto/cryptlib.c:513:7: Taking false branch
        511.   		}
        512.   	else
        513.   		if (locking_callback != NULL)
                     ^
        514.   			locking_callback(mode,type,file,line);
        515.   	}

crypto/cryptlib.c:498:2: 
        496.   		}
        497.   #endif
        498. > 	if (type < 0)
        499.   		{
        500.   		if (dynlock_lock_callback != NULL)

crypto/cryptlib.c:515:2: return from a call to CRYPTO_lock
        513.   		if (locking_callback != NULL)
        514.   			locking_callback(mode,type,file,line);
        515.   	}
                ^
        516.   
        517.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/cryptlib.c:541:3: 
      539.   		CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);
      540.   
      541. > 		ret= *pointer+amount;
      542.   #ifdef LOCK_DEBUG
      543.   		fprintf(stderr,"ladd:%08lx/%0xp:%2d+%2d->%2d %-18s %s:%d\n",
