[Bug c/65106] New: C99 intialization of struct with const member through a non-const pointer

[Bug c/65106] New: C99 intialization of struct with const member through a non-const pointer

[andrii.riabushenko at barclays dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65106

            Bug ID: 65106
           Summary: C99 intialization of struct with const member through
                    a non-const pointer
           Product: gcc
           Version: 4.9.3
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
          Assignee: unassigned at gcc dot gnu.org
          Reporter: andrii.riabushenko at barclays dot com

I noticed that such C99 code is valid in Clang, but not in GCC:

#include<stdlib.h>

struct A {
  int x;
  const int y;
}

struct A* make() 
{
  struct A *ptr = malloc(sizeof(struct A));
  *ptr = (struct A) {10, 10};
}

I find this language construct rather useful. I quickly scanned the C standard
and I can't find the evidence that is actually prohibited. There is a
difference between assignment a const member (ptr->y = 10) that should be
prohibited and actual struct initialization through non-const pointer. For some
reason GCC does not distinguish these 2 cases.

[Bug c/65106] C99 intialization of struct with const member through a non-const pointer

[joseph at codesourcery dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65106

--- Comment #1 from joseph at codesourcery dot com <joseph at codesourcery dot com> ---
See the definition of "modifiable lvalue" (6.3.2.1#1): "... if it is a 
structure or union, does not have any member (including, recursively, any 
member or element of all contained aggregates or unions) with a 
const-qualified type".  (Together with 6.5.16#2 "An assignment operator 
shall have a modifiable lvalue as its left operand.".)

(It is however valid to pass arguments and return values of such types, 
notwithstanding references to assignment in such contexts; see DR#427.)

[Bug c/65106] C99 intialization of struct with const member through a non-const pointer

[andrii.riabushenko at barclays dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65106

--- Comment #2 from Andrey Riabushenko <andrii.riabushenko at barclays dot com> ---
Thanks Joseph for pointing out relevant standard sections, hence standard does
not allow for that.

Given that implicit copies of structs with constant members are happening today 
(pass as argument by value and return value) and some compilers do support it,
can we consider this as compiler extension?

[Bug c/65106] C99 intialization of struct with const member through a non-const pointer

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65106

--- Comment #3 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Function arguments and return values don't modify existing objects, the copies
are new objects. In the assignment in your code you modify an existing object.
If it was allowed what would prevent you from doing:

  struct A a = { 1, 2 }
  struct A *ptr = &a;
  *ptr = (struct A) {10, 10};

Or simply:

  struct A *ptr = malloc(sizeof(struct A));
  *ptr = (struct A) {10, 10};
  *ptr = (struct A) {11, 11};

(Clang allows both of these, despite the fact they modify a const object).

[Bug c/65106] C99 intialization of struct with const member through a non-const pointer

[mpolacek at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65106

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
                 CC|                            |mpolacek at gcc dot gnu.org
         Resolution|---                         |INVALID

--- Comment #4 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
Looks like this doesn't point to a bug in GCC.