Assignment of a struct in a for loop error with gcc and not with clang

Hello I got this warning with gcc(version 5.4.0) on a C11 program compiled with the following command:

$ gcc -g -Wall -std=c11 main.c -o minishell   
main.c: In function ‘process_new’:
main.c:184:10: error: assignment of read-only variable ‘s’
        s = slice_next(s, ':')) {

But nothing with clang (version 3.8.0):

$ clang -g -Wall -std=c11 main.c -o minishell # Compile without warning.

I am on Ubuntu 16.04.

Here is the code

// The loop that generate the warning with gcc.
for (str_slice s = slice_at(paths, ':');
       !slice_empty(s);
       s = slice_next(s, ':')) {
//       ^ Gcc complains here.
    const char *full_path = build_full_path(progname, s);
    /* I use with full_path but nothing with s after this point. */ 
    // There is no aliasing on full_path at this point.
    free((void *)full_path); .
  }

And here the definition of str_slice:

typedef struct _str_slice {
  const char* data;
  const uint32_t len; // end - data len of slice.
//^^^^^ Source of gcc warning.
} str_slice;

And the functions to use it:

inline
uint32_t slice_len(const str_slice slice) {
  return slice.len;
}

inline
const char* slice_data(const str_slice s) {
  return s.data;
}

inline
str_slice slice_new(const char* data, uint32_t len) {
  return (str_slice) { data, len };
}

inline
str_slice slice_at(const char* data, const char c) {
  const char* end = strchr(data, c);
  return slice_new(data, end - data);
}

inline
str_slice slice_next(const str_slice s, const char c) {
  const char* data = slice_data(s) + slice_len(s) + 1; // skip c
  const char* end = strchr(data, c);
  if (end != NULL) {
    return slice_new(data, end - data);
  } else {
    return slice_new(NULL, 0);
  }
}

inline
bool slice_empty(const str_slice s) {
  return s.len == 0;
}

And if necessary the code about build_full_path

const char* build_full_path(const char* progname, const str_slice slice) {
  size_t len_progname = strlen(progname);
  // Save additional 2 bytes for adding '/' and '\0'.
  size_t full_path_size = len_progname + slice.len + 2; 
  size_t malloc_size = sizeof(char) * full_path_size;
  char *full_path = malloc(malloc_size);

  full_path[full_path_size - 1] = '\0';
  memcpy(full_path, slice.data, slice.len);
  full_path[slice.len] = '/';
  memcpy(full_path + slice.len + 1, progname, len_progname);

  return (const char *) full_path;
}

When compile with clang I got an executable with the good behavior. So I made something wrong? Or I found a bug?

Here the full code of my program(outdated): https://gist.github.com/darnuria/12af88c509310c2b40e0031522882720

Edit: Use of memcpy instead of strncpy. Remove of const on scalar types.

In the structure the data member len is declared as a constant data member.

typedef struct _str_slice {
  const char* data;
  const uint32_t len; // end - data len of slice.
  ^^^^^^     
} str_slice;

It means that it can be changed and as result you may not assign one object of the structure to another object of the structure.