gobject-introspection-1.80.1-1.fc41

List of Defects

Error: GCC_ANALYZER_WARNING: [#def1]
gobject-introspection-1.80.1/girepository/cmph/bdz.c: scope_hint: In function ‘bdz_alloc_graph3’
gobject-introspection-1.80.1/girepository/cmph/bdz.c:70:28: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz.c:70:28: note: only use operands of an integer type inside the size argument
#   68|   {
#   69|   	graph3->edges=malloc(nedges*sizeof(bdz_edge_t));
#   70|-> 	graph3->first_edge=malloc(nvertices*sizeof(cmph_uint32));
#   71|   	graph3->vert_degree=malloc((size_t)nvertices);	
#   72|   };

Error: GCC_ANALYZER_WARNING: [#def2]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:71:29: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz.c:71:29: note: only use operands of an integer type inside the size argument
#   69|   	graph3->edges=malloc(nedges*sizeof(bdz_edge_t));
#   70|   	graph3->first_edge=malloc(nvertices*sizeof(cmph_uint32));
#   71|-> 	graph3->vert_degree=malloc((size_t)nvertices);	
#   72|   };
#   73|   static void bdz_init_graph3(bdz_graph3_t * graph3, cmph_uint32 nedges, cmph_uint32 nvertices)

Error: GCC_ANALYZER_WARNING (CWE-688): [#def3]
gobject-introspection-1.80.1/girepository/cmph/bdz.c: scope_hint: In function ‘bdz_init_graph3’
gobject-introspection-1.80.1/girepository/cmph/bdz.c:75:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘graph3.first_edge’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#   73|   static void bdz_init_graph3(bdz_graph3_t * graph3, cmph_uint32 nedges, cmph_uint32 nvertices)
#   74|   {
#   75|-> 	memset(graph3->first_edge,0xff,nvertices*sizeof(cmph_uint32));
#   76|   	memset(graph3->vert_degree,0,(size_t)nvertices);
#   77|   	graph3->nedges=0;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def4]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:76:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘graph3.vert_degree’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#   74|   {
#   75|   	memset(graph3->first_edge,0xff,nvertices*sizeof(cmph_uint32));
#   76|-> 	memset(graph3->vert_degree,0,(size_t)nvertices);
#   77|   	graph3->nedges=0;
#   78|   };

Error: CLANG_WARNING: [#def5]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:129:7: warning[core.uninitialized.Assign]: Assigned value is garbage or undefined
#  127|   	cmph_uint32 i,j=0,vert,edge1,edge2;
#  128|   	for(i=0;i<3;i++){
#  129|-> 		vert=graph3->edges[curr_edge].vertices[i];
#  130|   		edge1=graph3->first_edge[vert];
#  131|   		edge2=NULL_EDGE;

Error: CLANG_WARNING: [#def6]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:134:39: warning[core.UndefinedBinaryOperatorResult]: The left operand of '==' is a garbage value
#  132|   		while(edge1!=curr_edge&&edge1!=NULL_EDGE){
#  133|   			edge2=edge1;
#  134|-> 			if(graph3->edges[edge1].vertices[0]==vert){
#  135|   				j=0;
#  136|   			} else if(graph3->edges[edge1].vertices[1]==vert){

Error: GCC_ANALYZER_WARNING (CWE-688): [#def7]
gobject-introspection-1.80.1/girepository/cmph/bdz.c: scope_hint: In function ‘bdz_generate_queue’
gobject-introspection-1.80.1/girepository/cmph/bdz.c:166:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘marked_edge’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  164|   	cmph_uint32 tmp_edge;
#  165|   	cmph_uint8 * marked_edge =malloc((size_t)(nedges >> 3) + 1);
#  166|-> 	memset(marked_edge, 0, (size_t)(nedges >> 3) + 1);
#  167|   
#  168|   	for(i=0;i<nedges;i++){

Error: GCC_ANALYZER_WARNING (CWE-457): [#def8]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:169:19: warning[-Wanalyzer-use-of-uninitialized-value]: use of uninitialized value ‘*<unknown>.vertices[0]’
#  167|   
#  168|   	for(i=0;i<nedges;i++){
#  169|-> 		v0=graph3->edges[i].vertices[0];
#  170|   		v1=graph3->edges[i].vertices[1];
#  171|   		v2=graph3->edges[i].vertices[2];

Error: GCC_ANALYZER_WARNING (CWE-476): [#def9]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:176:52: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘queue’
gobject-introspection-1.80.1/girepository/cmph/bdz.c: scope_hint: In function ‘bdz_generate_queue’
#  174|   				graph3->vert_degree[v2]==1){
#  175|   			if(!GETBIT(marked_edge,i)) {
#  176|-> 				queue[queue_head++]=i;
#  177|   				SETBIT(marked_edge,i);
#  178|   			}

Error: GCC_ANALYZER_WARNING (CWE-476): [#def10]
gobject-introspection-1.80.1/girepository/cmph/bdz.c: scope_hint: In function ‘bdz_new’
gobject-introspection-1.80.1/girepository/cmph/bdz.c:354:20: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘mphf’
#  352|   	#endif
#  353|   	mphf = (cmph_t *)malloc(sizeof(cmph_t));
#  354|-> 	mphf->algo = mph->algo;
#  355|   	bdzf = (bdz_data_t *)malloc(sizeof(bdz_data_t));
#  356|   	bdzf->g = bdz->g;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def11]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:356:17: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘bdzf’
#  354|   	mphf->algo = mph->algo;
#  355|   	bdzf = (bdz_data_t *)malloc(sizeof(bdz_data_t));
#  356|-> 	bdzf->g = bdz->g;
#  357|   	bdz->g = NULL; //transfer memory ownership
#  358|   	bdzf->hl = bdz->hl;

Error: GCC_ANALYZER_WARNING: [#def12]
gobject-introspection-1.80.1/girepository/cmph/bdz.c: scope_hint: In function ‘assigning’
gobject-introspection-1.80.1/girepository/cmph/bdz.c:422:32: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz.c:422:32: note: only use operands of an integer type inside the size argument
#  420|   	cmph_uint8 * marked_vertices =malloc((size_t)(bdz->n >> 3) + 1);
#  421|           cmph_uint32 sizeg = (cmph_uint32)ceil(bdz->n/4.0);
#  422|-> 	bdz->g = (cmph_uint8 *)calloc((size_t)(sizeg), sizeof(cmph_uint8));	
#  423|   	memset(marked_vertices, 0, (size_t)(bdz->n >> 3) + 1);
#  424|   	memset(bdz->g, 0xff, (size_t)(sizeg));

Error: GCC_ANALYZER_WARNING (CWE-688): [#def13]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:423:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘marked_vertices’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  421|           cmph_uint32 sizeg = (cmph_uint32)ceil(bdz->n/4.0);
#  422|   	bdz->g = (cmph_uint8 *)calloc((size_t)(sizeg), sizeof(cmph_uint8));	
#  423|-> 	memset(marked_vertices, 0, (size_t)(bdz->n >> 3) + 1);
#  424|   	memset(bdz->g, 0xff, (size_t)(sizeg));
#  425|   

Error: GCC_ANALYZER_WARNING (CWE-688): [#def14]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:424:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*bdz.g’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  422|   	bdz->g = (cmph_uint8 *)calloc((size_t)(sizeg), sizeof(cmph_uint8));	
#  423|   	memset(marked_vertices, 0, (size_t)(bdz->n >> 3) + 1);
#  424|-> 	memset(bdz->g, 0xff, (size_t)(sizeg));
#  425|   
#  426|   	for(i=nedges-1;i+1>0;i--){

Error: GCC_ANALYZER_WARNING (CWE-688): [#def15]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:424:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘calloc((long unsigned int)sizeg, 1)’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  422|   	bdz->g = (cmph_uint8 *)calloc((size_t)(sizeg), sizeof(cmph_uint8));	
#  423|   	memset(marked_vertices, 0, (size_t)(bdz->n >> 3) + 1);
#  424|-> 	memset(bdz->g, 0xff, (size_t)(sizeg));
#  425|   
#  426|   	for(i=nedges-1;i+1>0;i--){

Error: GCC_ANALYZER_WARNING (CWE-476): [#def16]
gobject-introspection-1.80.1/girepository/cmph/bdz.c: scope_hint: In function ‘ranking’
gobject-introspection-1.80.1/girepository/cmph/bdz.c:468:27: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*bdz.ranktable’
#  466|   	bdz->ranktable = (cmph_uint32 *)calloc((size_t)bdz->ranktablesize, sizeof(cmph_uint32));
#  467|   	// ranktable computation
#  468|-> 	bdz->ranktable[0] = 0;	
#  469|   	i = 1;
#  470|   	while(1)

Error: GCC_ANALYZER_WARNING (CWE-476): [#def17]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:468:27: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘calloc((long unsigned int)*bdz.ranktablesize, 4)’
#  466|   	bdz->ranktable = (cmph_uint32 *)calloc((size_t)bdz->ranktablesize, sizeof(cmph_uint32));
#  467|   	// ranktable computation
#  468|-> 	bdz->ranktable[0] = 0;	
#  469|   	i = 1;
#  470|   	while(1)

Error: CLANG_WARNING: [#def18]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:500:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  498|   	hash_state_dump(data->hl, &buf, &buflen);
#  499|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  500|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  501|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  502|   	free(buf);

Error: CLANG_WARNING: [#def19]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:501:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  499|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  500|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  501|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  502|   	free(buf);
#  503|   

Error: CLANG_WARNING: [#def20]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:504:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  502|   	free(buf);
#  503|   
#  504|-> 	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  505|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  506|   	nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);

Error: CLANG_WARNING: [#def21]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:505:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  503|   
#  504|   	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  505|-> 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  506|   	nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
#  507|   	

Error: CLANG_WARNING: [#def22]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:506:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  504|   	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  505|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  506|-> 	nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
#  507|   	
#  508|   	sizeg = (cmph_uint32)ceil(data->n/4.0);

Error: CLANG_WARNING: [#def23]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:509:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  507|   	
#  508|   	sizeg = (cmph_uint32)ceil(data->n/4.0);
#  509|-> 	nbytes = fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);
#  510|   
#  511|   	nbytes = fwrite(&(data->k), sizeof(cmph_uint32), (size_t)1, fd);

Error: CLANG_WARNING: [#def24]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:511:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  509|   	nbytes = fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);
#  510|   
#  511|-> 	nbytes = fwrite(&(data->k), sizeof(cmph_uint32), (size_t)1, fd);
#  512|   	nbytes = fwrite(&(data->b), sizeof(cmph_uint8), (size_t)1, fd);
#  513|   	nbytes = fwrite(&(data->ranktablesize), sizeof(cmph_uint32), (size_t)1, fd);

Error: CLANG_WARNING: [#def25]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:512:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  510|   
#  511|   	nbytes = fwrite(&(data->k), sizeof(cmph_uint32), (size_t)1, fd);
#  512|-> 	nbytes = fwrite(&(data->b), sizeof(cmph_uint8), (size_t)1, fd);
#  513|   	nbytes = fwrite(&(data->ranktablesize), sizeof(cmph_uint32), (size_t)1, fd);
#  514|   

Error: CLANG_WARNING: [#def26]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:513:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  511|   	nbytes = fwrite(&(data->k), sizeof(cmph_uint32), (size_t)1, fd);
#  512|   	nbytes = fwrite(&(data->b), sizeof(cmph_uint8), (size_t)1, fd);
#  513|-> 	nbytes = fwrite(&(data->ranktablesize), sizeof(cmph_uint32), (size_t)1, fd);
#  514|   
#  515|   	nbytes = fwrite(data->ranktable, sizeof(cmph_uint32)*(data->ranktablesize), (size_t)1, fd);

Error: CLANG_WARNING: [#def27]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:541:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  539|   	mphf->data = bdz;
#  540|   
#  541|-> 	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  542|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  543|   	buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def28]
gobject-introspection-1.80.1/girepository/cmph/bdz.c: scope_hint: In function ‘bdz_load’
gobject-introspection-1.80.1/girepository/cmph/bdz.c:543:23: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/bdz.c:543:23: note: heap-based allocation
#  541|   	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  542|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  543|-> 	buf = (char *)malloc((size_t)buflen);
#  544|   	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  545|   	bdz->hl = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def29]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:544:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  542|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  543|   	buf = (char *)malloc((size_t)buflen);
#  544|-> 	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  545|   	bdz->hl = hash_state_load(buf, buflen);
#  546|   	free(buf);

Error: CLANG_WARNING: [#def30]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:550:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  548|   
#  549|   	DEBUGP("Reading m and n\n");
#  550|-> 	nbytes = fread(&(bdz->n), sizeof(cmph_uint32), (size_t)1, f);	
#  551|   	nbytes = fread(&(bdz->m), sizeof(cmph_uint32), (size_t)1, f);	
#  552|   	nbytes = fread(&(bdz->r), sizeof(cmph_uint32), (size_t)1, f);	

Error: CLANG_WARNING: [#def31]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:551:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  549|   	DEBUGP("Reading m and n\n");
#  550|   	nbytes = fread(&(bdz->n), sizeof(cmph_uint32), (size_t)1, f);	
#  551|-> 	nbytes = fread(&(bdz->m), sizeof(cmph_uint32), (size_t)1, f);	
#  552|   	nbytes = fread(&(bdz->r), sizeof(cmph_uint32), (size_t)1, f);	
#  553|   	sizeg = (cmph_uint32)ceil(bdz->n/4.0);

Error: CLANG_WARNING: [#def32]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:552:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  550|   	nbytes = fread(&(bdz->n), sizeof(cmph_uint32), (size_t)1, f);	
#  551|   	nbytes = fread(&(bdz->m), sizeof(cmph_uint32), (size_t)1, f);	
#  552|-> 	nbytes = fread(&(bdz->r), sizeof(cmph_uint32), (size_t)1, f);	
#  553|   	sizeg = (cmph_uint32)ceil(bdz->n/4.0);
#  554|   	bdz->g = (cmph_uint8 *)calloc((size_t)(sizeg), sizeof(cmph_uint8));

Error: GCC_ANALYZER_WARNING: [#def33]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:554:32: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz.c:554:32: note: only use operands of an integer type inside the size argument
#  552|   	nbytes = fread(&(bdz->r), sizeof(cmph_uint32), (size_t)1, f);	
#  553|   	sizeg = (cmph_uint32)ceil(bdz->n/4.0);
#  554|-> 	bdz->g = (cmph_uint8 *)calloc((size_t)(sizeg), sizeof(cmph_uint8));
#  555|   	nbytes = fread(bdz->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
#  556|   

Error: CLANG_WARNING: [#def34]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:555:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  553|   	sizeg = (cmph_uint32)ceil(bdz->n/4.0);
#  554|   	bdz->g = (cmph_uint8 *)calloc((size_t)(sizeg), sizeof(cmph_uint8));
#  555|-> 	nbytes = fread(bdz->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
#  556|   
#  557|   	nbytes = fread(&(bdz->k), sizeof(cmph_uint32), (size_t)1, f);

Error: CLANG_WARNING: [#def35]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:557:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  555|   	nbytes = fread(bdz->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
#  556|   
#  557|-> 	nbytes = fread(&(bdz->k), sizeof(cmph_uint32), (size_t)1, f);
#  558|   	nbytes = fread(&(bdz->b), sizeof(cmph_uint8), (size_t)1, f);
#  559|   	nbytes = fread(&(bdz->ranktablesize), sizeof(cmph_uint32), (size_t)1, f);

Error: CLANG_WARNING: [#def36]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:558:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  556|   
#  557|   	nbytes = fread(&(bdz->k), sizeof(cmph_uint32), (size_t)1, f);
#  558|-> 	nbytes = fread(&(bdz->b), sizeof(cmph_uint8), (size_t)1, f);
#  559|   	nbytes = fread(&(bdz->ranktablesize), sizeof(cmph_uint32), (size_t)1, f);
#  560|   

Error: CLANG_WARNING: [#def37]
gobject-introspection-1.80.1/girepository/cmph/bdz.c:559:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  557|   	nbytes = fread(&(bdz->k), sizeof(cmph_uint32), (size_t)1, f);
#  558|   	nbytes = fread(&(bdz->b), sizeof(cmph_uint8), (size_t)1, f);
#  559|-> 	nbytes = fread(&(bdz->ranktablesize), sizeof(cmph_uint32), (size_t)1, f);
#  560|   
#  561|   	bdz->ranktable = (cmph_uint32 *)calloc((size_t)bdz->ranktablesize, sizeof(cmph_uint32));

Error: GCC_ANALYZER_WARNING: [#def38]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c: scope_hint: In function ‘bdz_ph_alloc_graph3’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:57:28: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:57:28: note: only use operands of an integer type inside the size argument
#   55|   {
#   56|   	graph3->edges=malloc(nedges*sizeof(bdz_ph_edge_t));
#   57|-> 	graph3->first_edge=malloc(nvertices*sizeof(cmph_uint32));
#   58|   	graph3->vert_degree=malloc((size_t)nvertices);	
#   59|   };

Error: GCC_ANALYZER_WARNING: [#def39]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:58:29: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:58:29: note: only use operands of an integer type inside the size argument
#   56|   	graph3->edges=malloc(nedges*sizeof(bdz_ph_edge_t));
#   57|   	graph3->first_edge=malloc(nvertices*sizeof(cmph_uint32));
#   58|-> 	graph3->vert_degree=malloc((size_t)nvertices);	
#   59|   };
#   60|   static void bdz_ph_init_graph3(bdz_ph_graph3_t * graph3, cmph_uint32 nedges, cmph_uint32 nvertices)

Error: GCC_ANALYZER_WARNING (CWE-688): [#def40]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c: scope_hint: In function ‘bdz_ph_init_graph3’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:62:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘graph3.first_edge’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#   60|   static void bdz_ph_init_graph3(bdz_ph_graph3_t * graph3, cmph_uint32 nedges, cmph_uint32 nvertices)
#   61|   {
#   62|-> 	memset(graph3->first_edge,0xff,nvertices*sizeof(cmph_uint32));
#   63|   	memset(graph3->vert_degree,0,(size_t)nvertices);
#   64|   	graph3->nedges=0;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def41]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:63:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘graph3.vert_degree’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#   61|   {
#   62|   	memset(graph3->first_edge,0xff,nvertices*sizeof(cmph_uint32));
#   63|-> 	memset(graph3->vert_degree,0,(size_t)nvertices);
#   64|   	graph3->nedges=0;
#   65|   };

Error: CLANG_WARNING: [#def42]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:116:7: warning[core.uninitialized.Assign]: Assigned value is garbage or undefined
#  114|   	cmph_uint32 i,j=0,vert,edge1,edge2;
#  115|   	for(i=0;i<3;i++){
#  116|-> 		vert=graph3->edges[curr_edge].vertices[i];
#  117|   		edge1=graph3->first_edge[vert];
#  118|   		edge2=NULL_EDGE;

Error: CLANG_WARNING: [#def43]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:121:39: warning[core.UndefinedBinaryOperatorResult]: The left operand of '==' is a garbage value
#  119|   		while(edge1!=curr_edge&&edge1!=NULL_EDGE){
#  120|   			edge2=edge1;
#  121|-> 			if(graph3->edges[edge1].vertices[0]==vert){
#  122|   				j=0;
#  123|   			} else if(graph3->edges[edge1].vertices[1]==vert){

Error: GCC_ANALYZER_WARNING (CWE-688): [#def44]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c: scope_hint: In function ‘bdz_ph_generate_queue’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:153:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘marked_edge’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  151|   	cmph_uint32 tmp_edge;
#  152|   	cmph_uint8 * marked_edge =malloc((size_t)(nedges >> 3) + 1);
#  153|-> 	memset(marked_edge, 0, (size_t)(nedges >> 3) + 1);
#  154|   
#  155|   	for(i=0;i<nedges;i++){

Error: GCC_ANALYZER_WARNING (CWE-457): [#def45]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:156:19: warning[-Wanalyzer-use-of-uninitialized-value]: use of uninitialized value ‘*<unknown>.vertices[0]’
#  154|   
#  155|   	for(i=0;i<nedges;i++){
#  156|-> 		v0=graph3->edges[i].vertices[0];
#  157|   		v1=graph3->edges[i].vertices[1];
#  158|   		v2=graph3->edges[i].vertices[2];

Error: GCC_ANALYZER_WARNING (CWE-476): [#def46]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:163:52: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘queue’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c: scope_hint: In function ‘bdz_ph_generate_queue’
#  161|   				graph3->vert_degree[v2]==1){
#  162|   			if(!GETBIT(marked_edge,i)) {
#  163|-> 				queue[queue_head++]=i;
#  164|   				SETBIT(marked_edge,i);
#  165|   			}

Error: GCC_ANALYZER_WARNING (CWE-476): [#def47]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c: scope_hint: In function ‘bdz_ph_new’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:324:20: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘mphf’
#  322|   	#endif
#  323|   	mphf = (cmph_t *)malloc(sizeof(cmph_t));
#  324|-> 	mphf->algo = mph->algo;
#  325|   	bdz_phf = (bdz_ph_data_t *)malloc(sizeof(bdz_ph_data_t));
#  326|   	bdz_phf->g = bdz_ph->g;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def48]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:326:20: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘bdz_phf’
#  324|   	mphf->algo = mph->algo;
#  325|   	bdz_phf = (bdz_ph_data_t *)malloc(sizeof(bdz_ph_data_t));
#  326|-> 	bdz_phf->g = bdz_ph->g;
#  327|   	bdz_ph->g = NULL; //transfer memory ownership
#  328|   	bdz_phf->hl = bdz_ph->hl;

Error: GCC_ANALYZER_WARNING: [#def49]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c: scope_hint: In function ‘assigning’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:387:35: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:387:35: note: only use operands of an integer type inside the size argument
#  385|   	cmph_uint8 * marked_vertices =malloc((size_t)(bdz_ph->n >> 3) + 1);
#  386|   	cmph_uint32 sizeg = (cmph_uint32)ceil(bdz_ph->n/4.0);
#  387|-> 	bdz_ph->g = (cmph_uint8 *)calloc((size_t)sizeg, sizeof(cmph_uint8));	
#  388|   	memset(marked_vertices, 0, (size_t)(bdz_ph->n >> 3) + 1);
#  389|   	//memset(bdz_ph->g, 0xff, sizeg);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def50]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:388:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘marked_vertices’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  386|   	cmph_uint32 sizeg = (cmph_uint32)ceil(bdz_ph->n/4.0);
#  387|   	bdz_ph->g = (cmph_uint8 *)calloc((size_t)sizeg, sizeof(cmph_uint8));	
#  388|-> 	memset(marked_vertices, 0, (size_t)(bdz_ph->n >> 3) + 1);
#  389|   	//memset(bdz_ph->g, 0xff, sizeg);
#  390|   

Error: GCC_ANALYZER_WARNING: [#def51]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c: scope_hint: In function ‘bdz_ph_optimization’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:432:44: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:432:44: note: only use operands of an integer type inside the size argument
#  430|   	cmph_uint8 byte = 0;
#  431|   	cmph_uint32 sizeg = (cmph_uint32)ceil(bdz_ph->n/5.0);
#  432|-> 	cmph_uint8 * new_g = (cmph_uint8 *)calloc((size_t)sizeg, sizeof(cmph_uint8));	
#  433|   	cmph_uint8 value;
#  434|   	cmph_uint32 idx;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def52]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:438:18: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘new_g’
#  436|   	{	
#  437|               idx = i/5;
#  438|->             byte = new_g[idx];
#  439|               value = GETVALUE(bdz_ph->g, i);
#  440|               byte = (cmph_uint8) (byte + value*pow3_table[i%5U]);

Error: CLANG_WARNING: [#def53]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:463:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  461|   	hash_state_dump(data->hl, &buf, &buflen);
#  462|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  463|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  464|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  465|   	free(buf);

Error: CLANG_WARNING: [#def54]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:464:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  462|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  463|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  464|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  465|   	free(buf);
#  466|   

Error: CLANG_WARNING: [#def55]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:467:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  465|   	free(buf);
#  466|   
#  467|-> 	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  468|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  469|   	nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);

Error: CLANG_WARNING: [#def56]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:468:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  466|   
#  467|   	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  468|-> 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  469|   	nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
#  470|   	sizeg = (cmph_uint32)ceil(data->n/5.0);	

Error: CLANG_WARNING: [#def57]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:469:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  467|   	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  468|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  469|-> 	nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
#  470|   	sizeg = (cmph_uint32)ceil(data->n/5.0);	
#  471|   	nbytes = fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);

Error: CLANG_WARNING: [#def58]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:496:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  494|   	mphf->data = bdz_ph;
#  495|   
#  496|-> 	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  497|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  498|   	buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def59]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c: scope_hint: In function ‘bdz_ph_load’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:498:23: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:498:23: note: heap-based allocation
#  496|   	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  497|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  498|-> 	buf = (char *)malloc((size_t)buflen);
#  499|   	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  500|   	bdz_ph->hl = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def60]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:499:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  497|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  498|   	buf = (char *)malloc((size_t)buflen);
#  499|-> 	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  500|   	bdz_ph->hl = hash_state_load(buf, buflen);
#  501|   	free(buf);

Error: CLANG_WARNING: [#def61]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:505:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  503|   
#  504|   	DEBUGP("Reading m and n\n");
#  505|-> 	nbytes = fread(&(bdz_ph->n), sizeof(cmph_uint32), (size_t)1, f);	
#  506|   	nbytes = fread(&(bdz_ph->m), sizeof(cmph_uint32), (size_t)1, f);	
#  507|   	nbytes = fread(&(bdz_ph->r), sizeof(cmph_uint32), (size_t)1, f);	

Error: CLANG_WARNING: [#def62]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:506:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  504|   	DEBUGP("Reading m and n\n");
#  505|   	nbytes = fread(&(bdz_ph->n), sizeof(cmph_uint32), (size_t)1, f);	
#  506|-> 	nbytes = fread(&(bdz_ph->m), sizeof(cmph_uint32), (size_t)1, f);	
#  507|   	nbytes = fread(&(bdz_ph->r), sizeof(cmph_uint32), (size_t)1, f);	
#  508|   	sizeg = (cmph_uint32)ceil(bdz_ph->n/5.0);

Error: CLANG_WARNING: [#def63]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:507:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  505|   	nbytes = fread(&(bdz_ph->n), sizeof(cmph_uint32), (size_t)1, f);	
#  506|   	nbytes = fread(&(bdz_ph->m), sizeof(cmph_uint32), (size_t)1, f);	
#  507|-> 	nbytes = fread(&(bdz_ph->r), sizeof(cmph_uint32), (size_t)1, f);	
#  508|   	sizeg = (cmph_uint32)ceil(bdz_ph->n/5.0);
#  509|   	bdz_ph->g = (cmph_uint8 *)calloc((size_t)sizeg, sizeof(cmph_uint8));

Error: GCC_ANALYZER_WARNING: [#def64]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:509:35: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:509:35: note: only use operands of an integer type inside the size argument
#  507|   	nbytes = fread(&(bdz_ph->r), sizeof(cmph_uint32), (size_t)1, f);	
#  508|   	sizeg = (cmph_uint32)ceil(bdz_ph->n/5.0);
#  509|-> 	bdz_ph->g = (cmph_uint8 *)calloc((size_t)sizeg, sizeof(cmph_uint8));
#  510|   	nbytes = fread(bdz_ph->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
#  511|   

Error: GCC_ANALYZER_WARNING (CWE-476): [#def65]
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:5: included_from: Included from here.
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:80:48: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*bdz_ph.g + (sizetype)(i >> 2)’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:439:21: note: in expansion of macro ‘GETVALUE’
gobject-introspection-1.80.1/girepository/cmph/bdz_ph.c:439:21: note: in expansion of macro ‘GETVALUE’
#   78|    * GETVALUE(array, i) is a macro that get a value for a 2-bit integer stored in an array.
#   79|    */
#   80|-> #define GETVALUE(array, i) ((cmph_uint8)((array[i >> 2] >> ((i & 0x00000003U) << 1U)) & 0x00000003U))
#   81|   
#   82|   

Error: GCC_ANALYZER_WARNING (CWE-476): [#def66]
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c:6: included_from: Included from here.
gobject-introspection-1.80.1/girepository/cmph/bitbool.h: scope_hint: In function ‘set_bits_value’
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:121:19: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘bits_table’
#  119|   	register cmph_uint32 shift2 = 32 - shift1;
#  120|   	
#  121|-> 	bits_table[word_idx] &= ~((string_mask) << shift1);
#  122|   	bits_table[word_idx] |= bits_string << shift1;
#  123|   	

Error: GCC_ANALYZER_WARNING (CWE-1335): [#def67]
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:126:59: warning[-Wanalyzer-shift-count-overflow]: shift by count (‘32’) >= precision of type (‘32’)
#  124|   	if(shift2 < string_length)
#  125|   	{
#  126|-> 		bits_table[word_idx+1] &= ~((string_mask) >> shift2);
#  127|   		bits_table[word_idx+1] |= bits_string >> shift2;
#  128|   	};

Error: GCC_ANALYZER_WARNING (CWE-1335): [#def68]
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:127:55: warning[-Wanalyzer-shift-count-overflow]: shift by count (‘32’) >= precision of type (‘32’)
#  125|   	{
#  126|   		bits_table[word_idx+1] &= ~((string_mask) >> shift2);
#  127|-> 		bits_table[word_idx+1] |= bits_string >> shift2;
#  128|   	};
#  129|   };

Error: GCC_ANALYZER_WARNING (CWE-1335): [#def69]
gobject-introspection-1.80.1/girepository/cmph/bitbool.h: scope_hint: In function ‘get_bits_value’
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:142:56: warning[-Wanalyzer-shift-count-overflow]: shift by count (‘32’) >= precision of type (‘32’)
#  140|   	
#  141|   	if(shift2 < string_length)
#  142|-> 		bits_string |= (bits_table[word_idx+1] << shift2) & string_mask;
#  143|   
#  144|   	return bits_string;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def70]
gobject-introspection-1.80.1/girepository/cmph/bitbool.h: scope_hint: In function ‘set_bits_at_pos’
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:154:19: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘bits_table’
#  152|   	register cmph_uint32 string_mask = (1U << string_length) - 1;
#  153|   	
#  154|-> 	bits_table[word_idx] &= ~((string_mask) << shift1);
#  155|   	bits_table[word_idx] |= bits_string << shift1;
#  156|   	if(shift2 < string_length)

Error: GCC_ANALYZER_WARNING (CWE-1335): [#def71]
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:158:59: warning[-Wanalyzer-shift-count-overflow]: shift by count (‘32’) >= precision of type (‘32’)
#  156|   	if(shift2 < string_length)
#  157|   	{
#  158|-> 		bits_table[word_idx+1] &= ~((string_mask) >> shift2);
#  159|   		bits_table[word_idx+1] |= bits_string >> shift2;
#  160|   	}

Error: GCC_ANALYZER_WARNING (CWE-1335): [#def72]
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:159:55: warning[-Wanalyzer-shift-count-overflow]: shift by count (‘32’) >= precision of type (‘32’)
#  157|   	{
#  158|   		bits_table[word_idx+1] &= ~((string_mask) >> shift2);
#  159|-> 		bits_table[word_idx+1] |= bits_string >> shift2;
#  160|   	}
#  161|   };

Error: GCC_ANALYZER_WARNING (CWE-1335): [#def73]
gobject-introspection-1.80.1/girepository/cmph/bitbool.h: scope_hint: In function ‘get_bits_at_pos’
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:174:56: warning[-Wanalyzer-shift-count-overflow]: shift by count (‘32’) >= precision of type (‘32’)
#  172|   
#  173|   	if(shift2 < string_length)
#  174|-> 		bits_string |= (bits_table[word_idx+1] << shift2) & string_mask;
#  175|   	return bits_string;
#  176|   }

Error: GCC_ANALYZER_WARNING (CWE-476): [#def74]
gobject-introspection-1.80.1/girepository/cmph/bmz.c: scope_hint: In function ‘bmz_new’
gobject-introspection-1.80.1/girepository/cmph/bmz.c:79:47: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*bmz.hashes + (long unsigned int)i * 8’
#   77|   
#   78|   	bmz->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*3);
#   79|-> 	for(i = 0; i < 3; ++i) bmz->hashes[i] = NULL;
#   80|   
#   81|   	do

Error: GCC_ANALYZER_WARNING (CWE-688): [#def75]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:136:11: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘visited’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  134|   	  DEBUGP("Searching step\n");
#  135|   	  visited = (cmph_uint8 *)malloc((size_t)bmz->n/8 + 1);
#  136|-> 	  memset(visited, 0, (size_t)bmz->n/8 + 1);
#  137|   	  used_edges = (cmph_uint8 *)malloc((size_t)bmz->m/8 + 1);
#  138|   	  memset(used_edges, 0, (size_t)bmz->m/8 + 1);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def76]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:138:11: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘used_edges’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  136|   	  memset(visited, 0, (size_t)bmz->n/8 + 1);
#  137|   	  used_edges = (cmph_uint8 *)malloc((size_t)bmz->m/8 + 1);
#  138|-> 	  memset(used_edges, 0, (size_t)bmz->m/8 + 1);
#  139|   	  free(bmz->g);
#  140|   	  bmz->g = (cmph_uint32 *)calloc((size_t)bmz->n, sizeof(cmph_uint32));

Error: CPPCHECK_WARNING (CWE-401): [#def77]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:321: error[memleakOnRealloc]: Common realloc mistake: 'unused_g_values' nulled but not freed upon failure
#  319|   					        if(nunused_g_values == unused_g_values_capacity)
#  320|   						{
#  321|->    						        unused_g_values = (cmph_uint32 *)realloc(unused_g_values, (unused_g_values_capacity + BUFSIZ)*sizeof(cmph_uint32));
#  322|   						        unused_g_values_capacity += BUFSIZ;  							
#  323|   						} 

Error: GCC_ANALYZER_WARNING (CWE-476): [#def78]
gobject-introspection-1.80.1/girepository/cmph/bmz.c: scope_hint: In function ‘bmz_traverse_critical_nodes_heuristic’
gobject-introspection-1.80.1/girepository/cmph/bmz.c:324:85: warning[-Wanalyzer-null-dereference]: dereference of NULL ‘unused_g_values’
gobject-introspection-1.80.1/girepository/cmph/bmz.c:7: included_from: Included from here.
gobject-introspection-1.80.1/girepository/cmph/bmz.c:310:61: note: in expansion of macro ‘GETBIT’
#  322|   						        unused_g_values_capacity += BUFSIZ;  							
#  323|   						} 
#  324|-> 						unused_g_values[nunused_g_values++] = next_g;							
#  325|   
#  326|   					}

Error: CLANG_WARNING: [#def79]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:459:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  457|   	__cmph_dump(mphf, fd);
#  458|   
#  459|-> 	nbytes = fwrite(&two, sizeof(cmph_uint32), (size_t)1, fd);
#  460|   
#  461|   	hash_state_dump(data->hashes[0], &buf, &buflen);

Error: CLANG_WARNING: [#def80]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:463:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  461|   	hash_state_dump(data->hashes[0], &buf, &buflen);
#  462|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  463|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  464|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  465|   	free(buf);

Error: CLANG_WARNING: [#def81]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:464:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  462|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  463|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  464|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  465|   	free(buf);
#  466|   

Error: CLANG_WARNING: [#def82]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:469:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  467|   	hash_state_dump(data->hashes[1], &buf, &buflen);
#  468|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  469|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  470|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  471|   	free(buf);

Error: CLANG_WARNING: [#def83]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:470:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  468|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  469|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  470|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  471|   	free(buf);
#  472|   

Error: CLANG_WARNING: [#def84]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:473:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  471|   	free(buf);
#  472|   
#  473|-> 	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  474|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  475|   	

Error: CLANG_WARNING: [#def85]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:474:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  472|   
#  473|   	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  474|-> 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  475|   	
#  476|   	nbytes = fwrite(data->g, sizeof(cmph_uint32)*(data->n), (size_t)1, fd);

Error: CLANG_WARNING: [#def86]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:499:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  497|   	DEBUGP("Loading bmz mphf\n");
#  498|   	mphf->data = bmz;
#  499|-> 	nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
#  500|   	bmz->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
#  501|   	bmz->hashes[nhashes] = NULL;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def87]
gobject-introspection-1.80.1/girepository/cmph/bmz.c: scope_hint: In function ‘bmz_load’
gobject-introspection-1.80.1/girepository/cmph/bmz.c:500:21: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘bmz’
#  498|   	mphf->data = bmz;
#  499|   	nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
#  500|-> 	bmz->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
#  501|   	bmz->hashes[nhashes] = NULL;
#  502|   	DEBUGP("Reading %u hashes\n", nhashes);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def88]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:500:40: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘(long unsigned int)(nhashes + 1) * 8’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/bmz.c:500:40: note: heap-based allocation
#  498|   	mphf->data = bmz;
#  499|   	nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
#  500|-> 	bmz->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
#  501|   	bmz->hashes[nhashes] = NULL;
#  502|   	DEBUGP("Reading %u hashes\n", nhashes);

Error: GCC_ANALYZER_WARNING (CWE-823): [#def89]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:501:30: warning[-Wanalyzer-tainted-offset]: use of attacker-controlled value ‘(long unsigned int)nhashes * 8’ as offset without upper-bounds checking
#  499|   	nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
#  500|   	bmz->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
#  501|-> 	bmz->hashes[nhashes] = NULL;
#  502|   	DEBUGP("Reading %u hashes\n", nhashes);
#  503|   	for (i = 0; i < nhashes; ++i)

Error: CLANG_WARNING: [#def90]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:506:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  504|   	{
#  505|   		hash_state_t *state = NULL;
#  506|-> 		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  507|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  508|   		buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def91]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:508:31: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/bmz.c:508:31: note: heap-based allocation
#  506|   		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  507|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  508|-> 		buf = (char *)malloc((size_t)buflen);
#  509|   		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  510|   		state = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def92]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:509:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  507|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  508|   		buf = (char *)malloc((size_t)buflen);
#  509|-> 		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  510|   		state = hash_state_load(buf, buflen);
#  511|   		bmz->hashes[i] = state;

Error: CLANG_WARNING: [#def93]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:516:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  514|   
#  515|   	DEBUGP("Reading m and n\n");
#  516|-> 	nbytes = fread(&(bmz->n), sizeof(cmph_uint32), (size_t)1, f);	
#  517|   	nbytes = fread(&(bmz->m), sizeof(cmph_uint32), (size_t)1, f);	
#  518|   

Error: GCC_ANALYZER_WARNING (CWE-401): [#def94]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:516:18: warning[-Wanalyzer-malloc-leak]: leak of ‘<unknown>’
#  514|   
#  515|   	DEBUGP("Reading m and n\n");
#  516|-> 	nbytes = fread(&(bmz->n), sizeof(cmph_uint32), (size_t)1, f);	
#  517|   	nbytes = fread(&(bmz->m), sizeof(cmph_uint32), (size_t)1, f);	
#  518|   

Error: CLANG_WARNING: [#def95]
gobject-introspection-1.80.1/girepository/cmph/bmz.c:517:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  515|   	DEBUGP("Reading m and n\n");
#  516|   	nbytes = fread(&(bmz->n), sizeof(cmph_uint32), (size_t)1, f);	
#  517|-> 	nbytes = fread(&(bmz->m), sizeof(cmph_uint32), (size_t)1, f);	
#  518|   
#  519|   	bmz->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*bmz->n);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def96]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c: scope_hint: In function ‘bmz8_new’
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:83:48: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*bmz8.hashes + (long unsigned int)i * 8’
#   81|   
#   82|   	bmz8->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*3);
#   83|-> 	for(i = 0; i < 3; ++i) bmz8->hashes[i] = NULL;
#   84|   
#   85|   	do

Error: GCC_ANALYZER_WARNING (CWE-688): [#def97]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:142:11: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘visited’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  140|   	  DEBUGP("Searching step\n");
#  141|   	  visited = (cmph_uint8 *)malloc((size_t)bmz8->n/8 + 1);
#  142|-> 	  memset(visited, 0, (size_t)bmz8->n/8 + 1);
#  143|   	  used_edges = (cmph_uint8 *)malloc((size_t)bmz8->m/8 + 1);
#  144|   	  memset(used_edges, 0, (size_t)bmz8->m/8 + 1);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def98]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:144:11: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘used_edges’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  142|   	  memset(visited, 0, (size_t)bmz8->n/8 + 1);
#  143|   	  used_edges = (cmph_uint8 *)malloc((size_t)bmz8->m/8 + 1);
#  144|-> 	  memset(used_edges, 0, (size_t)bmz8->m/8 + 1);
#  145|   	  free(bmz8->g);
#  146|   	  bmz8->g = (cmph_uint8 *)calloc((size_t)bmz8->n, sizeof(cmph_uint8));

Error: CPPCHECK_WARNING (CWE-401): [#def99]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:330: error[memleakOnRealloc]: Common realloc mistake: 'unused_g_values' nulled but not freed upon failure
#  328|   					        if(nunused_g_values == unused_g_values_capacity)
#  329|   						{
#  330|-> 							unused_g_values = (cmph_uint8*)realloc(unused_g_values, ((size_t)(unused_g_values_capacity + BUFSIZ))*sizeof(cmph_uint8));
#  331|   						        unused_g_values_capacity += (cmph_uint8)BUFSIZ;  							
#  332|   						} 

Error: GCC_ANALYZER_WARNING (CWE-476): [#def100]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c: scope_hint: In function ‘bmz8_traverse_critical_nodes_heuristic’
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:333:85: warning[-Wanalyzer-null-dereference]: dereference of NULL ‘unused_g_values’
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:7: included_from: Included from here.
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:319:61: note: in expansion of macro ‘GETBIT’
#  331|   						        unused_g_values_capacity += (cmph_uint8)BUFSIZ;  							
#  332|   						} 
#  333|-> 						unused_g_values[nunused_g_values++] = next_g;							
#  334|   
#  335|   					}

Error: CLANG_WARNING: [#def101]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:468:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  466|   	__cmph_dump(mphf, fd);
#  467|   
#  468|-> 	nbytes = fwrite(&two, sizeof(cmph_uint8), (size_t)1, fd);
#  469|   
#  470|   	hash_state_dump(data->hashes[0], &buf, &buflen);

Error: CLANG_WARNING: [#def102]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:472:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  470|   	hash_state_dump(data->hashes[0], &buf, &buflen);
#  471|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  472|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  473|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  474|   	free(buf);

Error: CLANG_WARNING: [#def103]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:473:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  471|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  472|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  473|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  474|   	free(buf);
#  475|   

Error: CLANG_WARNING: [#def104]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:478:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  476|   	hash_state_dump(data->hashes[1], &buf, &buflen);
#  477|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  478|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  479|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  480|   	free(buf);

Error: CLANG_WARNING: [#def105]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:479:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  477|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  478|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  479|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  480|   	free(buf);
#  481|   

Error: CLANG_WARNING: [#def106]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:482:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  480|   	free(buf);
#  481|   
#  482|-> 	nbytes = fwrite(&(data->n), sizeof(cmph_uint8), (size_t)1, fd);
#  483|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint8), (size_t)1, fd);
#  484|   	

Error: CLANG_WARNING: [#def107]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:483:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  481|   
#  482|   	nbytes = fwrite(&(data->n), sizeof(cmph_uint8), (size_t)1, fd);
#  483|-> 	nbytes = fwrite(&(data->m), sizeof(cmph_uint8), (size_t)1, fd);
#  484|   	
#  485|   	nbytes = fwrite(data->g, sizeof(cmph_uint8)*(data->n), (size_t)1, fd);

Error: CLANG_WARNING: [#def108]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:509:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  507|   	DEBUGP("Loading bmz8 mphf\n");
#  508|   	mphf->data = bmz8;
#  509|-> 	nbytes = fread(&nhashes, sizeof(cmph_uint8), (size_t)1, f);
#  510|   	bmz8->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(size_t)(nhashes + 1));
#  511|   	bmz8->hashes[nhashes] = NULL;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def109]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c: scope_hint: In function ‘bmz8_load’
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:510:22: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘bmz8’
#  508|   	mphf->data = bmz8;
#  509|   	nbytes = fread(&nhashes, sizeof(cmph_uint8), (size_t)1, f);
#  510|-> 	bmz8->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(size_t)(nhashes + 1));
#  511|   	bmz8->hashes[nhashes] = NULL;
#  512|   	DEBUGP("Reading %u hashes\n", nhashes);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def110]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:510:41: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘(long unsigned int)((int)nhashes + 1) * 8’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:510:41: note: heap-based allocation
#  508|   	mphf->data = bmz8;
#  509|   	nbytes = fread(&nhashes, sizeof(cmph_uint8), (size_t)1, f);
#  510|-> 	bmz8->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(size_t)(nhashes + 1));
#  511|   	bmz8->hashes[nhashes] = NULL;
#  512|   	DEBUGP("Reading %u hashes\n", nhashes);

Error: GCC_ANALYZER_WARNING (CWE-823): [#def111]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:511:31: warning[-Wanalyzer-tainted-offset]: use of attacker-controlled value ‘(long unsigned int)nhashes * 8’ as offset without upper-bounds checking
#  509|   	nbytes = fread(&nhashes, sizeof(cmph_uint8), (size_t)1, f);
#  510|   	bmz8->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(size_t)(nhashes + 1));
#  511|-> 	bmz8->hashes[nhashes] = NULL;
#  512|   	DEBUGP("Reading %u hashes\n", nhashes);
#  513|   	for (i = 0; i < nhashes; ++i)

Error: CLANG_WARNING: [#def112]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:516:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  514|   	{
#  515|   		hash_state_t *state = NULL;
#  516|-> 		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  517|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  518|   		buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def113]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:518:31: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:518:31: note: heap-based allocation
#  516|   		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  517|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  518|-> 		buf = (char *)malloc((size_t)buflen);
#  519|   		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  520|   		state = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def114]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:519:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  517|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  518|   		buf = (char *)malloc((size_t)buflen);
#  519|-> 		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  520|   		state = hash_state_load(buf, buflen);
#  521|   		bmz8->hashes[i] = state;

Error: CLANG_WARNING: [#def115]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:526:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  524|   
#  525|   	DEBUGP("Reading m and n\n");
#  526|-> 	nbytes = fread(&(bmz8->n), sizeof(cmph_uint8), (size_t)1, f);	
#  527|   	nbytes = fread(&(bmz8->m), sizeof(cmph_uint8), (size_t)1, f);	
#  528|   

Error: GCC_ANALYZER_WARNING (CWE-401): [#def116]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:526:18: warning[-Wanalyzer-malloc-leak]: leak of ‘<unknown>’
#  524|   
#  525|   	DEBUGP("Reading m and n\n");
#  526|-> 	nbytes = fread(&(bmz8->n), sizeof(cmph_uint8), (size_t)1, f);	
#  527|   	nbytes = fread(&(bmz8->m), sizeof(cmph_uint8), (size_t)1, f);	
#  528|   

Error: CLANG_WARNING: [#def117]
gobject-introspection-1.80.1/girepository/cmph/bmz8.c:527:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  525|   	DEBUGP("Reading m and n\n");
#  526|   	nbytes = fread(&(bmz8->n), sizeof(cmph_uint8), (size_t)1, f);	
#  527|-> 	nbytes = fread(&(bmz8->m), sizeof(cmph_uint8), (size_t)1, f);	
#  528|   
#  529|   	bmz8->g = (cmph_uint8 *)malloc(sizeof(cmph_uint8)*bmz8->n);

Error: GCC_ANALYZER_WARNING: [#def118]
gobject-introspection-1.80.1/girepository/cmph/brz.c: scope_hint: In function ‘brz_new’
gobject-introspection-1.80.1/girepository/cmph/brz.c:155:38: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/brz.c:155:38: note: only use operands of an integer type inside the size argument
#  153|           brz->k = (cmph_uint32)ceil(brz->m/((double)brz->b));
#  154|   	DEBUGP("k: %u\n", brz->k);
#  155|-> 	brz->size   = (cmph_uint8 *) calloc((size_t)brz->k, sizeof(cmph_uint8));
#  156|   	
#  157|   	// Clustering the keys by graph id.

Error: GCC_ANALYZER_WARNING (CWE-476): [#def119]
gobject-introspection-1.80.1/girepository/cmph/brz.c: scope_hint: In function ‘brz_gen_mphf’
gobject-introspection-1.80.1/girepository/cmph/brz.c:265:31: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buckets_size’
#  263|   				fprintf(stderr, "Flushing  %u\n", nkeys_in_buffer);
#  264|   			}
#  265|-> 			value = buckets_size[0];
#  266|   			sum = 0;
#  267|   			keylen1 = 0;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def120]
gobject-introspection-1.80.1/girepository/cmph/brz.c:288:25: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘filename’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_sprintf’ must be non-null
#  286|   			}
#  287|   			filename = (char *)calloc(strlen((char *)(brz->tmp_dir)) + 11, sizeof(char));
#  288|-> 			sprintf(filename, "%s%u.cmph",brz->tmp_dir, nflushes);
#  289|   			tmp_fd = fopen(filename, "wb");
#  290|   			free(filename);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def121]
gobject-introspection-1.80.1/girepository/cmph/brz.c:294:69: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘keys_index’
#  292|   			for(i = 0; i < nkeys_in_buffer; i++)
#  293|   			{
#  294|-> 				memcpy(&keylen1, buffer + keys_index[i], sizeof(keylen1));
#  295|   				nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
#  296|   			}

Error: CLANG_WARNING: [#def122]
gobject-introspection-1.80.1/girepository/cmph/brz.c:295:5: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  293|   			{
#  294|   				memcpy(&keylen1, buffer + keys_index[i], sizeof(keylen1));
#  295|-> 				nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
#  296|   			}
#  297|   			nkeys_in_buffer = 0;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def123]
gobject-introspection-1.80.1/girepository/cmph/brz.c:295:42: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘fopen(filename, "wb")’ where non-null expected
gobject-introspection-1.80.1/girepository/cmph/cmph.h:5: included_from: Included from here.
gobject-introspection-1.80.1/girepository/cmph/fch.h:4: included_from: Included from here.
gobject-introspection-1.80.1/girepository/cmph/brz.c:2: included_from: Included from here.
/usr/include/stdio.h:745:15: note: argument 4 of ‘fwrite’ must be non-null
#  293|   			{
#  294|   				memcpy(&keylen1, buffer + keys_index[i], sizeof(keylen1));
#  295|-> 				nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
#  296|   			}
#  297|   			nkeys_in_buffer = 0;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def124]
gobject-introspection-1.80.1/girepository/cmph/brz.c:302:25: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘fopen(filename, "wb")’ where non-null expected
/usr/include/stdio.h:184:12: note: argument 1 of ‘fclose’ must be non-null
#  300|   			nflushes++;
#  301|   			free(keys_index);
#  302|-> 			fclose(tmp_fd);
#  303|   		}
#  304|   		memcpy(buffer + memory_usage, &keylen, sizeof(keylen));

Error: GCC_ANALYZER_WARNING (CWE-476): [#def125]
gobject-introspection-1.80.1/girepository/cmph/brz.c:304:17: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buffer’
#  302|   			fclose(tmp_fd);
#  303|   		}
#  304|-> 		memcpy(buffer + memory_usage, &keylen, sizeof(keylen));
#  305|   		memcpy(buffer + memory_usage + sizeof(keylen), key, (size_t)keylen);
#  306|   		memory_usage += keylen + (cmph_uint32)sizeof(keylen);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def126]
gobject-introspection-1.80.1/girepository/cmph/brz.c:328:23: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buckets_size’
#  326|   			fprintf(stderr, "Flushing  %u\n", nkeys_in_buffer);
#  327|   		}
#  328|-> 		value = buckets_size[0];
#  329|   		sum = 0;
#  330|   		keylen1 = 0;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def127]
gobject-introspection-1.80.1/girepository/cmph/brz.c:350:17: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘filename’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_sprintf’ must be non-null
#  348|   		}
#  349|   		filename = (char *)calloc(strlen((char *)(brz->tmp_dir)) + 11, sizeof(char));
#  350|-> 		sprintf(filename, "%s%u.cmph",brz->tmp_dir, nflushes);
#  351|   		tmp_fd = fopen(filename, "wb");
#  352|   		free(filename);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def128]
gobject-introspection-1.80.1/girepository/cmph/brz.c:356:61: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘keys_index’
#  354|   		for(i = 0; i < nkeys_in_buffer; i++)
#  355|   		{
#  356|-> 			memcpy(&keylen1, buffer + keys_index[i], sizeof(keylen1));
#  357|   			nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
#  358|   		}

Error: CLANG_WARNING: [#def129]
gobject-introspection-1.80.1/girepository/cmph/brz.c:357:4: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  355|   		{
#  356|   			memcpy(&keylen1, buffer + keys_index[i], sizeof(keylen1));
#  357|-> 			nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
#  358|   		}
#  359|   		nkeys_in_buffer = 0;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def130]
gobject-introspection-1.80.1/girepository/cmph/brz.c:357:34: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘fopen(filename, "wb")’ where non-null expected
/usr/include/stdio.h:745:15: note: argument 4 of ‘fwrite’ must be non-null
#  355|   		{
#  356|   			memcpy(&keylen1, buffer + keys_index[i], sizeof(keylen1));
#  357|-> 			nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
#  358|   		}
#  359|   		nkeys_in_buffer = 0;

Error: CLANG_WARNING: [#def131]
gobject-introspection-1.80.1/girepository/cmph/brz.c:359:3: warning[deadcode.DeadStores]: Value stored to 'nkeys_in_buffer' is never read
#  357|   			nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
#  358|   		}
#  359|-> 		nkeys_in_buffer = 0;
#  360|   		memory_usage = 0;
#  361|   		memset((void *)buckets_size, 0, brz->k*sizeof(cmph_uint32));

Error: CLANG_WARNING: [#def132]
gobject-introspection-1.80.1/girepository/cmph/brz.c:360:3: warning[deadcode.DeadStores]: Value stored to 'memory_usage' is never read
#  358|   		}
#  359|   		nkeys_in_buffer = 0;
#  360|-> 		memory_usage = 0;
#  361|   		memset((void *)buckets_size, 0, brz->k*sizeof(cmph_uint32));
#  362|   		nflushes++;

Error: CLANG_WARNING: [#def133]
gobject-introspection-1.80.1/girepository/cmph/brz.c:376:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  374|   	}
#  375|   	/* Starting to dump to disk the resultant MPHF: __cmph_dump function */
#  376|-> 	nbytes = fwrite(cmph_names[CMPH_BRZ], (size_t)(strlen(cmph_names[CMPH_BRZ]) + 1), (size_t)1, brz->mphf_fd);
#  377|   	nbytes = fwrite(&(brz->m), sizeof(brz->m), (size_t)1, brz->mphf_fd);
#  378|   	nbytes = fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);

Error: CLANG_WARNING: [#def134]
gobject-introspection-1.80.1/girepository/cmph/brz.c:377:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  375|   	/* Starting to dump to disk the resultant MPHF: __cmph_dump function */
#  376|   	nbytes = fwrite(cmph_names[CMPH_BRZ], (size_t)(strlen(cmph_names[CMPH_BRZ]) + 1), (size_t)1, brz->mphf_fd);
#  377|-> 	nbytes = fwrite(&(brz->m), sizeof(brz->m), (size_t)1, brz->mphf_fd);
#  378|   	nbytes = fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);
#  379|   	nbytes = fwrite(&(brz->algo), sizeof(brz->algo), (size_t)1, brz->mphf_fd);

Error: CLANG_WARNING: [#def135]
gobject-introspection-1.80.1/girepository/cmph/brz.c:378:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  376|   	nbytes = fwrite(cmph_names[CMPH_BRZ], (size_t)(strlen(cmph_names[CMPH_BRZ]) + 1), (size_t)1, brz->mphf_fd);
#  377|   	nbytes = fwrite(&(brz->m), sizeof(brz->m), (size_t)1, brz->mphf_fd);
#  378|-> 	nbytes = fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);
#  379|   	nbytes = fwrite(&(brz->algo), sizeof(brz->algo), (size_t)1, brz->mphf_fd);
#  380|   	nbytes = fwrite(&(brz->k), sizeof(cmph_uint32), (size_t)1, brz->mphf_fd); // number of MPHFs

Error: CLANG_WARNING: [#def136]
gobject-introspection-1.80.1/girepository/cmph/brz.c:379:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  377|   	nbytes = fwrite(&(brz->m), sizeof(brz->m), (size_t)1, brz->mphf_fd);
#  378|   	nbytes = fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);
#  379|-> 	nbytes = fwrite(&(brz->algo), sizeof(brz->algo), (size_t)1, brz->mphf_fd);
#  380|   	nbytes = fwrite(&(brz->k), sizeof(cmph_uint32), (size_t)1, brz->mphf_fd); // number of MPHFs
#  381|   	nbytes = fwrite(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, brz->mphf_fd);

Error: CLANG_WARNING: [#def137]
gobject-introspection-1.80.1/girepository/cmph/brz.c:380:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  378|   	nbytes = fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);
#  379|   	nbytes = fwrite(&(brz->algo), sizeof(brz->algo), (size_t)1, brz->mphf_fd);
#  380|-> 	nbytes = fwrite(&(brz->k), sizeof(cmph_uint32), (size_t)1, brz->mphf_fd); // number of MPHFs
#  381|   	nbytes = fwrite(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, brz->mphf_fd);
#  382|     if (nbytes == 0 && ferror(brz->mphf_fd)) {

Error: CLANG_WARNING: [#def138]
gobject-introspection-1.80.1/girepository/cmph/brz.c:392:2: warning[deadcode.DeadStores]: Value stored to 'memory_usage' is never read
#  390|   	buffer_h0    = (cmph_uint32 *)calloc((size_t)nflushes, sizeof(cmph_uint32));
#  391|   	
#  392|-> 	memory_usage = 0;
#  393|   	for(i = 0; i < nflushes; i++)
#  394|   	{

Error: CLANG_WARNING: [#def139]
gobject-introspection-1.80.1/girepository/cmph/brz.c:413:16: warning[unix.Malloc]: Use of memory allocated with size zero
#  411|   	{
#  412|   		i = brz_min_index(buffer_h0, nflushes);
#  413|-> 		cur_bucket = buffer_h0[i];
#  414|   		key = (char *)buffer_manager_read_key(buff_manager, i, &keylen);
#  415|   		if(key)

Error: GCC_ANALYZER_WARNING (CWE-476): [#def140]
gobject-introspection-1.80.1/girepository/cmph/brz.c:413:28: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buffer_h0’
#  411|   	{
#  412|   		i = brz_min_index(buffer_h0, nflushes);
#  413|-> 		cur_bucket = buffer_h0[i];
#  414|   		key = (char *)buffer_manager_read_key(buff_manager, i, &keylen);
#  415|   		if(key)

Error: GCC_ANALYZER_WARNING (CWE-476): [#def141]
gobject-introspection-1.80.1/girepository/cmph/brz.c:422:53: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘keys_vd’
#  420|   				h0 = hash(brz->h0, key+sizeof(keylen), keylen) % brz->k;
#  421|   				if (h0 != buffer_h0[i]) break;
#  422|-> 				keys_vd[nkeys_vd++] = (cmph_uint8 *)key;
#  423|   				key = NULL; //transfer memory ownership
#  424|   				e++;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def142]
gobject-introspection-1.80.1/girepository/cmph/brz.c:430:53: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘keys_vd’
gobject-introspection-1.80.1/girepository/cmph/brz.c:16: included_from: Included from here.
#  428|   			{
#  429|   				assert(nkeys_vd < brz->size[cur_bucket]);
#  430|-> 				keys_vd[nkeys_vd++] = buffer_merge[i];
#  431|   				buffer_merge[i] = NULL; //transfer memory ownership
#  432|   				e++;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def143]
gobject-introspection-1.80.1/girepository/cmph/brz.c:430:67: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buffer_merge’
#  428|   			{
#  429|   				assert(nkeys_vd < brz->size[cur_bucket]);
#  430|-> 				keys_vd[nkeys_vd++] = buffer_merge[i];
#  431|   				buffer_merge[i] = NULL; //transfer memory ownership
#  432|   				e++;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def144]
gobject-introspection-1.80.1/girepository/cmph/brz.c:440:45: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘keys_vd’
#  438|   		{
#  439|   			assert(nkeys_vd < brz->size[cur_bucket]);
#  440|-> 			keys_vd[nkeys_vd++] = buffer_merge[i];
#  441|   			buffer_merge[i] = NULL; //transfer memory ownership
#  442|   			e++;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def145]
gobject-introspection-1.80.1/girepository/cmph/brz.c:440:59: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buffer_merge’
#  438|   		{
#  439|   			assert(nkeys_vd < brz->size[cur_bucket]);
#  440|-> 			keys_vd[nkeys_vd++] = buffer_merge[i];
#  441|   			buffer_merge[i] = NULL; //transfer memory ownership
#  442|   			e++;

Error: CLANG_WARNING: [#def146]
gobject-introspection-1.80.1/girepository/cmph/brz.c:494:11: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  492|   				default: assert(0);
#  493|   			}
#  494|-> 		        nbytes = fwrite(bufmphf, (size_t)buflenmphf, (size_t)1, brz->mphf_fd);
#  495|   			free(bufmphf);
#  496|   			bufmphf = NULL;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def147]
gobject-introspection-1.80.1/girepository/cmph/brz.c: scope_hint: In function ‘brz_copy_partial_fch_mphf’
gobject-introspection-1.80.1/girepository/cmph/brz.c:541:9: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buf’
#  539|   	*buflen = buflenh1 + buflenh2 + n + 2U * (cmph_uint32)sizeof(cmph_uint32);
#  540|   	buf = (char *)malloc((size_t)(*buflen));
#  541|-> 	memcpy(buf, &buflenh1, sizeof(cmph_uint32));
#  542|   	memcpy(buf+sizeof(cmph_uint32), bufh1, (size_t)buflenh1);
#  543|   	memcpy(buf+sizeof(cmph_uint32)+buflenh1, &buflenh2, sizeof(cmph_uint32));

Error: GCC_ANALYZER_WARNING (CWE-476): [#def148]
gobject-introspection-1.80.1/girepository/cmph/brz.c: scope_hint: In function ‘brz_copy_partial_bmz8_mphf’
gobject-introspection-1.80.1/girepository/cmph/brz.c:562:9: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buf’
#  560|   	*buflen = buflenh1 + buflenh2 + n + 2U * (cmph_uint32)sizeof(cmph_uint32);
#  561|   	buf = (char *)malloc((size_t)(*buflen));
#  562|-> 	memcpy(buf, &buflenh1, sizeof(cmph_uint32));
#  563|   	memcpy(buf+sizeof(cmph_uint32), bufh1, (size_t)buflenh1);
#  564|   	memcpy(buf+sizeof(cmph_uint32)+buflenh1, &buflenh2, sizeof(cmph_uint32));

Error: CLANG_WARNING: [#def149]
gobject-introspection-1.80.1/girepository/cmph/brz.c:584:9: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  582|           hash_state_dump(data->h0, &buf, &buflen);
#  583|           DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  584|->         nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  585|           nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  586|           free(buf);

Error: CLANG_WARNING: [#def150]
gobject-introspection-1.80.1/girepository/cmph/brz.c:585:9: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  583|           DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  584|           nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  585|->         nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  586|           free(buf);
#  587|   	// Dumping m and the vector offset.

Error: CLANG_WARNING: [#def151]
gobject-introspection-1.80.1/girepository/cmph/brz.c:588:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  586|           free(buf);
#  587|   	// Dumping m and the vector offset.
#  588|-> 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);	
#  589|   	nbytes = fwrite(data->offset, sizeof(cmph_uint32)*(data->k), (size_t)1, fd);
#  590|   	if (nbytes == 0 && ferror(fd)) {

Error: CLANG_WARNING: [#def152]
gobject-introspection-1.80.1/girepository/cmph/brz.c:607:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  605|   	DEBUGP("Loading brz mphf\n");
#  606|   	mphf->data = brz;
#  607|-> 	nbytes = fread(&(brz->c), sizeof(double), (size_t)1, f);
#  608|   	nbytes = fread(&(brz->algo), sizeof(brz->algo), (size_t)1, f); // Reading algo.
#  609|   	nbytes = fread(&(brz->k), sizeof(cmph_uint32), (size_t)1, f);

Error: CLANG_WARNING: [#def153]
gobject-introspection-1.80.1/girepository/cmph/brz.c:608:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  606|   	mphf->data = brz;
#  607|   	nbytes = fread(&(brz->c), sizeof(double), (size_t)1, f);
#  608|-> 	nbytes = fread(&(brz->algo), sizeof(brz->algo), (size_t)1, f); // Reading algo.
#  609|   	nbytes = fread(&(brz->k), sizeof(cmph_uint32), (size_t)1, f);
#  610|   	brz->size   = (cmph_uint8 *) malloc(sizeof(cmph_uint8)*brz->k);

Error: CLANG_WARNING: [#def154]
gobject-introspection-1.80.1/girepository/cmph/brz.c:609:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  607|   	nbytes = fread(&(brz->c), sizeof(double), (size_t)1, f);
#  608|   	nbytes = fread(&(brz->algo), sizeof(brz->algo), (size_t)1, f); // Reading algo.
#  609|-> 	nbytes = fread(&(brz->k), sizeof(cmph_uint32), (size_t)1, f);
#  610|   	brz->size   = (cmph_uint8 *) malloc(sizeof(cmph_uint8)*brz->k);
#  611|   	nbytes = fread(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, f);	

Error: GCC_ANALYZER_WARNING (CWE-476): [#def155]
gobject-introspection-1.80.1/girepository/cmph/brz.c: scope_hint: In function ‘brz_load’
gobject-introspection-1.80.1/girepository/cmph/brz.c:610:67: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘brz’
#  608|   	nbytes = fread(&(brz->algo), sizeof(brz->algo), (size_t)1, f); // Reading algo.
#  609|   	nbytes = fread(&(brz->k), sizeof(cmph_uint32), (size_t)1, f);
#  610|-> 	brz->size   = (cmph_uint8 *) malloc(sizeof(cmph_uint8)*brz->k);
#  611|   	nbytes = fread(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, f);	
#  612|   	brz->h1 = (hash_state_t **)malloc(sizeof(hash_state_t *)*brz->k);

Error: CLANG_WARNING: [#def156]
gobject-introspection-1.80.1/girepository/cmph/brz.c:611:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  609|   	nbytes = fread(&(brz->k), sizeof(cmph_uint32), (size_t)1, f);
#  610|   	brz->size   = (cmph_uint8 *) malloc(sizeof(cmph_uint8)*brz->k);
#  611|-> 	nbytes = fread(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, f);	
#  612|   	brz->h1 = (hash_state_t **)malloc(sizeof(hash_state_t *)*brz->k);
#  613|   	brz->h2 = (hash_state_t **)malloc(sizeof(hash_state_t *)*brz->k);

Error: CLANG_WARNING: [#def157]
gobject-introspection-1.80.1/girepository/cmph/brz.c:620:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  618|   	{
#  619|   		// h1
#  620|-> 		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  621|   		DEBUGP("Hash state 1 has %u bytes\n", buflen);
#  622|   		buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def158]
gobject-introspection-1.80.1/girepository/cmph/brz.c:622:31: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/brz.c:622:31: note: heap-based allocation
#  620|   		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  621|   		DEBUGP("Hash state 1 has %u bytes\n", buflen);
#  622|-> 		buf = (char *)malloc((size_t)buflen);
#  623|   		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  624|   		brz->h1[i] = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def159]
gobject-introspection-1.80.1/girepository/cmph/brz.c:623:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  621|   		DEBUGP("Hash state 1 has %u bytes\n", buflen);
#  622|   		buf = (char *)malloc((size_t)buflen);
#  623|-> 		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  624|   		brz->h1[i] = hash_state_load(buf, buflen);
#  625|   		free(buf);

Error: CLANG_WARNING: [#def160]
gobject-introspection-1.80.1/girepository/cmph/brz.c:627:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  625|   		free(buf);
#  626|   		//h2
#  627|-> 		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  628|   		DEBUGP("Hash state 2 has %u bytes\n", buflen);
#  629|   		buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def161]
gobject-introspection-1.80.1/girepository/cmph/brz.c:629:31: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/brz.c:629:31: note: heap-based allocation
#  627|   		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  628|   		DEBUGP("Hash state 2 has %u bytes\n", buflen);
#  629|-> 		buf = (char *)malloc((size_t)buflen);
#  630|   		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  631|   		brz->h2[i] = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def162]
gobject-introspection-1.80.1/girepository/cmph/brz.c:630:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  628|   		DEBUGP("Hash state 2 has %u bytes\n", buflen);
#  629|   		buf = (char *)malloc((size_t)buflen);
#  630|-> 		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  631|   		brz->h2[i] = hash_state_load(buf, buflen);
#  632|   		free(buf);

Error: GCC_ANALYZER_WARNING: [#def163]
gobject-introspection-1.80.1/girepository/cmph/brz.c:644:43: warning[-Wanalyzer-imprecise-fp-arithmetic]: use of floating-point arithmetic here might yield unexpected results
gobject-introspection-1.80.1/girepository/cmph/brz.c:644:43: note: only use operands of an integer type inside the size argument
#  642|   		}
#  643|   		DEBUGP("g_i has %u bytes\n", n);
#  644|-> 		brz->g[i] = (cmph_uint8 *)calloc((size_t)n, sizeof(cmph_uint8));
#  645|   		nbytes = fread(brz->g[i], sizeof(cmph_uint8)*n, (size_t)1, f);
#  646|   	}

Error: CLANG_WARNING: [#def164]
gobject-introspection-1.80.1/girepository/cmph/brz.c:645:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  643|   		DEBUGP("g_i has %u bytes\n", n);
#  644|   		brz->g[i] = (cmph_uint8 *)calloc((size_t)n, sizeof(cmph_uint8));
#  645|-> 		nbytes = fread(brz->g[i], sizeof(cmph_uint8)*n, (size_t)1, f);
#  646|   	}
#  647|   	//loading h0

Error: GCC_ANALYZER_WARNING (CWE-401): [#def165]
gobject-introspection-1.80.1/girepository/cmph/brz.c:645:35: warning[-Wanalyzer-malloc-leak]: leak of ‘calloc((long unsigned int)n, 1)’
#  643|   		DEBUGP("g_i has %u bytes\n", n);
#  644|   		brz->g[i] = (cmph_uint8 *)calloc((size_t)n, sizeof(cmph_uint8));
#  645|-> 		nbytes = fread(brz->g[i], sizeof(cmph_uint8)*n, (size_t)1, f);
#  646|   	}
#  647|   	//loading h0

Error: CLANG_WARNING: [#def166]
gobject-introspection-1.80.1/girepository/cmph/brz.c:648:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  646|   	}
#  647|   	//loading h0
#  648|-> 	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  649|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  650|   	buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def167]
gobject-introspection-1.80.1/girepository/cmph/brz.c:650:23: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/brz.c:650:23: note: heap-based allocation
#  648|   	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  649|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  650|-> 	buf = (char *)malloc((size_t)buflen);
#  651|   	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  652|   	brz->h0 = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def168]
gobject-introspection-1.80.1/girepository/cmph/brz.c:651:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  649|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  650|   	buf = (char *)malloc((size_t)buflen);
#  651|-> 	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  652|   	brz->h0 = hash_state_load(buf, buflen);
#  653|   	free(buf);

Error: CLANG_WARNING: [#def169]
gobject-introspection-1.80.1/girepository/cmph/brz.c:656:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  654|   
#  655|   	//loading c, m, and the vector offset.	
#  656|-> 	nbytes = fread(&(brz->m), sizeof(cmph_uint32), (size_t)1, f);
#  657|   	brz->offset = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*brz->k);
#  658|   	nbytes = fread(brz->offset, sizeof(cmph_uint32)*(brz->k), (size_t)1, f);

Error: CLANG_WARNING: [#def170]
gobject-introspection-1.80.1/girepository/cmph/brz.c:704:2: warning[deadcode.DeadStores]: Value stored to 'mphf_bucket' is never read
#  702|   	h1 = hash(brz->h1[h0], key, keylen) % m;
#  703|   	h2 = hash(brz->h2[h0], key, keylen) % m;
#  704|-> 	mphf_bucket = 0;
#  705|   	h1 = mixh10h11h12(b, p1, p2, h1);
#  706|   	mphf_bucket = (cmph_uint8)((h2 + brz->g[h0][h1]) % m);

Error: CLANG_WARNING: [#def171]
gobject-introspection-1.80.1/girepository/cmph/brz.c:871:2: warning[deadcode.DeadStores]: Value stored to 'n' is never read
#  869|   	size += hash_state_packed_size(h2_type) * data->k;
#  870|   	
#  871|-> 	n = 0;
#  872|   	for(i = 0; i < data->k; i++)
#  873|   	{

Error: CLANG_WARNING: [#def172]
gobject-introspection-1.80.1/girepository/cmph/brz.c:1011:2: warning[deadcode.DeadStores]: Value stored to 'mphf_bucket' is never read
# 1009|   	h2 = hash_packed(h2_ptr, h2_type, key, keylen) % m;
# 1010|   
# 1011|-> 	mphf_bucket = 0;
# 1012|   	h1 = mixh10h11h12(b, p1, p2, h1);
# 1013|   	mphf_bucket = (cmph_uint8)((h2 + g[h1]) % m);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def173]
gobject-introspection-1.80.1/girepository/cmph/buffer_entry.c: scope_hint: In function ‘buffer_entry_read_key’
gobject-introspection-1.80.1/girepository/cmph/buffer_entry.c:72:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*buffer_entry.buff + (sizetype)*buffer_entry.pos’ where non-null expected
<built-in>: note: argument 2 of ‘__builtin_memcpy’ must be non-null
#   70|   		buffer_entry_load(buffer_entry);
#   71|   	}
#   72|-> 	memcpy(keylen + copied_bytes, buffer_entry->buff + buffer_entry->pos, (size_t)lacked_bytes);
#   73|   	buffer_entry->pos += lacked_bytes;
#   74|   	

Error: GCC_ANALYZER_WARNING (CWE-476): [#def174]
gobject-introspection-1.80.1/girepository/cmph/buffer_entry.c:78:9: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘buf’
#   76|   	copied_bytes = 0;
#   77|   	buf = (cmph_uint8 *)malloc(*keylen + sizeof(*keylen));
#   78|->         memcpy(buf, keylen, sizeof(*keylen));
#   79|   	if((buffer_entry->pos + lacked_bytes) > buffer_entry->nbytes) {
#   80|   		copied_bytes = buffer_entry->nbytes - buffer_entry->pos;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def175]
gobject-introspection-1.80.1/girepository/cmph/buffer_entry.c:87:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*buffer_entry.buff + (sizetype)*buffer_entry.pos’ where non-null expected
<built-in>: note: argument 2 of ‘__builtin_memcpy’ must be non-null
#   85|   		buffer_entry_load(buffer_entry);
#   86|   	}        
#   87|-> 	memcpy(buf+sizeof(*keylen)+copied_bytes, buffer_entry->buff + buffer_entry->pos, (size_t)lacked_bytes);
#   88|   	buffer_entry->pos += lacked_bytes;
#   89|   	return buf;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def176]
gobject-introspection-1.80.1/girepository/cmph/buffer_manager.c: scope_hint: In function ‘buffer_manager_new’
gobject-introspection-1.80.1/girepository/cmph/buffer_manager.c:28:49: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘calloc((long unsigned int)nentries, 8)’
gobject-introspection-1.80.1/girepository/cmph/buffer_manager.c:4: included_from: Included from here.
#   26|   	for(i = 0; i < buff_manager->nentries; i++)
#   27|   	{
#   28|-> 		buff_manager->buffer_entries[i] = buffer_entry_new(memory_avail_entry);
#   29|   	}	
#   30|   	return buff_manager;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def177]
gobject-introspection-1.80.1/girepository/cmph/chd.c: scope_hint: In function ‘chd_new’
gobject-introspection-1.80.1/girepository/cmph/chd.c:133:43: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘vals_table’
gobject-introspection-1.80.1/girepository/cmph/chd.c:13: included_from: Included from here.
gobject-introspection-1.80.1/girepository/cmph/chd.c:131:21: note: in expansion of macro ‘GETBIT32’
#  131|   		if(!GETBIT32(occup_table, i))
#  132|   		{
#  133|-> 			vals_table[idx++] = i;
#  134|   		}
#  135|   	}

Error: GCC_ANALYZER_WARNING (CWE-476): [#def178]
gobject-introspection-1.80.1/girepository/cmph/chd.c:146:20: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘mphf’
#  144|   
#  145|   	mphf = (cmph_t *)malloc(sizeof(cmph_t));
#  146|-> 	mphf->algo = mph->algo;
#  147|   	chdf = (chd_data_t *)malloc(sizeof(chd_data_t));
#  148|   	

Error: GCC_ANALYZER_WARNING (CWE-476): [#def179]
gobject-introspection-1.80.1/girepository/cmph/chd.c:149:25: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘chdf’
#  147|   	chdf = (chd_data_t *)malloc(sizeof(chd_data_t));
#  148|   	
#  149|-> 	chdf->packed_cr = packed_cr;
#  150|   	packed_cr = NULL; //transfer memory ownership
#  151|   

Error: CLANG_WARNING: [#def180]
gobject-introspection-1.80.1/girepository/cmph/chd.c:184:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  182|   	mphf->data = chd;
#  183|   
#  184|-> 	nbytes = fread(&chd->packed_chd_phf_size, sizeof(cmph_uint32), (size_t)1, fd);
#  185|   	DEBUGP("Loading CHD_PH perfect hash function with %u bytes to disk\n", chd->packed_chd_phf_size);
#  186|   	chd->packed_chd_phf = (cmph_uint8 *) calloc((size_t)chd->packed_chd_phf_size,(size_t)1);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def181]
gobject-introspection-1.80.1/girepository/cmph/chd.c: scope_hint: In function ‘chd_load’
gobject-introspection-1.80.1/girepository/cmph/chd.c:186:64: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘chd’
#  184|   	nbytes = fread(&chd->packed_chd_phf_size, sizeof(cmph_uint32), (size_t)1, fd);
#  185|   	DEBUGP("Loading CHD_PH perfect hash function with %u bytes to disk\n", chd->packed_chd_phf_size);
#  186|-> 	chd->packed_chd_phf = (cmph_uint8 *) calloc((size_t)chd->packed_chd_phf_size,(size_t)1);
#  187|   	nbytes = fread(chd->packed_chd_phf, chd->packed_chd_phf_size, (size_t)1, fd);
#  188|   

Error: CLANG_WARNING: [#def182]
gobject-introspection-1.80.1/girepository/cmph/chd.c:187:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  185|   	DEBUGP("Loading CHD_PH perfect hash function with %u bytes to disk\n", chd->packed_chd_phf_size);
#  186|   	chd->packed_chd_phf = (cmph_uint8 *) calloc((size_t)chd->packed_chd_phf_size,(size_t)1);
#  187|-> 	nbytes = fread(chd->packed_chd_phf, chd->packed_chd_phf_size, (size_t)1, fd);
#  188|   
#  189|   	nbytes = fread(&chd->packed_cr_size, sizeof(cmph_uint32), (size_t)1, fd);

Error: CLANG_WARNING: [#def183]
gobject-introspection-1.80.1/girepository/cmph/chd.c:189:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  187|   	nbytes = fread(chd->packed_chd_phf, chd->packed_chd_phf_size, (size_t)1, fd);
#  188|   
#  189|-> 	nbytes = fread(&chd->packed_cr_size, sizeof(cmph_uint32), (size_t)1, fd);
#  190|   	DEBUGP("Loading Compressed rank structure, which has %u bytes\n", chd->packed_cr_size);
#  191|   	chd->packed_cr = (cmph_uint8 *) calloc((size_t)chd->packed_cr_size, (size_t)1);

Error: GCC_ANALYZER_WARNING (CWE-401): [#def184]
gobject-introspection-1.80.1/girepository/cmph/chd.c:189:18: warning[-Wanalyzer-malloc-leak]: leak of ‘<unknown>’
#  187|   	nbytes = fread(chd->packed_chd_phf, chd->packed_chd_phf_size, (size_t)1, fd);
#  188|   
#  189|-> 	nbytes = fread(&chd->packed_cr_size, sizeof(cmph_uint32), (size_t)1, fd);
#  190|   	DEBUGP("Loading Compressed rank structure, which has %u bytes\n", chd->packed_cr_size);
#  191|   	chd->packed_cr = (cmph_uint8 *) calloc((size_t)chd->packed_cr_size, (size_t)1);

Error: CLANG_WARNING: [#def185]
gobject-introspection-1.80.1/girepository/cmph/chd.c:208:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  206|   
#  207|   	DEBUGP("Dumping CHD_PH perfect hash function with %u bytes to disk\n", data->packed_chd_phf_size);
#  208|-> 	nbytes = fwrite(&data->packed_chd_phf_size, sizeof(cmph_uint32), (size_t)1, fd);
#  209|   	nbytes = fwrite(data->packed_chd_phf, data->packed_chd_phf_size, (size_t)1, fd);
#  210|   

Error: CLANG_WARNING: [#def186]
gobject-introspection-1.80.1/girepository/cmph/chd.c:209:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  207|   	DEBUGP("Dumping CHD_PH perfect hash function with %u bytes to disk\n", data->packed_chd_phf_size);
#  208|   	nbytes = fwrite(&data->packed_chd_phf_size, sizeof(cmph_uint32), (size_t)1, fd);
#  209|-> 	nbytes = fwrite(data->packed_chd_phf, data->packed_chd_phf_size, (size_t)1, fd);
#  210|   
#  211|   	DEBUGP("Dumping compressed rank structure with %u bytes to disk\n", data->packed_cr_size);

Error: CLANG_WARNING: [#def187]
gobject-introspection-1.80.1/girepository/cmph/chd.c:212:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  210|   
#  211|   	DEBUGP("Dumping compressed rank structure with %u bytes to disk\n", data->packed_cr_size);
#  212|-> 	nbytes = fwrite(&data->packed_cr_size, sizeof(cmph_uint32), (size_t)1, fd);
#  213|   	nbytes = fwrite(data->packed_cr, data->packed_cr_size, (size_t)1, fd);
#  214|   	if (nbytes == 0 && ferror(fd)) {

Error: GCC_ANALYZER_WARNING (CWE-476): [#def188]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:87:67: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘tmp_map_item’
#   85|   	register chd_ph_item_t * tmp_item;
#   86|   	register chd_ph_map_item_t * tmp_map_item = map_items + item_idx;
#   87|-> 	register chd_ph_bucket_t * bucket = buckets + tmp_map_item->bucket_num;
#   88|   	tmp_item = items + bucket->items_list;
#   89|   	

Error: GCC_ANALYZER_WARNING (CWE-457): [#def189]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c: scope_hint: In function ‘chd_ph_bucket_insert’
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:87:67: warning[-Wanalyzer-use-of-uninitialized-value]: use of uninitialized value ‘*tmp_map_item.bucket_num’
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:6: included_from: Included from here.
#   85|   	register chd_ph_item_t * tmp_item;
#   86|   	register chd_ph_map_item_t * tmp_map_item = map_items + item_idx;
#   87|-> 	register chd_ph_bucket_t * bucket = buckets + tmp_map_item->bucket_num;
#   88|   	tmp_item = items + bucket->items_list;
#   89|   	

Error: GCC_ANALYZER_WARNING (CWE-476): [#def190]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c: scope_hint: In function ‘chd_ph_mapping’
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:248:37: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘map_item’
#  246|   
#  247|   			g = hl[0] % chd_ph->nbuckets;
#  248|-> 			map_item->f = hl[1] % chd_ph->n;
#  249|   			map_item->h = hl[2] % (chd_ph->n - 1) + 1;
#  250|   			map_item->bucket_num=g;

Error: CLANG_WARNING: [#def191]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:272:4: warning[deadcode.DeadStores]: Value stored to 'map_item' is never read
#  270|   		for(i = 0; i < chd_ph->m; i++)
#  271|   		{
#  272|-> 			map_item = (map_items + i);
#  273|   			if(!chd_ph_bucket_insert(buckets, map_items, items, chd_ph->nbuckets, i))
#  274|   				break;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def192]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c: scope_hint: In function ‘chd_ph_ordering’
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:314:38: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘sorted_lists’
#  312|   		sorted_lists[bucket_size].size++;
#  313|   	};
#  314|-> 	sorted_lists[1].buckets_list = 0;
#  315|   	// Determine final position of list of buckets into the contiguous array that will store all the buckets
#  316|   	for(i = 2; i <= max_bucket_size; i++)

Error: CLANG_WARNING: [#def193]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:349:2: warning[deadcode.DeadStores]: Value stored to 'i' is never read
#  347|   	output_items = (chd_ph_item_t*)calloc(nitems, sizeof(chd_ph_item_t));
#  348|   	position = 0;
#  349|-> 	i = 0;
#  350|   	for(bucket_size = 1; bucket_size <= max_bucket_size; bucket_size++)
#  351|   	{

Error: CLANG_WARNING: [#def194]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:699:40: warning[unix.MallocSizeof]: Result of 'calloc' is converted to a pointer of type 'cmph_uint8', which is incompatible with sizeof operand type 'cmph_uint32'
#  697|   	
#  698|   	if(chd_ph->keys_per_bin == 1)
#  699|-> 		chd_ph->occup_table = (cmph_uint8 *) calloc(((chd_ph->n + 31)/32), sizeof(cmph_uint32));
#  700|   	else
#  701|   		chd_ph->occup_table = (cmph_uint8 *) calloc(chd_ph->n, sizeof(cmph_uint8));

Error: GCC_ANALYZER_WARNING (CWE-476): [#def195]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c: scope_hint: In function ‘chd_ph_new’
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:808:20: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘mphf’
#  806|   
#  807|   	mphf = (cmph_t *)malloc(sizeof(cmph_t));
#  808|-> 	mphf->algo = mph->algo;
#  809|   	chd_phf = (chd_ph_data_t *)malloc(sizeof(chd_ph_data_t));
#  810|   	

Error: GCC_ANALYZER_WARNING (CWE-476): [#def196]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:811:21: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘chd_phf’
#  809|   	chd_phf = (chd_ph_data_t *)malloc(sizeof(chd_ph_data_t));
#  810|   	
#  811|-> 	chd_phf->cs = chd_ph->cs;
#  812|   	chd_ph->cs = NULL; //transfer memory ownership
#  813|   	chd_phf->hl = chd_ph->hl;

Error: CLANG_WARNING: [#def197]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:848:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  846|   	mphf->data = chd_ph;
#  847|   
#  848|-> 	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  849|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  850|   	buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def198]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c: scope_hint: In function ‘chd_ph_load’
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:850:23: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:850:23: note: heap-based allocation
#  848|   	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  849|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  850|-> 	buf = (char *)malloc((size_t)buflen);
#  851|   	nbytes = fread(buf, (size_t)buflen, (size_t)1, fd);
#  852|   	chd_ph->hl = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def199]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:851:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  849|   	DEBUGP("Hash state has %u bytes\n", buflen);
#  850|   	buf = (char *)malloc((size_t)buflen);
#  851|-> 	nbytes = fread(buf, (size_t)buflen, (size_t)1, fd);
#  852|   	chd_ph->hl = hash_state_load(buf, buflen);
#  853|   	free(buf);

Error: CLANG_WARNING: [#def200]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:855:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  853|   	free(buf);
#  854|   	
#  855|-> 	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  856|   	DEBUGP("Compressed sequence structure has %u bytes\n", buflen);
#  857|   	buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def201]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:857:23: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:857:23: note: heap-based allocation
#  855|   	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  856|   	DEBUGP("Compressed sequence structure has %u bytes\n", buflen);
#  857|-> 	buf = (char *)malloc((size_t)buflen);
#  858|   	nbytes = fread(buf, (size_t)buflen, (size_t)1, fd);
#  859|   	chd_ph->cs = (compressed_seq_t *) calloc(1, sizeof(compressed_seq_t)); 

Error: CLANG_WARNING: [#def202]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:858:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  856|   	DEBUGP("Compressed sequence structure has %u bytes\n", buflen);
#  857|   	buf = (char *)malloc((size_t)buflen);
#  858|-> 	nbytes = fread(buf, (size_t)buflen, (size_t)1, fd);
#  859|   	chd_ph->cs = (compressed_seq_t *) calloc(1, sizeof(compressed_seq_t)); 
#  860|   	compressed_seq_load(chd_ph->cs, buf, buflen);

Error: CLANG_WARNING: [#def203]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:865:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  863|   	// loading n and nbuckets
#  864|   	DEBUGP("Reading n and nbuckets\n");
#  865|-> 	nbytes = fread(&(chd_ph->n), sizeof(cmph_uint32), (size_t)1, fd);	
#  866|   	nbytes = fread(&(chd_ph->nbuckets), sizeof(cmph_uint32), (size_t)1, fd);	
#  867|   	if (nbytes == 0 && ferror(fd)) {

Error: CLANG_WARNING: [#def204]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:884:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  882|   	hash_state_dump(data->hl, &buf, &buflen);
#  883|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  884|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  885|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  886|   	free(buf);

Error: CLANG_WARNING: [#def205]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:885:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  883|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  884|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  885|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  886|   	free(buf);
#  887|   

Error: CLANG_WARNING: [#def206]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:890:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  888|   	compressed_seq_dump(data->cs, &buf, &buflen);
#  889|   	DEBUGP("Dumping compressed sequence structure with %u bytes to disk\n", buflen);
#  890|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  891|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  892|   	free(buf);

Error: CLANG_WARNING: [#def207]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:891:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  889|   	DEBUGP("Dumping compressed sequence structure with %u bytes to disk\n", buflen);
#  890|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  891|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  892|   	free(buf);
#  893|   

Error: CLANG_WARNING: [#def208]
gobject-introspection-1.80.1/girepository/cmph/chd_ph.c:895:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  893|   
#  894|   	// dumping n and nbuckets
#  895|-> 	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  896|   	nbytes = fwrite(&(data->nbuckets), sizeof(cmph_uint32), (size_t)1, fd);
#  897|   	if (nbytes == 0 && ferror(fd)) {

Error: GCC_ANALYZER_WARNING (CWE-476): [#def209]
gobject-introspection-1.80.1/girepository/cmph/chm.c: scope_hint: In function ‘chm_new’
gobject-introspection-1.80.1/girepository/cmph/chm.c:71:47: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*chm.hashes + (long unsigned int)i * 8’
#   69|   
#   70|   	chm->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*3);
#   71|-> 	for(i = 0; i < 3; ++i) chm->hashes[i] = NULL;
#   72|   	//Mapping step
#   73|   	if (mph->verbosity)

Error: GCC_ANALYZER_WARNING (CWE-688): [#def210]
gobject-introspection-1.80.1/girepository/cmph/chm.c:112:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘visited’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  110|   	DEBUGP("Assignment step\n");
#  111|    	visited = (cmph_uint8 *)malloc((size_t)(chm->n/8 + 1));
#  112|-> 	memset(visited, 0, (size_t)(chm->n/8 + 1));
#  113|   	free(chm->g);
#  114|   	chm->g = (cmph_uint32 *)malloc(chm->n * sizeof(cmph_uint32));

Error: GCC_ANALYZER_WARNING (CWE-476): [#def211]
gobject-introspection-1.80.1/girepository/cmph/chm.c:129:20: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘mphf’
gobject-introspection-1.80.1/girepository/cmph/chm.c:11: included_from: Included from here.
#  127|   
#  128|   	mphf = (cmph_t *)malloc(sizeof(cmph_t));
#  129|-> 	mphf->algo = mph->algo;
#  130|   	chmf = (chm_data_t *)malloc(sizeof(chm_data_t));
#  131|   	chmf->g = chm->g;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def212]
gobject-introspection-1.80.1/girepository/cmph/chm.c:131:17: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘chmf’
#  129|   	mphf->algo = mph->algo;
#  130|   	chmf = (chm_data_t *)malloc(sizeof(chm_data_t));
#  131|-> 	chmf->g = chm->g;
#  132|   	chm->g = NULL; //transfer memory ownership
#  133|   	chmf->hashes = chm->hashes;

Error: CLANG_WARNING: [#def213]
gobject-introspection-1.80.1/girepository/cmph/chm.c:212:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  210|   	__cmph_dump(mphf, fd);
#  211|   
#  212|-> 	nbytes = fwrite(&two, sizeof(cmph_uint32), (size_t)1, fd);
#  213|   	hash_state_dump(data->hashes[0], &buf, &buflen);
#  214|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);

Error: CLANG_WARNING: [#def214]
gobject-introspection-1.80.1/girepository/cmph/chm.c:215:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  213|   	hash_state_dump(data->hashes[0], &buf, &buflen);
#  214|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  215|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  216|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  217|   	free(buf);

Error: CLANG_WARNING: [#def215]
gobject-introspection-1.80.1/girepository/cmph/chm.c:216:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  214|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  215|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  216|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  217|   	free(buf);
#  218|   

Error: CLANG_WARNING: [#def216]
gobject-introspection-1.80.1/girepository/cmph/chm.c:221:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  219|   	hash_state_dump(data->hashes[1], &buf, &buflen);
#  220|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  221|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  222|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  223|   	free(buf);

Error: CLANG_WARNING: [#def217]
gobject-introspection-1.80.1/girepository/cmph/chm.c:222:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  220|   	DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  221|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  222|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  223|   	free(buf);
#  224|   

Error: CLANG_WARNING: [#def218]
gobject-introspection-1.80.1/girepository/cmph/chm.c:225:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  223|   	free(buf);
#  224|   
#  225|-> 	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  226|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  227|   	

Error: CLANG_WARNING: [#def219]
gobject-introspection-1.80.1/girepository/cmph/chm.c:226:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  224|   
#  225|   	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
#  226|-> 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  227|   	
#  228|   	nbytes = fwrite(data->g, sizeof(cmph_uint32)*data->n, (size_t)1, fd);

Error: CLANG_WARNING: [#def220]
gobject-introspection-1.80.1/girepository/cmph/chm.c:251:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  249|   	DEBUGP("Loading chm mphf\n");
#  250|   	mphf->data = chm;
#  251|-> 	nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
#  252|   	chm->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
#  253|   	chm->hashes[nhashes] = NULL;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def221]
gobject-introspection-1.80.1/girepository/cmph/chm.c: scope_hint: In function ‘chm_load’
gobject-introspection-1.80.1/girepository/cmph/chm.c:252:21: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘chm’
#  250|   	mphf->data = chm;
#  251|   	nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
#  252|-> 	chm->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
#  253|   	chm->hashes[nhashes] = NULL;
#  254|   	DEBUGP("Reading %u hashes\n", nhashes);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def222]
gobject-introspection-1.80.1/girepository/cmph/chm.c:252:40: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘(long unsigned int)(nhashes + 1) * 8’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/chm.c:252:40: note: heap-based allocation
#  250|   	mphf->data = chm;
#  251|   	nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
#  252|-> 	chm->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
#  253|   	chm->hashes[nhashes] = NULL;
#  254|   	DEBUGP("Reading %u hashes\n", nhashes);

Error: GCC_ANALYZER_WARNING (CWE-823): [#def223]
gobject-introspection-1.80.1/girepository/cmph/chm.c:253:30: warning[-Wanalyzer-tainted-offset]: use of attacker-controlled value ‘(long unsigned int)nhashes * 8’ as offset without upper-bounds checking
#  251|   	nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
#  252|   	chm->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
#  253|-> 	chm->hashes[nhashes] = NULL;
#  254|   	DEBUGP("Reading %u hashes\n", nhashes);
#  255|   	for (i = 0; i < nhashes; ++i)

Error: CLANG_WARNING: [#def224]
gobject-introspection-1.80.1/girepository/cmph/chm.c:258:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  256|   	{
#  257|   		hash_state_t *state = NULL;
#  258|-> 		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  259|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  260|   		buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def225]
gobject-introspection-1.80.1/girepository/cmph/chm.c:260:31: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/chm.c:260:31: note: heap-based allocation
#  258|   		nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  259|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  260|-> 		buf = (char *)malloc((size_t)buflen);
#  261|   		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  262|   		state = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def226]
gobject-introspection-1.80.1/girepository/cmph/chm.c:261:3: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  259|   		DEBUGP("Hash state has %u bytes\n", buflen);
#  260|   		buf = (char *)malloc((size_t)buflen);
#  261|-> 		nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  262|   		state = hash_state_load(buf, buflen);
#  263|   		chm->hashes[i] = state;

Error: CLANG_WARNING: [#def227]
gobject-introspection-1.80.1/girepository/cmph/chm.c:268:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  266|   
#  267|   	DEBUGP("Reading m and n\n");
#  268|-> 	nbytes = fread(&(chm->n), sizeof(cmph_uint32), (size_t)1, f);	
#  269|   	nbytes = fread(&(chm->m), sizeof(cmph_uint32), (size_t)1, f);	
#  270|   

Error: GCC_ANALYZER_WARNING (CWE-401): [#def228]
gobject-introspection-1.80.1/girepository/cmph/chm.c:268:18: warning[-Wanalyzer-malloc-leak]: leak of ‘<unknown>’
#  266|   
#  267|   	DEBUGP("Reading m and n\n");
#  268|-> 	nbytes = fread(&(chm->n), sizeof(cmph_uint32), (size_t)1, f);	
#  269|   	nbytes = fread(&(chm->m), sizeof(cmph_uint32), (size_t)1, f);	
#  270|   

Error: CLANG_WARNING: [#def229]
gobject-introspection-1.80.1/girepository/cmph/chm.c:269:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  267|   	DEBUGP("Reading m and n\n");
#  268|   	nbytes = fread(&(chm->n), sizeof(cmph_uint32), (size_t)1, f);	
#  269|-> 	nbytes = fread(&(chm->m), sizeof(cmph_uint32), (size_t)1, f);	
#  270|   
#  271|   	chm->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*chm->n);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def230]
gobject-introspection-1.80.1/girepository/cmph/cmph.c: scope_hint: In function ‘key_byte_vector_read’
gobject-introspection-1.80.1/girepository/cmph/cmph.c:89:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*key’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memcpy’ must be non-null
#   87|   	size = *keylen;
#   88|   	*key = (char *)malloc(size);
#   89|-> 	memcpy(*key, keys_vd[cmph_vector->position] + sizeof(*keylen), size);
#   90|   	cmph_vector->position = cmph_vector->position + 1;
#   91|   	return (int)(*keylen);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def231]
gobject-introspection-1.80.1/girepository/cmph/cmph.c: scope_hint: In function ‘key_struct_vector_read’
gobject-introspection-1.80.1/girepository/cmph/cmph.c:103:5: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*key’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memcpy’ must be non-null
#  101|       size = *keylen;
#  102|       *key = (char *)malloc(size);
#  103|->     memcpy(*key, (keys_vd + (cmph_struct_vector->position * cmph_struct_vector->struct_size) + cmph_struct_vector->key_offset), size);
#  104|       cmph_struct_vector->position = cmph_struct_vector->position + 1;
#  105|       return (int)(*keylen);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def232]
gobject-introspection-1.80.1/girepository/cmph/cmph.c: scope_hint: In function ‘key_vector_read’
gobject-introspection-1.80.1/girepository/cmph/cmph.c:116:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*key’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_strcpy’ must be non-null
#  114|   	size = *keylen;
#  115|           *key = (char *)malloc(size + 1);
#  116|->         strcpy(*key, keys_vd[cmph_vector->position]);
#  117|           cmph_vector->position = cmph_vector->position + 1;
#  118|   	return (int)(*keylen);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def233]
gobject-introspection-1.80.1/girepository/cmph/cmph_structs.c: scope_hint: In function ‘__config_new’
gobject-introspection-1.80.1/girepository/cmph/cmph_structs.c:12:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘mph’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#   10|   {
#   11|   	cmph_config_t *mph = (cmph_config_t *)malloc(sizeof(cmph_config_t));
#   12|-> 	memset(mph, 0, sizeof(cmph_config_t));
#   13|   	if (mph == NULL) return NULL;
#   14|   	mph->key_source = key_source;

Error: CLANG_WARNING: [#def234]
gobject-introspection-1.80.1/girepository/cmph/cmph_structs.c:29:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#   27|   {
#   28|   	register size_t nbytes;
#   29|-> 	nbytes = fwrite(cmph_names[mphf->algo], (size_t)(strlen(cmph_names[mphf->algo]) + 1), (size_t)1, fd);
#   30|   	nbytes = fwrite(&(mphf->size), sizeof(mphf->size), (size_t)1, fd);
#   31|           if (nbytes == 0 && ferror(fd)) {

Error: GCC_ANALYZER_WARNING (CWE-476): [#def235]
gobject-introspection-1.80.1/girepository/cmph/cmph_structs.c: scope_hint: In function ‘__cmph_load’
gobject-introspection-1.80.1/girepository/cmph/cmph_structs.c:65:20: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘mphf’
#   63|   	}
#   64|   	mphf = (cmph_t *)malloc(sizeof(cmph_t));
#   65|-> 	mphf->algo = algo;
#   66|   	nbytes = fread(&(mphf->size), sizeof(mphf->size), (size_t)1, f);
#   67|   	mphf->data = NULL;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def236]
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c: scope_hint: In function ‘compressed_rank_generate’
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c:64:35: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘select_vec’
#   62|   			j++;
#   63|   		}
#   64|-> 		select_vec[i - 1] = j;
#   65|   	};
#   66|   

Error: CLANG_WARNING: [#def237]
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c:188:2: warning[deadcode.DeadStores]: Value stored to 'pos' is never read
#  186|   	}
#  187|   	#endif
#  188|-> 	pos += vals_rems_size;
#  189|   
#  190|   	DEBUGP("Dumped compressed rank structure with size %u bytes\n", *buflen);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def238]
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c: scope_hint: In function ‘compressed_rank_load’
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c:238:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*cr.vals_rems’ where non-null expected
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:111:43: note: in definition of macro ‘BITS_TABLE_SIZE’
<built-in>: note: argument 1 of ‘__builtin_memcpy’ must be non-null
#  236|   	cr->vals_rems = (cmph_uint32 *) calloc(vals_rems_size, sizeof(cmph_uint32));
#  237|   	vals_rems_size *= 4;
#  238|-> 	memcpy(cr->vals_rems, buf + pos, vals_rems_size);
#  239|   	
#  240|   	#ifdef DEBUG	

Error: CLANG_WARNING: [#def239]
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c:246:2: warning[deadcode.DeadStores]: Value stored to 'pos' is never read
#  244|   	}
#  245|   	#endif
#  246|-> 	pos += vals_rems_size;
#  247|   	
#  248|   	DEBUGP("Loaded compressed rank structure with size %u bytes\n", buflen);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def240]
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c: scope_hint: In function ‘compressed_rank_pack’
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c:260:17: warning[-Wanalyzer-null-argument]: use of NULL ‘buf’ where non-null expected
<built-in>: note: argument 2 of ‘__builtin_memcpy’ must be non-null
#  258|   		cmph_uint32 buflen = 0;
#  259|   		compressed_rank_dump(cr, &buf, &buflen);
#  260|-> 		memcpy(cr_packed, buf, buflen);
#  261|   		free(buf);
#  262|   	}

Error: CLANG_WARNING: [#def241]
gobject-introspection-1.80.1/girepository/cmph/compressed_rank.c:284:38: warning[deadcode.DeadStores]: Although the value stored to 'ptr' is used in the enclosing expression, the value is never actually read from 'ptr'
#  282|   	register cmph_uint32 * bits_vec = sel_packed + 2; // skipping n and m
#  283|   
#  284|-> 	register cmph_uint32 * vals_rems = (ptr += (buflen_sel >> 2)); 
#  285|   
#  286|   	// compressed sequence query computation

Error: GCC_ANALYZER_WARNING (CWE-476): [#def242]
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c: scope_hint: In function ‘compressed_seq_generate’
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c:60:36: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘lengths’
#   58|   		if(vals_table[i] == 0)
#   59|   		{
#   60|-> 			lengths[i] = 0;
#   61|   		}
#   62|   		else

Error: GCC_ANALYZER_WARNING (CWE-476): [#def243]
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c:64:36: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘lengths’
#   62|   		else
#   63|   		{
#   64|-> 			lengths[i] = compressed_seq_i_log2(vals_table[i] + 1);
#   65|   			cs->total_length += lengths[i];
#   66|   		};

Error: GCC_ANALYZER_WARNING (CWE-688): [#def244]
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c: scope_hint: In function ‘compressed_seq_load’
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c:287:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*cs.length_rems’ where non-null expected
gobject-introspection-1.80.1/girepository/cmph/bitbool.h:111:43: note: in definition of macro ‘BITS_TABLE_SIZE’
<built-in>: note: argument 1 of ‘__builtin_memcpy’ must be non-null
#  285|   	cs->length_rems = (cmph_uint32 *) calloc(length_rems_size, sizeof(cmph_uint32));
#  286|   	length_rems_size *= 4;
#  287|-> 	memcpy(cs->length_rems, buf + pos, length_rems_size);
#  288|   	
#  289|   	#ifdef DEBUG

Error: GCC_ANALYZER_WARNING (CWE-688): [#def245]
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c:305:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*cs.store_table’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memcpy’ must be non-null
#  303|   	cs->store_table = (cmph_uint32 *) calloc(store_table_size, sizeof(cmph_uint32));
#  304|           store_table_size *= 4;
#  305|-> 	memcpy(cs->store_table, buf + pos, store_table_size);
#  306|   	
#  307|   	#ifdef DEBUG

Error: GCC_ANALYZER_WARNING (CWE-688): [#def246]
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c: scope_hint: In function ‘compressed_seq_pack’
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c:324:17: warning[-Wanalyzer-null-argument]: use of NULL ‘buf’ where non-null expected
<built-in>: note: argument 2 of ‘__builtin_memcpy’ must be non-null
#  322|   		cmph_uint32 buflen = 0;
#  323|   		compressed_seq_dump(cs, &buf, &buflen);
#  324|-> 		memcpy(cs_packed, buf, buflen);
#  325|   		free(buf);
#  326|   	}

Error: CLANG_WARNING: [#def247]
gobject-introspection-1.80.1/girepository/cmph/compressed_seq.c:356:17: warning[deadcode.DeadStores]: Although the value stored to 'ptr' is used in the enclosing expression, the value is never actually read from 'ptr'
#  354|   	length_rems = (ptr += (buflen_sel >> 2));
#  355|   	length_rems_size = BITS_TABLE_SIZE(n, rem_r);
#  356|-> 	store_table = (ptr += length_rems_size);
#  357|   
#  358|   

Error: GCC_ANALYZER_WARNING (CWE-688): [#def248]
gobject-introspection-1.80.1/girepository/cmph/fch.c: scope_hint: In function ‘check_for_collisions_h2’
gobject-introspection-1.80.1/girepository/cmph/fch.c:132:17: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘hashtable’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  130|   	{
#  131|   		cmph_uint32 nkeys = fch_buckets_get_size(buckets, sorted_indexes[i]);
#  132|-> 		memset(hashtable, 0, (size_t)fch->m);
#  133|   		//DEBUGP("bucket %u -- nkeys: %u\n", i, nkeys);
#  134|   		for (j = 0; j < nkeys; j++)

Error: GCC_ANALYZER_WARNING (CWE-476): [#def249]
gobject-introspection-1.80.1/girepository/cmph/fch.c: scope_hint: In function ‘searching’
gobject-introspection-1.80.1/girepository/cmph/fch.c:177:33: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘random_table’
#  175|   	for(i = 0; i < fch->m; i++)
#  176|   	{
#  177|-> 		random_table[i] = i;
#  178|   	}
#  179|   	permut(random_table, fch->m);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def250]
gobject-introspection-1.80.1/girepository/cmph/fch.c:182:39: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘random_table’
#  180|   	for(i = 0; i < fch->m; i++)
#  181|   	{
#  182|-> 		map_table[random_table[i]] = i;
#  183|   	}
#  184|   	do {   

Error: CLANG_WARNING: [#def251]
gobject-introspection-1.80.1/girepository/cmph/fch.c:212:43: warning[unix.Malloc]: Use of memory allocated with size zero
#  210|   				counter = 0; 
#  211|   				restart = 0; // false
#  212|-> 				fch->g[sorted_indexes[i]] = (fch->m + random_table[filled_count + z] - h2) % fch->m;
#  213|   				//DEBUGP("g[%u]: %u\n", sorted_indexes[i], fch->g[sorted_indexes[i]]);
#  214|   				j = INDEX;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def252]
gobject-introspection-1.80.1/girepository/cmph/fch.c:212:83: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘random_table’
#  210|   				counter = 0; 
#  211|   				restart = 0; // false
#  212|-> 				fch->g[sorted_indexes[i]] = (fch->m + random_table[filled_count + z] - h2) % fch->m;
#  213|   				//DEBUGP("g[%u]: %u\n", sorted_indexes[i], fch->g[sorted_indexes[i]]);
#  214|   				j = INDEX;

Error: CLANG_WARNING: [#def253]
gobject-introspection-1.80.1/girepository/cmph/fch.c:235:7: warning[deadcode.DeadStores]: Value stored to 'counter' is never read
#  233|   						restart = 1; // true
#  234|   						filled_count = filled_count - counter;
#  235|-> 						counter = 0; 
#  236|   						break;
#  237|   					}

Error: GCC_ANALYZER_WARNING (CWE-476): [#def254]
gobject-introspection-1.80.1/girepository/cmph/fch.c: scope_hint: In function ‘fch_new’
gobject-introspection-1.80.1/girepository/cmph/fch.c:294:20: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘mphf’
gobject-introspection-1.80.1/girepository/cmph/fch.c: scope_hint: In function ‘fch_new’
#  292|   	if (iterations == 0) return NULL;
#  293|   	mphf = (cmph_t *)malloc(sizeof(cmph_t));
#  294|-> 	mphf->algo = mph->algo;
#  295|   	fchf = (fch_data_t *)malloc(sizeof(fch_data_t));
#  296|   	fchf->g = fch->g;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def255]
gobject-introspection-1.80.1/girepository/cmph/fch.c:296:17: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘fchf’
gobject-introspection-1.80.1/girepository/cmph/fch.c: scope_hint: In function ‘fch_new’
#  294|   	mphf->algo = mph->algo;
#  295|   	fchf = (fch_data_t *)malloc(sizeof(fch_data_t));
#  296|-> 	fchf->g = fch->g;
#  297|   	fch->g = NULL; //transfer memory ownership
#  298|   	fchf->h1 = fch->h1;

Error: CLANG_WARNING: [#def256]
gobject-introspection-1.80.1/girepository/cmph/fch.c:332:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  330|   	hash_state_dump(data->h1, &buf, &buflen);
#  331|   	//DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  332|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  333|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  334|   	free(buf);

Error: CLANG_WARNING: [#def257]
gobject-introspection-1.80.1/girepository/cmph/fch.c:333:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  331|   	//DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  332|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  333|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  334|   	free(buf);
#  335|   

Error: CLANG_WARNING: [#def258]
gobject-introspection-1.80.1/girepository/cmph/fch.c:338:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  336|   	hash_state_dump(data->h2, &buf, &buflen);
#  337|   	//DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  338|-> 	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  339|   	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  340|   	free(buf);

Error: CLANG_WARNING: [#def259]
gobject-introspection-1.80.1/girepository/cmph/fch.c:339:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  337|   	//DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
#  338|   	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
#  339|-> 	nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
#  340|   	free(buf);
#  341|   

Error: CLANG_WARNING: [#def260]
gobject-introspection-1.80.1/girepository/cmph/fch.c:342:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  340|   	free(buf);
#  341|   
#  342|-> 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  343|   	nbytes = fwrite(&(data->c), sizeof(double), (size_t)1, fd);
#  344|   	nbytes = fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);

Error: CLANG_WARNING: [#def261]
gobject-introspection-1.80.1/girepository/cmph/fch.c:343:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  341|   
#  342|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  343|-> 	nbytes = fwrite(&(data->c), sizeof(double), (size_t)1, fd);
#  344|   	nbytes = fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);
#  345|   	nbytes = fwrite(&(data->p1), sizeof(double), (size_t)1, fd);

Error: CLANG_WARNING: [#def262]
gobject-introspection-1.80.1/girepository/cmph/fch.c:344:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  342|   	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
#  343|   	nbytes = fwrite(&(data->c), sizeof(double), (size_t)1, fd);
#  344|-> 	nbytes = fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);
#  345|   	nbytes = fwrite(&(data->p1), sizeof(double), (size_t)1, fd);
#  346|   	nbytes = fwrite(&(data->p2), sizeof(double), (size_t)1, fd);

Error: CLANG_WARNING: [#def263]
gobject-introspection-1.80.1/girepository/cmph/fch.c:345:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  343|   	nbytes = fwrite(&(data->c), sizeof(double), (size_t)1, fd);
#  344|   	nbytes = fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);
#  345|-> 	nbytes = fwrite(&(data->p1), sizeof(double), (size_t)1, fd);
#  346|   	nbytes = fwrite(&(data->p2), sizeof(double), (size_t)1, fd);
#  347|   	nbytes = fwrite(data->g, sizeof(cmph_uint32)*(data->b), (size_t)1, fd);

Error: CLANG_WARNING: [#def264]
gobject-introspection-1.80.1/girepository/cmph/fch.c:346:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  344|   	nbytes = fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);
#  345|   	nbytes = fwrite(&(data->p1), sizeof(double), (size_t)1, fd);
#  346|-> 	nbytes = fwrite(&(data->p2), sizeof(double), (size_t)1, fd);
#  347|   	nbytes = fwrite(data->g, sizeof(cmph_uint32)*(data->b), (size_t)1, fd);
#  348|   	if (nbytes == 0 && ferror(fd)) {

Error: GCC_ANALYZER_WARNING (CWE-476): [#def265]
gobject-introspection-1.80.1/girepository/cmph/fch.c: scope_hint: In function ‘fch_load’
gobject-introspection-1.80.1/girepository/cmph/fch.c:373:17: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘fch’
#  371|   	mphf->data = fch;
#  372|   	//DEBUGP("Reading h1\n");
#  373|-> 	fch->h1 = NULL;
#  374|   	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  375|   	//DEBUGP("Hash state of h1 has %u bytes\n", buflen);

Error: CLANG_WARNING: [#def266]
gobject-introspection-1.80.1/girepository/cmph/fch.c:374:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  372|   	//DEBUGP("Reading h1\n");
#  373|   	fch->h1 = NULL;
#  374|-> 	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  375|   	//DEBUGP("Hash state of h1 has %u bytes\n", buflen);
#  376|   	buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def267]
gobject-introspection-1.80.1/girepository/cmph/fch.c:376:23: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/fch.c:376:23: note: heap-based allocation
#  374|   	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  375|   	//DEBUGP("Hash state of h1 has %u bytes\n", buflen);
#  376|-> 	buf = (char *)malloc((size_t)buflen);
#  377|   	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  378|   	fch->h1 = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def268]
gobject-introspection-1.80.1/girepository/cmph/fch.c:377:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  375|   	//DEBUGP("Hash state of h1 has %u bytes\n", buflen);
#  376|   	buf = (char *)malloc((size_t)buflen);
#  377|-> 	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  378|   	fch->h1 = hash_state_load(buf, buflen);
#  379|   	free(buf);

Error: CLANG_WARNING: [#def269]
gobject-introspection-1.80.1/girepository/cmph/fch.c:385:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  383|   	//DEBUGP("Reading h2\n");
#  384|   	fch->h2 = NULL;
#  385|-> 	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  386|   	//DEBUGP("Hash state of h2 has %u bytes\n", buflen);
#  387|   	buf = (char *)malloc((size_t)buflen);

Error: GCC_ANALYZER_WARNING (CWE-789): [#def270]
gobject-introspection-1.80.1/girepository/cmph/fch.c:387:23: warning[-Wanalyzer-tainted-allocation-size]: use of attacker-controlled value ‘buflen’ as allocation size without upper-bounds checking
gobject-introspection-1.80.1/girepository/cmph/fch.c:387:23: note: heap-based allocation
#  385|   	nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
#  386|   	//DEBUGP("Hash state of h2 has %u bytes\n", buflen);
#  387|-> 	buf = (char *)malloc((size_t)buflen);
#  388|   	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  389|   	fch->h2 = hash_state_load(buf, buflen);

Error: CLANG_WARNING: [#def271]
gobject-introspection-1.80.1/girepository/cmph/fch.c:388:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  386|   	//DEBUGP("Hash state of h2 has %u bytes\n", buflen);
#  387|   	buf = (char *)malloc((size_t)buflen);
#  388|-> 	nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
#  389|   	fch->h2 = hash_state_load(buf, buflen);
#  390|   	free(buf);

Error: CLANG_WARNING: [#def272]
gobject-introspection-1.80.1/girepository/cmph/fch.c:394:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  392|   	
#  393|   	//DEBUGP("Reading m and n\n");
#  394|-> 	nbytes = fread(&(fch->m), sizeof(cmph_uint32), (size_t)1, f);
#  395|   	nbytes = fread(&(fch->c), sizeof(double), (size_t)1, f);
#  396|   	nbytes = fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);

Error: CLANG_WARNING: [#def273]
gobject-introspection-1.80.1/girepository/cmph/fch.c:395:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  393|   	//DEBUGP("Reading m and n\n");
#  394|   	nbytes = fread(&(fch->m), sizeof(cmph_uint32), (size_t)1, f);
#  395|-> 	nbytes = fread(&(fch->c), sizeof(double), (size_t)1, f);
#  396|   	nbytes = fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);
#  397|   	nbytes = fread(&(fch->p1), sizeof(double), (size_t)1, f);

Error: CLANG_WARNING: [#def274]
gobject-introspection-1.80.1/girepository/cmph/fch.c:396:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  394|   	nbytes = fread(&(fch->m), sizeof(cmph_uint32), (size_t)1, f);
#  395|   	nbytes = fread(&(fch->c), sizeof(double), (size_t)1, f);
#  396|-> 	nbytes = fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);
#  397|   	nbytes = fread(&(fch->p1), sizeof(double), (size_t)1, f);
#  398|   	nbytes = fread(&(fch->p2), sizeof(double), (size_t)1, f);

Error: CLANG_WARNING: [#def275]
gobject-introspection-1.80.1/girepository/cmph/fch.c:397:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  395|   	nbytes = fread(&(fch->c), sizeof(double), (size_t)1, f);
#  396|   	nbytes = fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);
#  397|-> 	nbytes = fread(&(fch->p1), sizeof(double), (size_t)1, f);
#  398|   	nbytes = fread(&(fch->p2), sizeof(double), (size_t)1, f);
#  399|   

Error: CLANG_WARNING: [#def276]
gobject-introspection-1.80.1/girepository/cmph/fch.c:398:2: warning[deadcode.DeadStores]: Value stored to 'nbytes' is never read
#  396|   	nbytes = fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);
#  397|   	nbytes = fread(&(fch->p1), sizeof(double), (size_t)1, f);
#  398|-> 	nbytes = fread(&(fch->p2), sizeof(double), (size_t)1, f);
#  399|   
#  400|   	fch->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*fch->b);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def277]
gobject-introspection-1.80.1/girepository/cmph/graph.c: scope_hint: In function ‘graph_clear_edges’
gobject-introspection-1.80.1/girepository/cmph/graph.c:165:53: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*g.first + (long unsigned int)i * 4’
#  163|   {
#  164|   	cmph_uint32 i;
#  165|-> 	for (i = 0; i < g->nnodes; ++i) g->first[i] = EMPTY;
#  166|   	for (i = 0; i < g->nedges*2; ++i) 
#  167|   	{

Error: GCC_ANALYZER_WARNING (CWE-476): [#def278]
gobject-introspection-1.80.1/girepository/cmph/graph.c:168:29: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*g.edges + (long unsigned int)i * 4’
#  166|   	for (i = 0; i < g->nedges*2; ++i) 
#  167|   	{
#  168|-> 		g->edges[i] = EMPTY;
#  169|   		g->next[i] = EMPTY;
#  170|   	}

Error: GCC_ANALYZER_WARNING (CWE-476): [#def279]
gobject-introspection-1.80.1/girepository/cmph/graph.c:169:28: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*g.next + (long unsigned int)i * 4’
#  167|   	{
#  168|   		g->edges[i] = EMPTY;
#  169|-> 		g->next[i] = EMPTY;
#  170|   	}
#  171|   	g->cedges = 0;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def280]
gobject-introspection-1.80.1/girepository/cmph/graph.c: scope_hint: In function ‘graph_is_cyclic’
gobject-introspection-1.80.1/girepository/cmph/graph.c:234:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘deleted’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  232|   	cmph_uint8 *deleted = (cmph_uint8 *)malloc((g->nedges*sizeof(cmph_uint8))/8 + 1);
#  233|   	size_t deleted_len = g->nedges/8 + 1;
#  234|-> 	memset(deleted, 0, deleted_len);
#  235|   
#  236|   	DEBUGP("Looking for cycles in graph with %u vertices and %u edges\n", g->nnodes, g->nedges);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def281]
gobject-introspection-1.80.1/girepository/cmph/graph.c: scope_hint: In function ‘graph_obtain_critical_nodes’
gobject-introspection-1.80.1/girepository/cmph/graph.c:265:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘deleted’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  263|   	cmph_uint8 *deleted = (cmph_uint8 *)malloc((g->nedges*sizeof(cmph_uint8))/8+1);
#  264|   	size_t deleted_len = g->nedges/8 + 1;
#  265|-> 	memset(deleted, 0, deleted_len);
#  266|   	free(g->critical_nodes);
#  267|   	g->critical_nodes = (cmph_uint8 *)malloc((g->nnodes*sizeof(cmph_uint8))/8 + 1);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def282]
gobject-introspection-1.80.1/girepository/cmph/graph.c:269:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*g.critical_nodes’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memset’ must be non-null
#  267|   	g->critical_nodes = (cmph_uint8 *)malloc((g->nnodes*sizeof(cmph_uint8))/8 + 1);
#  268|   	g->ncritical_nodes = 0;
#  269|-> 	memset(g->critical_nodes, 0, (g->nnodes*sizeof(cmph_uint8))/8 + 1);
#  270|   	DEBUGP("Looking for the 2-core in graph with %u vertices and %u edges\n", g->nnodes, g->nedges);
#  271|   	for (v = 0; v < g->nnodes; ++v)

Error: GCC_ANALYZER_WARNING (CWE-688): [#def283]
gobject-introspection-1.80.1/girepository/cmph/hash.c: scope_hint: In function ‘hash_state_dump’
gobject-introspection-1.80.1/girepository/cmph/hash.c:68:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*buf’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memcpy’ must be non-null
#   66|   	}
#   67|   	*buf = (char *)malloc(strlen(cmph_hash_names[state->hashfunc]) + 1 + *buflen);
#   68|-> 	memcpy(*buf, cmph_hash_names[state->hashfunc], strlen(cmph_hash_names[state->hashfunc]) + 1);
#   69|   	DEBUGP("Algobuf is %u\n", *(cmph_uint32 *)algobuf);
#   70|   	len = *buflen;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def284]
gobject-introspection-1.80.1/girepository/cmph/jenkins_hash.c: scope_hint: In function ‘jenkins_state_new’
gobject-introspection-1.80.1/girepository/cmph/jenkins_hash.c:91:21: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘state’
#   89|   	jenkins_state_t *state = (jenkins_state_t *)malloc(sizeof(jenkins_state_t));
#   90|   	DEBUGP("Initializing jenkins hash\n");
#   91|-> 	state->seed = ((cmph_uint32)rand() % size);
#   92|   	return state;
#   93|   }

Error: CLANG_WARNING: [#def285]
gobject-introspection-1.80.1/girepository/cmph/jenkins_hash.c:223:17: warning[unix.MallocSizeof]: Result of 'malloc' is converted to a pointer of type 'char', which is incompatible with sizeof operand type 'cmph_uint32'
#  221|   {
#  222|   	*buflen = sizeof(cmph_uint32);
#  223|-> 	*buf = (char *)malloc(sizeof(cmph_uint32));
#  224|   	if (!*buf) 
#  225|   	{

Error: GCC_ANALYZER_WARNING (CWE-476): [#def286]
gobject-introspection-1.80.1/girepository/cmph/jenkins_hash.c: scope_hint: In function ‘jenkins_state_copy’
gobject-introspection-1.80.1/girepository/cmph/jenkins_hash.c:237:30: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘dest_state’
#  235|   {
#  236|   	jenkins_state_t *dest_state = (jenkins_state_t *)malloc(sizeof(jenkins_state_t));
#  237|-> 	dest_state->hashfunc = src_state->hashfunc;
#  238|   	dest_state->seed = src_state->seed;
#  239|   	return dest_state;

Error: GCC_ANALYZER_WARNING (CWE-476): [#def287]
gobject-introspection-1.80.1/girepository/cmph/jenkins_hash.c: scope_hint: In function ‘jenkins_state_load’
gobject-introspection-1.80.1/girepository/cmph/jenkins_hash.c:245:21: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘state’
#  243|   {
#  244|   	jenkins_state_t *state = (jenkins_state_t *)malloc(sizeof(jenkins_state_t));
#  245|-> 	state->seed = *(cmph_uint32 *)buf;
#  246|   	state->hashfunc = CMPH_HASH_JENKINS;
#  247|   	DEBUGP("Loaded jenkins state with seed %u\n", state->seed);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def288]
gobject-introspection-1.80.1/girepository/cmph/select.c: scope_hint: In function ‘select_generate_sel_table’
gobject-introspection-1.80.1/girepository/cmph/select.c:84:65: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘bits_table’
#   82|   		{
#   83|   			old_part_sum = part_sum; 
#   84|-> 			part_sum += rank_lookup_table[bits_table[vec_idx]];
#   85|   			vec_idx++;
#   86|   		} while (part_sum <= one_idx);

Error: GCC_ANALYZER_WARNING (CWE-476): [#def289]
gobject-introspection-1.80.1/girepository/cmph/select.c:88:50: warning[-Wanalyzer-possible-null-dereference]: dereference of possibly-NULL ‘*sel.select_table’
#   86|   		} while (part_sum <= one_idx);
#   87|   		
#   88|-> 		sel->select_table[sel_table_idx] = select_lookup_table[bits_table[vec_idx - 1]][one_idx - old_part_sum] + ((vec_idx - 1) << 3); // ((vec_idx - 1) << 3) = ((vec_idx - 1) * 8)
#   89|   		one_idx += STEP_SELECT_TABLE ;
#   90|   		sel_table_idx++;

Error: GCC_ANALYZER_WARNING (CWE-688): [#def290]
gobject-introspection-1.80.1/girepository/cmph/select.c: scope_hint: In function ‘select_load’
gobject-introspection-1.80.1/girepository/cmph/select.c:278:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*sel.bits_vec’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memcpy’ must be non-null
#  276|   	sel->select_table = (cmph_uint32 *)calloc(sel_table_size/sizeof(cmph_uint32), sizeof(cmph_uint32));
#  277|   
#  278|-> 	memcpy(sel->bits_vec, buf + pos, vec_size);
#  279|   	pos += vec_size;
#  280|   	memcpy(sel->select_table, buf + pos, sel_table_size);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def291]
gobject-introspection-1.80.1/girepository/cmph/select.c:280:9: warning[-Wanalyzer-possible-null-argument]: use of possibly-NULL ‘*sel.select_table’ where non-null expected
<built-in>: note: argument 1 of ‘__builtin_memcpy’ must be non-null
#  278|   	memcpy(sel->bits_vec, buf + pos, vec_size);
#  279|   	pos += vec_size;
#  280|-> 	memcpy(sel->select_table, buf + pos, sel_table_size);
#  281|   	
#  282|   	DEBUGP("Loaded select structure with size %u bytes\n", buflen);

Error: GCC_ANALYZER_WARNING (CWE-688): [#def292]
gobject-introspection-1.80.1/girepository/cmph/select.c: scope_hint: In function ‘select_pack’
gobject-introspection-1.80.1/girepository/cmph/select.c:298:17: warning[-Wanalyzer-null-argument]: use of NULL ‘buf’ where non-null expected
<built-in>: note: argument 2 of ‘__builtin_memcpy’ must be non-null
#  296|   		cmph_uint32 buflen = 0;
#  297|   		select_dump(sel, &buf, &buflen);
#  298|-> 		memcpy(sel_packed, buf, buflen);
#  299|   		free(buf);
#  300|   	}

Error: CPPCHECK_WARNING (CWE-457): [#def293]
gobject-introspection-1.80.1/girepository/gibaseinfo.c:545: error[uninitvar]: Uninitialized variables: &blob.name, &blob.value
#  543|     first = (AttributeBlob *) &rinfo->typelib->data[header->attributes];
#  544|   
#  545|->   res = bsearch (&blob, first, header->n_attributes,
#  546|                    header->attribute_blob_size, cmp_attribute);
#  547|   

Error: CLANG_WARNING: [#def294]
gobject-introspection-1.80.1/girepository/girffi.c:394:10: warning[unix.Malloc]: Potential leak of memory pointed to by 'atypes'
#  392|   
#  393|     atypes = g_callable_info_get_ffi_arg_types (callable_info, &n_args);
#  394|->   status = ffi_prep_cif (cif, FFI_DEFAULT_ABI, n_args,
#  395|                            g_callable_info_get_ffi_return_type (callable_info),
#  396|                            atypes);

Error: CLANG_WARNING: [#def295]
gobject-introspection-1.80.1/girepository/girmodule.c:558:3: warning[deadcode.DeadStores]: Value stored to 'header' is never read
#  556|   
#  557|     data = g_realloc (data, offset2);
#  558|->   header = (Header*) data;
#  559|   
#  560|     data = add_directory_index_section (data, module, &offset2);

Error: CLANG_WARNING: [#def296]
gobject-introspection-1.80.1/girepository/girnode.c:594:32: warning[core.NullDereference]: Access to field 'type' results in a dereference of a null pointer (loaded from variable 'node')
#  592|   
#  593|     g_debug ("node %p type '%s'", node,
#  594|-> 	   _g_ir_node_type_to_string (node->type));
#  595|   
#  596|     switch (node->type)

Error: COMPILER_WARNING (CWE-476): [#def297]
gobject-introspection-1.80.1/girepository/girparser.c:661:11: warning[-Wnull-dereference]: potential null pointer dereference
#  661 |       if (*str == '<')
#      |           ^~~~
#  659|         str += strlen ("Error");
#  660|   
#  661|->       if (*str == '<')
#  662|   	{
#  663|   	  char *tmp, *end;

Error: CLANG_WARNING: [#def298]
gobject-introspection-1.80.1/girepository/girparser.c:661:11: warning[core.NullDereference]: Dereference of null pointer (loaded from variable 'str')
#  659|         str += strlen ("Error");
#  660|   
#  661|->       if (*str == '<')
#  662|   	{
#  663|   	  char *tmp, *end;

Error: CPPCHECK_WARNING (CWE-457): [#def299]
gobject-introspection-1.80.1/girepository/girparser.c:1633: error[legacyUninitvar]: Uninitialized variable: target_state
# 1631|       g_assert_not_reached ();
# 1632|   
# 1633|->   if (!introspectable_prelude (context, attribute_names, attribute_values, ctx, target_state))
# 1634|       return TRUE;
# 1635|   

Error: CLANG_WARNING: [#def300]
gobject-introspection-1.80.1/redhat-linux-build/gi-scan.c:184:16: warning[deadcode.DeadStores]: Although the value stored to 'event_num' is used in the enclosing expression, the value is never actually read from 'event_num'

Error: CPPCHECK_WARNING (CWE-476): [#def301]
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerlexer.c:2905: warning[nullPointer]: Possible null pointer dereference: b
# 2903|       
# 2904|   	yy_flush_buffer( b );
# 2905|-> 
# 2906|   	b->yy_input_file = file;
# 2907|   	b->yy_fill_buffer = 1;

Error: CPPCHECK_WARNING (CWE-476): [#def302]
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerlexer.c:2906: warning[nullPointer]: Possible null pointer dereference: b
# 2904|   	yy_flush_buffer( b );
# 2905|   
# 2906|-> 	b->yy_input_file = file;
# 2907|   	b->yy_fill_buffer = 1;
# 2908|   

Error: GCC_ANALYZER_WARNING (CWE-457): [#def303]
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerparser.c: scope_hint: In function ‘yyparse’
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerparser.c:816:7: warning[-Wanalyzer-use-of-uninitialized-value]: use of uninitialized value ‘yyss’
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerparser.c:801:9: note: in expansion of macro ‘YYCOPY’
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerparser.c:2355:9: note: in expansion of macro ‘YYSTACK_RELOCATE’
/usr/lib64/glib-2.0/include/glibconfig.h:9: included_from: Included from here.
/usr/include/glib-2.0/glib/gtypes.h:34: included_from: Included from here.
/usr/include/glib-2.0/glib/galloca.h:34: included_from: Included from here.
/usr/include/glib-2.0/glib.h:32: included_from: Included from here.
gobject-introspection-1.80.1/giscanner/scannerparser.y:34: included_from: Included from here.
/usr/include/glib-2.0/glib/gmacros.h:1243:31: note: in expansion of macro ‘_G_BOOLEAN_EXPR_IMPL’
/usr/include/glib-2.0/glib/gmacros.h:1244:43: note: in expansion of macro ‘_G_BOOLEAN_EXPR’
/usr/include/glib-2.0/glib/gmessages.h:664:9: note: in expansion of macro ‘G_LIKELY’
gobject-introspection-1.80.1/giscanner/scannerparser.y:1715:3: note: in expansion of macro ‘g_return_val_if_fail’
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerparser.c:816:25: note: in definition of macro ‘YYCOPY’
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerparser.c:2355:9: note: in expansion of macro ‘YYSTACK_RELOCATE’
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerparser.c:801:9: note: in expansion of macro ‘YYCOPY’
gobject-introspection-1.80.1/redhat-linux-build/giscanner/scannerparser.c:2355:9: note: in expansion of macro ‘YYSTACK_RELOCATE’
#  814|   #  if defined __GNUC__ && 1 < __GNUC__
#  815|   #   define YYCOPY(Dst, Src, Count) \
#  816|->       __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
#  817|   #  else
#  818|   #   define YYCOPY(Dst, Src, Count)              \

Error: CLANG_WARNING: [#def304]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspect52jtpgd6/SLetter-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def305]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspect56yuuzxd/GObject-2.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def306]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspect592bqvsc/GIRepository-2.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def307]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspect6g48gl14/Utility-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def308]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspect_wtwf5_z/GtkFrob-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def309]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectare_fcg3/GIMarshallingTests-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def310]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectb7fkvqon/WarnLib-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def311]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectdhdr8386/GetType-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def312]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspecthut8ntp5/Everything-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def313]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectkj8v8kbw/Typedefs-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def314]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectlxjtw1_g/Bar-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def315]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectocrl1fmv/Offsets-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def316]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectpg8zcd4y/Gio-2.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def317]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectqptn4x7y/GLib-2.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def318]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspects3ixkxwk/GModule-2.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CLANG_WARNING: [#def319]
gobject-introspection-1.80.1/redhat-linux-build/tmp-introspectzd5ubv0r/Regress-1.0.c:799:27: warning[core.NullDereference]: Access to field 'message' results in a dereference of a null pointer (loaded from variable 'error')

Error: CPPCHECK_WARNING (CWE-457): [#def320]
gobject-introspection-1.80.1/tests/repository/gitypelibtest.c:271: warning[uninitvar]: Uninitialized variables: sig_info.dummy1, sig_info.dummy2, sig_info.dummy3, sig_info.dummy4, sig_info.dummy5, sig_info.dummy6, sig_info.dummy7
#  269|     g_assert (i >= 0);
#  270|   
#  271|->   g_assert_cmpint (g_callable_info_get_n_args (sig_info), ==, 2);
#  272|   
#  273|     /* verify array argument */

Error: GCC_ANALYZER_WARNING (CWE-775): [#def321]
gobject-introspection-1.80.1/tools/compiler.c: scope_hint: In function ‘write_out_typelib’
gobject-introspection-1.80.1/tools/compiler.c:118:10: warning[-Wanalyzer-file-leak]: leak of FILE ‘file’
gobject-introspection-1.80.1/tools/compiler.c:27: included_from: Included from here.
gobject-introspection-1.80.1/tools/compiler.c:83:14: note: in expansion of macro ‘g_fopen’
#  116|     g_free (tmp_filename);
#  117|   
#  118|->   return success;
#  119|   }
#  120|   

Error: GCC_ANALYZER_WARNING (CWE-401): [#def322]
gobject-introspection-1.80.1/tools/compiler.c:118:10: warning[-Wanalyzer-malloc-leak]: leak of ‘file’
gobject-introspection-1.80.1/tools/compiler.c:83:14: note: in expansion of macro ‘g_fopen’
#  116|     g_free (tmp_filename);
#  117|   
#  118|->   return success;
#  119|   }
#  120|   

Scan Properties

analyzer-version-clang18.1.3
analyzer-version-cppcheck2.13.0
analyzer-version-gcc14.0.1
analyzer-version-gcc-analyzer14.0.1
analyzer-version-shellcheck0.10.0
enabled-pluginsclang, cppcheck, gcc, shellcheck
exit-code0
hostip-172-16-1-36.us-west-2.compute.internal
mock-configfedora-41-x86_64
project-namegobject-introspection-1.80.1-1.fc41
store-results-to/tmp/tmprwlu6zxs/gobject-introspection-1.80.1-1.fc41.tar.xz
time-created2024-04-22 10:52:50
time-finished2024-04-22 10:54:48
toolcsmock
tool-args'/usr/bin/csmock' '-r' 'fedora-41-x86_64' '-t' 'cppcheck,gcc,clang,shellcheck' '-o' '/tmp/tmprwlu6zxs/gobject-introspection-1.80.1-1.fc41.tar.xz' '--gcc-analyze' '/tmp/tmprwlu6zxs/gobject-introspection-1.80.1-1.fc41.src.rpm'
tool-versioncsmock-3.5.3-1.el9