engines/ccgost/gost_sign.c:205: error: NULL_DEREFERENCE
  pointer `dsa->pub_key` last assigned on line 204 could be null and is dereferenced by call to `BN_mod_exp()` at line 205, column 2.
Showing all 99 steps of the trace


engines/ccgost/gost_sign.c:194:1: start of procedure gost94_compute_public()
192.    *
193.    */
194. > int gost94_compute_public(DSA *dsa)
195.   	{
196.   	/* Now fill algorithm parameters with correct values */

engines/ccgost/gost_sign.c:197:2: 
195.   	{
196.   	/* Now fill algorithm parameters with correct values */
197. > 	BN_CTX *ctx = BN_CTX_new();
198.   	if (!dsa->g)
199.   		{

crypto/bn/bn_ctx.c:214:1: start of procedure BN_CTX_new()
  212.   #endif
  213.   
  214. > BN_CTX *BN_CTX_new(void)
  215.   	{
  216.   	BN_CTX *ret = OPENSSL_malloc(sizeof(BN_CTX));

crypto/bn/bn_ctx.c:216:2: 
  214.   BN_CTX *BN_CTX_new(void)
  215.   	{
  216. > 	BN_CTX *ret = OPENSSL_malloc(sizeof(BN_CTX));
  217.   	if(!ret)
  218.   		{

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/bn/bn_ctx.c:217:6: Taking true branch
  215.   	{
  216.   	BN_CTX *ret = OPENSSL_malloc(sizeof(BN_CTX));
  217.   	if(!ret)
              ^
  218.   		{
  219.   		BNerr(BN_F_BN_CTX_NEW,ERR_R_MALLOC_FAILURE);

crypto/bn/bn_ctx.c:219:3: 
  217.   	if(!ret)
  218.   		{
  219. > 		BNerr(BN_F_BN_CTX_NEW,ERR_R_MALLOC_FAILURE);
  220.   		return NULL;
  221.   		}

crypto/err/err.c:706:1: start of procedure ERR_put_error()
    704.   /********************************************************/
    705.   
    706. > void ERR_put_error(int lib, int func, int reason, const char *file,
    707.   	     int line)
    708.   	{

crypto/err/err.c:730:2: Skipping ERR_get_state(): empty list of specs
    728.   	}
    729.   #endif
    730.   	es=ERR_get_state();
            ^
    731.   
    732.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:732:2: 
    730.   	es=ERR_get_state();
    731.   
    732. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
    733.   	if (es->top == es->bottom)
    734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:733:6: Taking false branch
    731.   
    732.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
    733.   	if (es->top == es->bottom)
                ^
    734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    735.   	es->err_flags[es->top]=0;

crypto/err/err.c:735:2: 
    733.   	if (es->top == es->bottom)
    734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    735. > 	es->err_flags[es->top]=0;
    736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    737.   	es->err_file[es->top]=file;

crypto/err/err.c:736:2: 
    734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    735.   	es->err_flags[es->top]=0;
    736. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    737.   	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;

crypto/err/err.c:737:2: 
    735.   	es->err_flags[es->top]=0;
    736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    737. > 	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);

crypto/err/err.c:738:2: 
    736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    737.   	es->err_file[es->top]=file;
    738. > 	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
    740.   	}

crypto/err/err.c:739:2: Taking true branch
    737.   	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
            ^
    740.   	}
    741.   

crypto/err/err.c:739:2: Taking false branch
    737.   	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
            ^
    740.   	}
    741.   

crypto/err/err.c:739:2: Loop condition is false. Leaving loop
    737.   	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
            ^
    740.   	}
    741.   

crypto/err/err.c:740:2: return from a call to ERR_put_error
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
    740.   	}
            ^
    741.   
    742.   void ERR_clear_error(void)

crypto/bn/bn_ctx.c:220:3: 
  218.   		{
  219.   		BNerr(BN_F_BN_CTX_NEW,ERR_R_MALLOC_FAILURE);
  220. > 		return NULL;
  221.   		}
  222.   	/* Initialise the structure */

crypto/bn/bn_ctx.c:229:2: return from a call to BN_CTX_new
  227.   	ret->too_many = 0;
  228.   	return ret;
  229.   	}
          ^
  230.   
  231.   void BN_CTX_free(BN_CTX *ctx)

engines/ccgost/gost_sign.c:198:7: Taking false branch
196.   	/* Now fill algorithm parameters with correct values */
197.   	BN_CTX *ctx = BN_CTX_new();
198.   	if (!dsa->g)
             ^
199.   		{
200.   		GOSTerr(GOST_F_GOST94_COMPUTE_PUBLIC,GOST_R_KEY_IS_NOT_INITALIZED);

engines/ccgost/gost_sign.c:204:2: 
202.   		}	
203.   	/* Compute public key  y = a^x mod p */
204. > 	dsa->pub_key=BN_new();
205.   	BN_mod_exp(dsa->pub_key, dsa->g,dsa->priv_key,dsa->p,ctx);
206.   	BN_CTX_free(ctx);

crypto/bn/bn_lib.c:298:1: start of procedure BN_new()
  296.   	}
  297.   
  298. > BIGNUM *BN_new(void)
  299.   	{
  300.   	BIGNUM *ret;

crypto/bn/bn_lib.c:302:6: 
  300.   	BIGNUM *ret;
  301.   
  302. > 	if ((ret=(BIGNUM *)OPENSSL_malloc(sizeof(BIGNUM))) == NULL)
  303.   		{
  304.   		BNerr(BN_F_BN_NEW,ERR_R_MALLOC_FAILURE);

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/bn/bn_lib.c:302:6: Taking true branch
  300.   	BIGNUM *ret;
  301.   
  302.   	if ((ret=(BIGNUM *)OPENSSL_malloc(sizeof(BIGNUM))) == NULL)
              ^
  303.   		{
  304.   		BNerr(BN_F_BN_NEW,ERR_R_MALLOC_FAILURE);

crypto/bn/bn_lib.c:304:3: 
  302.   	if ((ret=(BIGNUM *)OPENSSL_malloc(sizeof(BIGNUM))) == NULL)
  303.   		{
  304. > 		BNerr(BN_F_BN_NEW,ERR_R_MALLOC_FAILURE);
  305.   		return(NULL);
  306.   		}

crypto/err/err.c:706:1: start of procedure ERR_put_error()
    704.   /********************************************************/
    705.   
    706. > void ERR_put_error(int lib, int func, int reason, const char *file,
    707.   	     int line)
    708.   	{

crypto/err/err.c:730:2: Skipping ERR_get_state(): empty list of specs
    728.   	}
    729.   #endif
    730.   	es=ERR_get_state();
            ^
    731.   
    732.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:732:2: 
    730.   	es=ERR_get_state();
    731.   
    732. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
    733.   	if (es->top == es->bottom)
    734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:733:6: Taking false branch
    731.   
    732.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
    733.   	if (es->top == es->bottom)
                ^
    734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    735.   	es->err_flags[es->top]=0;

crypto/err/err.c:735:2: 
    733.   	if (es->top == es->bottom)
    734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    735. > 	es->err_flags[es->top]=0;
    736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    737.   	es->err_file[es->top]=file;

crypto/err/err.c:736:2: 
    734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
    735.   	es->err_flags[es->top]=0;
    736. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    737.   	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;

crypto/err/err.c:737:2: 
    735.   	es->err_flags[es->top]=0;
    736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    737. > 	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);

crypto/err/err.c:738:2: 
    736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
    737.   	es->err_file[es->top]=file;
    738. > 	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
    740.   	}

crypto/err/err.c:739:2: Taking true branch
    737.   	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
            ^
    740.   	}
    741.   

crypto/err/err.c:739:2: Taking false branch
    737.   	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
            ^
    740.   	}
    741.   

crypto/err/err.c:739:2: Loop condition is false. Leaving loop
    737.   	es->err_file[es->top]=file;
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
            ^
    740.   	}
    741.   

crypto/err/err.c:740:2: return from a call to ERR_put_error
    738.   	es->err_line[es->top]=line;
    739.   	err_clear_data(es,es->top);
    740.   	}
            ^
    741.   
    742.   void ERR_clear_error(void)

crypto/bn/bn_lib.c:305:3: 
  303.   		{
  304.   		BNerr(BN_F_BN_NEW,ERR_R_MALLOC_FAILURE);
  305. > 		return(NULL);
  306.   		}
  307.   	ret->flags=BN_FLG_MALLOCED;

crypto/bn/bn_lib.c:314:2: return from a call to BN_new
  312.   	bn_check_top(ret);
  313.   	return(ret);
  314.   	}
          ^
  315.   
  316.   /* This is used both by bn_expand2() and bn_dup_expand() */

engines/ccgost/gost_sign.c:205:2: 
203.   	/* Compute public key  y = a^x mod p */
204.   	dsa->pub_key=BN_new();
205. > 	BN_mod_exp(dsa->pub_key, dsa->g,dsa->priv_key,dsa->p,ctx);
206.   	BN_CTX_free(ctx);
207.   	return 1;

crypto/bn/bn_exp.c:163:1: start of procedure BN_mod_exp()
  161.   
  162.   
  163. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  164.   	       BN_CTX *ctx)
  165.   	{

crypto/bn/bn_exp.c:213:6: Taking false branch
  211.   /*	if ((m->d[m->top-1]&BN_TBIT) && BN_is_odd(m)) */
  212.   
  213.   	if (BN_is_odd(m))
              ^
  214.   		{
  215.   #  ifdef MONT_EXP_WORD

crypto/bn/bn_exp.c:228:5: 
  226.   #endif
  227.   #ifdef RECP_MUL_MOD
  228. > 		{ ret=BN_mod_exp_recp(r,a,p,m,ctx); }
  229.   #else
  230.   		{ ret=BN_mod_exp_simple(r,a,p,m,ctx); }

crypto/bn/bn_exp.c:238:1: start of procedure BN_mod_exp_recp()
    236.   
    237.   
    238. > int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    239.   		    const BIGNUM *m, BN_CTX *ctx)
    240.   	{

crypto/bn/bn_exp.c:241:2: 
    239.   		    const BIGNUM *m, BN_CTX *ctx)
    240.   	{
    241. > 	int i,j,bits,ret=0,wstart,wend,window,wvalue;
    242.   	int start=1;
    243.   	BIGNUM *aa;

crypto/bn/bn_exp.c:242:2: 
    240.   	{
    241.   	int i,j,bits,ret=0,wstart,wend,window,wvalue;
    242. > 	int start=1;
    243.   	BIGNUM *aa;
    244.   	/* Table of variables obtained from 'ctx' */

crypto/bn/bn_exp.c:248:6: Taking true branch
    246.   	BN_RECP_CTX recp;
    247.   
    248.   	if (BN_get_flags(p, BN_FLG_CONSTTIME) != 0)
                ^
    249.   		{
    250.   		/* BN_FLG_CONSTTIME only supported by BN_mod_exp_mont() */

crypto/bn/bn_exp.c:251:3: 
    249.   		{
    250.   		/* BN_FLG_CONSTTIME only supported by BN_mod_exp_mont() */
    251. > 		BNerr(BN_F_BN_MOD_EXP_RECP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
    252.   		return -1;
    253.   		}

crypto/err/err.c:706:1: start of procedure ERR_put_error()
      704.   /********************************************************/
      705.   
      706. > void ERR_put_error(int lib, int func, int reason, const char *file,
      707.   	     int line)
      708.   	{

crypto/err/err.c:730:2: Skipping ERR_get_state(): empty list of specs
      728.   	}
      729.   #endif
      730.   	es=ERR_get_state();
              ^
      731.   
      732.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:732:2: 
      730.   	es=ERR_get_state();
      731.   
      732. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
      733.   	if (es->top == es->bottom)
      734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:733:6: Taking false branch
      731.   
      732.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
      733.   	if (es->top == es->bottom)
                  ^
      734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
      735.   	es->err_flags[es->top]=0;

crypto/err/err.c:735:2: 
      733.   	if (es->top == es->bottom)
      734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
      735. > 	es->err_flags[es->top]=0;
      736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
      737.   	es->err_file[es->top]=file;

crypto/err/err.c:736:2: 
      734.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
      735.   	es->err_flags[es->top]=0;
      736. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
      737.   	es->err_file[es->top]=file;
      738.   	es->err_line[es->top]=line;

crypto/err/err.c:737:2: 
      735.   	es->err_flags[es->top]=0;
      736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
      737. > 	es->err_file[es->top]=file;
      738.   	es->err_line[es->top]=line;
      739.   	err_clear_data(es,es->top);

crypto/err/err.c:738:2: 
      736.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
      737.   	es->err_file[es->top]=file;
      738. > 	es->err_line[es->top]=line;
      739.   	err_clear_data(es,es->top);
      740.   	}

crypto/err/err.c:739:2: Taking true branch
      737.   	es->err_file[es->top]=file;
      738.   	es->err_line[es->top]=line;
      739.   	err_clear_data(es,es->top);
              ^
      740.   	}
      741.   

crypto/err/err.c:739:2: Taking true branch
      737.   	es->err_file[es->top]=file;
      738.   	es->err_line[es->top]=line;
      739.   	err_clear_data(es,es->top);
              ^
      740.   	}
      741.   

crypto/mem.c:377:1: start of procedure CRYPTO_free()
        375.   	}
        376.   
        377. > void CRYPTO_free(void *str)
        378.   	{
        379.   	if (free_debug_func != NULL)

crypto/mem.c:379:6: Taking true branch
        377.   void CRYPTO_free(void *str)
        378.   	{
        379.   	if (free_debug_func != NULL)
                    ^
        380.   		free_debug_func(str, 0);
        381.   #ifdef LEVITTE_DEBUG_MEM

crypto/mem.c:380:3: Skipping __function_pointer__(): unresolved function pointer
        378.   	{
        379.   	if (free_debug_func != NULL)
        380.   		free_debug_func(str, 0);
                 ^
        381.   #ifdef LEVITTE_DEBUG_MEM
        382.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         < 0x%p\n", str);

crypto/mem.c:384:2: Skipping __function_pointer__(): unresolved function pointer
        382.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         < 0x%p\n", str);
        383.   #endif
        384.   	free_func(str);
                ^
        385.   	if (free_debug_func != NULL)
        386.   		free_debug_func(NULL, 1);

crypto/mem.c:385:6: Taking true branch
        383.   #endif
        384.   	free_func(str);
        385.   	if (free_debug_func != NULL)
                    ^
        386.   		free_debug_func(NULL, 1);
        387.   	}

crypto/mem.c:386:3: Skipping __function_pointer__(): unresolved function pointer
        384.   	free_func(str);
        385.   	if (free_debug_func != NULL)
        386.   		free_debug_func(NULL, 1);
                 ^
        387.   	}
        388.   

crypto/mem.c:385:2: 
        383.   #endif
        384.   	free_func(str);
        385. > 	if (free_debug_func != NULL)
        386.   		free_debug_func(NULL, 1);
        387.   	}

crypto/mem.c:387:2: return from a call to CRYPTO_free
        385.   	if (free_debug_func != NULL)
        386.   		free_debug_func(NULL, 1);
        387.   	}
                ^
        388.   
        389.   void *CRYPTO_remalloc(void *a, int num, const char *file, int line)

crypto/err/err.c:739:2: Loop condition is false. Leaving loop
      737.   	es->err_file[es->top]=file;
      738.   	es->err_line[es->top]=line;
      739.   	err_clear_data(es,es->top);
              ^
      740.   	}
      741.   

crypto/err/err.c:740:2: return from a call to ERR_put_error
      738.   	es->err_line[es->top]=line;
      739.   	err_clear_data(es,es->top);
      740.   	}
              ^
      741.   
      742.   void ERR_clear_error(void)

crypto/bn/bn_exp.c:252:3: 
    250.   		/* BN_FLG_CONSTTIME only supported by BN_mod_exp_mont() */
    251.   		BNerr(BN_F_BN_MOD_EXP_RECP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
    252. > 		return -1;
    253.   		}
    254.   

crypto/bn/bn_exp.c:368:2: return from a call to BN_mod_exp_recp
    366.   	bn_check_top(r);
    367.   	return(ret);
    368.   	}
            ^
    369.   
    370.   

crypto/bn/bn_exp.c:234:2: 
  232.   
  233.   	bn_check_top(r);
  234. > 	return(ret);
  235.   	}
  236.   

crypto/bn/bn_exp.c:235:2: return from a call to BN_mod_exp
  233.   	bn_check_top(r);
  234.   	return(ret);
  235.   	}
          ^
  236.   
  237.   
