valgrind conditional jump or move depends on uninitialized

Question

Valgrind is throwing two warning for two lines of codes, mentioned in the comments next to each.

Warning 1:

invalid write of size 8, Address ... is 8 bytes inside a block of size 9 alloc'd

data[size] = NULL;

Warning 2:

Conditional jump or move depends on uninitialized values(s)

for (char **ptr = data; *ptr; ptr++) { // warning -> Conditional jump or move depends on uninitialized values(s)
    free(*ptr);
}

---

Here's a complete code,

Callee

char **getList() {
    char **list = (char *[]) {"John", "Jane", NULL};

    int size = 0;
    for (char **ptr = list; *ptr; ptr++) {
        size++;
    }

    char **data = malloc(sizeof(char *) * size + 1);
    if (data == NULL) goto exception;

    for (int i = 0; *list; list++, i++) {
        data[i] = malloc(sizeof(char) * (strlen(*list) + 1));
        if (data[i] == NULL) goto exception;
        strcpy(data[i], *list);
    }

    data[size] = NULL; // this line gives warning
    // warning -> invalid write of size 8, Address ... is 8 bytes inside a block of size 9 alloc'd
    return data;

    exception:
    fprintf(stderr, "data allocation failed.\n");
    return NULL;
}

Caller different file/scope

char **data = getList();

for (char **ptr = data; *ptr; ptr++) { // warning -> Conditional jump or move depends on uninitialized values(s)
    free(*ptr);
}
free(data);

Answer 1

Writing based on the suggestions on a new slate.

Edit updated based on the comments.

char **getList(void) {
    const char * const list[] = {"John", "Jane", NULL};

    unsigned int size = 0;
    const char * const *ptr;
    for (ptr = list; *ptr != NULL; ptr++) {
        size++;
    }

    char **data = malloc(sizeof(char *) * (size + 1));
    if (data == NULL) goto exception;

    ptr = list;
    for (unsigned int i = 0; *ptr != NULL; ptr++, i++) {
        const size_t cache = strlen(*ptr) + 1;
        data[i] = malloc(cache);
        if (data[i] == NULL) goto exception;
        memcpy(data[i], *ptr, cache);
    }

    data[size] = NULL;
    return data;

    exception:
    fprintf(stderr, "Allocation failed.\n");
    return NULL;
}

---

VERSION 2

With the help of Using C-string: "Address of stack memory associated with local variable returned"

const char * const *getList(void) {
    static const char * const list[] = {"John", "Jane", NULL};
    return list;
}

Answer 2

The code below is not tested. My recommendations are

• Use strdup
• Use calloc

• Try to avoid using goto

  char **getList() { char **list = (char *[]) {"John", "Jane", NULL};

  // this size is a compile time constant, no need to
  calculate it at runtime
  size_t size = sizeof(list)/sizeof(list[0]);
  
  // using calloc initializes everything to 0/NULL
  // -> no need to set the last element then
  char **data = calloc(sizeof(char *), size);
  
  // don't use goto
  if (data != NULL)
  {
      for (size_t i = 0U; i < size; i++)
      {
          if (list[i] != NULL)
          {
              // don't re-invent the wheel with strlen/memcpy
              // just use strdup
              data[i] = strdup(list[i]);
              if (data[i] == NULL) goto exception;
          }
      }
      return data;
  }
  
  exception:
  // you need to do more cleanup here
  // for instance if the 'data' calloc succeeds, the "John" strdup succeeds
  // but the "Jane" strdup fails then you have two leaks. That said fixing
  // small leaks when you are out of memory usually isn't your biggest issue.
  fprintf(stderr, "data allocation failed.\n");
  return NULL;
  

  }