X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=inline;f=include%2Flibiberty.h;h=8f7d5f64930ee4111f1cce245c90c720c7b46b10;hb=8b8c7c9f49992750f66f81b4601d593a3858d98c;hp=3f51e41312d1a111e4540537a20468f147a45e82;hpb=e172dbf8aa714653f2a1758df60fc169886be232;p=deliverable%2Fbinutils-gdb.git diff --git a/include/libiberty.h b/include/libiberty.h index 3f51e41312..8f7d5f6493 100644 --- a/include/libiberty.h +++ b/include/libiberty.h @@ -1,6 +1,6 @@ /* Function declarations for libiberty. - Copyright 2001, 2002, 2005 Free Software Foundation, Inc. + Copyright (C) 1997-2016 Free Software Foundation, Inc. Note - certain prototypes declared in this header file are for functions whoes implementation copyright does not belong to the @@ -80,8 +80,19 @@ extern void freeargv (char **); /* Duplicate an argument vector. Allocates memory using malloc. Use freeargv to free the vector. */ -extern char **dupargv (char **) ATTRIBUTE_MALLOC; +extern char **dupargv (char * const *) ATTRIBUTE_MALLOC; +/* Expand "@file" arguments in argv. */ + +extern void expandargv (int *, char ***); + +/* Write argv to an @-file, inserting necessary quoting. */ + +extern int writeargv (char * const *, FILE *); + +/* Return the number of elements in argv. */ + +extern int countargv (char * const *); /* Return the last component of a path name. Note that we can't use a prototype here because the parameter is declared inconsistently @@ -94,16 +105,33 @@ extern char **dupargv (char **) ATTRIBUTE_MALLOC; 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 *); +#if defined (__GNU_LIBRARY__ ) || defined (__linux__) \ + || defined (__FreeBSD__) || defined (__OpenBSD__) || defined (__NetBSD__) \ + || defined (__CYGWIN__) || defined (__CYGWIN32__) || defined (__MINGW32__) \ + || defined (__DragonFly__) || defined (HAVE_DECL_BASENAME) +extern char *basename (const char *) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_NONNULL(1); #else -extern char *basename (); +/* 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_RETURNS_NONNULL ATTRIBUTE_NONNULL(1); + +/* Same, but assumes DOS semantics (drive name, backslash is also a + dir separator) regardless of host. */ + +extern const char *dos_lbasename (const char *) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_NONNULL(1); + +/* 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 *) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_NONNULL(1); /* A well-defined realpath () that is always compiled in. */ @@ -113,7 +141,7 @@ extern char *lrealpath (const char *); 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_RETURNS_NONNULL ATTRIBUTE_SENTINEL; /* Concatenate an arbitrary number of strings. You must pass NULL as the last argument of this function, to terminate the list of @@ -122,7 +150,7 @@ extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL; 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_RETURNS_NONNULL ATTRIBUTE_SENTINEL; /* Determine the length of concatenating an arbitrary number of strings. You must pass NULL as the last argument of this function, @@ -135,14 +163,14 @@ extern unsigned long concat_length (const char *, ...) ATTRIBUTE_SENTINEL; 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_RETURNS_NONNULL ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL; /* 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_RETURNS_NONNULL ATTRIBUTE_SENTINEL; /* This is the global area used by concat_copy2. */ @@ -153,7 +181,7 @@ extern char *libiberty_concat_ptr; strings. Allocates memory using alloca. The arguments are evaluated twice! */ #define ACONCAT(ACONCAT_PARAMS) \ - (libiberty_concat_ptr = alloca (concat_length ACONCAT_PARAMS + 1), \ + (libiberty_concat_ptr = (char *) alloca (concat_length ACONCAT_PARAMS + 1), \ concat_copy2 ACONCAT_PARAMS) /* Check whether two file descriptors refer to the same file. */ @@ -191,9 +219,21 @@ extern long get_run_time (void); extern char *make_relative_prefix (const char *, const char *, const char *) ATTRIBUTE_MALLOC; +/* 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; + +/* Returns a pointer to a directory path suitable for creating temporary + files in. */ + +extern const char *choose_tmpdir (void) ATTRIBUTE_RETURNS_NONNULL; + /* 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. */ @@ -223,7 +263,7 @@ 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. */ @@ -265,35 +305,37 @@ extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN; 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 @@ -303,27 +345,35 @@ extern double physmem_available (void); /* Scalar allocators. */ +#define XALLOCA(T) ((T *) alloca (sizeof (T))) #define XNEW(T) ((T *) xmalloc (sizeof (T))) #define XCNEW(T) ((T *) xcalloc (1, sizeof (T))) +#define XDUP(T, P) ((T *) xmemdup ((P), sizeof (T), sizeof (T))) #define XDELETE(P) free ((void*) (P)) /* Array allocators. */ +#define XALLOCAVEC(T, N) ((T *) alloca (sizeof (T) * (N))) #define XNEWVEC(T, N) ((T *) xmalloc (sizeof (T) * (N))) #define XCNEWVEC(T, N) ((T *) xcalloc ((N), sizeof (T))) +#define XDUPVEC(T, P, N) ((T *) xmemdup ((P), sizeof (T) * (N), sizeof (T) * (N))) #define XRESIZEVEC(T, P, N) ((T *) xrealloc ((void *) (P), sizeof (T) * (N))) #define XDELETEVEC(P) free ((void*) (P)) /* Allocators for variable-sized structures and raw buffers. */ +#define XALLOCAVAR(T, S) ((T *) alloca ((S))) #define XNEWVAR(T, S) ((T *) xmalloc ((S))) #define XCNEWVAR(T, S) ((T *) xcalloc (1, (S))) +#define XDUPVAR(T, P, S1, S2) ((T *) xmemdup ((P), (S1), (S2))) #define XRESIZEVAR(T, P, S) ((T *) xrealloc ((P), (S))) /* Type-safe obstack allocator. */ #define XOBNEW(O, T) ((T *) obstack_alloc ((O), sizeof (T))) - +#define XOBNEWVEC(O, T, N) ((T *) obstack_alloc ((O), sizeof (T) * (N))) +#define XOBNEWVAR(O, T, S) ((T *) obstack_alloc ((O), (S))) +#define XOBFINISH(O, T) ((T) obstack_finish ((O))) /* hex character manipulation routines */ @@ -356,7 +406,7 @@ extern void hex_init (void); 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. */ @@ -387,6 +437,24 @@ extern struct pex_obj *pex_init (int flags, const char *pname, PEX_BINARY_INPUT. */ #define PEX_BINARY_OUTPUT 0x20 +/* Capture stderr to a pipe. The output can be read by + calling pex_read_err and reading from the returned + FILE object. This flag may be specified only for + the last program in a pipeline. + + This flag is supported only on Unix and Windows. */ +#define PEX_STDERR_TO_PIPE 0x40 + +/* Capture stderr in binary mode. This flag is ignored + on Unix. */ +#define PEX_BINARY_ERROR 0x80 + +/* Append stdout to existing file instead of truncating it. */ +#define PEX_STDOUT_APPEND 0x100 + +/* Thes same as PEX_STDOUT_APPEND, but for STDERR. */ +#define PEX_STDERR_APPEND 0x200 + /* Execute one program. Returns NULL on success. On error returns an error string (typically just the name of a system call); the error string is statically allocated. @@ -442,6 +510,37 @@ extern const char *pex_run (struct pex_obj *obj, int flags, const char *outname, const char *errname, int *err); +/* As for pex_run (), but takes an extra parameter to enable the + environment for the child process to be specified. + + ENV The environment for the child process, specified as + an array of character pointers. Each element of the + array should point to a string of the form VAR=VALUE, + with the exception of the last element which must be + a null pointer. +*/ + +extern const char *pex_run_in_environment (struct pex_obj *obj, int flags, + const char *executable, + char * const *argv, + char * const *env, + const char *outname, + const char *errname, int *err); + +/* Return a stream for a temporary file to pass to the first program + in the pipeline as input. The file name is chosen as for pex_run. + pex_run closes the file automatically; don't close it yourself. */ + +extern FILE *pex_input_file (struct pex_obj *obj, int flags, + const char *in_name); + +/* Return a stream for a pipe connected to the standard input of the + first program in the pipeline. You must have passed + `PEX_USE_PIPES' to `pex_init'. Close the returned stream + yourself. */ + +extern FILE *pex_input_pipe (struct pex_obj *obj, int binary); + /* Read the standard output of the last program to be executed. pex_run can not be called after this. BINARY should be non-zero if the file should be opened in binary mode; this is ignored on Unix. @@ -450,6 +549,14 @@ extern const char *pex_run (struct pex_obj *obj, int flags, extern FILE *pex_read_output (struct pex_obj *, int binary); +/* Read the standard error of the last program to be executed. + pex_run can not be called after this. BINARY should be non-zero if + the file should be opened in binary mode; this is ignored on Unix. + Returns NULL on error. Don't call fclose on the returned FILE; it + will be closed by pex_free. */ + +extern FILE *pex_read_err (struct pex_obj *, int binary); + /* Return exit status of all programs in VECTOR. COUNT indicates the size of VECTOR. The status codes in the vector are in the order of the calls to pex_run. Returns 0 on error, 1 on success. */ @@ -472,7 +579,8 @@ struct pex_time extern int pex_get_times (struct pex_obj *, int count, struct pex_time *vector); -/* Clean up a pex_obj. */ +/* Clean up a pex_obj. If you have not called pex_get_times or + pex_get_status, this will try to kill the subprocesses. */ extern void pex_free (struct pex_obj *); @@ -513,21 +621,82 @@ extern int pexecute (const char *, char * const *, const char *, extern int pwait (int, int *, int); -#if !HAVE_DECL_ASPRINTF +#if defined(HAVE_DECL_ASPRINTF) && !HAVE_DECL_ASPRINTF /* Like sprintf but provides a pointer to malloc'd storage, which must be freed by the caller. */ extern int asprintf (char **, const char *, ...) ATTRIBUTE_PRINTF_2; #endif +/* Like asprintf but allocates memory without fail. This works like + xmalloc. */ + +extern char *xasprintf (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_PRINTF_1; + #if !HAVE_DECL_VASPRINTF /* Like vsprintf but provides a pointer to malloc'd storage, which must be freed by the caller. */ -extern int vasprintf (char **, const char *, va_list) - ATTRIBUTE_PRINTF(2,0); +extern int vasprintf (char **, const char *, va_list) ATTRIBUTE_PRINTF(2,0); +#endif + +/* Like vasprintf but allocates memory without fail. This works like + xmalloc. */ + +extern char *xvasprintf (const char *, va_list) ATTRIBUTE_MALLOC ATTRIBUTE_PRINTF(1,0); + +#if defined(HAVE_DECL_SNPRINTF) && !HAVE_DECL_SNPRINTF +/* Like sprintf but prints at most N characters. */ +extern int snprintf (char *, size_t, const char *, ...) ATTRIBUTE_PRINTF_3; +#endif + +#if defined(HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF +/* Like vsprintf but prints at most N characters. */ +extern int vsnprintf (char *, size_t, const char *, va_list) ATTRIBUTE_PRINTF(3,0); +#endif + +#if defined (HAVE_DECL_STRNLEN) && !HAVE_DECL_STRNLEN +extern size_t strnlen (const char *, size_t); +#endif + +#if defined(HAVE_DECL_STRVERSCMP) && !HAVE_DECL_STRVERSCMP +/* Compare version strings. */ +extern int strverscmp (const char *, const char *); +#endif + +#if defined(HAVE_DECL_STRTOL) && !HAVE_DECL_STRTOL +extern long int strtol (const char *nptr, + char **endptr, int base); +#endif + +#if defined(HAVE_DECL_STRTOUL) && !HAVE_DECL_STRTOUL +extern unsigned long int strtoul (const char *nptr, + char **endptr, int base); #endif +#if defined(HAVE_LONG_LONG) && defined(HAVE_DECL_STRTOLL) && !HAVE_DECL_STRTOLL +__extension__ +extern long long int strtoll (const char *nptr, + char **endptr, int base); +#endif + +#if defined(HAVE_LONG_LONG) && defined(HAVE_DECL_STRTOULL) && !HAVE_DECL_STRTOULL +__extension__ +extern unsigned long long int strtoull (const char *nptr, + char **endptr, int base); +#endif + +#if defined(HAVE_DECL_STRVERSCMP) && !HAVE_DECL_STRVERSCMP +/* Compare version strings. */ +extern int strverscmp (const char *, const char *); +#endif + +/* Set the title of a process */ +extern void setproctitle (const char *name, ...); + +/* Increase stack limit if possible. */ +extern void stack_limit_increase (unsigned long); + #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) /* Drastically simplified alloca configurator. If we're using GCC,