Merge branch 'tc/memzero-array' into next

gitster · gitster · commit 4d2f7755b560 · 2025-12-17T14:45:28.000+09:00
MEMZERO_ARRAY() helper is introduced to avoid clearing only the
first N bytes of an N-element array whose elements are larger than
a byte.

* tc/memzero-array:
  contrib/coccinelle: pass include paths to spatch(1)
  git-compat-util: introduce MEMZERO_ARRAY() macro
diff --git a/Makefile b/Makefile
@@ -982,7 +982,7 @@ SANITIZE_LEAK =
 SANITIZE_ADDRESS =
 
 # For the 'coccicheck' target
-SPATCH_INCLUDE_FLAGS = --all-includes
+SPATCH_INCLUDE_FLAGS = --all-includes $(addprefix -I ,compat ewah refs sha256 trace2 win32 xdiff)
 SPATCH_FLAGS =
 SPATCH_TEST_FLAGS =
 
diff --git a/builtin/last-modified.c b/builtin/last-modified.c
@@ -327,7 +327,7 @@ static void process_parent(struct last_modified *lm,
 	if (!(parent->object.flags & PARENT1))
 		active_paths_free(lm, parent);
 
-	memset(lm->scratch->words, 0x0, lm->scratch->word_alloc * sizeof(eword_t));
+	MEMZERO_ARRAY(lm->scratch->words, lm->scratch->word_alloc);
 	diff_queue_clear(&diff_queued_diff);
 }
 
diff --git a/compat/simple-ipc/ipc-win32.c b/compat/simple-ipc/ipc-win32.c
@@ -686,7 +686,7 @@ static LPSECURITY_ATTRIBUTES get_sa(struct my_sa_data *d)
 		goto fail;
 	}
 
-	memset(ea, 0, NR_EA * sizeof(EXPLICIT_ACCESS));
+	MEMZERO_ARRAY(ea, NR_EA);
 
 	ea[0].grfAccessPermissions = GENERIC_READ | GENERIC_WRITE;
 	ea[0].grfAccessMode = SET_ACCESS;
diff --git a/contrib/coccinelle/array.cocci b/contrib/coccinelle/array.cocci
@@ -101,3 +101,23 @@ expression dst, src, n;
 -ALLOC_ARRAY(dst, n);
 -COPY_ARRAY(dst, src, n);
 +DUP_ARRAY(dst, src, n);
+
+@@
+type T;
+T *ptr;
+expression n;
+@@
+- memset(ptr, \( 0x0 \| 0 \), n * \( sizeof(T)
+-                                 \| sizeof(*ptr)
+-                                 \) )
++ MEMZERO_ARRAY(ptr, n)
+
+@@
+type T;
+T[] ptr;
+expression n;
+@@
+- memset(ptr, \( 0x0 \| 0 \), n * \( sizeof(T)
+-                                 \| sizeof(*ptr)
+-                                 \) )
++ MEMZERO_ARRAY(ptr, n)
diff --git a/contrib/coccinelle/meson.build b/contrib/coccinelle/meson.build
@@ -50,6 +50,11 @@ foreach header : headers_to_check
   coccinelle_headers += meson.project_source_root() / header
 endforeach
 
+coccinelle_includes = []
+foreach path : ['compat', 'ewah', 'refs', 'sha256', 'trace2', 'win32', 'xdiff']
+  coccinelle_includes += ['-I', meson.project_source_root() / path]
+endforeach
+
 patches = [ ]
 foreach source : coccinelle_sources
   patches += custom_target(
@@ -58,6 +63,7 @@ foreach source : coccinelle_sources
       '--all-includes',
       '--sp-file', concatenated_rules,
       '--patch', meson.project_source_root(),
+      coccinelle_includes,
       '@INPUT@',
     ],
     input: meson.project_source_root() / source,
diff --git a/diff-delta.c b/diff-delta.c
@@ -171,7 +171,7 @@ struct delta_index * create_delta_index(const void *buf, unsigned long bufsize)
 	mem = hash + hsize;
 	entry = mem;
 
-	memset(hash, 0, hsize * sizeof(*hash));
+	MEMZERO_ARRAY(hash, hsize);
 
 	/* allocate an array to count hash entries */
 	hash_count = calloc(hsize, sizeof(*hash_count));
diff --git a/ewah/bitmap.c b/ewah/bitmap.c
@@ -46,8 +46,7 @@ static void bitmap_grow(struct bitmap *self, size_t word_alloc)
 {
 	size_t old_size = self->word_alloc;
 	ALLOC_GROW(self->words, word_alloc, self->word_alloc);
-	memset(self->words + old_size, 0x0,
-	       (self->word_alloc - old_size) * sizeof(eword_t));
+	MEMZERO_ARRAY(self->words + old_size, (self->word_alloc - old_size));
 }
 
 void bitmap_set(struct bitmap *self, size_t pos)
@@ -192,8 +191,8 @@ void bitmap_or_ewah(struct bitmap *self, struct ewah_bitmap *other)
 	if (self->word_alloc < other_final) {
 		self->word_alloc = other_final;
 		REALLOC_ARRAY(self->words, self->word_alloc);
-		memset(self->words + original_size, 0x0,
-			(self->word_alloc - original_size) * sizeof(eword_t));
+		MEMZERO_ARRAY(self->words + original_size,
+		              (self->word_alloc - original_size));
 	}
 
 	ewah_iterator_init(&it, other);
diff --git a/git-compat-util.h b/git-compat-util.h
@@ -726,6 +726,7 @@ static inline uint64_t u64_add(uint64_t a, uint64_t b)
 #define ALLOC_ARRAY(x, alloc) (x) = xmalloc(st_mult(sizeof(*(x)), (alloc)))
 #define CALLOC_ARRAY(x, alloc) (x) = xcalloc((alloc), sizeof(*(x)))
 #define REALLOC_ARRAY(x, alloc) (x) = xrealloc((x), st_mult(sizeof(*(x)), (alloc)))
+#define MEMZERO_ARRAY(x, alloc) memset((x), 0x0, st_mult(sizeof(*(x)), (alloc)))
 
 #define COPY_ARRAY(dst, src, n) copy_array((dst), (src), (n), sizeof(*(dst)) + \
 	BARF_UNLESS_COPYABLE((dst), (src)))
diff --git a/hashmap.c b/hashmap.c
@@ -194,7 +194,7 @@ void hashmap_partial_clear_(struct hashmap *map, ssize_t entry_offset)
 		return;
 	if (entry_offset >= 0)  /* called by hashmap_clear_entries */
 		free_individual_entries(map, entry_offset);
-	memset(map->table, 0, map->tablesize * sizeof(struct hashmap_entry *));
+	MEMZERO_ARRAY(map->table, map->tablesize);
 	map->shrink_at = 0;
 	map->private_size = 0;
 }
diff --git a/pack-revindex.c b/pack-revindex.c
@@ -75,7 +75,7 @@ static void sort_revindex(struct revindex_entry *entries, unsigned n, off_t max)
 	for (bits = 0; max >> bits; bits += DIGIT_SIZE) {
 		unsigned i;
 
-		memset(pos, 0, BUCKETS * sizeof(*pos));
+		MEMZERO_ARRAY(pos, BUCKETS);
 
 		/*
 		 * We want pos[i] to store the index of the last element that

Original file line number	Diff line number	Diff line change
`@@ -327,7 +327,7 @@ static void process_parent(struct last_modified *lm,`
`327`	`327`	`if (!(parent->object.flags & PARENT1))`
`328`	`328`	`active_paths_free(lm, parent);`
`329`	`329`
`330`		`- memset(lm->scratch->words, 0x0, lm->scratch->word_alloc * sizeof(eword_t));`
	`330`	`+ MEMZERO_ARRAY(lm->scratch->words, lm->scratch->word_alloc);`
`331`	`331`	`diff_queue_clear(&diff_queued_diff);`
`332`	`332`	`}`
`333`	`333`
Original file line number	Diff line number	Diff line change
`@@ -686,7 +686,7 @@ static LPSECURITY_ATTRIBUTES get_sa(struct my_sa_data *d)`
`686`	`686`	`goto fail;`
`687`	`687`	`}`
`688`	`688`
`689`		`- memset(ea, 0, NR_EA * sizeof(EXPLICIT_ACCESS));`
	`689`	`+ MEMZERO_ARRAY(ea, NR_EA);`
`690`	`690`
`691`	`691`	`ea[0].grfAccessPermissions = GENERIC_READ \| GENERIC_WRITE;`
`692`	`692`	`ea[0].grfAccessMode = SET_ACCESS;`
Original file line number	Diff line number	Diff line change
`@@ -46,8 +46,7 @@ static void bitmap_grow(struct bitmap *self, size_t word_alloc)`
`46`	`46`	`{`
`47`	`47`	`size_t old_size = self->word_alloc;`
`48`	`48`	`ALLOC_GROW(self->words, word_alloc, self->word_alloc);`
`49`		`- memset(self->words + old_size, 0x0,`
`50`		`- (self->word_alloc - old_size) * sizeof(eword_t));`
	`49`	`+ MEMZERO_ARRAY(self->words + old_size, (self->word_alloc - old_size));`
`51`	`50`	`}`
`52`	`51`
`53`	`52`	`void bitmap_set(struct bitmap *self, size_t pos)`
`@@ -192,8 +191,8 @@ void bitmap_or_ewah(struct bitmap self, struct ewah_bitmap other)`
`192`	`191`	`if (self->word_alloc < other_final) {`
`193`	`192`	`self->word_alloc = other_final;`
`194`	`193`	`REALLOC_ARRAY(self->words, self->word_alloc);`
`195`		`- memset(self->words + original_size, 0x0,`
`196`		`- (self->word_alloc - original_size) * sizeof(eword_t));`
	`194`	`+ MEMZERO_ARRAY(self->words + original_size,`
	`195`	`+ (self->word_alloc - original_size));`
`197`	`196`	`}`
`198`	`197`
`199`	`198`	`ewah_iterator_init(&it, other);`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,7 @@ void hashmap_partial_clear_(struct hashmap *map, ssize_t entry_offset)`
`194`	`194`	`return;`
`195`	`195`	`if (entry_offset >= 0) /* called by hashmap_clear_entries */`
`196`	`196`	`free_individual_entries(map, entry_offset);`
`197`		`- memset(map->table, 0, map->tablesize * sizeof(struct hashmap_entry *));`
	`197`	`+ MEMZERO_ARRAY(map->table, map->tablesize);`
`198`	`198`	`map->shrink_at = 0;`
`199`	`199`	`map->private_size = 0;`
`200`	`200`	`}`