--- a/ChangeLog	Mon Jun 13 08:37:24 2016 -0700
+++ b/ChangeLog	Mon Jun 13 11:17:03 2016 -0700
@@ -1,3 +1,14 @@
+2016-06-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+	xalloc-oversized: port to GCC 7; fewer warnings
+	GCC 7 will have a better way to deal with integer overflow.
+	Plus, fix a warnings problem reported by Tim Ruehsen in:
+	http://lists.gnu.org/archive/html/bug-gnulib/2016-06/msg00022.html
+	* lib/xalloc-oversized.h (__xalloc_oversized): New macro.
+	(xalloc_oversized): Use plain __builtin_mul_overflow if GCC 7 or later.
+	For GCC 5, use __xalloc_oversized if both args are constants,
+	or if pedantic.
+
 2016-06-08  Paul Eggert  <eggert@cs.ucla.edu>
 
 	regex: port to Sun C

--- a/lib/xalloc-oversized.h	Mon Jun 13 08:37:24 2016 -0700
+++ b/lib/xalloc-oversized.h	Mon Jun 13 11:17:03 2016 -0700
@@ -20,15 +20,13 @@
 
 #include <stddef.h>
 
+/* Default for (non-Clang) compilers that lack __has_builtin.  */
 #ifndef __has_builtin
 # define __has_builtin(x) 0
 #endif
 
-/* Return 1 if an array of N objects, each of size S, cannot exist due
-   to size arithmetic overflow.  S must be positive and N must be
-   nonnegative.  This is a macro, not a function, so that it
-   works correctly even when SIZE_MAX < N.
-
+/* True if N * S would overflow in a size calculation.
+   This expands to a constant expression if N and S are both constants.
    By gnulib convention, SIZE_MAX represents overflow in size
    calculations, so the conservative dividend to use here is
    SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
@@ -36,12 +34,38 @@
    sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
    exactly-SIZE_MAX allocations on such hosts; this avoids a test and
    branch when S is known to be 1.  */
-#if 5 <= __GNUC__ || __has_builtin (__builtin_mul_overflow)
+#define __xalloc_oversized(n, s) \
+    ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
+
+
+/* Return 1 if an array of N objects, each of size S, cannot exist due
+   to size arithmetic overflow.  S must be positive and N must be
+   nonnegative.  This is a macro, not a function, so that it
+   works correctly even when SIZE_MAX < N.  */
+
+/* GCC 7 __builtin_mul_overflow should easily compute this.  See:
+   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68120  */
+#if 7 <= __GNUC__
+# define xalloc_oversized(n, s) __builtin_mul_overflow (n, s, (size_t *) NULL)
+
+/* GCC 5 and Clang __builtin_mul_overflow needs a temporary, and
+   should be used only for non-constant operands, so that
+   xalloc_oversized is a constant expression if both arguments are.
+   Do not use this if pedantic, since pedantic GCC issues a diagnostic
+   for ({ ... }).  */
+#elif ((5 <= __GNUC__ \
+        || (__has_builtin (__builtin_mul_overflow) \
+            && __has_builtin (__builtin_constant_p))) \
+       && !__STRICT_ANSI__)
 # define xalloc_oversized(n, s) \
-    ({ size_t __xalloc_size; __builtin_mul_overflow (n, s, &__xalloc_size); })
+   (__builtin_constant_p (n) && __builtin_constant_p (s) \
+    ? __xalloc_oversized (n, s) \
+    : ({ size_t __xalloc_size; __builtin_mul_overflow (n, s, &__xalloc_size); }))
+
+/* Other compilers use integer division; this may be slower but is
+   more portable.  */
 #else
-# define xalloc_oversized(n, s) \
-    ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
+# define xalloc_oversized(n, s) __xalloc_oversized (n, s)
 #endif
 
 #endif /* !XALLOC_OVERSIZED_H_ */