[PATCH 1/3] Fix _GL_HAVE__STATIC_ASSERT typo

[PATCH 1/3] Fix _GL_HAVE__STATIC_ASSERT typo

[Paul Eggert]

* lib/verify.h (_Static_assert): For the FreeBSD workaround,
use _GL_HAVE__STATIC_ASSERT, not _GL_HAVE_STATIC_ASSERT.
---
 ChangeLog    | 6 ++++++
 lib/verify.h | 6 +++---
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index 31e05adbd..12231d97b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2019-05-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+	Fix _GL_HAVE__STATIC_ASSERT typo
+	* lib/verify.h (_Static_assert): For the FreeBSD workaround,
+	use _GL_HAVE__STATIC_ASSERT, not _GL_HAVE_STATIC_ASSERT.
+
 2019-05-05  Bruno Haible  <bruno@clisp.org>
 
 	wcwidth: Ensure width 1, not 2, for ambiguous characters.
diff --git a/lib/verify.h b/lib/verify.h
index 6930645a3..eccd7e201 100644
--- a/lib/verify.h
+++ b/lib/verify.h
@@ -32,18 +32,18 @@
    down we could also use it with other compilers, but since this
    affects only the quality of diagnostics, why bother?  */
 #if (4 < __GNUC__ + (6 <= __GNUC_MINOR__) \
-     && (201112L <= __STDC_VERSION__  || !defined __STRICT_ANSI__) \
+     && (201112L <= __STDC_VERSION__ || !defined __STRICT_ANSI__) \
      && !defined __cplusplus)
 # define _GL_HAVE__STATIC_ASSERT 1
 #endif
-#if (6 <= __GNUC__) && defined __cplusplus
+#if 6 <= __GNUC__ && defined __cplusplus
 # define _GL_HAVE_STATIC_ASSERT 1
 #endif
 
 /* FreeBSD 9.1 <sys/cdefs.h>, included by <stddef.h> and lots of other
    system headers, defines a conflicting _Static_assert that is no
    better than ours; override it.  */
-#ifndef _GL_HAVE_STATIC_ASSERT
+#ifndef _GL_HAVE__STATIC_ASSERT
 # include <stddef.h>
 # undef _Static_assert
 #endif
-- 
2.21.0

[PATCH 2/3] Support C2X and C++17 static_assert

[Paul Eggert]

C2X and C++17 finally added support for a simple, single-argument
‘static_assert’ that implements what the Gnulib ‘verify’ macro was
doing back in 2005.  Implement static_assert on older platforms.
The only remaining advantage of ‘verify’ is a shorter name.
* doc/posix-headers/assert.texi (assert.h):
* doc/verify.texi (Compile-time Assertions):
Modernize for C2X and C++17.
* lib/verify.h (_GL_HAVE__STATIC_ASSERT1, _GL_HAVE_STATIC_ASSERT1):
New macros.
(_GL_HAVE__STATIC_ASSERT): Remove.
(_GL_HAVE__STATIC_ASSERT): Rely more heavily on __STDC_VERSION__.
(_GL_VERIFY_TRUE, _GL_VERIFY_TYPE): Remove 2nd arg, the diagnostic
string.  All callers changed.
(_GL_VERIFY): Require 3 or more args, of which only the first 2
are used.  All callers changed.
(_Static_assert): Allow either 1 or 2 args, and define if
!_GL_HAVE__STATIC_ASSERT1 instead of defining if
!_GL_HAVE__STATIC_ASSERT.
(static_assert): Define if !_GL_HAVE_STATIC_ASSERT1 instead
of defining if !_GL_HAVE_STATIC_ASSERT.
(verify_expr, verify): Don’t bother trying to copy the expression
into the diagnostic, since 1-argument static_assert doesn’t.
(verify): Prefer 1-argument _Static_assert if it works.
* m4/assert_h.m4 (gl_ASSERT_H): Check for 1-argument static_assert.
---
 ChangeLog                     | 28 ++++++++++
 doc/posix-headers/assert.texi | 21 +++++---
 doc/verify.texi               | 15 +++---
 lib/verify.h                  | 97 +++++++++++++++++++----------------
 m4/assert_h.m4                |  2 +
 5 files changed, 105 insertions(+), 58 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index 12231d97b..760cde3c6 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,31 @@
+2019-05-09  Paul Eggert  <eggert@cs.ucla.edu>
+
+	Support C2X and C++17 static_assert
+	C2X and C++17 finally added support for a simple, single-argument
+	‘static_assert’ that implements what the Gnulib ‘verify’ macro was
+	doing back in 2005.  Implement static_assert on older platforms.
+	The only remaining advantage of ‘verify’ is a shorter name.
+	* doc/posix-headers/assert.texi (assert.h):
+	* doc/verify.texi (Compile-time Assertions):
+	Modernize for C2X and C++17.
+	* lib/verify.h (_GL_HAVE__STATIC_ASSERT1, _GL_HAVE_STATIC_ASSERT1):
+	New macros.
+	(_GL_HAVE__STATIC_ASSERT): Remove.
+	(_GL_HAVE__STATIC_ASSERT): Rely more heavily on __STDC_VERSION__.
+	(_GL_VERIFY_TRUE, _GL_VERIFY_TYPE): Remove 2nd arg, the diagnostic
+	string.  All callers changed.
+	(_GL_VERIFY): Require 3 or more args, of which only the first 2
+	are used.  All callers changed.
+	(_Static_assert): Allow either 1 or 2 args, and define if
+	!_GL_HAVE__STATIC_ASSERT1 instead of defining if
+	!_GL_HAVE__STATIC_ASSERT.
+	(static_assert): Define if !_GL_HAVE_STATIC_ASSERT1 instead
+	of defining if !_GL_HAVE_STATIC_ASSERT.
+	(verify_expr, verify): Don’t bother trying to copy the expression
+	into the diagnostic, since 1-argument static_assert doesn’t.
+	(verify): Prefer 1-argument _Static_assert if it works.
+	* m4/assert_h.m4 (gl_ASSERT_H): Check for 1-argument static_assert.
+
 2019-05-08  Paul Eggert  <eggert@cs.ucla.edu>
 
 	Fix _GL_HAVE__STATIC_ASSERT typo
diff --git a/doc/posix-headers/assert.texi b/doc/posix-headers/assert.texi
index 785a07aa9..fa99d3b88 100644
--- a/doc/posix-headers/assert.texi
+++ b/doc/posix-headers/assert.texi
@@ -5,29 +5,34 @@ POSIX specification:@* @url{http://www.opengroup.org/onlinepubs/9699919799/based
 
 Gnulib module: assert-h
 
-See also the Gnulib module @code{assert}.
+See also the Gnulib modules @code{assert} and @code{verify}.
 
 Portability problems fixed by Gnulib:
 @itemize
 @item
-The C11 and C++11 @code{static_assert}, and the C11
-@code{_Static_assert}, are not supported by many platforms.
-For example, GCC versions before 4.6.0 do not support @code{_Static_assert},
-and G++ versions through at least 4.6.0 do not support @code{static_assert}.
+On older platforms @code{static_assert} and @code{_Static_assert} do
+not allow the second string-literal argument to be omitted.  For
+example, GCC versions before 9.1 do not support the single-argument
+@code{static_assert} that was standardized by C2X and C++17.
+@item
+Even-older platforms do not support @code{static_assert} or
+@code{_Static_assert} at all.  For example, GCC versions before 4.6 do
+not support @code{_Static_assert}, and G++ versions before 4.3 do not
+support @code{static_assert}, which was standardized by C11 and C++11.
 @end itemize
 
 Portability problems not fixed by Gnulib:
 @itemize
 @item
-C11 @code{_Static_assert} and C++11 @code{static_assert}
+C @code{_Static_assert} and C++ @code{static_assert}
 are keywords that can be used without including @code{<assert.h>}.
 The Gnulib substitutes are macros that require including @code{<assert.h>}.
 @item
-The C11 @code{static_assert} and @code{_Static_assert} can also
+The C @code{static_assert} and @code{_Static_assert} can also
 be used within a @code{struct} or @code{union} specifier, in place of
 an ordinary declaration of a member of the struct or union.  The
 Gnulib substitute can be used only as an ordinary declaration.
 @item
-In C99, @code{assert} can be applied to any scalar expression.
+In C99 and later, @code{assert} can be applied to any scalar expression.
 In C89, the argument to @code{assert} is of type @code{int}.
 @end itemize
diff --git a/doc/verify.texi b/doc/verify.texi
index 3a92f2e05..65aede210 100644
--- a/doc/verify.texi
+++ b/doc/verify.texi
@@ -52,15 +52,18 @@ integer constant expression, then a compiler might reject a usage like
 @samp{verify (@var{V});} even when @var{V} is
 nonzero.
 
-Although the standard @code{assert} macro is a runtime test, C11
-specifies a builtin @code{_Static_assert (@var{V},
-@var{STRING-LITERAL})}, its @file{assert.h} header has a similar macro
-named @code{static_assert}, and C++11 has a similar
+Although the standard @code{assert} macro is a runtime test, C2X
+specifies a builtin @code{_Static_assert (@var{V})},
+its @file{assert.h} header has a similar macro
+named @code{static_assert}, and C++17 has a similar
 @code{static_assert} builtin.  These builtins and macros differ
 from @code{verify} in two major ways.  First, they can also be used
 within a @code{struct} or @code{union} specifier, in place of an
-ordinary member declaration.  Second, they require the programmer to
-specify a compile-time diagnostic as a string literal.
+ordinary member declaration.  Second, they allow the programmer to
+specify, as an optional second argument, a compile-time diagnostic as
+a string literal.  If your program is not intended to be portable to
+compilers that lack C2X or C++17 @code{static_assert}, the only
+advantage of @code{verify} is that its name is a bit shorter.
 
 The @file{verify.h} header defines one more macro, @code{assume
 (@var{E})}, which expands to an expression of type @code{void}
diff --git a/lib/verify.h b/lib/verify.h
index eccd7e201..d7e15bc8a 100644
--- a/lib/verify.h
+++ b/lib/verify.h
@@ -21,23 +21,31 @@
 #define _GL_VERIFY_H
 
 
-/* Define _GL_HAVE__STATIC_ASSERT to 1 if _Static_assert works as per C11.
-   This is supported by GCC 4.6.0 and later, in C mode, and its use
-   here generates easier-to-read diagnostics when verify (R) fails.
-
-   Define _GL_HAVE_STATIC_ASSERT to 1 if static_assert works as per C++11.
-   This is supported by GCC 6.1.0 and later, in C++ mode.
-
-   Use this only with GCC.  If we were willing to slow 'configure'
-   down we could also use it with other compilers, but since this
-   affects only the quality of diagnostics, why bother?  */
-#if (4 < __GNUC__ + (6 <= __GNUC_MINOR__) \
-     && (201112L <= __STDC_VERSION__ || !defined __STRICT_ANSI__) \
-     && !defined __cplusplus)
-# define _GL_HAVE__STATIC_ASSERT 1
-#endif
-#if 6 <= __GNUC__ && defined __cplusplus
-# define _GL_HAVE_STATIC_ASSERT 1
+/* Define _GL_HAVE__STATIC_ASSERT to 1 if _Static_assert (R, DIAGNOSTIC)
+   works as per C11.  This is supported by GCC 4.6.0 and later, in C
+   mode.
+
+   Define _GL_HAVE__STATIC_ASSERT1 to 1 if _Static_assert (R) works as
+   per C2X, and define _GL_HAVE_STATIC_ASSERT1 if static_assert (R)
+   works as per C++17.  This is supported by GCC 9.1 and later.
+
+   Support compilers claiming conformance to the relevant standard,
+   and also support GCC when not pedantic.  If we were willing to slow
+   'configure' down we could also use it with other compilers, but
+   since this affects only the quality of diagnostics, why bother?  */
+#ifndef __cplusplus
+# if (201112L <= __STDC_VERSION__ \
+      || (!defined __STRICT_ANSI__ && 4 < __GNUC__ + (6 <= __GNUC_MINOR__)))
+#  define _GL_HAVE__STATIC_ASSERT 1
+# endif
+# if (202000L <= __STDC_VERSION__ \
+      || (!defined __STRICT_ANSI__ && 9 <= __GNUC__))
+#  define _GL_HAVE__STATIC_ASSERT1 1
+# endif
+#else
+# if 201703L <= __cplusplus || 9 <= __GNUC__
+#  define _GL_HAVE_STATIC_ASSERT1 1
+# endif
 #endif
 
 /* FreeBSD 9.1 <sys/cdefs.h>, included by <stddef.h> and lots of other
@@ -167,11 +175,9 @@
 #define _GL_GENSYM(prefix) _GL_CONCAT (prefix, _GL_COUNTER)
 
 /* Verify requirement R at compile-time, as an integer constant expression
-   that returns 1.  If R is false, fail at compile-time, preferably
-   with a diagnostic that includes the string-literal DIAGNOSTIC.  */
+   that returns 1.  If R is false, fail at compile-time.  */
 
-#define _GL_VERIFY_TRUE(R, DIAGNOSTIC) \
-   (!!sizeof (_GL_VERIFY_TYPE (R, DIAGNOSTIC)))
+#define _GL_VERIFY_TRUE(R) (!!sizeof (_GL_VERIFY_TYPE (R)))
 
 #ifdef __cplusplus
 # if !GNULIB_defined_struct__gl_verify_type
@@ -181,40 +187,43 @@ template <int w>
   };
 #  define GNULIB_defined_struct__gl_verify_type 1
 # endif
-# define _GL_VERIFY_TYPE(R, DIAGNOSTIC) \
-    _gl_verify_type<(R) ? 1 : -1>
-#elif defined _GL_HAVE__STATIC_ASSERT
-# define _GL_VERIFY_TYPE(R, DIAGNOSTIC) \
+# define _GL_VERIFY_TYPE(R) _gl_verify_type<(R) ? 1 : -1>
+#elif defined _GL_HAVE__STATIC_ASSERT1
+# define _GL_VERIFY_TYPE(R) \
     struct {                                   \
-      _Static_assert (R, DIAGNOSTIC);          \
+      _Static_assert (R); \
       int _gl_dummy;                          \
     }
 #else
-# define _GL_VERIFY_TYPE(R, DIAGNOSTIC) \
+# define _GL_VERIFY_TYPE(R)                                             \
     struct { unsigned int _gl_verify_error_if_negative: (R) ? 1 : -1; }
 #endif
 
 /* Verify requirement R at compile-time, as a declaration without a
-   trailing ';'.  If R is false, fail at compile-time, preferably
-   with a diagnostic that includes the string-literal DIAGNOSTIC.
+   trailing ';'.  If R is false, fail at compile-time.
+
+   This macro requires three or more arguments but uses at most the first
+   two, so that the _Static_assert macro optionally defined below supports
+   both the C11 two-argument syntax and the C2X one-argument syntax.
 
    Unfortunately, unlike C11, this implementation must appear as an
    ordinary declaration, and cannot appear inside struct { ... }.  */
 
-#ifdef _GL_HAVE__STATIC_ASSERT
-# define _GL_VERIFY _Static_assert
+#if defined _GL_HAVE__STATIC_ASSERT
+# define _GL_VERIFY(R, DIAGNOSTIC, ...) _Static_assert (R, DIAGNOSTIC)
 #else
-# define _GL_VERIFY(R, DIAGNOSTIC)				       \
+# define _GL_VERIFY(R, DIAGNOSTIC, ...)                                \
     extern int (*_GL_GENSYM (_gl_verify_function) (void))	       \
-      [_GL_VERIFY_TRUE (R, DIAGNOSTIC)]
+      [_GL_VERIFY_TRUE (R)]
 #endif
 
 /* _GL_STATIC_ASSERT_H is defined if this code is copied into assert.h.  */
 #ifdef _GL_STATIC_ASSERT_H
-# if !defined _GL_HAVE__STATIC_ASSERT && !defined _Static_assert
-#  define _Static_assert(R, DIAGNOSTIC) _GL_VERIFY (R, DIAGNOSTIC)
+# if !defined _GL_HAVE__STATIC_ASSERT1 && !defined _Static_assert
+#  define _Static_assert(...) \
+     _GL_VERIFY (__VA_ARGS__, "static assertion failed", -)
 # endif
-# if !defined _GL_HAVE_STATIC_ASSERT && !defined static_assert
+# if !defined _GL_HAVE_STATIC_ASSERT1 && !defined static_assert
 #  define static_assert _Static_assert /* C11 requires this #define.  */
 # endif
 #endif
@@ -235,22 +244,22 @@ template <int w>
 
    verify_true is obsolescent; please use verify_expr instead.  */
 
-#define verify_true(R) _GL_VERIFY_TRUE (R, "verify_true (" #R ")")
+#define verify_true(R) _GL_VERIFY_TRUE (R)
 
 /* Verify requirement R at compile-time.  Return the value of the
    expression E.  */
 
-#define verify_expr(R, E) \
-   (_GL_VERIFY_TRUE (R, "verify_expr (" #R ", " #E ")") ? (E) : (E))
+#define verify_expr(R, E) (_GL_VERIFY_TRUE (R) ? (E) : (E))
 
 /* Verify requirement R at compile-time, as a declaration without a
-   trailing ';'.  */
+   trailing ';'.  verify (R) acts like static_assert (R) except that
+   it is portable to C11/C++14 and earlier, and its name is shorter
+   and may be more convenient.  */
 
-#ifdef __GNUC__
-# define verify(R) _GL_VERIFY (R, "verify (" #R ")")
+#ifdef _GL_HAVE__STATIC_ASSERT1
+# define verify(R) _Static_assert (R)
 #else
-/* PGI barfs if R is long.  Play it safe.  */
-# define verify(R) _GL_VERIFY (R, "verify (...)")
+# define verify(R) _GL_VERIFY (R, "verify (...)", -)
 #endif
 
 #ifndef __has_builtin
diff --git a/m4/assert_h.m4 b/m4/assert_h.m4
index cf11bae6a..ee278b206 100644
--- a/m4/assert_h.m4
+++ b/m4/assert_h.m4
@@ -14,9 +14,11 @@ AC_DEFUN([gl_ASSERT_H],
        [AC_LANG_PROGRAM(
           [[#include <assert.h>
             static_assert (2 + 2 == 4, "arithmetic doesn't work");
+            static_assert (2 + 2 == 4);
           ]],
           [[
             static_assert (sizeof (char) == 1, "sizeof doesn't work");
+            static_assert (sizeof (char) == 1);
           ]])],
        [gl_cv_static_assert=yes],
        [gl_cv_static_assert=no])])
-- 
2.21.0

[PATCH 3/3] verify: remove verify_true

[Paul Eggert]

* NEWS: Mention this.
* lib/verify.h (verify_true): Remove.
* tests/test-verify.c (item): Test verify_expr, not verify_true.
---
 ChangeLog           |  5 +++++
 NEWS                |  2 ++
 lib/verify.h        | 13 +++----------
 tests/test-verify.c |  2 +-
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index 760cde3c6..10c513cb6 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,10 @@
 2019-05-09  Paul Eggert  <eggert@cs.ucla.edu>
 
+	verify: remove verify_true
+	* NEWS: Mention this.
+	* lib/verify.h (verify_true): Remove.
+	* tests/test-verify.c (item): Test verify_expr, not verify_true.
+
 	Support C2X and C++17 static_assert
 	C2X and C++17 finally added support for a simple, single-argument
 	‘static_assert’ that implements what the Gnulib ‘verify’ macro was
diff --git a/NEWS b/NEWS
index 77b9f24a7..2655d7fc9 100644
--- a/NEWS
+++ b/NEWS
@@ -55,6 +55,8 @@ User visible incompatible changes
 
 Date        Modules         Changes
 
+2019-05-90  verify          verify_true (deprecated 2011-06-15) is removed.
+
 2019-02-02  c-strtod        This and related modules no longer define
                             the HAVE_C99_STRTOLD macro.  Programs requiring
                             standard strtold should use the strtold module.
diff --git a/lib/verify.h b/lib/verify.h
index d7e15bc8a..f8e4eff02 100644
--- a/lib/verify.h
+++ b/lib/verify.h
@@ -149,9 +149,9 @@
      which do not support _Static_assert, also do not warn about the
      last declaration mentioned above.
 
-   * GCC warns if -Wnested-externs is enabled and verify() is used
+   * GCC warns if -Wnested-externs is enabled and 'verify' is used
      within a function body; but inside a function, you can always
-     arrange to use verify_expr() instead.
+     arrange to use verify_expr instead.
 
    * In C++, any struct definition inside sizeof is invalid.
      Use a template type to work around the problem.  */
@@ -235,17 +235,10 @@ template <int w>
    assert (R), there is no run-time overhead.
 
    There are two macros, since no single macro can be used in all
-   contexts in C.  verify_true (R) is for scalar contexts, including
+   contexts in C.  verify_expr (R, E) is for scalar contexts, including
    integer constant expression contexts.  verify (R) is for declaration
    contexts, e.g., the top level.  */
 
-/* Verify requirement R at compile-time, as an integer constant expression.
-   Return 1.  This is equivalent to verify_expr (R, 1).
-
-   verify_true is obsolescent; please use verify_expr instead.  */
-
-#define verify_true(R) _GL_VERIFY_TRUE (R)
-
 /* Verify requirement R at compile-time.  Return the value of the
    expression E.  */
 
diff --git a/tests/test-verify.c b/tests/test-verify.c
index e677d8aff..0afbcabde 100644
--- a/tests/test-verify.c
+++ b/tests/test-verify.c
@@ -39,7 +39,7 @@ verify (1 == 1); verify (1 == 1); /* should be ok */
 
 enum
 {
-  item = verify_true (1 == 1) * 0 + 17 /* should be ok */
+  item = verify_expr (1 == 1, 10) * 0 + 17 /* should be ok */
 };
 
 static int
-- 
2.21.0

Re: [PATCH 3/3] verify: remove verify_true

[Bruno Haible]

Hi Paul,

>  2019-05-09  Paul Eggert  <eggert@cs.ucla.edu>
>  
> +	verify: remove verify_true
> +	* NEWS: Mention this.
> +	* lib/verify.h (verify_true): Remove.
> +	* tests/test-verify.c (item): Test verify_expr, not verify_true.
> +

As a consequence of this change, the test-verify.c file does not compile
any more on AIX 7.1 with xlc:

  xlc: 1501-230 (S) Internal compiler error; please contact your Service Representative. For more information visit:
  http://www.ibm.com/support/docview.wss?uid=swg21110810

The machine is gcc111.fsffrance.org.

The compiler version is
         IBM XL C for AIX, V12.1 (5765-J01, 5725-C71)
         
         Copyright IBM Corp. 1991, 2012 and by others.
         All Rights Reserved.
         US Government Users Restricted Rights - 
         Use, duplication or disclosure restricted by 
         GSA ADP Schedule Contract with IBM Corp.
         -----------------------------------------
         Version: 12.01.0000.0000
         Version: 12.01.0000.0000
         Driver 120315
         120321
         Compiler Services 120315
         120203
         Date: Wed Mar 21 21:39:51 EDT 2012
         -----------------------------------------

The following compiles fine:

enum
{
  item = verify_true (1 == 1) * 0 + 17 /* should be ok */
};
int item1 = verify_expr (1 == 1, 10) * 0 + 17;
const int item2 = verify_expr (1 == 1, 10) * 0 + 17;

But the following does not:

enum
{
  item = verify_expr (1 == 1, 10) * 0 + 17 /* should be ok */
};

So, it's apparently the use of verify_expr in an enum value.
We had a similar bug with HP-UX cc in the past.

Do you see other options than
  (a) reintroduce verify_true and check that it's usable in enum.
  (b) relax the check and only check that it's usable as a static initializer.
?

Bruno

Re: [PATCH 3/3] verify: remove verify_true

[Paul Eggert]

[-- Attachment #1: Type: text/plain, Size: 863 bytes --]

On 6/18/19 3:26 PM, Bruno Haible wrote:
> Do you see other options than
>    (a) reintroduce verify_true and check that it's usable in enum.
>    (b) relax the check and only check that it's usable as a static initializer.

Also (c) relax the check so that the buggy compiler passes but continue 
to check that verify_expr is usable in an enum. Sort of a hack, but 
there it is - it's arguably good enough since the (now-removed) 
verify_true macro can also make that buggy compiler crash if we 
complicate the test a bit. I installed the attached, which worked for me 
on gcc111.

>           Version: 12.01.0000.0000
Quite possibly that compiler bug is fixed in xlc by now; IBM says the 
current xlc 12.1 release is 12.1.0.21 dated January 2019. I don't know 
who's maintaining gcc111 though.

https://www-01.ibm.com/support/docview.wss?uid=swg27038605#121021


[-- Attachment #2: 0001-verify-tests-work-around-xlc-bug.patch --]
[-- Type: text/x-patch, Size: 1430 bytes --]

From 75acd2ec14fcc0b0695e8a108167562d65417f79 Mon Sep 17 00:00:00 2001
From: Paul Eggert <eggert@cs.ucla.edu>
Date: Tue, 18 Jun 2019 17:41:46 -0700
Subject: [PATCH] verify-tests: work around xlc bug

Problem reported by Bruno Haible in:
https://lists.gnu.org/r/bug-gnulib/2019-06/msg00049.html
* tests/test-verify.c (item): Move the arithmetic inside the
verify_expr, to avoid tickling a bug in IBM AIX xlc V12.1.
---
 ChangeLog           | 8 ++++++++
 tests/test-verify.c | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/ChangeLog b/ChangeLog
index 3ab71a3d9..c76ac8852 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2019-06-18  Paul Eggert  <eggert@cs.ucla.edu>
+
+	verify-tests: work around xlc bug
+	Problem reported by Bruno Haible in:
+	https://lists.gnu.org/r/bug-gnulib/2019-06/msg00049.html
+	* tests/test-verify.c (item): Move the arithmetic inside the
+	verify_expr, to avoid tickling a bug in IBM AIX xlc V12.1.
+
 2019-06-16  Bruno Haible  <bruno@clisp.org>
 
 	Restore Emacs time-stamp hook applicability.
diff --git a/tests/test-verify.c b/tests/test-verify.c
index 0afbcabde..98983c3c4 100644
--- a/tests/test-verify.c
+++ b/tests/test-verify.c
@@ -39,7 +39,7 @@ verify (1 == 1); verify (1 == 1); /* should be ok */
 
 enum
 {
-  item = verify_expr (1 == 1, 10) * 0 + 17 /* should be ok */
+  item = verify_expr (1 == 1, 10 * 0 + 17) /* should be ok */
 };
 
 static int
-- 
2.21.0