tests: use xmalloc to allocate implementation array

The benchmark and tests must fail in case of allocation failure in the
implementation array.  Also annotate the x* allocators in support.h so
that the compiler has more information about them.

Reviewed-by: Florian Weimer <fweimer@redhat.com>

diff --git a/benchtests/bench-string.h b/benchtests/bench-string.h
index fd25264..12f2747 100644 (file)
--- a/benchtests/bench-string.h
+++ b/benchtests/bench-string.h
@@ -18,6 +18,7 @@
 
 #include <getopt.h>
 #include <sys/cdefs.h>
+#include <programs/xmalloc.h>
 
 /* We are compiled under _ISOMAC, so libc-symbols.h does not do this
    for us.  */
@@ -200,8 +201,8 @@ static impl_t *impl_array;
                 skip = impl;                                                 \
               else                                                           \
                 impl_count++;                                                \
-            a = impl_array = malloc ((impl_count + func_count) *             \
-                                  sizeof (impl_t));                          \
+            a = impl_array = xmalloc ((impl_count + func_count) *            \
+                                      sizeof (impl_t));                      \
             for (impl = __start_impls; impl < __stop_impls; ++impl)          \
               if (impl != skip)                                              \
                 *a++ = *impl;                                                \

diff --git a/string/test-string.h b/string/test-string.h
index febde61..78b66ef 100644 (file)
--- a/string/test-string.h
+++ b/string/test-string.h
@@ -18,6 +18,7 @@
    <https://www.gnu.org/licenses/>.  */
 
 #include <sys/cdefs.h>
+#include <support/support.h>
 
 typedef struct
 {
@@ -146,8 +147,8 @@ static impl_t *impl_array;
              skip = impl;                                              \
            else                                                        \
              impl_count++;                                             \
-         a = impl_array = malloc ((impl_count + func_count) *          \
-                                  sizeof (impl_t));                    \
+         a = impl_array = xmalloc ((impl_count + func_count) *         \
+                                   sizeof (impl_t));                   \
          for (impl = __start_impls; impl < __stop_impls; ++impl)       \
            if (impl != skip)                                           \
              *a++ = *impl;                                             \

diff --git a/support/support.h b/support/support.h
index dbd270c..834dba9 100644 (file)
--- a/support/support.h
+++ b/support/support.h
@@ -87,14 +87,24 @@ int support_descriptor_supports_holes (int fd);
 /* Error-checking wrapper functions which terminate the process on
    error.  */
 
-void *xmalloc (size_t) __attribute__ ((malloc));
-void *xcalloc (size_t n, size_t s) __attribute__ ((malloc));
-void *xrealloc (void *p, size_t n);
-void *xposix_memalign (size_t alignment, size_t n);
+extern void *xmalloc (size_t n)
+  __attribute_malloc__ __attribute_alloc_size__ ((1)) __attr_dealloc_free
+  __returns_nonnull;
+extern void *xcalloc (size_t n, size_t s)
+  __attribute_malloc__ __attribute_alloc_size__ ((1, 2)) __attr_dealloc_free
+  __returns_nonnull;
+extern void *xrealloc (void *o, size_t n)
+  __attribute_malloc__ __attribute_alloc_size__ ((2)) __attr_dealloc_free;
+extern char *xstrdup (const char *) __attribute_malloc__ __attr_dealloc_free
+  __returns_nonnull;
+void *xposix_memalign (size_t alignment, size_t n)
+  __attribute_malloc__ __attribute_alloc_size__ ((2)) __attr_dealloc_free
+  __returns_nonnull;
 char *xasprintf (const char *format, ...)
-  __attribute__ ((format (printf, 1, 2), malloc));
-char *xstrdup (const char *);
-char *xstrndup (const char *, size_t);
+  __attribute__ ((format (printf, 1, 2), malloc)) __attr_dealloc_free
+  __returns_nonnull;
+char *xstrdup (const char *) __attr_dealloc_free __returns_nonnull;
+char *xstrndup (const char *, size_t) __attr_dealloc_free __returns_nonnull;
 char *xsetlocale (int category, const char *locale);
 locale_t xnewlocale (int category_mask, const char *locale, locale_t base);
 char *xuselocale (locale_t newloc);