(C) pointers passed to func differ from original - c

Question

Segfault I find myself unable to diagnose.
I have a benchmark func chrono which receives an array strings of pointers to randomly generated strings, and an array of corresponding sizes. For debug, I print strings (the pointer to pointers), strings[1] (one of them), and sizes (the pointer). (I also print some strings in chrono, to be sure, and compare to their original contents in the func that generates them: all is fine up to there.) What is to be benchmarked is a func that feeds a pack of strings into a string pool:
void pool_store_pack (StringPool * pool,
char ** strings, size_t * sizes, uint n_new);
For debug, I print the same data inside pool_store_pack. And the values are different. strings has changed, and both strings[1] and sizes are null. Here is an example output:
strings:0x9842fa8 (n°1:0x984200c)
sizes:0x9843f48
some strings: `#PR` `MOB` `TBQ`
strings:0x804a824 (n°1:(nil))
sizes:(nil)
segmentation fault (core dumped)
I have tried to reduce the bug to a simpler form, but it is difficult precisely because it is test code, not app code, that drives an autonomous piece of library. When I try to reproduce the bug from scratch, I just get as expected pointers and pointers to pointers with the same values in the receiving funcs as in the sending one. However, I can post the code of the 3 relevant funcs if it helps (but you won`t be able to run it, since it just drives other funcs).
I am pretty sure to be missing an obvious point, but cannot see it and am blocked and frustrated for hours ;-) Can you help?
EDIT: So, here is the whole code involved:
/* Put pack of strings in pool.
*/
void pool_store_pack (StringPool * pool,
char ** strings, size_t * sizes, uint n_new) {
pool_grow(pool, n_new);
// debug /////////////////////////////////////////////////////////
printfl("n_new:%u", n_new);
printfl("strings:%p (n°1:%p)", strings, strings[1]);
printfl("sizes:%p", sizes);
printfl("some sizes: %u %u %u", sizes[1], sizes[3], sizes[9]);
printfl("some strings: '%s' '%s' '%s'", strings[1], strings[3], strings[9]);
end();
uint i;
for (i = 0; i < n_new; i++) pool_store(pool, strings[i], sizes[i]);
}
// generate random strings (constants used here are defined somewhere else)
static char ** data_strings (char ** p_bytes) {
char * bytes = malloc(n_strings * l * sizeof(char));
check_mem(bytes);
char ** strings = malloc(n_strings * sizeof(char *));
check_mem(strings);
char * s;
uint i,j;
srandom(time(NULL));
for (i=0; i<n_strings; i++) {
s = bytes + i*l;
s[size] = NUL;
for (j=0; j<size; j++) s[j] = '#' + random()%n_letters;
strings[i] = s;
}
//~ for (i=0; i<n_strings; i++) printf("'%s' ", strings[i]); line();
printfl("some strings: '%s' '%s' '%s'", strings[1], strings[3], strings[9]);
* p_bytes = bytes;
return strings;
}
// benchmark
static void chrono () {
printfl ("=== chrono pool ===============================================");
uint i;
clock_t t1, t2;
float dt;
// test data string
char * bytes;
char ** strings = data_strings(& bytes);
// string sizes are all equal to size (3)
size_t * sizes = malloc(n_strings * sizeof(size_t));
check_mem(sizes);
for (i=0; i<n_strings; i++) sizes[i] = size;
// debug ///////////////////////////////////////////////////////////////////
printfl("n_strings:%u", n_strings);
printfl("strings:%p (n°1:%p)", strings, strings[1]);
printfl("sizes:%p", sizes);
printfl("some sizes: %u %u %u", sizes[1], sizes[3], sizes[9]);
printfl("some strings: '%s' '%s' '%s'", strings[1], strings[3], strings[9]);
// now, feed the pool
StringPool * pool = stringpool();
t1 = clock();
pool_store_pack(pool, strings, sizes, n_strings);
t2 = clock();
end();
dt = 1.0 * (t2 - t1) / CLOCKS_PER_SEC;
print("pool data : "); show_pool_data(pool);
print("pool stats : "); show_pool_stats(pool, false);
printfl("time : %.3f", dt);
free(bytes);
free(strings);
}

Answer 1

OK runs! There were 2 bugs in fact, interacting with each other. First, a wrong redefinition of a static constant giving the sizes of an initial set of strings to feed the pool (in fact only "", so this set has length 1). Second, an inversion of 2 instructions making the pool beeing used before initialised. The interaction is that the initialisation also used pool_store_pack to feed the pool with said initial strings.
==>
What I got as debug output (and showed you) was reflecting the data from calling this func pool_store_pack for pool initialisation, not from the chrono func (thus, strings[1] was nil because there is only one string in the initial set!). And sizes was nil because it is the static constant wrongly changed... Mama mia!
Thanks to you all! Unfortunately I cannot vote you up, since there are only comments...