# HG changeset patch
# User Paul Eggert <eggert@cs.ucla.edu>
# Date 1424484587 28800
# Node ID b941bb9e9efb18b25c6c1219e7ad41cea47ac5bc
# Parent  d4306001742a977429cb468c3cd506e2f3f0b5b0
printf, isinf, etc.: noncanonical != NaN

Do not require that isinf, printf, etc. treat noncanonical
values as NaNs.  Instead, require only that they do not crash.
Problem reported by Joseph Myers in:
https://sourceware.org/ml/libc-alpha/2015-02/msg00244.html
* doc/posix-functions/dprintf.texi (dprintf):
* doc/posix-functions/fprintf.texi (fprintf):
* doc/posix-functions/isfinite.texi (isfinite):
* doc/posix-functions/isinf.texi (isinf):
* doc/posix-functions/isnan.texi (isnan):
* doc/posix-functions/printf.texi (printf):
* doc/posix-functions/snprintf.texi (snprintf):
* doc/posix-functions/sprintf.texi (sprintf):
* doc/posix-functions/vdprintf.texi (vdprintf):
* doc/posix-functions/vfprintf.texi (vfprintf):
* doc/posix-functions/vprintf.texi (vprintf):
* doc/posix-functions/vsnprintf.texi (vsnprintf):
* doc/posix-functions/vsprintf.texi (vsprintf):
Document this.
* m4/isfinite.m4 (gl_ISFINITEL_WORKS):
* m4/isinf.m4 (gl_ISINFL_WORKS):
* m4/isnanl.m4 (gl_FUNC_ISNANL_WORKS):
* m4/printf.m4 (gl_PRINTF_INFINITE_LONG_DOUBLE):
* tests/test-isfinite.c (test_isfinitel):
* tests/test-isinf.c (test_isinfl):
* tests/test-isnan.c (test_long_double):
* tests/test-isnanl.h (main):
* tests/test-snprintf-posix.h (test_function):
* tests/test-sprintf-posix.h (test_function):
* tests/test-vasnprintf-posix.c (test_function):
* tests/test-vasprintf-posix.c (test_function):
o	Test only that noncanonical values do not cause crashes, not that
they are treated as NaNs.  In some cases this means a larger
output buffer is needed.

diff --git a/ChangeLog b/ChangeLog
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,40 @@
+2015-02-20  Paul Eggert  <eggert@cs.ucla.edu>
+
+	printf, isinf, etc.: noncanonical != NaN
+	Do not require that isinf, printf, etc. treat noncanonical
+	values as NaNs.  Instead, require only that they do not crash.
+	Problem reported by Joseph Myers in:
+	https://sourceware.org/ml/libc-alpha/2015-02/msg00244.html
+	* doc/posix-functions/dprintf.texi (dprintf):
+	* doc/posix-functions/fprintf.texi (fprintf):
+	* doc/posix-functions/isfinite.texi (isfinite):
+	* doc/posix-functions/isinf.texi (isinf):
+	* doc/posix-functions/isnan.texi (isnan):
+	* doc/posix-functions/printf.texi (printf):
+	* doc/posix-functions/snprintf.texi (snprintf):
+	* doc/posix-functions/sprintf.texi (sprintf):
+	* doc/posix-functions/vdprintf.texi (vdprintf):
+	* doc/posix-functions/vfprintf.texi (vfprintf):
+	* doc/posix-functions/vprintf.texi (vprintf):
+	* doc/posix-functions/vsnprintf.texi (vsnprintf):
+	* doc/posix-functions/vsprintf.texi (vsprintf):
+	Document this.
+	* m4/isfinite.m4 (gl_ISFINITEL_WORKS):
+	* m4/isinf.m4 (gl_ISINFL_WORKS):
+	* m4/isnanl.m4 (gl_FUNC_ISNANL_WORKS):
+	* m4/printf.m4 (gl_PRINTF_INFINITE_LONG_DOUBLE):
+	* tests/test-isfinite.c (test_isfinitel):
+	* tests/test-isinf.c (test_isinfl):
+	* tests/test-isnan.c (test_long_double):
+	* tests/test-isnanl.h (main):
+	* tests/test-snprintf-posix.h (test_function):
+	* tests/test-sprintf-posix.h (test_function):
+	* tests/test-vasnprintf-posix.c (test_function):
+	* tests/test-vasprintf-posix.c (test_function):
+o	Test only that noncanonical values do not cause crashes, not that
+	they are treated as NaNs.  In some cases this means a larger
+	output buffer is needed.
+
 2015-02-20  Jaroslav Skarvada  <jskarvad@redhat.com>
 
 	fts: remove redundant close() (trivial)
diff --git a/doc/posix-functions/dprintf.texi b/doc/posix-functions/dprintf.texi
--- a/doc/posix-functions/dprintf.texi
+++ b/doc/posix-functions/dprintf.texi
@@ -17,10 +17,6 @@
 Portability problems fixed by Gnulib module @code{dprintf-posix}:
 @itemize
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6.
@@ -33,6 +29,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/fprintf.texi b/doc/posix-functions/fprintf.texi
--- a/doc/posix-functions/fprintf.texi
+++ b/doc/posix-functions/fprintf.texi
@@ -20,10 +20,6 @@
 incorrect result on some platforms:
 AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
@@ -91,6 +87,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/isfinite.texi b/doc/posix-functions/isfinite.texi
--- a/doc/posix-functions/isfinite.texi
+++ b/doc/posix-functions/isfinite.texi
@@ -15,12 +15,6 @@
 This macro incorrectly yields true for some @samp{double} arguments, on some
 platforms:
 Linux/ia64 (signalling NaNs).
-@item
-This macro incorrectly yields true for some @samp{long double} arguments, on
-some platforms:
-x86 (pseudo-zeroes, unnormalized numbers, pseudo-denormals),
-x86_64 (pseudo-denormals),
-ia64 (pseudo-NaN, pseudo-Infinity, pseudo-zeroes, unnormalized numbers, pseudo-denormals).
 @end itemize
 
 Portability problems not fixed by Gnulib:
@@ -28,4 +22,8 @@
 @item
 It is implementation-dependent whether @code{isfinite} raises an
 exception given a signaling NaN operand.
+@item
+This macro returns an unspecified result when given noncanonical values
+such as unnormalized numbers, pseudo-denormals, pseudo-NaNs,
+pseudo-Infinities, and pseudo-zeroes.
 @end itemize
diff --git a/doc/posix-functions/isinf.texi b/doc/posix-functions/isinf.texi
--- a/doc/posix-functions/isinf.texi
+++ b/doc/posix-functions/isinf.texi
@@ -11,12 +11,12 @@
 @item
 This macro is missing on some platforms:
 AIX 5.1, IRIX 6.5, OSF/1 5.1, Solaris 11 2011-11.
-@item
-This macro incorrectly yields true for some @samp{long double} arguments, on
-some platforms:
-OpenBSD 4.9/x86 (pseudo-Infinity).
 @end itemize
 
 Portability problems not fixed by Gnulib:
 @itemize
+@item
+This macro returns an unspecified result when given noncanonical values
+such as unnormalized numbers, pseudo-denormals, pseudo-NaNs,
+pseudo-Infinities, and pseudo-zeroes.
 @end itemize
diff --git a/doc/posix-functions/isnan.texi b/doc/posix-functions/isnan.texi
--- a/doc/posix-functions/isnan.texi
+++ b/doc/posix-functions/isnan.texi
@@ -19,17 +19,12 @@
 IRIX 6.5, OSF/1 5.1 with gcc, Solaris 11 2011-11.
 @item
 On IRIX 6.5 with @code{cc}, @code{isnan} does not recognize some NaNs.
-@item
-On NetBSD/i386 and glibc/ia64, @code{isnan} does not recognize some
-forms of NaNs, such as pseudo-NaNs, pseudo-Infinities, and
-unnormalized numbers.
-@item
-On i686 and @var{x}86-64, @code{__builtin_isnanl} (and thus
-@code{isnan} implementations based on it) in GCC 4.0 and later does
-not recognize pseudo-denormals as NaNs, and similarly for
-pseudo-zeroes, unnormalized numbers, and pseudo-denormals on ia64.
 @end itemize
 
 Portability problems not fixed by Gnulib:
 @itemize
+@item
+This macro returns an unspecified result when given noncanonical values
+such as unnormalized numbers, pseudo-denormals, pseudo-NaNs,
+pseudo-Infinities, and pseudo-zeroes.
 @end itemize
diff --git a/doc/posix-functions/printf.texi b/doc/posix-functions/printf.texi
--- a/doc/posix-functions/printf.texi
+++ b/doc/posix-functions/printf.texi
@@ -20,10 +20,6 @@
 incorrect result on some platforms:
 AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
@@ -91,6 +87,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/snprintf.texi b/doc/posix-functions/snprintf.texi
--- a/doc/posix-functions/snprintf.texi
+++ b/doc/posix-functions/snprintf.texi
@@ -39,10 +39,6 @@
 incorrect result on some platforms:
 AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
@@ -99,6 +95,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/sprintf.texi b/doc/posix-functions/sprintf.texi
--- a/doc/posix-functions/sprintf.texi
+++ b/doc/posix-functions/sprintf.texi
@@ -20,10 +20,6 @@
 incorrect result on some platforms:
 AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
@@ -74,6 +70,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/vdprintf.texi b/doc/posix-functions/vdprintf.texi
--- a/doc/posix-functions/vdprintf.texi
+++ b/doc/posix-functions/vdprintf.texi
@@ -24,10 +24,6 @@
 printf of @samp{long double} numbers is unsupported on some platforms:
 BeOS.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, BeOS.
@@ -47,6 +43,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/vfprintf.texi b/doc/posix-functions/vfprintf.texi
--- a/doc/posix-functions/vfprintf.texi
+++ b/doc/posix-functions/vfprintf.texi
@@ -20,10 +20,6 @@
 incorrect result on some platforms:
 AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
@@ -91,6 +87,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/vprintf.texi b/doc/posix-functions/vprintf.texi
--- a/doc/posix-functions/vprintf.texi
+++ b/doc/posix-functions/vprintf.texi
@@ -20,10 +20,6 @@
 incorrect result on some platforms:
 AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
@@ -91,6 +87,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/vsnprintf.texi b/doc/posix-functions/vsnprintf.texi
--- a/doc/posix-functions/vsnprintf.texi
+++ b/doc/posix-functions/vsnprintf.texi
@@ -39,10 +39,6 @@
 incorrect result on some platforms:
 AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
@@ -96,6 +92,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/doc/posix-functions/vsprintf.texi b/doc/posix-functions/vsprintf.texi
--- a/doc/posix-functions/vsprintf.texi
+++ b/doc/posix-functions/vsprintf.texi
@@ -20,10 +20,6 @@
 incorrect result on some platforms:
 AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
 @item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
 This function does not support the @samp{a} and @samp{A} directives on some
 platforms:
 glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
@@ -74,6 +70,10 @@
 Portability problems not fixed by Gnulib:
 @itemize
 @item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
 When formatting an integer with grouping flag, this function inserts thousands
 separators even in the "C" locale on some platforms:
 NetBSD 5.1.
diff --git a/m4/isfinite.m4 b/m4/isfinite.m4
--- a/m4/isfinite.m4
+++ b/m4/isfinite.m4
@@ -1,4 +1,4 @@
-# isfinite.m4 serial 14
+# isfinite.m4 serial 15
 dnl Copyright (C) 2007-2015 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -34,13 +34,8 @@
   AC_SUBST([ISFINITE_LIBM])
 ])
 
-dnl Test whether isfinite() on 'long double' recognizes all numbers which are
-dnl neither finite nor infinite. This test fails e.g. on i686, x86_64, ia64,
-dnl because of
-dnl - pseudo-denormals on x86_64,
-dnl - pseudo-zeroes, unnormalized numbers, and pseudo-denormals on i686,
-dnl - pseudo-NaN, pseudo-Infinity, pseudo-zeroes, unnormalized numbers, and
-dnl   pseudo-denormals on ia64.
+dnl Test whether isfinite() on 'long double' recognizes all canonical values
+dnl which are neither finite nor infinite.
 AC_DEFUN([gl_ISFINITEL_WORKS],
 [
   AC_REQUIRE([AC_PROG_CC])
@@ -114,52 +109,41 @@
     if (isfinite (x.value))
       result |= 2;
   }
-  /* The isfinite macro should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* isfinite should return something even for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    if (isfinite (x.value))
+    if (isfinite (x.value) && !isfinite (x.value))
       result |= 4;
   }
   { /* Pseudo-Infinity.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    if (isfinite (x.value))
+    if (isfinite (x.value) && !isfinite (x.value))
       result |= 8;
   }
   { /* Pseudo-Zero.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    if (isfinite (x.value))
+    if (isfinite (x.value) && !isfinite (x.value))
       result |= 16;
   }
   { /* Unnormalized number.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    if (isfinite (x.value))
+    if (isfinite (x.value) && !isfinite (x.value))
       result |= 32;
   }
   { /* Pseudo-Denormal.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    if (isfinite (x.value))
+    if (isfinite (x.value) && !isfinite (x.value))
       result |= 64;
   }
 #endif
 
   return result;
 }]])], [gl_cv_func_isfinitel_works=yes], [gl_cv_func_isfinitel_works=no],
-      [case "$host_cpu" in
-                               # Guess no on ia64, x86_64, i386.
-         ia64 | x86_64 | i*86) gl_cv_func_isfinitel_works="guessing no";;
-         *)                    gl_cv_func_isfinitel_works="guessing yes";;
-       esac
-      ])
+      [gl_cv_func_isfinitel_works="guessing yes"])
     ])
 ])
diff --git a/m4/isinf.m4 b/m4/isinf.m4
--- a/m4/isinf.m4
+++ b/m4/isinf.m4
@@ -1,4 +1,4 @@
-# isinf.m4 serial 10
+# isinf.m4 serial 11
 dnl Copyright (C) 2007-2015 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -37,13 +37,8 @@
 
 dnl Test whether isinf() works:
 dnl 1) Whether it correctly returns false for LDBL_MAX.
-dnl 2) Whether on 'long double' recognizes all numbers which are neither
-dnl    finite nor infinite. This test fails on OpenBSD/x86, but could also
-dnl    fail e.g. on i686, x86_64, ia64, because of
-dnl    - pseudo-denormals on x86_64,
-dnl    - pseudo-zeroes, unnormalized numbers, and pseudo-denormals on i686,
-dnl    - pseudo-NaN, pseudo-Infinity, pseudo-zeroes, unnormalized numbers, and
-dnl      pseudo-denormals on ia64.
+dnl 2) Whether on 'long double' recognizes all canonical values which are
+dnl    infinite.
 AC_DEFUN([gl_ISINFL_WORKS],
 [
   AC_REQUIRE([AC_PROG_CC])
@@ -121,55 +116,41 @@
     if (isinf (x.value))
       result |= 2;
   }
-  /* The isinf macro should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* isinf should return something even for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    if (isinf (x.value))
+    if (isinf (x.value) && !isinf (x.value))
       result |= 4;
   }
   { /* Pseudo-Infinity.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    if (isinf (x.value))
+    if (isinf (x.value) && !isinf (x.value))
       result |= 8;
   }
   { /* Pseudo-Zero.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    if (isinf (x.value))
+    if (isinf (x.value) && !isinf (x.value))
       result |= 16;
   }
   { /* Unnormalized number.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    if (isinf (x.value))
+    if (isinf (x.value) && !isinf (x.value))
       result |= 32;
   }
   { /* Pseudo-Denormal.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    if (isinf (x.value))
+    if (isinf (x.value) && !isinf (x.value))
       result |= 64;
   }
 #endif
 
   return result;
 }]])], [gl_cv_func_isinfl_works=yes], [gl_cv_func_isinfl_works=no],
-      [
-       case "$host" in
-           # Guess no on OpenBSD ia64, x86_64, i386.
-         ia64-*-openbsd* | x86_64-*-openbsd* | i*86-*-openbsd*)
-            gl_cv_func_isinfl_works="guessing no";;
-         *)
-            gl_cv_func_isinfl_works="guessing yes";;
-       esac
-      ])
+      [gl_cv_func_isinfl_works="guessing yes"])
     ])
 ])
diff --git a/m4/isnanl.m4 b/m4/isnanl.m4
--- a/m4/isnanl.m4
+++ b/m4/isnanl.m4
@@ -1,4 +1,4 @@
-# isnanl.m4 serial 18
+# isnanl.m4 serial 19
 dnl Copyright (C) 2007-2015 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -108,11 +108,8 @@
     ])
 ])
 
-dnl Test whether isnanl() recognizes all numbers which are neither finite nor
-dnl infinite. This test fails e.g. on NetBSD/i386 and on glibc/ia64.
-dnl Also, the GCC >= 4.0 built-in __builtin_isnanl does not pass the tests
-dnl - for pseudo-denormals on i686 and x86_64,
-dnl - for pseudo-zeroes, unnormalized numbers, and pseudo-denormals on ia64.
+dnl Test whether isnanl() recognizes all canonical numbers which are neither
+dnl finite nor infinite.
 AC_DEFUN([gl_FUNC_ISNANL_WORKS],
 [
   AC_REQUIRE([AC_PROG_CC])
@@ -197,41 +194,35 @@
     if (!isnanl (x.value))
       result |= 2;
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* isnanl should return something even for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    if (!isnanl (x.value))
+    if (isnanl (x.value) && !isnanl (x.value))
       result |= 4;
   }
   { /* Pseudo-Infinity.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    if (!isnanl (x.value))
+    if (isnanl (x.value) && !isnanl (x.value))
       result |= 8;
   }
   { /* Pseudo-Zero.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    if (!isnanl (x.value))
+    if (isnanl (x.value) && !isnanl (x.value))
       result |= 16;
   }
   { /* Unnormalized number.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    if (!isnanl (x.value))
+    if (isnanl (x.value) && !isnanl (x.value))
       result |= 32;
   }
   { /* Pseudo-Denormal.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    if (!isnanl (x.value))
+    if (isnanl (x.value) && !isnanl (x.value))
       result |= 64;
   }
 #endif
@@ -240,16 +231,6 @@
 }]])],
         [gl_cv_func_isnanl_works=yes],
         [gl_cv_func_isnanl_works=no],
-        [case "$host_cpu" in
-                                 # Guess no on ia64, x86_64, i386.
-           ia64 | x86_64 | i*86) gl_cv_func_isnanl_works="guessing no";;
-           *)
-             case "$host_os" in
-               netbsd*) gl_cv_func_isnanl_works="guessing no";;
-               *)       gl_cv_func_isnanl_works="guessing yes";;
-             esac
-             ;;
-         esac
-        ])
+        [gl_cv_func_isnanl_works="guessing yes"])
     ])
 ])
diff --git a/m4/printf.m4 b/m4/printf.m4
--- a/m4/printf.m4
+++ b/m4/printf.m4
@@ -1,4 +1,4 @@
-# printf.m4 serial 51
+# printf.m4 serial 52
 dnl Copyright (C) 2003, 2007-2015 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -365,66 +365,51 @@
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    if (sprintf (buf, "%Lf", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lf", x.value) <= 0)
       result |= 4;
-    if (sprintf (buf, "%Le", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Le", x.value) <= 0)
       result |= 4;
-    if (sprintf (buf, "%Lg", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lg", x.value) <= 0)
       result |= 4;
   }
   { /* Pseudo-Infinity.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    if (sprintf (buf, "%Lf", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lf", x.value) <= 0)
       result |= 8;
-    if (sprintf (buf, "%Le", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Le", x.value) <= 0)
       result |= 8;
-    if (sprintf (buf, "%Lg", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lg", x.value) <= 0)
       result |= 8;
   }
   { /* Pseudo-Zero.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    if (sprintf (buf, "%Lf", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lf", x.value) <= 0)
       result |= 16;
-    if (sprintf (buf, "%Le", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Le", x.value) <= 0)
       result |= 16;
-    if (sprintf (buf, "%Lg", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lg", x.value) <= 0)
       result |= 16;
   }
   { /* Unnormalized number.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    if (sprintf (buf, "%Lf", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lf", x.value) <= 0)
       result |= 32;
-    if (sprintf (buf, "%Le", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Le", x.value) <= 0)
       result |= 32;
-    if (sprintf (buf, "%Lg", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lg", x.value) <= 0)
       result |= 32;
   }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    if (sprintf (buf, "%Lf", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lf", x.value) <= 0)
       result |= 64;
-    if (sprintf (buf, "%Le", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Le", x.value) <= 0)
       result |= 64;
-    if (sprintf (buf, "%Lg", x.value) < 0
-        || !strisnan (buf, 0, strlen (buf)))
+    if (sprintf (buf, "%Lg", x.value) <= 0)
       result |= 64;
   }
 #endif
diff --git a/tests/test-isfinite.c b/tests/test-isfinite.c
--- a/tests/test-isfinite.c
+++ b/tests/test-isfinite.c
@@ -199,37 +199,31 @@
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
     ASSERT (!isfinite (x.value));
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* isfinite should return something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    ASSERT (!isfinite (x.value));
+    ASSERT (isfinite (x.value) || !isfinite (x.value));
   }
   { /* Pseudo-Infinity.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    ASSERT (!isfinite (x.value));
+    ASSERT (isfinite (x.value) || !isfinite (x.value));
   }
   { /* Pseudo-Zero.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    ASSERT (!isfinite (x.value));
+    ASSERT (isfinite (x.value) || !isfinite (x.value));
   }
   { /* Unnormalized number.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    ASSERT (!isfinite (x.value));
+    ASSERT (isfinite (x.value) || !isfinite (x.value));
   }
   { /* Pseudo-Denormal.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    ASSERT (!isfinite (x.value));
+    ASSERT (isfinite (x.value) || !isfinite (x.value));
   }
 #endif
 
diff --git a/tests/test-isinf.c b/tests/test-isinf.c
--- a/tests/test-isinf.c
+++ b/tests/test-isinf.c
@@ -205,37 +205,31 @@
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
     ASSERT (!isinf (x.value));
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* isinf should return something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    ASSERT (!isinf (x.value));
+    ASSERT (isinf (x.value) || !isinf (x.value));
   }
   { /* Pseudo-Infinity.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    ASSERT (!isinf (x.value));
+    ASSERT (isinf (x.value) || !isinf (x.value));
   }
   { /* Pseudo-Zero.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    ASSERT (!isinf (x.value));
+    ASSERT (isinf (x.value) || !isinf (x.value));
   }
   { /* Unnormalized number.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    ASSERT (!isinf (x.value));
+    ASSERT (isinf (x.value) || !isinf (x.value));
   }
   { /* Pseudo-Denormal.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    ASSERT (!isinf (x.value));
+    ASSERT (isinf (x.value) || !isinf (x.value));
   }
 #endif
 
diff --git a/tests/test-isnan.c b/tests/test-isnan.c
--- a/tests/test-isnan.c
+++ b/tests/test-isnan.c
@@ -186,37 +186,31 @@
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
     ASSERT (isnan (x.value));
   }
-  /* The isnan function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* isnan should return something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    ASSERT (isnan (x.value));
+    ASSERT (isnan (x.value) || !isnan (x.value));
   }
   { /* Pseudo-Infinity.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    ASSERT (isnan (x.value));
+    ASSERT (isnan (x.value) || !isnan (x.value));
   }
   { /* Pseudo-Zero.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    ASSERT (isnan (x.value));
+    ASSERT (isnan (x.value) || !isnan (x.value));
   }
   { /* Unnormalized number.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    ASSERT (isnan (x.value));
+    ASSERT (isnan (x.value) || !isnan (x.value));
   }
   { /* Pseudo-Denormal.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    ASSERT (isnan (x.value));
+    ASSERT (isnan (x.value) || !isnan (x.value));
   }
 #endif
 }
diff --git a/tests/test-isnanl.h b/tests/test-isnanl.h
--- a/tests/test-isnanl.h
+++ b/tests/test-isnanl.h
@@ -98,37 +98,31 @@
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
     ASSERT (isnanl (x.value));
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* isnanl should return something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    ASSERT (isnanl (x.value));
+    ASSERT (isnanl (x.value) || !isnanl (x.value));
   }
   { /* Pseudo-Infinity.  */
     static memory_long_double x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    ASSERT (isnanl (x.value));
+    ASSERT (isnanl (x.value) || !isnanl (x.value));
   }
   { /* Pseudo-Zero.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    ASSERT (isnanl (x.value));
+    ASSERT (isnanl (x.value) || !isnanl (x.value));
   }
   { /* Unnormalized number.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    ASSERT (isnanl (x.value));
+    ASSERT (isnanl (x.value) || !isnanl (x.value));
   }
   { /* Pseudo-Denormal.  */
     static memory_long_double x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    ASSERT (isnanl (x.value));
+    ASSERT (isnanl (x.value) || !isnanl (x.value));
   }
 #endif
 
diff --git a/tests/test-snprintf-posix.h b/tests/test-snprintf-posix.h
--- a/tests/test-snprintf-posix.h
+++ b/tests/test-snprintf-posix.h
@@ -79,6 +79,7 @@
 {
   char buf[8];
   int size;
+  char result[5000];
 
   /* Test return value convention.  */
 
@@ -107,7 +108,6 @@
   /* Test support of size specifiers as in C99.  */
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
     ASSERT (strcmp (result, "12345671 33") == 0);
@@ -115,7 +115,6 @@
   }
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%zu %d", (size_t) 12345672, 33, 44, 55);
     ASSERT (strcmp (result, "12345672 33") == 0);
@@ -123,7 +122,6 @@
   }
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
     ASSERT (strcmp (result, "12345673 33") == 0);
@@ -131,7 +129,6 @@
   }
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", (long double) 1.5, 33, 44, 55);
     ASSERT (strcmp (result, "1.5 33") == 0);
@@ -142,7 +139,6 @@
      output of floating-point numbers.  */
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%a %d", 3.1416015625, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
@@ -153,7 +149,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%A %d", -3.1416015625, 33, 44, 55);
     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
@@ -164,7 +159,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%a %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0x0p+0 33") == 0);
@@ -172,7 +166,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%a %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -181,7 +174,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%a %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0);
@@ -189,7 +181,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%a %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0);
@@ -197,7 +188,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%a %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -207,7 +197,6 @@
   }
 
   { /* Rounding near the decimal point.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.0a %d", 1.5, 33, 44, 55);
     ASSERT (strcmp (result, "0x2p+0 33") == 0
@@ -218,7 +207,6 @@
   }
 
   { /* Rounding with precision 0.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.0a %d", 1.51, 33, 44, 55);
     ASSERT (strcmp (result, "0x2p+0 33") == 0
@@ -229,7 +217,6 @@
   }
 
   { /* Rounding with precision 1.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.1a %d", 1.51, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
@@ -240,7 +227,6 @@
   }
 
   { /* Rounding with precision 2.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2a %d", 1.51, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
@@ -251,7 +237,6 @@
   }
 
   { /* Rounding with precision 3.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.3a %d", 1.51, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
@@ -262,7 +247,6 @@
   }
 
   { /* Rounding can turn a ...FFF into a ...000.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.3a %d", 1.49999, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
@@ -274,7 +258,6 @@
 
   { /* Rounding can turn a ...FFF into a ...000.
        This shows a Mac OS X 10.3.9 (Darwin 7.9) bug.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.1a %d", 1.999, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
@@ -285,7 +268,6 @@
   }
 
   { /* Width.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%10a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
@@ -296,7 +278,6 @@
   }
 
   { /* Small precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.10a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
@@ -307,7 +288,6 @@
   }
 
   { /* Large precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.50a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
@@ -318,7 +298,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%-10a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
@@ -329,7 +308,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%+a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
@@ -340,7 +318,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "% a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
@@ -351,7 +328,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
@@ -362,7 +338,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#a %d", 1.0, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.p+0 33") == 0
@@ -373,7 +348,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%010a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
@@ -384,7 +358,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%010a %d", Infinityd (), 33, 44, 55);
     /* "0000000inf 33" is not a valid result; see
@@ -394,7 +367,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%050a %d", NaNd (), 33, 44, 55);
     /* "0000000nan 33" is not a valid result; see
@@ -406,7 +378,6 @@
   }
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", 3.1416015625L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
@@ -417,7 +388,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LA %d", -3.1416015625L, 33, 44, 55);
     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
@@ -428,7 +398,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0x0p+0 33") == 0);
@@ -436,7 +405,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -445,7 +413,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0);
@@ -453,7 +420,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0);
@@ -461,7 +427,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -473,7 +438,6 @@
   { /* Quiet NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -485,36 +449,6 @@
     /* Signalling NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
-  { /* Pseudo-NaN.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Infinity.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -522,43 +456,50 @@
             && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
+  /* snprintf should print something for noncanonical values.  */
+  { /* Pseudo-NaN.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Infinity.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
   { /* Pseudo-Zero.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Unnormalized number.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
 #endif
 
   { /* Rounding near the decimal point.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.0La %d", 1.5L, 33, 44, 55);
     ASSERT (strcmp (result, "0x2p+0 33") == 0
@@ -569,7 +510,6 @@
   }
 
   { /* Rounding with precision 0.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.0La %d", 1.51L, 33, 44, 55);
     ASSERT (strcmp (result, "0x2p+0 33") == 0
@@ -580,7 +520,6 @@
   }
 
   { /* Rounding with precision 1.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.1La %d", 1.51L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
@@ -591,7 +530,6 @@
   }
 
   { /* Rounding with precision 2.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2La %d", 1.51L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
@@ -602,7 +540,6 @@
   }
 
   { /* Rounding with precision 3.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.3La %d", 1.51L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
@@ -613,7 +550,6 @@
   }
 
   { /* Rounding can turn a ...FFF into a ...000.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.3La %d", 1.49999L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
@@ -626,7 +562,6 @@
   { /* Rounding can turn a ...FFF into a ...000.
        This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a
        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.1La %d", 1.999L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
@@ -637,7 +572,6 @@
   }
 
   { /* Width.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%10La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
@@ -648,7 +582,6 @@
   }
 
   { /* Small precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.10La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
@@ -659,7 +592,6 @@
   }
 
   { /* Large precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.50La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
@@ -670,7 +602,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%-10La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
@@ -681,7 +612,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%+La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
@@ -692,7 +622,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "% La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
@@ -703,7 +632,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
@@ -714,7 +642,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#La %d", 1.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.p+0 33") == 0
@@ -725,7 +652,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%010La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
@@ -736,7 +662,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%010La %d", Infinityl (), 33, 44, 55);
     /* "0000000inf 33" is not a valid result; see
@@ -746,7 +671,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%050La %d", NaNl (), 33, 44, 55);
     /* "0000000nan 33" is not a valid result; see
@@ -760,7 +684,6 @@
   /* Test the support of the %f format directive.  */
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%f %d", 12.75, 33, 44, 55);
     ASSERT (strcmp (result, "12.750000 33") == 0);
@@ -768,7 +691,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%f %d", 1234567.0, 33, 44, 55);
     ASSERT (strcmp (result, "1234567.000000 33") == 0);
@@ -856,7 +778,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[100];
         int retval =
           my_snprintf (result, sizeof (result), "%f", data[k].value);
         ASSERT (strmatch (data[k].string, result));
@@ -865,7 +786,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%f %d", -0.03125, 33, 44, 55);
     ASSERT (strcmp (result, "-0.031250 33") == 0);
@@ -873,7 +793,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%f %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000 33") == 0);
@@ -881,7 +800,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%f %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -890,7 +808,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%f %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -899,7 +816,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%f %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -908,7 +824,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%f %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -918,7 +833,6 @@
   }
 
   { /* Width.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%10f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "  1.750000 33") == 0);
@@ -926,7 +840,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%-10f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000   33") == 0);
@@ -934,7 +847,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%+f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "+1.750000 33") == 0);
@@ -942,7 +854,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "% f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, " 1.750000 33") == 0);
@@ -950,7 +861,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000 33") == 0);
@@ -958,7 +868,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "2. 33") == 0);
@@ -966,7 +875,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015f %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "00001234.000000 33") == 0);
@@ -974,7 +882,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015f %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -983,7 +890,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%050f %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -993,7 +899,6 @@
   }
 
   { /* Precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.f %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "1234 33") == 0);
@@ -1001,7 +906,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2f %d", 999.951, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -1009,7 +913,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2f %d", 999.996, 33, 44, 55);
     ASSERT (strcmp (result, "1000.00 33") == 0);
@@ -1017,7 +920,6 @@
   }
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", 12.75L, 33, 44, 55);
     ASSERT (strcmp (result, "12.750000 33") == 0);
@@ -1025,7 +927,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", 1234567.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1234567.000000 33") == 0);
@@ -1113,7 +1014,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[100];
         int retval =
           my_snprintf (result, sizeof (result), "%Lf", data[k].value);
         ASSERT (strmatch (data[k].string, result));
@@ -1122,7 +1022,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", -0.03125L, 33, 44, 55);
     ASSERT (strcmp (result, "-0.031250 33") == 0);
@@ -1130,7 +1029,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000 33") == 0);
@@ -1138,7 +1036,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -1147,7 +1044,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -1156,7 +1052,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -1165,7 +1060,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1177,7 +1071,6 @@
   { /* Quiet NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1189,58 +1082,6 @@
     /* Signalling NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
-  { /* Pseudo-NaN.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Infinity.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Zero.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Unnormalized number.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1248,21 +1089,50 @@
             && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
+  /* snprintf should print something for noncanonical values.  */
+  { /* Pseudo-NaN.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Infinity.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Zero.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Unnormalized number.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
 #endif
 
   { /* Width.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%10Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "  1.750000 33") == 0);
@@ -1270,7 +1140,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%-10Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000   33") == 0);
@@ -1278,7 +1147,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%+Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "+1.750000 33") == 0);
@@ -1286,7 +1154,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "% Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, " 1.750000 33") == 0);
@@ -1294,7 +1161,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000 33") == 0);
@@ -1302,7 +1168,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "2. 33") == 0);
@@ -1310,7 +1175,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015Lf %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "00001234.000000 33") == 0);
@@ -1318,7 +1182,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015Lf %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -1327,7 +1190,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%050Lf %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -1337,7 +1199,6 @@
   }
 
   { /* Precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.Lf %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1234 33") == 0);
@@ -1345,7 +1206,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2Lf %d", 999.951L, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -1353,7 +1213,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2Lf %d", 999.996L, 33, 44, 55);
     ASSERT (strcmp (result, "1000.00 33") == 0);
@@ -1363,7 +1222,6 @@
   /* Test the support of the %F format directive.  */
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%F %d", 12.75, 33, 44, 55);
     ASSERT (strcmp (result, "12.750000 33") == 0);
@@ -1371,7 +1229,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%F %d", 1234567.0, 33, 44, 55);
     ASSERT (strcmp (result, "1234567.000000 33") == 0);
@@ -1379,7 +1236,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%F %d", -0.03125, 33, 44, 55);
     ASSERT (strcmp (result, "-0.031250 33") == 0);
@@ -1387,7 +1243,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%F %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000 33") == 0);
@@ -1395,7 +1250,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%F %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -1404,7 +1258,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%F %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "INF 33") == 0
@@ -1413,7 +1266,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%F %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-INF 33") == 0
@@ -1422,7 +1274,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%F %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1432,7 +1283,6 @@
   }
 
   { /* FLAG_ZERO.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015F %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "00001234.000000 33") == 0);
@@ -1440,7 +1290,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015F %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "           -INF 33") == 0
@@ -1449,7 +1298,6 @@
   }
 
   { /* Precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.F %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "1234 33") == 0);
@@ -1457,7 +1305,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2F %d", 999.951, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -1465,7 +1312,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2F %d", 999.996, 33, 44, 55);
     ASSERT (strcmp (result, "1000.00 33") == 0);
@@ -1473,7 +1319,6 @@
   }
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LF %d", 12.75L, 33, 44, 55);
     ASSERT (strcmp (result, "12.750000 33") == 0);
@@ -1481,7 +1326,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LF %d", 1234567.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1234567.000000 33") == 0);
@@ -1489,7 +1333,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LF %d", -0.03125L, 33, 44, 55);
     ASSERT (strcmp (result, "-0.031250 33") == 0);
@@ -1497,7 +1340,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LF %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000 33") == 0);
@@ -1505,7 +1347,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LF %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -1514,7 +1355,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LF %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "INF 33") == 0
@@ -1523,7 +1363,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LF %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-INF 33") == 0
@@ -1532,7 +1371,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%LF %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1542,7 +1380,6 @@
   }
 
   { /* FLAG_ZERO.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015LF %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "00001234.000000 33") == 0);
@@ -1550,7 +1387,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015LF %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "           -INF 33") == 0
@@ -1559,7 +1395,6 @@
   }
 
   { /* Precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.LF %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1234 33") == 0);
@@ -1567,7 +1402,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2LF %d", 999.951L, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -1575,7 +1409,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.2LF %d", 999.996L, 33, 44, 55);
     ASSERT (strcmp (result, "1000.00 33") == 0);
@@ -1585,7 +1418,6 @@
   /* Test the support of the %e format directive.  */
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%e %d", 12.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.275000e+01 33") == 0
@@ -1594,7 +1426,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%e %d", 1234567.0, 33, 44, 55);
     ASSERT (strcmp (result, "1.234567e+06 33") == 0
@@ -1683,7 +1514,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[100];
         int retval =
           my_snprintf (result, sizeof (result), "%e", data[k].value);
         const char *expected = data[k].string;
@@ -1700,7 +1530,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%e %d", -0.03125, 33, 44, 55);
     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
@@ -1709,7 +1538,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%e %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000e+00 33") == 0
@@ -1718,7 +1546,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%e %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -1728,7 +1555,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%e %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -1737,7 +1563,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%e %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -1746,7 +1571,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%e %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1756,7 +1580,6 @@
   }
 
   { /* Width.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%15e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
@@ -1765,7 +1588,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%-15e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000e+00    33") == 0
@@ -1774,7 +1596,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%+e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
@@ -1783,7 +1604,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "% e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
@@ -1792,7 +1612,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000e+00 33") == 0
@@ -1801,7 +1620,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "2.e+00 33") == 0
@@ -1810,7 +1628,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.e %d", 9.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.e+01 33") == 0
@@ -1819,7 +1636,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015e %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
@@ -1828,7 +1644,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015e %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -1837,7 +1652,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%050e %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -1847,7 +1661,6 @@
   }
 
   { /* Precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.e %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "1e+03 33") == 0
@@ -1856,7 +1669,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.4e %d", 999.951, 33, 44, 55);
     ASSERT (strcmp (result, "9.9995e+02 33") == 0
@@ -1865,7 +1677,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.4e %d", 999.996, 33, 44, 55);
     ASSERT (strcmp (result, "1.0000e+03 33") == 0
@@ -1874,7 +1685,6 @@
   }
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", 12.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.275000e+01 33") == 0
@@ -1883,7 +1693,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", 1234567.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1.234567e+06 33") == 0
@@ -1972,7 +1781,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[100];
         int retval =
           my_snprintf (result, sizeof (result), "%Le", data[k].value);
         const char *expected = data[k].string;
@@ -1989,7 +1797,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", -0.03125L, 33, 44, 55);
     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
@@ -1998,7 +1805,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000e+00 33") == 0
@@ -2007,7 +1813,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -2017,7 +1822,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -2026,7 +1830,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -2035,7 +1838,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2047,7 +1849,6 @@
   { /* Quiet NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2059,36 +1860,6 @@
     /* Signalling NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
-  { /* Pseudo-NaN.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Infinity.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2096,43 +1867,50 @@
             && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
+  /* snprintf should print something for noncanonical values.  */
+  { /* Pseudo-NaN.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Infinity.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
   { /* Pseudo-Zero.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Unnormalized number.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
 #endif
 
   { /* Width.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%15Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
@@ -2141,7 +1919,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%-15Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000e+00    33") == 0
@@ -2150,7 +1927,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%+Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
@@ -2159,7 +1935,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "% Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
@@ -2168,7 +1943,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000e+00 33") == 0
@@ -2177,7 +1951,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "2.e+00 33") == 0
@@ -2186,7 +1959,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.Le %d", 9.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.e+01 33") == 0
@@ -2195,7 +1967,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015Le %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
@@ -2204,7 +1975,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015Le %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -2213,7 +1983,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%050Le %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -2223,7 +1992,6 @@
   }
 
   { /* Precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.Le %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1e+03 33") == 0
@@ -2232,7 +2000,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.4Le %d", 999.951L, 33, 44, 55);
     ASSERT (strcmp (result, "9.9995e+02 33") == 0
@@ -2241,7 +2008,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.4Le %d", 999.996L, 33, 44, 55);
     ASSERT (strcmp (result, "1.0000e+03 33") == 0
@@ -2252,7 +2018,6 @@
   /* Test the support of the %g format directive.  */
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%g %d", 12.75, 33, 44, 55);
     ASSERT (strcmp (result, "12.75 33") == 0);
@@ -2260,7 +2025,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%g %d", 1234567.0, 33, 44, 55);
     ASSERT (strcmp (result, "1.23457e+06 33") == 0
@@ -2349,7 +2113,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[100];
         int retval =
           my_snprintf (result, sizeof (result), "%g", data[k].value);
         const char *expected = data[k].string;
@@ -2367,7 +2130,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%g %d", -0.03125, 33, 44, 55);
     ASSERT (strcmp (result, "-0.03125 33") == 0);
@@ -2375,7 +2137,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%g %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0 33") == 0);
@@ -2383,7 +2144,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%g %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -2392,7 +2152,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%g %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -2401,7 +2160,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%g %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -2410,7 +2168,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%g %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2420,7 +2177,6 @@
   }
 
   { /* Width.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%10g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "      1.75 33") == 0);
@@ -2428,7 +2184,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%-10g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.75       33") == 0);
@@ -2436,7 +2191,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%+g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "+1.75 33") == 0);
@@ -2444,7 +2198,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "% g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, " 1.75 33") == 0);
@@ -2452,7 +2205,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.75000 33") == 0);
@@ -2460,7 +2212,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "2. 33") == 0);
@@ -2468,7 +2219,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.g %d", 9.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.e+01 33") == 0
@@ -2477,7 +2227,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%010g %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "0000001234 33") == 0);
@@ -2485,7 +2234,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015g %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -2494,7 +2242,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%050g %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -2504,7 +2251,6 @@
   }
 
   { /* Precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.g %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "1e+03 33") == 0
@@ -2513,7 +2259,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.5g %d", 999.951, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -2521,7 +2266,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.5g %d", 999.996, 33, 44, 55);
     ASSERT (strcmp (result, "1000 33") == 0);
@@ -2529,7 +2273,6 @@
   }
 
   { /* A positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", 12.75L, 33, 44, 55);
     ASSERT (strcmp (result, "12.75 33") == 0);
@@ -2537,7 +2280,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", 1234567.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1.23457e+06 33") == 0
@@ -2626,7 +2368,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[100];
         int retval =
           my_snprintf (result, sizeof (result), "%Lg", data[k].value);
         const char *expected = data[k].string;
@@ -2644,7 +2385,6 @@
   }
 
   { /* A negative number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", -0.03125L, 33, 44, 55);
     ASSERT (strcmp (result, "-0.03125 33") == 0);
@@ -2652,7 +2392,6 @@
   }
 
   { /* Positive zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0 33") == 0);
@@ -2660,7 +2399,6 @@
   }
 
   { /* Negative zero.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -2669,7 +2407,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -2678,7 +2415,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -2687,7 +2423,6 @@
   }
 
   { /* NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2699,7 +2434,6 @@
   { /* Quiet NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2711,58 +2445,6 @@
     /* Signalling NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
-  { /* Pseudo-NaN.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Infinity.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Zero.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    char result[100];
-    int retval =
-      my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Unnormalized number.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2770,21 +2452,50 @@
             && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
+  /* snprintf should print something for noncanonical values.  */
+  { /* Pseudo-NaN.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Infinity.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Zero.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Unnormalized number.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
+    int retval =
+      my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
 #endif
 
   { /* Width.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%10Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "      1.75 33") == 0);
@@ -2792,7 +2503,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%-10Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.75       33") == 0);
@@ -2800,7 +2510,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%+Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "+1.75 33") == 0);
@@ -2808,7 +2517,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "% Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, " 1.75 33") == 0);
@@ -2816,7 +2524,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.75000 33") == 0);
@@ -2824,7 +2531,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "2. 33") == 0);
@@ -2832,7 +2538,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%#.Lg %d", 9.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.e+01 33") == 0
@@ -2841,7 +2546,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%010Lg %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0000001234 33") == 0);
@@ -2849,7 +2553,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%015Lg %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -2858,7 +2561,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%050Lg %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -2868,7 +2570,6 @@
   }
 
   { /* Precision.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.Lg %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1e+03 33") == 0
@@ -2877,7 +2578,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.5Lg %d", 999.951L, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -2885,7 +2585,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%.5Lg %d", 999.996L, 33, 44, 55);
     ASSERT (strcmp (result, "1000 33") == 0);
@@ -2896,7 +2595,6 @@
 
   {
     int count = -1;
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
     ASSERT (strcmp (result, "123 ") == 0);
@@ -2907,7 +2605,6 @@
   /* Test the support of the POSIX/XSI format strings with positions.  */
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
     ASSERT (strcmp (result, "55 33") == 0);
@@ -2917,7 +2614,6 @@
   /* Test the support of the grouping flag.  */
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "%'d %d", 1234567, 99);
     ASSERT (result[strlen (result) - 1] == '9');
@@ -2927,7 +2623,6 @@
   /* Test the support of the left-adjust flag.  */
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "a%*sc", -3, "b");
     ASSERT (strcmp (result, "ab  c") == 0);
@@ -2935,7 +2630,6 @@
   }
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "a%-*sc", 3, "b");
     ASSERT (strcmp (result, "ab  c") == 0);
@@ -2943,7 +2637,6 @@
   }
 
   {
-    char result[100];
     int retval =
       my_snprintf (result, sizeof (result), "a%-*sc", -3, "b");
     ASSERT (strcmp (result, "ab  c") == 0);
@@ -2953,7 +2646,6 @@
   /* Test the support of large precision.  */
 
   {
-    char result[5000];
     int retval =
       my_snprintf (result, sizeof (result), "%.4000d %d", 1234567, 99);
     size_t i;
@@ -2964,7 +2656,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_snprintf (result, sizeof (result), "%.*d %d", 4000, 1234567, 99);
     size_t i;
@@ -2975,7 +2666,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_snprintf (result, sizeof (result), "%.4000d %d", -1234567, 99);
     size_t i;
@@ -2987,7 +2677,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_snprintf (result, sizeof (result), "%.4000u %d", 1234567, 99);
     size_t i;
@@ -2998,7 +2687,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_snprintf (result, sizeof (result), "%.4000o %d", 1234567, 99);
     size_t i;
@@ -3009,7 +2697,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_snprintf (result, sizeof (result), "%.4000x %d", 1234567, 99);
     size_t i;
@@ -3020,7 +2707,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_snprintf (result, sizeof (result), "%#.4000x %d", 1234567, 99);
     size_t i;
@@ -3033,7 +2719,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_snprintf (result, sizeof (result), "%.4000f %d", 1.0, 99);
     size_t i;
@@ -3046,7 +2731,6 @@
   }
 
   {
-    char result[1000];
     int retval =
       my_snprintf (result, sizeof (result), "%.511f %d", 1.0, 99);
     size_t i;
@@ -3060,7 +2744,6 @@
 
   {
     char input[5000];
-    char result[5000];
     int retval;
     size_t i;
 
@@ -3084,7 +2767,6 @@
     for (i = 1; i <= 8; i++)
       {
         char *block;
-        char result[5000];
         int retval;
 
         block = (char *) malloc (i);
@@ -3104,7 +2786,6 @@
       {
         wchar_t *block;
         size_t j;
-        char result[5000];
         int retval;
 
         block = (wchar_t *) malloc (i * sizeof (wchar_t));
diff --git a/tests/test-sprintf-posix.h b/tests/test-sprintf-posix.h
--- a/tests/test-sprintf-posix.h
+++ b/tests/test-sprintf-posix.h
@@ -77,6 +77,7 @@
 static void
 test_function (int (*my_sprintf) (char *, const char *, ...))
 {
+  char result[5000];
   char buf[8];
 
   /* Test return value convention.  */
@@ -93,7 +94,6 @@
   /* Test support of size specifiers as in C99.  */
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
     ASSERT (strcmp (result, "12345671 33") == 0);
@@ -101,7 +101,6 @@
   }
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "%zu %d", (size_t) 12345672, 33, 44, 55);
     ASSERT (strcmp (result, "12345672 33") == 0);
@@ -109,7 +108,6 @@
   }
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
     ASSERT (strcmp (result, "12345673 33") == 0);
@@ -117,7 +115,6 @@
   }
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
     ASSERT (strcmp (result, "1.5 33") == 0);
@@ -128,7 +125,6 @@
      output of floating-point numbers.  */
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
@@ -139,7 +135,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%A %d", -3.1416015625, 33, 44, 55);
     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
@@ -150,7 +145,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0x0p+0 33") == 0);
@@ -158,7 +152,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%a %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -167,7 +160,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%a %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0);
@@ -175,7 +167,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%a %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0);
@@ -183,7 +174,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%a %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -193,7 +183,6 @@
   }
 
   { /* Rounding near the decimal point.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
     ASSERT (strcmp (result, "0x2p+0 33") == 0
@@ -204,7 +193,6 @@
   }
 
   { /* Rounding with precision 0.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.0a %d", 1.51, 33, 44, 55);
     ASSERT (strcmp (result, "0x2p+0 33") == 0
@@ -215,7 +203,6 @@
   }
 
   { /* Rounding with precision 1.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
@@ -226,7 +213,6 @@
   }
 
   { /* Rounding with precision 2.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
@@ -237,7 +223,6 @@
   }
 
   { /* Rounding with precision 3.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
@@ -248,7 +233,6 @@
   }
 
   { /* Rounding can turn a ...FFF into a ...000.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
@@ -260,7 +244,6 @@
 
   { /* Rounding can turn a ...FFF into a ...000.
        This shows a Mac OS X 10.3.9 (Darwin 7.9) bug.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
@@ -271,7 +254,6 @@
   }
 
   { /* Width.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
@@ -282,7 +264,6 @@
   }
 
   { /* Small precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
@@ -293,7 +274,6 @@
   }
 
   { /* Large precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
@@ -304,7 +284,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%-10a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
@@ -315,7 +294,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%+a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
@@ -326,7 +304,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "% a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
@@ -337,7 +314,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
@@ -348,7 +324,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#a %d", 1.0, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.p+0 33") == 0
@@ -359,7 +334,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
@@ -370,7 +344,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%010a %d", Infinityd (), 33, 44, 55);
     /* "0000000inf 33" is not a valid result; see
@@ -380,7 +353,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%050a %d", NaNd (), 33, 44, 55);
     /* "0000000nan 33" is not a valid result; see
@@ -392,7 +364,6 @@
   }
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
@@ -403,7 +374,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LA %d", -3.1416015625L, 33, 44, 55);
     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
@@ -414,7 +384,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0x0p+0 33") == 0);
@@ -422,7 +391,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -431,7 +399,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0);
@@ -439,7 +406,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0);
@@ -447,7 +413,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -459,7 +424,6 @@
   { /* Quiet NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -471,36 +435,6 @@
     /* Signalling NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
-    char result[1000];
-    int retval =
-      my_sprintf (result, "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
-  { /* Pseudo-NaN.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    char result[1000];
-    int retval =
-      my_sprintf (result, "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Infinity.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -508,43 +442,50 @@
             && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
+  /* sprintf should print something for noncanonical values.  */
+  { /* Pseudo-NaN.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
+    int retval =
+      my_sprintf (result, "%La %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Infinity.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
+    int retval =
+      my_sprintf (result, "%La %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
   { /* Pseudo-Zero.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Unnormalized number.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
 #endif
 
   { /* Rounding near the decimal point.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
     ASSERT (strcmp (result, "0x2p+0 33") == 0
@@ -555,7 +496,6 @@
   }
 
   { /* Rounding with precision 0.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.0La %d", 1.51L, 33, 44, 55);
     ASSERT (strcmp (result, "0x2p+0 33") == 0
@@ -566,7 +506,6 @@
   }
 
   { /* Rounding with precision 1.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
@@ -577,7 +516,6 @@
   }
 
   { /* Rounding with precision 2.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
@@ -588,7 +526,6 @@
   }
 
   { /* Rounding with precision 3.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
@@ -599,7 +536,6 @@
   }
 
   { /* Rounding can turn a ...FFF into a ...000.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
@@ -612,7 +548,6 @@
   { /* Rounding can turn a ...FFF into a ...000.
        This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a
        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
@@ -623,7 +558,6 @@
   }
 
   { /* Width.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
@@ -634,7 +568,6 @@
   }
 
   { /* Small precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
@@ -645,7 +578,6 @@
   }
 
   { /* Large precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
@@ -656,7 +588,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
@@ -667,7 +598,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%+La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
@@ -678,7 +608,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "% La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
@@ -689,7 +618,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
@@ -700,7 +628,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#La %d", 1.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0x1.p+0 33") == 0
@@ -711,7 +638,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
@@ -722,7 +648,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%010La %d", Infinityl (), 33, 44, 55);
     /* "0000000inf 33" is not a valid result; see
@@ -732,7 +657,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%050La %d", NaNl (), 33, 44, 55);
     /* "0000000nan 33" is not a valid result; see
@@ -746,7 +670,6 @@
   /* Test the support of the %f format directive.  */
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%f %d", 12.75, 33, 44, 55);
     ASSERT (strcmp (result, "12.750000 33") == 0);
@@ -754,7 +677,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%f %d", 1234567.0, 33, 44, 55);
     ASSERT (strcmp (result, "1234567.000000 33") == 0);
@@ -842,7 +764,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[1000];
         int retval =
           my_sprintf (result, "%f", data[k].value);
         ASSERT (strmatch (data[k].string, result));
@@ -851,7 +772,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%f %d", -0.03125, 33, 44, 55);
     ASSERT (strcmp (result, "-0.031250 33") == 0);
@@ -859,7 +779,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%f %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000 33") == 0);
@@ -867,7 +786,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%f %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -876,7 +794,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%f %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -885,7 +802,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%f %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -894,7 +810,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%f %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -904,7 +819,6 @@
   }
 
   { /* Width.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%10f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "  1.750000 33") == 0);
@@ -912,7 +826,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%-10f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000   33") == 0);
@@ -920,7 +833,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%+f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "+1.750000 33") == 0);
@@ -928,7 +840,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "% f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, " 1.750000 33") == 0);
@@ -936,7 +847,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000 33") == 0);
@@ -944,7 +854,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.f %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "2. 33") == 0);
@@ -952,7 +861,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015f %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "00001234.000000 33") == 0);
@@ -960,7 +868,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015f %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -969,7 +876,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%050f %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -979,7 +885,6 @@
   }
 
   { /* Precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.f %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "1234 33") == 0);
@@ -987,7 +892,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.2f %d", 999.951, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -995,7 +899,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.2f %d", 999.996, 33, 44, 55);
     ASSERT (strcmp (result, "1000.00 33") == 0);
@@ -1003,7 +906,6 @@
   }
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", 12.75L, 33, 44, 55);
     ASSERT (strcmp (result, "12.750000 33") == 0);
@@ -1011,7 +913,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", 1234567.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1234567.000000 33") == 0);
@@ -1099,7 +1000,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[1000];
         int retval =
           my_sprintf (result, "%Lf", data[k].value);
         ASSERT (strmatch (data[k].string, result));
@@ -1108,7 +1008,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", -0.03125L, 33, 44, 55);
     ASSERT (strcmp (result, "-0.031250 33") == 0);
@@ -1116,7 +1015,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000 33") == 0);
@@ -1124,7 +1022,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -1133,7 +1030,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -1142,7 +1038,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -1151,7 +1046,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1163,7 +1057,6 @@
   { /* Quiet NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1175,58 +1068,6 @@
     /* Signalling NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
-    char result[1000];
-    int retval =
-      my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
-  { /* Pseudo-NaN.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    char result[1000];
-    int retval =
-      my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Infinity.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    char result[1000];
-    int retval =
-      my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Zero.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    char result[1000];
-    int retval =
-      my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Unnormalized number.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1234,21 +1075,50 @@
             && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
+  /* sprintf should print something for noncanonical values.  */
+  { /* Pseudo-NaN.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
+    int retval =
+      my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Infinity.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
+    int retval =
+      my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Zero.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
+    int retval =
+      my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Unnormalized number.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
+    int retval =
+      my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
 #endif
 
   { /* Width.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%10Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "  1.750000 33") == 0);
@@ -1256,7 +1126,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%-10Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000   33") == 0);
@@ -1264,7 +1133,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%+Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "+1.750000 33") == 0);
@@ -1272,7 +1140,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "% Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, " 1.750000 33") == 0);
@@ -1280,7 +1147,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000 33") == 0);
@@ -1288,7 +1154,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.Lf %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "2. 33") == 0);
@@ -1296,7 +1161,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015Lf %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "00001234.000000 33") == 0);
@@ -1304,7 +1168,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015Lf %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -1313,7 +1176,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%050Lf %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -1323,7 +1185,6 @@
   }
 
   { /* Precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.Lf %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1234 33") == 0);
@@ -1331,7 +1192,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.2Lf %d", 999.951L, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -1339,7 +1199,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.2Lf %d", 999.996L, 33, 44, 55);
     ASSERT (strcmp (result, "1000.00 33") == 0);
@@ -1349,7 +1208,6 @@
   /* Test the support of the %F format directive.  */
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%F %d", 12.75, 33, 44, 55);
     ASSERT (strcmp (result, "12.750000 33") == 0);
@@ -1357,7 +1215,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%F %d", 1234567.0, 33, 44, 55);
     ASSERT (strcmp (result, "1234567.000000 33") == 0);
@@ -1365,7 +1222,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%F %d", -0.03125, 33, 44, 55);
     ASSERT (strcmp (result, "-0.031250 33") == 0);
@@ -1373,7 +1229,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%F %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000 33") == 0);
@@ -1381,7 +1236,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%F %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -1390,7 +1244,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%F %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "INF 33") == 0
@@ -1399,7 +1252,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%F %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-INF 33") == 0
@@ -1408,7 +1260,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%F %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1418,7 +1269,6 @@
   }
 
   { /* FLAG_ZERO.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015F %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "00001234.000000 33") == 0);
@@ -1426,7 +1276,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015F %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "           -INF 33") == 0
@@ -1435,7 +1284,6 @@
   }
 
   { /* Precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.F %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "1234 33") == 0);
@@ -1443,7 +1291,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.2F %d", 999.951, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -1451,7 +1298,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.2F %d", 999.996, 33, 44, 55);
     ASSERT (strcmp (result, "1000.00 33") == 0);
@@ -1459,7 +1305,6 @@
   }
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LF %d", 12.75L, 33, 44, 55);
     ASSERT (strcmp (result, "12.750000 33") == 0);
@@ -1467,7 +1312,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LF %d", 1234567.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1234567.000000 33") == 0);
@@ -1475,7 +1319,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LF %d", -0.03125L, 33, 44, 55);
     ASSERT (strcmp (result, "-0.031250 33") == 0);
@@ -1483,7 +1326,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LF %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000 33") == 0);
@@ -1491,7 +1333,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LF %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -1500,7 +1341,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LF %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "INF 33") == 0
@@ -1509,7 +1349,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LF %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-INF 33") == 0
@@ -1518,7 +1357,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%LF %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1528,7 +1366,6 @@
   }
 
   { /* FLAG_ZERO.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015LF %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "00001234.000000 33") == 0);
@@ -1536,7 +1373,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015LF %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "           -INF 33") == 0
@@ -1545,7 +1381,6 @@
   }
 
   { /* Precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.LF %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1234 33") == 0);
@@ -1553,7 +1388,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.2LF %d", 999.951L, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -1561,7 +1395,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.2LF %d", 999.996L, 33, 44, 55);
     ASSERT (strcmp (result, "1000.00 33") == 0);
@@ -1571,7 +1404,6 @@
   /* Test the support of the %e format directive.  */
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%e %d", 12.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.275000e+01 33") == 0
@@ -1580,7 +1412,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
     ASSERT (strcmp (result, "1.234567e+06 33") == 0
@@ -1669,7 +1500,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[1000];
         int retval =
           my_sprintf (result, "%e", data[k].value);
         const char *expected = data[k].string;
@@ -1686,7 +1516,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
@@ -1695,7 +1524,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000e+00 33") == 0
@@ -1704,7 +1532,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%e %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -1714,7 +1541,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%e %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -1723,7 +1549,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%e %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -1732,7 +1557,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%e %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -1742,7 +1566,6 @@
   }
 
   { /* Width.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
@@ -1751,7 +1574,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000e+00    33") == 0
@@ -1760,7 +1582,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
@@ -1769,7 +1590,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
@@ -1778,7 +1598,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000e+00 33") == 0
@@ -1787,7 +1606,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "2.e+00 33") == 0
@@ -1796,7 +1614,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.e+01 33") == 0
@@ -1805,7 +1622,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
@@ -1814,7 +1630,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015e %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -1823,7 +1638,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%050e %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -1833,7 +1647,6 @@
   }
 
   { /* Precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "1e+03 33") == 0
@@ -1842,7 +1655,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.4e %d", 999.951, 33, 44, 55);
     ASSERT (strcmp (result, "9.9995e+02 33") == 0
@@ -1851,7 +1663,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.4e %d", 999.996, 33, 44, 55);
     ASSERT (strcmp (result, "1.0000e+03 33") == 0
@@ -1860,7 +1671,6 @@
   }
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.275000e+01 33") == 0
@@ -1869,7 +1679,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1.234567e+06 33") == 0
@@ -1958,7 +1767,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[1000];
         int retval =
           my_sprintf (result, "%Le", data[k].value);
         const char *expected = data[k].string;
@@ -1975,7 +1783,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
@@ -1984,7 +1791,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0.000000e+00 33") == 0
@@ -1993,7 +1799,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -2003,7 +1808,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -2012,7 +1816,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -2021,7 +1824,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2033,7 +1835,6 @@
   { /* Quiet NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2045,36 +1846,6 @@
     /* Signalling NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
-    char result[1000];
-    int retval =
-      my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
-  { /* Pseudo-NaN.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    char result[1000];
-    int retval =
-      my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
-    ASSERT (retval == strlen (result));
-  }
-  { /* Pseudo-Infinity.  */
-    static union { unsigned int word[4]; long double value; } x =
-      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2082,43 +1853,50 @@
             && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
+  /* sprintf should print something for noncanonical values.  */
+  { /* Pseudo-NaN.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
+    int retval =
+      my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
+  { /* Pseudo-Infinity.  */
+    static union { unsigned int word[4]; long double value; } x =
+      { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
+    int retval =
+      my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
+    ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
+  }
   { /* Pseudo-Zero.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Unnormalized number.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
 #endif
 
   { /* Width.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%15Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
@@ -2127,7 +1905,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000e+00    33") == 0
@@ -2136,7 +1913,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
@@ -2145,7 +1921,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
@@ -2154,7 +1929,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.750000e+00 33") == 0
@@ -2163,7 +1937,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "2.e+00 33") == 0
@@ -2172,7 +1945,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.e+01 33") == 0
@@ -2181,7 +1953,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
@@ -2190,7 +1961,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015Le %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -2199,7 +1969,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%050Le %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -2209,7 +1978,6 @@
   }
 
   { /* Precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1e+03 33") == 0
@@ -2218,7 +1986,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.4Le %d", 999.951L, 33, 44, 55);
     ASSERT (strcmp (result, "9.9995e+02 33") == 0
@@ -2227,7 +1994,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.4Le %d", 999.996L, 33, 44, 55);
     ASSERT (strcmp (result, "1.0000e+03 33") == 0
@@ -2238,7 +2004,6 @@
   /* Test the support of the %g format directive.  */
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%g %d", 12.75, 33, 44, 55);
     ASSERT (strcmp (result, "12.75 33") == 0);
@@ -2246,7 +2011,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
     ASSERT (strcmp (result, "1.23457e+06 33") == 0
@@ -2335,7 +2099,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[1000];
         int retval =
           my_sprintf (result, "%g", data[k].value);
         const char *expected = data[k].string;
@@ -2353,7 +2116,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%g %d", -0.03125, 33, 44, 55);
     ASSERT (strcmp (result, "-0.03125 33") == 0);
@@ -2361,7 +2123,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%g %d", 0.0, 33, 44, 55);
     ASSERT (strcmp (result, "0 33") == 0);
@@ -2369,7 +2130,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%g %d", minus_zerod, 33, 44, 55);
     if (have_minus_zero ())
@@ -2378,7 +2138,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%g %d", Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -2387,7 +2146,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%g %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -2396,7 +2154,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%g %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2406,7 +2163,6 @@
   }
 
   { /* Width.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%10g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "      1.75 33") == 0);
@@ -2414,7 +2170,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%-10g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.75       33") == 0);
@@ -2422,7 +2177,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%+g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "+1.75 33") == 0);
@@ -2430,7 +2184,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "% g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, " 1.75 33") == 0);
@@ -2438,7 +2191,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.75000 33") == 0);
@@ -2446,7 +2198,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.g %d", 1.75, 33, 44, 55);
     ASSERT (strcmp (result, "2. 33") == 0);
@@ -2454,7 +2205,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
     ASSERT (strcmp (result, "1.e+01 33") == 0
@@ -2463,7 +2213,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%010g %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "0000001234 33") == 0);
@@ -2471,7 +2220,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015g %d", - Infinityd (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -2480,7 +2228,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%050g %d", NaNd (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -2490,7 +2237,6 @@
   }
 
   { /* Precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
     ASSERT (strcmp (result, "1e+03 33") == 0
@@ -2499,7 +2245,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.5g %d", 999.951, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -2507,7 +2252,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.5g %d", 999.996, 33, 44, 55);
     ASSERT (strcmp (result, "1000 33") == 0);
@@ -2515,7 +2259,6 @@
   }
 
   { /* A positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", 12.75L, 33, 44, 55);
     ASSERT (strcmp (result, "12.75 33") == 0);
@@ -2523,7 +2266,6 @@
   }
 
   { /* A larger positive number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1.23457e+06 33") == 0
@@ -2612,7 +2354,6 @@
     size_t k;
     for (k = 0; k < SIZEOF (data); k++)
       {
-        char result[1000];
         int retval =
           my_sprintf (result, "%Lg", data[k].value);
         const char *expected = data[k].string;
@@ -2630,7 +2371,6 @@
   }
 
   { /* A negative number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", -0.03125L, 33, 44, 55);
     ASSERT (strcmp (result, "-0.03125 33") == 0);
@@ -2638,7 +2378,6 @@
   }
 
   { /* Positive zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", 0.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0 33") == 0);
@@ -2646,7 +2385,6 @@
   }
 
   { /* Negative zero.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", minus_zerol, 33, 44, 55);
     if (have_minus_zero ())
@@ -2655,7 +2393,6 @@
   }
 
   { /* Positive infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "inf 33") == 0
@@ -2664,7 +2401,6 @@
   }
 
   { /* Negative infinity.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "-inf 33") == 0
@@ -2673,7 +2409,6 @@
   }
 
   { /* NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2685,7 +2420,6 @@
   { /* Quiet NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2697,7 +2431,6 @@
     /* Signalling NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
     ASSERT (strlen (result) >= 3 + 3
@@ -2705,72 +2438,50 @@
             && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* sprintf should print something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Pseudo-Infinity.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Pseudo-Zero.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Unnormalized number.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
   { /* Pseudo-Denormal.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
-    char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
   }
 #endif
 
   { /* Width.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%10Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "      1.75 33") == 0);
@@ -2778,7 +2489,6 @@
   }
 
   { /* FLAG_LEFT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%-10Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.75       33") == 0);
@@ -2786,7 +2496,6 @@
   }
 
   { /* FLAG_SHOWSIGN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%+Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "+1.75 33") == 0);
@@ -2794,7 +2503,6 @@
   }
 
   { /* FLAG_SPACE.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "% Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, " 1.75 33") == 0);
@@ -2802,7 +2510,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.75000 33") == 0);
@@ -2810,7 +2517,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.Lg %d", 1.75L, 33, 44, 55);
     ASSERT (strcmp (result, "2. 33") == 0);
@@ -2818,7 +2524,6 @@
   }
 
   { /* FLAG_ALT.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
     ASSERT (strcmp (result, "1.e+01 33") == 0
@@ -2827,7 +2532,6 @@
   }
 
   { /* FLAG_ZERO with finite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%010Lg %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "0000001234 33") == 0);
@@ -2835,7 +2539,6 @@
   }
 
   { /* FLAG_ZERO with infinite number.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%015Lg %d", - Infinityl (), 33, 44, 55);
     ASSERT (strcmp (result, "           -inf 33") == 0
@@ -2844,7 +2547,6 @@
   }
 
   { /* FLAG_ZERO with NaN.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%050Lg %d", NaNl (), 33, 44, 55);
     ASSERT (strlen (result) == 50 + 3
@@ -2854,7 +2556,6 @@
   }
 
   { /* Precision.  */
-    char result[1000];
     int retval =
       my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
     ASSERT (strcmp (result, "1e+03 33") == 0
@@ -2863,7 +2564,6 @@
   }
 
   { /* Precision with no rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.5Lg %d", 999.951L, 33, 44, 55);
     ASSERT (strcmp (result, "999.95 33") == 0);
@@ -2871,7 +2571,6 @@
   }
 
   { /* Precision with rounding.  */
-    char result[100];
     int retval =
       my_sprintf (result, "%.5Lg %d", 999.996L, 33, 44, 55);
     ASSERT (strcmp (result, "1000 33") == 0);
@@ -2882,7 +2581,6 @@
 
   {
     int count = -1;
-    char result[1000];
     int retval =
       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
     ASSERT (strcmp (result, "123 ") == 0);
@@ -2893,7 +2591,6 @@
   /* Test the support of the POSIX/XSI format strings with positions.  */
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "%2$d %1$d", 33, 55);
     ASSERT (strcmp (result, "55 33") == 0);
@@ -2903,7 +2600,6 @@
   /* Test the support of the grouping flag.  */
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "%'d %d", 1234567, 99);
     ASSERT (result[strlen (result) - 1] == '9');
@@ -2913,7 +2609,6 @@
   /* Test the support of the left-adjust flag.  */
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "a%*sc", -3, "b");
     ASSERT (strcmp (result, "ab  c") == 0);
@@ -2921,7 +2616,6 @@
   }
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "a%-*sc", 3, "b");
     ASSERT (strcmp (result, "ab  c") == 0);
@@ -2929,7 +2623,6 @@
   }
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "a%-*sc", -3, "b");
     ASSERT (strcmp (result, "ab  c") == 0);
@@ -2939,7 +2632,6 @@
   /* Test the support of large precision.  */
 
   {
-    char result[5000];
     int retval =
       my_sprintf (result, "%.4000d %d", 1234567, 99);
     size_t i;
@@ -2950,7 +2642,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_sprintf (result, "%.*d %d", 4000, 1234567, 99);
     size_t i;
@@ -2961,7 +2652,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_sprintf (result, "%.4000d %d", -1234567, 99);
     size_t i;
@@ -2973,7 +2663,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_sprintf (result, "%.4000u %d", 1234567, 99);
     size_t i;
@@ -2984,7 +2673,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_sprintf (result, "%.4000o %d", 1234567, 99);
     size_t i;
@@ -2995,7 +2683,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_sprintf (result, "%.4000x %d", 1234567, 99);
     size_t i;
@@ -3006,7 +2693,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_sprintf (result, "%#.4000x %d", 1234567, 99);
     size_t i;
@@ -3019,7 +2705,6 @@
   }
 
   {
-    char result[5000];
     int retval =
       my_sprintf (result, "%.4000f %d", 1.0, 99);
     size_t i;
@@ -3032,7 +2717,6 @@
   }
 
   {
-    char result[1000];
     int retval =
       my_sprintf (result, "%.511f %d", 1.0, 99);
     size_t i;
@@ -3046,7 +2730,6 @@
 
   {
     char input[5000];
-    char result[5000];
     int retval;
     size_t i;
 
@@ -3070,7 +2753,6 @@
     for (i = 1; i <= 8; i++)
       {
         char *block;
-        char result[5000];
         int retval;
 
         block = (char *) malloc (i);
@@ -3090,7 +2772,6 @@
       {
         wchar_t *block;
         size_t j;
-        char result[5000];
         int retval;
 
         block = (wchar_t *) malloc (i * sizeof (wchar_t));
diff --git a/tests/test-vasnprintf-posix.c b/tests/test-vasnprintf-posix.c
--- a/tests/test-vasnprintf-posix.c
+++ b/tests/test-vasnprintf-posix.c
@@ -589,13 +589,7 @@
     ASSERT (length == strlen (result));
     free (result);
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* asnprintf should print something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
@@ -603,10 +597,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Infinity.  */
@@ -616,10 +608,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Zero.  */
@@ -629,10 +619,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Unnormalized number.  */
@@ -642,10 +630,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Denormal.  */
@@ -655,10 +641,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
 #endif
@@ -1403,13 +1387,7 @@
     ASSERT (length == strlen (result));
     free (result);
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* asnprintf should print something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
@@ -1417,10 +1395,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Infinity.  */
@@ -1430,10 +1406,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Zero.  */
@@ -1443,10 +1417,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Unnormalized number.  */
@@ -1456,10 +1428,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Denormal.  */
@@ -1469,10 +1439,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
 #endif
@@ -2405,10 +2373,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   {
@@ -2419,19 +2385,11 @@
     char *result =
       my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* asnprintf should print something even for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
@@ -2439,10 +2397,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Infinity.  */
@@ -2452,10 +2408,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Zero.  */
@@ -2465,10 +2419,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Unnormalized number.  */
@@ -2478,10 +2430,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Denormal.  */
@@ -2491,10 +2441,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
 #endif
@@ -3179,13 +3127,7 @@
     ASSERT (length == strlen (result));
     free (result);
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* asnprintf should print something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
@@ -3193,10 +3135,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Infinity.  */
@@ -3206,10 +3146,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Zero.  */
@@ -3219,10 +3157,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Unnormalized number.  */
@@ -3232,10 +3168,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Denormal.  */
@@ -3245,10 +3179,8 @@
     char *result =
       my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (length == strlen (result));
+    ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
     free (result);
   }
 #endif
diff --git a/tests/test-vasprintf-posix.c b/tests/test-vasprintf-posix.c
--- a/tests/test-vasprintf-posix.c
+++ b/tests/test-vasprintf-posix.c
@@ -570,13 +570,7 @@
     ASSERT (retval == strlen (result));
     free (result);
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* asprintf should print something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
@@ -584,10 +578,8 @@
     int retval =
       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Infinity.  */
@@ -597,10 +589,8 @@
     int retval =
       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Zero.  */
@@ -610,10 +600,8 @@
     int retval =
       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Unnormalized number.  */
@@ -623,10 +611,8 @@
     int retval =
       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Denormal.  */
@@ -636,10 +622,8 @@
     int retval =
       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
 #endif
@@ -1384,13 +1368,7 @@
     ASSERT (retval == strlen (result));
     free (result);
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* asprintf should print something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
@@ -1398,10 +1376,8 @@
     int retval =
       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Infinity.  */
@@ -1411,10 +1387,8 @@
     int retval =
       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Zero.  */
@@ -1424,10 +1398,8 @@
     int retval =
       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Unnormalized number.  */
@@ -1437,10 +1409,8 @@
     int retval =
       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Denormal.  */
@@ -1450,10 +1420,8 @@
     int retval =
       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
 #endif
@@ -2406,13 +2374,7 @@
     ASSERT (retval == strlen (result));
     free (result);
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* asprintf should print something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
@@ -2420,10 +2382,8 @@
     int retval =
       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Infinity.  */
@@ -2433,10 +2393,8 @@
     int retval =
       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Zero.  */
@@ -2446,10 +2404,8 @@
     int retval =
       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Unnormalized number.  */
@@ -2459,10 +2415,8 @@
     int retval =
       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Denormal.  */
@@ -2472,10 +2426,8 @@
     int retval =
       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
 #endif
@@ -3160,13 +3112,7 @@
     ASSERT (retval == strlen (result));
     free (result);
   }
-  /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
-     Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
-       Intel IA-64 Architecture Software Developer's Manual, Volume 1:
-       Application Architecture.
-       Table 5-2 "Floating-Point Register Encodings"
-       Figure 5-6 "Memory to Floating-Point Register Data Translation"
-   */
+  /* asprintf should print something for noncanonical values.  */
   { /* Pseudo-NaN.  */
     static union { unsigned int word[4]; long double value; } x =
       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
@@ -3174,10 +3120,8 @@
     int retval =
       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Infinity.  */
@@ -3187,10 +3131,8 @@
     int retval =
       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Zero.  */
@@ -3200,10 +3142,8 @@
     int retval =
       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Unnormalized number.  */
@@ -3213,10 +3153,8 @@
     int retval =
       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
   { /* Pseudo-Denormal.  */
@@ -3226,10 +3164,8 @@
     int retval =
       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
     ASSERT (result != NULL);
-    ASSERT (strlen (result) >= 3 + 3
-            && strisnan (result, 0, strlen (result) - 3, 0)
-            && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
+    ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
     free (result);
   }
 #endif