]> Savannah Git Hosting - gnulib.git/commitdiff
flexmember: update comments again
authorPaul Eggert <eggert@cs.ucla.edu>
Sat, 25 May 2019 00:31:34 +0000 (17:31 -0700)
committerPaul Eggert <eggert@cs.ucla.edu>
Sat, 25 May 2019 00:32:40 +0000 (17:32 -0700)
* lib/flexmember.h, m4/flexmember.m4: Improve comments further.

ChangeLog
lib/flexmember.h
m4/flexmember.m4

index efa81e2ae573013a11506e135d5b82594780c720..2cd6145c7589bef2c5a8250fedaec76ff3cba566 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,8 @@
 2019-05-24  Paul Eggert  <eggert@cs.ucla.edu>
 
+       flexmember: update comments again
+       * lib/flexmember.h, m4/flexmember.m4: Improve comments further.
+
        flexmember: update comment
        * m4/flexmember.m4 (AC_C_FLEXIBLE_ARRAY_MEMBER): Improve comment.
 
index 8e79bce03f46ae0b97ecc39159c7a19976780f1d..431bec11ec964a9336265cf49c722e9357263042 100644 (file)
 # define FLEXALIGNOF(type) _Alignof (type)
 #endif
 
-/* Upper bound on the size of a struct of type TYPE with a flexible
-   array member named MEMBER that is followed by N bytes of other data.
-   This is not simply sizeof (TYPE) + N, since it may require
-   alignment on unusually picky C11 platforms, and
-   FLEXIBLE_ARRAY_MEMBER may be 1 on pre-C11 platforms.
+/* Yield a properly aligned upper bound on the size of a struct of
+   type TYPE with a flexible array member named MEMBER that is
+   followed by N bytes of other data.  The result is suitable as an
+   argument to malloc.  For example:
+
+     struct s { int n; char d[FLEXIBLE_ARRAY_MEMBER]; };
+     struct s *p = malloc (FLEXSIZEOF (struct s, d, n * sizeof (char)));
+
+   FLEXSIZEOF (TYPE, MEMBER, N) is not simply (sizeof (TYPE) + N),
+   since FLEXIBLE_ARRAY_MEMBER may be 1 on pre-C11 platforms.  Nor is
+   it simply (offsetof (TYPE, MEMBER) + N), as that might yield a size
+   that causes malloc to yield a pointer that is not properly aligned
+   for TYPE; for example, if sizeof (int) == alignof (int) == 4,
+   malloc (offsetof (struct s, d) + 3 * sizeof (char)) is equivalent
+   to malloc (7) and might yield a pointer that is not a multiple of 4
+   (which means the pointer is not properly aligned for struct s),
+   whereas malloc (FLEXSIZEOF (struct s, d, 3 * sizeof (char))) is
+   equivalent to malloc (8) and must yield a pointer that is a
+   multiple of 4.
+
    Yield a value less than N if and only if arithmetic overflow occurs.  */
 
 #define FLEXSIZEOF(type, member, n) \
index ef6373df299a958a7cc7ab01c9f2bd37ba054803..c245ab025f61eddc56a209f25a53ee38fad39e73 100644 (file)
@@ -34,16 +34,10 @@ AC_DEFUN([AC_C_FLEXIBLE_ARRAY_MEMBER],
     AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [],
       [Define to nothing if C supports flexible array members, and to
        1 if it does not.  That way, with a declaration like 'struct s
-       { int n; char d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack
+       { int n; short d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack
        can be used with pre-C99 compilers.
-       Use 'FLEXSIZEOF (struct s, d, N)' to calculate the size in bytes
-       of such a struct containing an N-element array, as both
-       'sizeof (struct s) + N * sizeof (char)' and
-       'offsetof (struct s, d) + N * sizeof (char)'
-       might compute a size that can cause malloc to align storage
-       improperly, even in C11.
-       Don't use 'offsetof (struct s, d@<:@0@:>@)', as this doesn't work with
-       MSVC and with C++ compilers.])
+       Use 'FLEXSIZEOF (struct s, d, N * sizeof (short))' to calculate
+       the size in bytes of such a struct containing an N-element array.])
   else
     AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [1])
   fi