Re: Apply attribute returns_nonnull in libiberty

[Marc Glisse <marc dot glisse at inria dot fr>]

With the patch now...

On Fri, 11 Oct 2013, Marc Glisse wrote:

> Hello,
>
> here are some uses for returns_nonnull in libiberty.
>
> Bootstrap+testsuite (default languages) on x86_64-unknown-linux-gnu.
>
> 2013-10-11  Marc Glisse  <marc.glisse@inria.fr>
>
> 	PR tree-optimization/58689
> include/
> 	* ansidecl.h (ATTRIBUTE_RETURNS_NONNULL): New macro.
> 	* libiberty.h (basename, lbasename, dos_lbasename, unix_lbasename,
> 	concat_copy): Mark with attributes nonnull(1) and returns_nonnull.
> 	(concat, reconcat, concat_copy2, choose_temp_base, xstrerror,
> 	xmalloc, xrealloc, xcalloc, xstrdup, xstrndup, xmemdup, pex_init):
> 	Mark with attribute returns_nonnull.
>
> libiberty/
> 	* concat.c: Remove note about xmalloc.

--
Marc Glisse

Index: include/ansidecl.h
===================================================================
--- include/ansidecl.h	(revision 203451)
+++ include/ansidecl.h	(working copy)
@@ -304,20 +304,29 @@ So instead we use the macro below and te
 
 /* Attribute `nonnull' was valid as of gcc 3.3.  */
 #ifndef ATTRIBUTE_NONNULL
 # if (GCC_VERSION >= 3003)
 #  define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m)))
 # else
 #  define ATTRIBUTE_NONNULL(m)
 # endif /* GNUC >= 3.3 */
 #endif /* ATTRIBUTE_NONNULL */
 
+/* Attribute `returns_nonnull' was valid as of gcc 4.9.  */
+#ifndef ATTRIBUTE_RETURNS_NONNULL
+# if (GCC_VERSION >= 4009)
+#  define ATTRIBUTE_RETURNS_NONNULL __attribute__ ((__returns_nonnull__))
+# else
+#  define ATTRIBUTE_RETURNS_NONNULL
+# endif /* GNUC >= 4.9 */
+#endif /* ATTRIBUTE_RETURNS_NONNULL */
+
 /* Attribute `pure' was valid as of gcc 3.0.  */
 #ifndef ATTRIBUTE_PURE
 # if (GCC_VERSION >= 3000)
 #  define ATTRIBUTE_PURE __attribute__ ((__pure__))
 # else
 #  define ATTRIBUTE_PURE
 # endif /* GNUC >= 3.0 */
 #endif /* ATTRIBUTE_PURE */
 
 /* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL.
Index: include/libiberty.h
===================================================================
--- include/libiberty.h	(revision 203451)
+++ include/libiberty.h	(working copy)
@@ -100,82 +100,82 @@ extern int countargv (char**);
    across different systems, sometimes as "char *" and sometimes as
    "const char *" */
 
 /* HAVE_DECL_* is a three-state macro: undefined, 0 or 1.  If it is
    undefined, we haven't run the autoconf check so provide the
    declaration without arguments.  If it is 0, we checked and failed
    to find the declaration so provide a fully prototyped one.  If it
    is 1, we found it so don't provide any declaration at all.  */
 #if !HAVE_DECL_BASENAME
 #if defined (__GNU_LIBRARY__ ) || defined (__linux__) || defined (__FreeBSD__) || defined (__OpenBSD__) || defined(__NetBSD__) || defined (__CYGWIN__) || defined (__CYGWIN32__) || defined (__MINGW32__) || defined (HAVE_DECL_BASENAME)
-extern char *basename (const char *);
+extern char *basename (const char *) ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURNS_NONNULL;
 #else
 /* Do not allow basename to be used if there is no prototype seen.  We
    either need to use the above prototype or have one from
    autoconf which would result in HAVE_DECL_BASENAME being set.  */
 #define basename basename_cannot_be_used_without_a_prototype
 #endif
 #endif
 
 /* A well-defined basename () that is always compiled in.  */
 
-extern const char *lbasename (const char *);
+extern const char *lbasename (const char *) ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURNS_NONNULL;
 
 /* Same, but assumes DOS semantics (drive name, backslash is also a
    dir separator) regardless of host.  */
 
-extern const char *dos_lbasename (const char *);
+extern const char *dos_lbasename (const char *) ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURNS_NONNULL;
 
 /* Same, but assumes Unix semantics (absolute paths always start with
    a slash, only forward slash is accepted as dir separator)
    regardless of host.  */
 
-extern const char *unix_lbasename (const char *);
+extern const char *unix_lbasename (const char *) ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURNS_NONNULL;
 
 /* A well-defined realpath () that is always compiled in.  */
 
 extern char *lrealpath (const char *);
 
 /* Concatenate an arbitrary number of strings.  You must pass NULL as
    the last argument of this function, to terminate the list of
    strings.  Allocates memory using xmalloc.  */
 
-extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
+extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL ATTRIBUTE_RETURNS_NONNULL;
 
 /* Concatenate an arbitrary number of strings.  You must pass NULL as
    the last argument of this function, to terminate the list of
    strings.  Allocates memory using xmalloc.  The first argument is
    not one of the strings to be concatenated, but if not NULL is a
    pointer to be freed after the new string is created, similar to the
    way xrealloc works.  */
 
-extern char *reconcat (char *, const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
+extern char *reconcat (char *, const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL ATTRIBUTE_RETURNS_NONNULL;
 
 /* Determine the length of concatenating an arbitrary number of
    strings.  You must pass NULL as the last argument of this function,
    to terminate the list of strings.  */
 
 extern unsigned long concat_length (const char *, ...) ATTRIBUTE_SENTINEL;
 
 /* Concatenate an arbitrary number of strings into a SUPPLIED area of
    memory.  You must pass NULL as the last argument of this function,
    to terminate the list of strings.  The supplied memory is assumed
    to be large enough.  */
 
-extern char *concat_copy (char *, const char *, ...) ATTRIBUTE_SENTINEL;
+extern char *concat_copy (char *, const char *, ...) ATTRIBUTE_SENTINEL ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURNS_NONNULL;
 
 /* Concatenate an arbitrary number of strings into a GLOBAL area of
    memory.  You must pass NULL as the last argument of this function,
    to terminate the list of strings.  The supplied memory is assumed
    to be large enough.  */
 
-extern char *concat_copy2 (const char *, ...) ATTRIBUTE_SENTINEL;
+extern char *concat_copy2 (const char *, ...) ATTRIBUTE_SENTINEL ATTRIBUTE_RETURNS_NONNULL;
 
 /* This is the global area used by concat_copy2.  */
 
 extern char *libiberty_concat_ptr;
 
 /* Concatenate an arbitrary number of strings.  You must pass NULL as
    the last argument of this function, to terminate the list of
    strings.  Allocates memory using alloca.  The arguments are
    evaluated twice!  */
 #define ACONCAT(ACONCAT_PARAMS) \
@@ -219,21 +219,21 @@ extern char *make_relative_prefix (const
 
 /* Generate a relocated path to some installation directory without
    attempting to follow any soft links.  Allocates
    return value using malloc.  */
 
 extern char *make_relative_prefix_ignore_links (const char *, const char *,
 						const char *) ATTRIBUTE_MALLOC;
 
 /* Choose a temporary directory to use for scratch files.  */
 
-extern char *choose_temp_base (void) ATTRIBUTE_MALLOC;
+extern char *choose_temp_base (void) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
 
 /* Return a temporary file name or NULL if unable to create one.  */
 
 extern char *make_temp_file (const char *) ATTRIBUTE_MALLOC;
 
 /* Remove a link to a file unless it is special. */
 
 extern int unlink_if_ordinary (const char *);
 
 /* Allocate memory filled with spaces.  Allocates using malloc.  */
@@ -249,21 +249,21 @@ extern int errno_max (void);
    "EINVAL").  */
 
 extern const char *strerrno (int);
 
 /* Given the name of an errno value, return the value.  */
 
 extern int strtoerrno (const char *);
 
 /* ANSI's strerror(), but more robust.  */
 
-extern char *xstrerror (int);
+extern char *xstrerror (int) ATTRIBUTE_RETURNS_NONNULL;
 
 /* Return the maximum signal number for which strsignal will return a
    string.  */
 
 extern int signo_max (void);
 
 /* Return a signal message string for a signal number
    (e.g., strsignal (SIGHUP) returns something like "Hangup").  */
 /* This is commented out as it can conflict with one in system headers.
    We still document its existence though.  */
@@ -291,44 +291,44 @@ extern void xexit (int status) ATTRIBUTE
 
 extern void xmalloc_set_program_name (const char *);
 
 /* Report an allocation failure.  */
 extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN;
 
 /* Allocate memory without fail.  If malloc fails, this will print a
    message to stderr (using the name set by xmalloc_set_program_name,
    if any) and then call xexit.  */
 
-extern void *xmalloc (size_t) ATTRIBUTE_MALLOC;
+extern void *xmalloc (size_t) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
 
 /* Reallocate memory without fail.  This works like xmalloc.  Note,
    realloc type functions are not suitable for attribute malloc since
    they may return the same address across multiple calls. */
 
-extern void *xrealloc (void *, size_t);
+extern void *xrealloc (void *, size_t) ATTRIBUTE_RETURNS_NONNULL;
 
 /* Allocate memory without fail and set it to zero.  This works like
    xmalloc.  */
 
-extern void *xcalloc (size_t, size_t) ATTRIBUTE_MALLOC;
+extern void *xcalloc (size_t, size_t) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
 
 /* Copy a string into a memory buffer without fail.  */
 
-extern char *xstrdup (const char *) ATTRIBUTE_MALLOC;
+extern char *xstrdup (const char *) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
 
 /* Copy at most N characters from string into a buffer without fail.  */
 
-extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC;
+extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
 
 /* Copy an existing memory buffer to a new memory buffer without fail.  */
 
-extern void *xmemdup (const void *, size_t, size_t) ATTRIBUTE_MALLOC;
+extern void *xmemdup (const void *, size_t, size_t) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
 
 /* Physical memory routines.  Return values are in BYTES.  */
 extern double physmem_total (void);
 extern double physmem_available (void);
 
 /* Compute the 32-bit CRC of a block of memory.  */
 extern unsigned int xcrc32 (const unsigned char *, int, unsigned int);
 
 /* These macros provide a K&R/C89/C++-friendly way of allocating structures
    with nice encapsulation.  The XDELETE*() macros are technically
@@ -392,21 +392,21 @@ extern void hex_init (void);
 
 /* Prepare to execute one or more programs, with standard output of
    each program fed to standard input of the next.
    FLAGS	As above.
    PNAME	The name of the program to report in error messages.
    TEMPBASE	A base name to use for temporary files; may be NULL to
    		use a random name.
    Returns NULL on error.  */
 
 extern struct pex_obj *pex_init (int flags, const char *pname,
-				 const char *tempbase);
+				 const char *tempbase) ATTRIBUTE_RETURNS_NONNULL;
 
 /* Flags for pex_run.  These are bits to be or'ed together.  */
 
 /* Last program in pipeline.  Standard output of program goes to
    OUTNAME, or, if OUTNAME is NULL, to standard output of caller.  Do
    not set this if you want to call pex_read_output.  After this is
    set, pex_run may no longer be called with the same struct
    pex_obj.  */
 #define PEX_LAST		0x1
 
Index: libiberty/concat.c
===================================================================
--- libiberty/concat.c	(revision 203451)
+++ libiberty/concat.c	(working copy)
@@ -18,37 +18,25 @@ License along with libiberty; see the fi
 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
 Boston, MA 02110-1301, USA.  */
 
 
 /*
 
 @deftypefn Extension char* concat (const char *@var{s1}, const char *@var{s2}, @
   @dots{}, @code{NULL})
 
 Concatenate zero or more of strings and return the result in freshly
-@code{xmalloc}ed memory.  Returns @code{NULL} if insufficient memory is
-available.  The argument list is terminated by the first @code{NULL}
-pointer encountered.  Pointers to empty strings are ignored.
+@code{xmalloc}ed memory.  The argument list is terminated by the first
+@code{NULL} pointer encountered.  Pointers to empty strings are ignored.
 
 @end deftypefn
 
-NOTES
-
-	This function uses xmalloc() which is expected to be a front end
-	function to malloc() that deals with low memory situations.  In
-	typical use, if malloc() returns NULL then xmalloc() diverts to an
-	error handler routine which never returns, and thus xmalloc will
-	never return a NULL pointer.  If the client application wishes to
-	deal with low memory situations itself, it should supply an xmalloc
-	that just directly invokes malloc and blindly returns whatever
-	malloc returns.
-
 */
 
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include "ansidecl.h"
 #include "libiberty.h"
 #include <sys/types.h>		/* size_t */