diff mbox series

[RFC,v1,1/4] Documentation change

Message ID 20240419184317.2138890-2-qing.zhao@oracle.com
State New
Headers
Series Allow flexible array members in unions and alone in structures [PR53548] |

Checks

Context Check Description
linaro-tcwg-bot/tcwg_gcc_build--master-arm success Testing passed
linaro-tcwg-bot/tcwg_gcc_build--master-aarch64 success Testing passed
linaro-tcwg-bot/tcwg_gcc_check--master-arm success Testing passed
linaro-tcwg-bot/tcwg_gcc_check--master-aarch64 success Testing passed

Commit Message

Qing Zhao April 19, 2024, 6:43 p.m. UTC 
  for allow flexible array members in unions and alone in structures [PR53548]

The request for GCC to accept that the C99 flexible array member can be
in a union or alone in a structure has been made a long time ago around 2012
for supporting several practical cases including glibc.

A GCC PR has been opened for such request at that time:

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

However, this PR was closed as WONTFIX around 2015 due to the following reason:

"there is an existing extension that makes the requested functionality possible"
i.e GCC fully supported that the zero-length array can be in a union or alone
in a structure for a long time. (though I didn't see any official documentation
on such extension)

It's reasonable to close PR53548 at that time since zero-length array extension
can be used for such purpose.

However, since GCC13, in order to improve the C/C++ security, we introduced
-fstrict-flex-arrays=n to gradually eliminate the "fake flexible array"
usages from C/C++ source code. As a result, zero-length arrays eventually
will be replaced by C99 flexiable array member completely.

Therefore, GCC needs to explicitly allow such extensions directly for C99
flexible arrays, since flexable array member in unions or alone in structs
are common code patterns in active use by the Linux kernel (and other projects).

For example, these do not error by default with GCC:

union one {
  int a;
  int b[0];
};

union two {
  int a;
  struct {
    struct { } __empty;
    int b[];
  };
};

But these do:

union three {
  int a;
  int b[];
};

struct four {
  int b[];
}

Clang has supported such extensions since March, 2024
https://github.com/llvm/llvm-project/pull/84428

GCC should also support such extensions. This will allow for
a seamless transition for code bases away from zero-length arrays without
losing existing code patterns.

gcc/ChangeLog:

	* doc/extend.texi: Add documentation for Flexible Array Members in
	Unions and Flexible Array Members alone in Structures.
---
 gcc/doc/extend.texi | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

Comments

Tom Tromey April 19, 2024, 8:54 p.m. UTC | #1 
>>>>> Qing Zhao <qing.zhao@oracle.com> writes:

> +The size of the union is as if the flexiable array member were omitted
> +except that it may have more trailing padding than the omission would imply.
> +
> +If all the members of a union are flexiable array member, the size of 

There's a couple of spots that say "flexiable" which should say "flexible".

thanks,
Tom
Qing Zhao April 22, 2024, 1:28 p.m. UTC | #2 
> On Apr 19, 2024, at 16:54, Tom Tromey <tom@tromey.com> wrote:
> 
>>>>>> Qing Zhao <qing.zhao@oracle.com> writes:
> 
>> +The size of the union is as if the flexiable array member were omitted
>> +except that it may have more trailing padding than the omission would imply.
>> +
>> +If all the members of a union are flexiable array member, the size of
> 
> There's a couple of spots that say "flexiable" which should say "flexible".

Thanks for catching those typo, I will fix them.

Qing
> 
> thanks,
> Tom
Joseph Myers April 23, 2024, 6:04 p.m. UTC | #3 
On Fri, 19 Apr 2024, Qing Zhao wrote:

> +The size of the union is as if the flexiable array member were omitted
> +except that it may have more trailing padding than the omission would imply.

"trailing padding" is more a concept for structures than for unions (where 
padding depends on which union member is active).  But I suppose it's 
still true that the union can be larger than without the flexible member, 
because of alignment considerations.

union u { char c; int a[]; };

needs to be sufficiently aligned for int, which means the size is a 
multiple of the size of int, whereas if the flexible array member weren't 
present, the size could be 1 byte.
Qing Zhao April 23, 2024, 6:21 p.m. UTC | #4 
> On Apr 23, 2024, at 14:04, Joseph Myers <josmyers@redhat.com> wrote:
> 
> On Fri, 19 Apr 2024, Qing Zhao wrote:
> 
>> +The size of the union is as if the flexiable array member were omitted
>> +except that it may have more trailing padding than the omission would imply.
> 
> "trailing padding" is more a concept for structures than for unions (where 
> padding depends on which union member is active).  But I suppose it's 
> still true that the union can be larger than without the flexible member, 
> because of alignment considerations.
> 
> union u { char c; int a[]; };
> 
> needs to be sufficiently aligned for int, which means the size is a 
> multiple of the size of int, whereas if the flexible array member weren't 
> present, the size could be 1 byte.

Yes, that’s exact what I tried to include in the documentation part -:)
And I have a testing case for this in the patch. 

However, I am not very confident on the wording of the doc, is the current wording good enough for this?
Or do you have any suggestion on how to make it better?

Thanks a lot!

Qing
> 
> -- 
> Joseph S. Myers
> josmyers@redhat.com
>
Joseph Myers April 23, 2024, 7:03 p.m. UTC | #5 
On Tue, 23 Apr 2024, Qing Zhao wrote:

> However, I am not very confident on the wording of the doc, is the 
> current wording good enough for this? Or do you have any suggestion on 
> how to make it better?

I'm not convinced the statement about size (in relation to a structure 
with the member omitted) is useful for unions the way it is for 
structures.  The structure with the member omitted is a relevant concept 
for thinking about a structure with a flexible array member (the flexible 
array member essentially goes after that structure); it's much less 
relevant for thinking about a union with a flexible array member.

(The statement that the size is zero when all members are flexible array 
members still seems a useful one to make.)
Qing Zhao April 23, 2024, 7:21 p.m. UTC | #6 
> On Apr 23, 2024, at 15:03, Joseph Myers <josmyers@redhat.com> wrote:
> 
> On Tue, 23 Apr 2024, Qing Zhao wrote:
> 
>> However, I am not very confident on the wording of the doc, is the 
>> current wording good enough for this? Or do you have any suggestion on 
>> how to make it better?
> 
> I'm not convinced the statement about size (in relation to a structure 
> with the member omitted) is useful for unions the way it is for 
> structures.  The structure with the member omitted is a relevant concept 
> for thinking about a structure with a flexible array member (the flexible 
> array member essentially goes after that structure); it's much less 
> relevant for thinking about a union with a flexible array member.

Okay, then I will delete that statement about size.
> 
> (The statement that the size is zero when all members are flexible array 
> members still seems a useful one to make.)
And only keep the size is zero when all members are flexible array members.

Thanks.

Qing
> 
> -- 
> Joseph S. Myers
> josmyers@redhat.com
>
diff mbox series

Patch

diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index 7b54a241a7bf..b12ce5fb9b87 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -42,6 +42,8 @@  extensions, accepted by GCC in C90 mode and in C++.
 * Named Address Spaces::Named address spaces.
 * Zero Length::         Zero-length arrays.
 * Empty Structures::    Structures with no members.
+* Flexible Array Members in Unions::  Unions with Flexible Array Members.
+* Flexible Array Members alone in Structures::  Structures with only Flexible Array Members.
 * Variable Length::     Arrays whose length is computed at run time.
 * Variadic Macros::     Macros with a variable number of arguments.
 * Escaped Newlines::    Slightly looser rules for escaped newlines.
@@ -1873,6 +1875,41 @@  The structure has size zero.  In C++, empty structures are part
 of the language.  G++ treats empty structures as if they had a single
 member of type @code{char}.
 
+@node Flexible Array Members in Unions
+@section Unions with Flexible Array Members
+@cindex unions with flexible array members
+@cindex unions with FAMs
+
+GCC permits a C99 flexible array member (FAM) to be in a union:
+
+@smallexample
+union with_fam @{
+  int a;
+  int b[];
+@};
+@end smallexample
+
+The size of the union is as if the flexiable array member were omitted
+except that it may have more trailing padding than the omission would imply.
+
+If all the members of a union are flexiable array member, the size of 
+such union is zero.
+
+@node Flexible Array Members alone in Structures
+@section Structures with only Flexible Array Members
+@cindex structures with only flexible array members
+@cindex structures with only FAMs
+
+GCC permits a C99 flexible array member (FAM) to be alone in a structure:
+
+@smallexample
+struct only_fam @{
+  int b[];
+@};
+@end smallexample
+
+The size of such structure gives the size zero.
+
 @node Variable Length
 @section Arrays of Variable Length
 @cindex variable-length arrays