X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=bfd%2Fopncls.c;h=a5bc2de3648135e2a304041b169c7c1d827f1b87;hb=a6ad7914429a22d3d835bd998b032212b776a08a;hp=56b5925cd6be0fbbe432c441f544a645da192505;hpb=a366f4ff7b68695744106ce633100166f872d232;p=thirdparty%2Fbinutils-gdb.git diff --git a/bfd/opncls.c b/bfd/opncls.c index 56b5925cd6b..a5bc2de3648 100644 --- a/bfd/opncls.c +++ b/bfd/opncls.c @@ -1,7 +1,5 @@ /* opncls.c -- open and close a BFD. - Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, - 2001, 2002, 2003, 2004, 2005 - Free Software Foundation, Inc. + Copyright (C) 1990-2022 Free Software Foundation, Inc. Written by Cygnus Support. @@ -9,7 +7,7 @@ This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -19,13 +17,15 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "objalloc.h" #include "libbfd.h" #include "libiberty.h" +#include "elf-bfd.h" #ifndef S_IXUSR #define S_IXUSR 0100 /* Execute by owner. */ @@ -37,9 +37,17 @@ #define S_IXOTH 0001 /* Execute by others. */ #endif -/* Counter used to initialize the bfd identifier. */ +/* Counters used to initialize the bfd identifier. */ -static unsigned int _bfd_id_counter = 0; +static unsigned int bfd_id_counter = 0; +static unsigned int bfd_reserved_id_counter = 0; + +/* +CODE_FRAGMENT +.{* Set to N to open the next N BFDs using an alternate id space. *} +.extern unsigned int bfd_use_reserved_id; +*/ +unsigned int bfd_use_reserved_id = 0; /* fdopen is a loser -- we should use stdio exclusively. Unfortunately if we do that we can't use fcntl. */ @@ -51,11 +59,17 @@ _bfd_new_bfd (void) { bfd *nbfd; - nbfd = bfd_zmalloc (sizeof (bfd)); + nbfd = (bfd *) bfd_zmalloc (sizeof (bfd)); if (nbfd == NULL) return NULL; - nbfd->id = _bfd_id_counter++; + if (bfd_use_reserved_id) + { + nbfd->id = --bfd_reserved_id_counter; + --bfd_use_reserved_id; + } + else + nbfd->id = bfd_id_counter++; nbfd->memory = objalloc_create (); if (nbfd->memory == NULL) @@ -67,31 +81,21 @@ _bfd_new_bfd (void) nbfd->arch_info = &bfd_default_arch_struct; - nbfd->direction = no_direction; - nbfd->iostream = NULL; - nbfd->where = 0; if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc, - 251)) + sizeof (struct section_hash_entry), 13)) { + objalloc_free ((struct objalloc *) nbfd->memory); free (nbfd); return NULL; } - nbfd->sections = NULL; - nbfd->section_last = NULL; - nbfd->format = bfd_unknown; - nbfd->my_archive = NULL; - nbfd->origin = 0; - nbfd->opened_once = FALSE; - nbfd->output_has_begun = FALSE; - nbfd->section_count = 0; - nbfd->usrdata = NULL; - nbfd->cacheable = FALSE; - nbfd->flags = BFD_NO_FLAGS; - nbfd->mtime_set = FALSE; + + nbfd->archive_plugin_fd = -1; return nbfd; } +static const struct bfd_iovec opncls_iovec; + /* Allocate a new BFD as a member of archive OBFD. */ bfd * @@ -104,26 +108,83 @@ _bfd_new_bfd_contained_in (bfd *obfd) return NULL; nbfd->xvec = obfd->xvec; nbfd->iovec = obfd->iovec; + if (obfd->iovec == &opncls_iovec) + nbfd->iostream = obfd->iostream; nbfd->my_archive = obfd; nbfd->direction = read_direction; nbfd->target_defaulted = obfd->target_defaulted; + nbfd->lto_output = obfd->lto_output; + nbfd->no_export = obfd->no_export; return nbfd; } /* Delete a BFD. */ -void +static void _bfd_delete_bfd (bfd *abfd) { - bfd_hash_table_free (&abfd->section_htab); - objalloc_free ((struct objalloc *) abfd->memory); + if (abfd->memory) + { + bfd_hash_table_free (&abfd->section_htab); + objalloc_free ((struct objalloc *) abfd->memory); + } + else + free ((char *) bfd_get_filename (abfd)); + + free (abfd->arelt_data); free (abfd); } +/* Free objalloc memory. */ + +bool +_bfd_free_cached_info (bfd *abfd) +{ + if (abfd->memory) + { + const char *filename = bfd_get_filename (abfd); + if (filename) + { + /* We can't afford to lose the bfd filename when freeing + abfd->memory, because that would kill the cache.c scheme + of closing and reopening files in order to limit the + number of open files. To reopen, you need the filename. + And indeed _bfd_compute_and_write_armap calls + _bfd_free_cached_info to free up space used by symbols + and by check_format_matches. Which we want to continue + doing to handle very large archives. Later the archive + elements are copied, which might require reopening files. + We also want to keep using objalloc memory for the + filename since that allows the name to be updated + without either leaking memory or implementing some sort + of reference counted string for copies of the filename. */ + size_t len = strlen (filename) + 1; + char *copy = bfd_malloc (len); + if (copy == NULL) + return false; + memcpy (copy, filename, len); + abfd->filename = copy; + } + bfd_hash_table_free (&abfd->section_htab); + objalloc_free ((struct objalloc *) abfd->memory); + + abfd->sections = NULL; + abfd->section_last = NULL; + abfd->outsymbols = NULL; + abfd->tdata.any = NULL; + abfd->usrdata = NULL; + abfd->memory = NULL; + } + + return true; +} + /* SECTION Opening and closing BFDs +SUBSECTION + Functions for opening and closing */ /* @@ -132,14 +193,14 @@ FUNCTION SYNOPSIS bfd *bfd_fopen (const char *filename, const char *target, - const char *mode, int fd); + const char *mode, int fd); DESCRIPTION Open the file @var{filename} with the target @var{target}. Return a pointer to the created BFD. If @var{fd} is not -1, then <> is used to open the file; otherwise, <> is used. @var{mode} is passed directly to <> or - <>. + <>. Calls <>, so @var{target} is interpreted as by that function. @@ -149,6 +210,11 @@ DESCRIPTION If <> is returned then an error has occured. Possible errors are <>, <> or <> error. + + On error, @var{fd} is always closed. + + A copy of the @var{filename} argument is stored in the newly created + BFD. It can be accessed via the bfd_get_filename() macro. */ bfd * @@ -159,34 +225,50 @@ bfd_fopen (const char *filename, const char *target, const char *mode, int fd) nbfd = _bfd_new_bfd (); if (nbfd == NULL) - return NULL; + { + if (fd != -1) + close (fd); + return NULL; + } target_vec = bfd_find_target (target, nbfd); if (target_vec == NULL) { + if (fd != -1) + close (fd); _bfd_delete_bfd (nbfd); return NULL; } - + #ifdef HAVE_FDOPEN if (fd != -1) nbfd->iostream = fdopen (fd, mode); else #endif - nbfd->iostream = fopen (filename, mode); + nbfd->iostream = _bfd_real_fopen (filename, mode); if (nbfd->iostream == NULL) { bfd_set_error (bfd_error_system_call); + if (fd != -1) + close (fd); _bfd_delete_bfd (nbfd); return NULL; } /* OK, put everything where it belongs. */ - nbfd->filename = filename; + + /* PR 11983: Do not cache the original filename, but + rather make a copy - the original might go away. */ + if (!bfd_set_filename (nbfd, filename)) + { + fclose (nbfd->iostream); + _bfd_delete_bfd (nbfd); + return NULL; + } /* Figure out whether the user is opening the file for reading, writing, or both, by looking at the MODE argument. */ - if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a') + if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a') && mode[1] == '+') nbfd->direction = both_direction; else if (mode[0] == 'r') @@ -194,18 +276,20 @@ bfd_fopen (const char *filename, const char *target, const char *mode, int fd) else nbfd->direction = write_direction; - if (! bfd_cache_init (nbfd)) + if (!bfd_cache_init (nbfd)) { + fclose (nbfd->iostream); _bfd_delete_bfd (nbfd); return NULL; } - nbfd->opened_once = TRUE; + nbfd->opened_once = true; + /* If we opened the file by name, mark it cacheable; we can close it and reopen it later. However, if a file descriptor was provided, then it may have been opened with special flags that make it unsafe to close and reopen the file. */ if (fd == -1) - bfd_set_cacheable (nbfd, TRUE); + (void) bfd_set_cacheable (nbfd, true); return nbfd; } @@ -227,6 +311,9 @@ DESCRIPTION If <> is returned then an error has occured. Possible errors are <>, <> or <> error. + + A copy of the @var{filename} argument is stored in the newly created + BFD. It can be accessed via the bfd_get_filename() macro. */ bfd * @@ -266,6 +353,11 @@ DESCRIPTION Possible errors are <>, <> and <>. + + On error, @var{fd} is closed. + + A copy of the @var{filename} argument is stored in the newly created + BFD. It can be accessed via the bfd_get_filename() macro. */ bfd * @@ -282,6 +374,10 @@ bfd_fdopenr (const char *filename, const char *target, int fd) fdflags = fcntl (fd, F_GETFL, NULL); if (fdflags == -1) { + int save = errno; + + close (fd); + errno = save; bfd_set_error (bfd_error_system_call); return NULL; } @@ -301,21 +397,57 @@ bfd_fdopenr (const char *filename, const char *target, int fd) /* FUNCTION - bfd_openstreamr + bfd_fdopenw SYNOPSIS - bfd *bfd_openstreamr (const char *, const char *, void *); + bfd *bfd_fdopenw (const char *filename, const char *target, int fd); DESCRIPTION + <> is exactly like <> with the exception that + the resulting BFD is suitable for output. +*/ + +bfd * +bfd_fdopenw (const char *filename, const char *target, int fd) +{ + bfd *out = bfd_fdopenr (filename, target, fd); + + if (out != NULL) + { + if (!bfd_write_p (out)) + { + close (fd); + _bfd_delete_bfd (out); + out = NULL; + bfd_set_error (bfd_error_invalid_operation); + } + else + out->direction = write_direction; + } + return out; +} + +/* +FUNCTION + bfd_openstreamr + +SYNOPSIS + bfd *bfd_openstreamr (const char * filename, const char * target, + void * stream); + +DESCRIPTION Open a BFD for read access on an existing stdio stream. When the BFD is passed to <>, the stream will be closed. + + A copy of the @var{filename} argument is stored in the newly created + BFD. It can be accessed via the bfd_get_filename() macro. */ bfd * bfd_openstreamr (const char *filename, const char *target, void *streamarg) { - FILE *stream = streamarg; + FILE *stream = (FILE *) streamarg; bfd *nbfd; const bfd_target *target_vec; @@ -331,7 +463,13 @@ bfd_openstreamr (const char *filename, const char *target, void *streamarg) } nbfd->iostream = stream; - nbfd->filename = filename; + /* PR 11983: Do not cache the original filename, but + rather make a copy - the original might go away. */ + if (!bfd_set_filename (nbfd, filename)) + { + _bfd_delete_bfd (nbfd); + return NULL; + } nbfd->direction = read_direction; if (! bfd_cache_init (nbfd)) @@ -348,47 +486,55 @@ FUNCTION bfd_openr_iovec SYNOPSIS - bfd *bfd_openr_iovec (const char *filename, const char *target, - void *(*open) (struct bfd *nbfd, - void *open_closure), - void *open_closure, - file_ptr (*pread) (struct bfd *nbfd, - void *stream, - void *buf, - file_ptr nbytes, - file_ptr offset), - int (*close) (struct bfd *nbfd, - void *stream)); + bfd *bfd_openr_iovec (const char *filename, const char *target, + void *(*open_func) (struct bfd *nbfd, + void *open_closure), + void *open_closure, + file_ptr (*pread_func) (struct bfd *nbfd, + void *stream, + void *buf, + file_ptr nbytes, + file_ptr offset), + int (*close_func) (struct bfd *nbfd, + void *stream), + int (*stat_func) (struct bfd *abfd, + void *stream, + struct stat *sb)); DESCRIPTION - - Create and return a BFD backed by a read-only @var{stream}. - The @var{stream} is created using @var{open}, accessed using - @var{pread} and destroyed using @var{close}. + Create and return a BFD backed by a read-only @var{stream}. + The @var{stream} is created using @var{open_func}, accessed using + @var{pread_func} and destroyed using @var{close_func}. Calls <>, so @var{target} is interpreted as by that function. - Calls @var{open} (which can call <> and + Calls @var{open_func} (which can call <> and <>) to obtain the read-only stream backing - the BFD. @var{open} either succeeds returning the + the BFD. @var{open_func} either succeeds returning the non-<> @var{stream}, or fails returning <> (setting <>). - Calls @var{pread} to request @var{nbytes} of data from + Calls @var{pread_func} to request @var{nbytes} of data from @var{stream} starting at @var{offset} (e.g., via a call to - <>). @var{pread} either succeeds returning the + <>). @var{pread_func} either succeeds returning the number of bytes read (which can be less than @var{nbytes} when end-of-file), or fails returning -1 (setting <>). - Calls @var{close} when the BFD is later closed using - <>. @var{close} either succeeds returning 0, or + Calls @var{close_func} when the BFD is later closed using + <>. @var{close_func} either succeeds returning 0, or fails returning -1 (setting <>). + Calls @var{stat_func} to fill in a stat structure for bfd_stat, + bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0 + on success, or returns -1 on failure (setting <>). + If <> returns <> then an error has occurred. Possible errors are <>, <> and <>. + A copy of the @var{filename} argument is stored in the newly created + BFD. It can be accessed via the bfd_get_filename() macro. */ struct opncls @@ -397,20 +543,21 @@ struct opncls file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset); int (*close) (struct bfd *abfd, void *stream); + int (*stat) (struct bfd *abfd, void *stream, struct stat *sb); file_ptr where; }; static file_ptr opncls_btell (struct bfd *abfd) { - struct opncls *vec = abfd->iostream; + struct opncls *vec = (struct opncls *) abfd->iostream; return vec->where; } static int opncls_bseek (struct bfd *abfd, file_ptr offset, int whence) { - struct opncls *vec = abfd->iostream; + struct opncls *vec = (struct opncls *) abfd->iostream; switch (whence) { case SEEK_SET: vec->where = offset; break; @@ -423,8 +570,9 @@ opncls_bseek (struct bfd *abfd, file_ptr offset, int whence) static file_ptr opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes) { - struct opncls *vec = abfd->iostream; + struct opncls *vec = (struct opncls *) abfd->iostream; file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where); + if (nread < 0) return nread; vec->where += nread; @@ -442,10 +590,11 @@ opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED, static int opncls_bclose (struct bfd *abfd) { - struct opncls *vec = abfd->iostream; + struct opncls *vec = (struct opncls *) abfd->iostream; /* Since the VEC's memory is bound to the bfd deleting the bfd will free it. */ int status = 0; + if (vec->close != NULL) status = (vec->close) (abfd, vec->stream); abfd->iostream = NULL; @@ -459,29 +608,44 @@ opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED) } static int -opncls_bstat (struct bfd *abfd ATTRIBUTE_UNUSED, struct stat *sb) +opncls_bstat (struct bfd *abfd, struct stat *sb) { + struct opncls *vec = (struct opncls *) abfd->iostream; + memset (sb, 0, sizeof (*sb)); - return 0; + if (vec->stat == NULL) + return 0; + + return (vec->stat) (abfd, vec->stream, sb); } -static const struct bfd_iovec opncls_iovec = { +static void * +opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED, + void *addr ATTRIBUTE_UNUSED, + bfd_size_type len ATTRIBUTE_UNUSED, + int prot ATTRIBUTE_UNUSED, + int flags ATTRIBUTE_UNUSED, + file_ptr offset ATTRIBUTE_UNUSED, + void **map_addr ATTRIBUTE_UNUSED, + bfd_size_type *map_len ATTRIBUTE_UNUSED) +{ + return (void *) -1; +} + +static const struct bfd_iovec opncls_iovec = +{ &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek, - &opncls_bclose, &opncls_bflush, &opncls_bstat + &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap }; bfd * bfd_openr_iovec (const char *filename, const char *target, - void *(*open) (struct bfd *nbfd, - void *open_closure), + void *(*open_p) (struct bfd *, void *), void *open_closure, - file_ptr (*pread) (struct bfd *abfd, - void *stream, - void *buf, - file_ptr nbytes, - file_ptr offset), - int (*close) (struct bfd *nbfd, - void *stream)) + file_ptr (*pread_p) (struct bfd *, void *, void *, + file_ptr, file_ptr), + int (*close_p) (struct bfd *, void *), + int (*stat_p) (struct bfd *, void *, struct stat *)) { bfd *nbfd; const bfd_target *target_vec; @@ -499,20 +663,28 @@ bfd_openr_iovec (const char *filename, const char *target, return NULL; } - nbfd->filename = filename; + /* PR 11983: Do not cache the original filename, but + rather make a copy - the original might go away. */ + if (!bfd_set_filename (nbfd, filename)) + { + _bfd_delete_bfd (nbfd); + return NULL; + } nbfd->direction = read_direction; - stream = open (nbfd, open_closure); + /* `open_p (...)' would get expanded by an the open(2) syscall macro. */ + stream = (*open_p) (nbfd, open_closure); if (stream == NULL) { _bfd_delete_bfd (nbfd); return NULL; } - vec = bfd_zalloc (nbfd, sizeof (struct opncls)); + vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls)); vec->stream = stream; - vec->pread = pread; - vec->close = close; + vec->pread = pread_p; + vec->close = close_p; + vec->stat = stat_p; nbfd->iovec = &opncls_iovec; nbfd->iostream = vec; @@ -538,6 +710,9 @@ DESCRIPTION Possible errors are <>, <>, <>. + + A copy of the @var{filename} argument is stored in the newly created + BFD. It can be accessed via the bfd_get_filename() macro. */ bfd * @@ -559,7 +734,13 @@ bfd_openw (const char *filename, const char *target) return NULL; } - nbfd->filename = filename; + /* PR 11983: Do not cache the original filename, but + rather make a copy - the original might go away. */ + if (!bfd_set_filename (nbfd, filename)) + { + _bfd_delete_bfd (nbfd); + return NULL; + } nbfd->direction = write_direction; if (bfd_open_file (nbfd) == NULL) @@ -573,16 +754,40 @@ bfd_openw (const char *filename, const char *target) return nbfd; } -/* +static inline void +_maybe_make_executable (bfd * abfd) +{ + /* If the file was open for writing and is now executable, + make it so. */ + if (abfd->direction == write_direction + && (abfd->flags & (EXEC_P | DYNAMIC)) != 0) + { + struct stat buf; + + if (stat (bfd_get_filename (abfd), &buf) == 0 + /* Do not attempt to change non-regular files. This is + here especially for configure scripts and kernel builds + which run tests with "ld [...] -o /dev/null". */ + && S_ISREG(buf.st_mode)) + { + unsigned int mask = umask (0); + + umask (mask); + chmod (bfd_get_filename (abfd), + (0777 + & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); + } + } +} +/* FUNCTION bfd_close SYNOPSIS - bfd_boolean bfd_close (bfd *abfd); + bool bfd_close (bfd *abfd); DESCRIPTION - Close a BFD. If the BFD was open for writing, then pending operations are completed and the file written out and closed. If the created file is executable, then <> is called @@ -597,50 +802,16 @@ RETURNS <> is returned if all is ok, otherwise <>. */ - -bfd_boolean +bool bfd_close (bfd *abfd) { - bfd_boolean ret; - if (bfd_write_p (abfd)) { if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) - return FALSE; - } - - if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) - return FALSE; - - /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io - vector. */ - if (!(abfd->flags & BFD_IN_MEMORY)) - ret = abfd->iovec->bclose (abfd); - else - ret = TRUE; - - /* If the file was open for writing and is now executable, - make it so. */ - if (ret - && abfd->direction == write_direction - && abfd->flags & EXEC_P) - { - struct stat buf; - - if (stat (abfd->filename, &buf) == 0) - { - unsigned int mask = umask (0); - - umask (mask); - chmod (abfd->filename, - (0777 - & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); - } + return false; } - _bfd_delete_bfd (abfd); - - return ret; + return bfd_close_all_done (abfd); } /* @@ -648,7 +819,7 @@ FUNCTION bfd_close_all_done SYNOPSIS - bfd_boolean bfd_close_all_done (bfd *); + bool bfd_close_all_done (bfd *); DESCRIPTION Close a BFD. Differs from <> since it does not @@ -665,31 +836,18 @@ RETURNS <> is returned if all is ok, otherwise <>. */ -bfd_boolean +bool bfd_close_all_done (bfd *abfd) { - bfd_boolean ret; + bool ret; - ret = bfd_cache_close (abfd); - - /* If the file was open for writing and is now executable, - make it so. */ - if (ret - && abfd->direction == write_direction - && abfd->flags & EXEC_P) - { - struct stat buf; + if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) + return false; - if (stat (abfd->filename, &buf) == 0) - { - unsigned int mask = umask (0); + ret = abfd->iovec->bclose (abfd) == 0; - umask (mask); - chmod (abfd->filename, - (0777 - & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); - } - } + if (ret) + _maybe_make_executable (abfd); _bfd_delete_bfd (abfd); @@ -706,7 +864,10 @@ SYNOPSIS DESCRIPTION Create a new BFD in the manner of <>, but without opening a file. The new BFD takes the target from the target - used by @var{template}. The format is always set to <>. + used by @var{templ}. The format is always set to <>. + + A copy of the @var{filename} argument is stored in the newly created + BFD. It can be accessed via the bfd_get_filename() macro. */ bfd * @@ -717,7 +878,13 @@ bfd_create (const char *filename, bfd *templ) nbfd = _bfd_new_bfd (); if (nbfd == NULL) return NULL; - nbfd->filename = filename; + /* PR 11983: Do not cache the original filename, but + rather make a copy - the original might go away. */ + if (!bfd_set_filename (nbfd, filename)) + { + _bfd_delete_bfd (nbfd); + return NULL; + } if (templ) nbfd->xvec = templ->xvec; nbfd->direction = no_direction; @@ -731,7 +898,7 @@ FUNCTION bfd_make_writable SYNOPSIS - bfd_boolean bfd_make_writable (bfd *abfd); + bool bfd_make_writable (bfd *abfd); DESCRIPTION Takes a BFD as created by <> and converts it @@ -743,7 +910,7 @@ RETURNS <> is returned if all is ok, otherwise <>. */ -bfd_boolean +bool bfd_make_writable (bfd *abfd) { struct bfd_in_memory *bim; @@ -751,20 +918,24 @@ bfd_make_writable (bfd *abfd) if (abfd->direction != no_direction) { bfd_set_error (bfd_error_invalid_operation); - return FALSE; + return false; } - bim = bfd_malloc (sizeof (struct bfd_in_memory)); + bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory)); + if (bim == NULL) + return false; /* bfd_error already set. */ abfd->iostream = bim; /* bfd_bwrite will grow these as needed. */ bim->size = 0; bim->buffer = 0; abfd->flags |= BFD_IN_MEMORY; + abfd->iovec = &_bfd_memory_iovec; + abfd->origin = 0; abfd->direction = write_direction; abfd->where = 0; - return TRUE; + return true; } /* @@ -772,7 +943,7 @@ FUNCTION bfd_make_readable SYNOPSIS - bfd_boolean bfd_make_readable (bfd *abfd); + bool bfd_make_readable (bfd *abfd); DESCRIPTION Takes a BFD as created by <> and @@ -784,21 +955,20 @@ DESCRIPTION RETURNS <> is returned if all is ok, otherwise <>. */ -bfd_boolean +bool bfd_make_readable (bfd *abfd) { if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY)) { bfd_set_error (bfd_error_invalid_operation); - return FALSE; + return false; } if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) - return FALSE; + return false; if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) - return FALSE; - + return false; abfd->arch_info = &bfd_default_arch_struct; @@ -806,15 +976,15 @@ bfd_make_readable (bfd *abfd) abfd->format = bfd_unknown; abfd->my_archive = NULL; abfd->origin = 0; - abfd->opened_once = FALSE; - abfd->output_has_begun = FALSE; + abfd->opened_once = false; + abfd->output_has_begun = false; abfd->section_count = 0; abfd->usrdata = NULL; - abfd->cacheable = FALSE; - abfd->flags = BFD_IN_MEMORY; - abfd->mtime_set = FALSE; + abfd->cacheable = false; + abfd->flags |= BFD_IN_MEMORY; + abfd->mtime_set = false; - abfd->target_defaulted = TRUE; + abfd->target_defaulted = true; abfd->direction = read_direction; abfd->sections = 0; abfd->symcount = 0; @@ -824,11 +994,11 @@ bfd_make_readable (bfd *abfd) bfd_section_list_clear (abfd); bfd_check_format (abfd, bfd_object); - return TRUE; + return true; } /* -INTERNAL_FUNCTION +FUNCTION bfd_alloc SYNOPSIS @@ -843,21 +1013,32 @@ void * bfd_alloc (bfd *abfd, bfd_size_type size) { void *ret; - - if (size != (unsigned long) size) + unsigned long ul_size = (unsigned long) size; + + if (size != ul_size + /* Note - although objalloc_alloc takes an unsigned long as its + argument, internally the size is treated as a signed long. This can + lead to problems where, for example, a request to allocate -1 bytes + can result in just 1 byte being allocated, rather than + ((unsigned long) -1) bytes. Also memory checkers will often + complain about attempts to allocate a negative amount of memory. + So to stop these problems we fail if the size is negative. */ + || ((signed long) ul_size) < 0) { bfd_set_error (bfd_error_no_memory); return NULL; } - ret = objalloc_alloc (abfd->memory, (unsigned long) size); + ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size); if (ret == NULL) bfd_set_error (bfd_error_no_memory); + else + abfd->alloc_size += size; return ret; } /* -INTERNAL_FUNCTION +FUNCTION bfd_zalloc SYNOPSIS @@ -900,10 +1081,11 @@ bfd_release (bfd *abfd, void *block) This facilitates "optional" provision of debugging information, without having to provide two complete copies of every binary object (with and - without debug symbols). -*/ + without debug symbols). */ + +#define GNU_DEBUGLINK ".gnu_debuglink" +#define GNU_DEBUGALTLINK ".gnu_debugaltlink" -#define GNU_DEBUGLINK ".gnu_debuglink" /* FUNCTION bfd_calc_gnu_debuglink_crc32 @@ -986,31 +1168,45 @@ bfd_calc_gnu_debuglink_crc32 (unsigned long crc, crc = ~crc & 0xffffffff; for (end = buf + len; buf < end; ++ buf) crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); - return ~crc & 0xffffffff;; + return ~crc & 0xffffffff; } /* INTERNAL_FUNCTION - get_debug_link_info + bfd_get_debug_link_info_1 SYNOPSIS - char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out); + char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out); DESCRIPTION - fetch the filename and CRC32 value for any separate debuginfo - associated with @var{abfd}. Return NULL if no such info found, - otherwise return filename and update @var{crc32_out}. + Extracts the filename and CRC32 value for any separate debug + information file associated with @var{abfd}. + + The @var{crc32_out} parameter is an untyped pointer because + this routine is used as a @code{get_func_type} function, but it + is expected to be an unsigned long pointer. + +RETURNS + The filename of the associated debug information file, or NULL + if there is no such file. If the filename was found then the + contents of @var{crc32_out} are updated to hold the corresponding + CRC32 value for the file. + + The returned filename is allocated with @code{malloc}; freeing + it is the responsibility of the caller. */ static char * -get_debug_link_info (bfd *abfd, unsigned long *crc32_out) +bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out) { asection *sect; - unsigned long crc32; + unsigned long *crc32 = (unsigned long *) crc32_out; bfd_byte *contents; - int crc_offset; + unsigned int crc_offset; char *name; + bfd_size_type size; + ufile_ptr file_size; BFD_ASSERT (abfd); BFD_ASSERT (crc32_out); @@ -1020,21 +1216,118 @@ get_debug_link_info (bfd *abfd, unsigned long *crc32_out) if (sect == NULL) return NULL; + size = bfd_section_size (sect); + file_size = bfd_get_size (abfd); + + /* PR 22794: Make sure that the section has a reasonable size. */ + if (size < 8 || (file_size != 0 && size >= file_size)) + return NULL; + if (!bfd_malloc_and_get_section (abfd, sect, &contents)) { - if (contents != NULL) - free (contents); + free (contents); return NULL; } - /* Crc value is stored after the filename, aligned up to 4 bytes. */ + /* CRC value is stored after the filename, aligned up to 4 bytes. */ name = (char *) contents; - crc_offset = strlen (name) + 1; + /* PR 17597: Avoid reading off the end of the buffer. */ + crc_offset = strnlen (name, size) + 1; crc_offset = (crc_offset + 3) & ~3; + if (crc_offset + 4 > size) + return NULL; + + *crc32 = bfd_get_32 (abfd, contents + crc_offset); + return name; +} - crc32 = bfd_get_32 (abfd, contents + crc_offset); - *crc32_out = crc32; +/* +FUNCTION + bfd_get_debug_link_info + +SYNOPSIS + char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out); + +DESCRIPTION + Extracts the filename and CRC32 value for any separate debug + information file associated with @var{abfd}. + +RETURNS + The filename of the associated debug information file, or NULL + if there is no such file. If the filename was found then the + contents of @var{crc32_out} are updated to hold the corresponding + CRC32 value for the file. + + The returned filename is allocated with @code{malloc}; freeing + it is the responsibility of the caller. +*/ + +char * +bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out) +{ + return bfd_get_debug_link_info_1 (abfd, crc32_out); +} + +/* +FUNCTION + bfd_get_alt_debug_link_info + +SYNOPSIS + char *bfd_get_alt_debug_link_info (bfd * abfd, + bfd_size_type *buildid_len, + bfd_byte **buildid_out); + +DESCRIPTION + Fetch the filename and BuildID value for any alternate debuginfo + associated with @var{abfd}. Return NULL if no such info found, + otherwise return filename and update @var{buildid_len} and + @var{buildid_out}. The returned filename and build_id are + allocated with @code{malloc}; freeing them is the responsibility + of the caller. +*/ + +char * +bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len, + bfd_byte **buildid_out) +{ + asection *sect; + bfd_byte *contents; + unsigned int buildid_offset; + char *name; + bfd_size_type size; + ufile_ptr file_size; + + BFD_ASSERT (abfd); + BFD_ASSERT (buildid_len); + BFD_ASSERT (buildid_out); + + sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK); + + if (sect == NULL) + return NULL; + + size = bfd_section_size (sect); + file_size = bfd_get_size (abfd); + if (size < 8 || (file_size != 0 && size >= file_size)) + return NULL; + + if (!bfd_malloc_and_get_section (abfd, sect, & contents)) + { + free (contents); + return NULL; + } + + /* BuildID value is stored after the filename. */ + name = (char *) contents; + buildid_offset = strnlen (name, size) + 1; + if (buildid_offset >= bfd_section_size (sect)) + return NULL; + + *buildid_len = size - buildid_offset; + *buildid_out = bfd_malloc (*buildid_len); + memcpy (*buildid_out, contents + buildid_offset, *buildid_len); + return name; } @@ -1043,155 +1336,261 @@ INTERNAL_FUNCTION separate_debug_file_exists SYNOPSIS - bfd_boolean separate_debug_file_exists - (char *name, unsigned long crc32); + bool separate_debug_file_exists + (char *name, void *crc32_p); DESCRIPTION Checks to see if @var{name} is a file and if its contents - match @var{crc32}. + match @var{crc32}, which is a pointer to an @code{unsigned + long} containing a CRC32. + + The @var{crc32_p} parameter is an untyped pointer because + this routine is used as a @code{check_func_type} function. */ -static bfd_boolean -separate_debug_file_exists (const char *name, const unsigned long crc) +static bool +separate_debug_file_exists (const char *name, void *crc32_p) { - static unsigned char buffer [8 * 1024]; + unsigned char buffer[8 * 1024]; unsigned long file_crc = 0; - int fd; + FILE *f; bfd_size_type count; + unsigned long crc; BFD_ASSERT (name); + BFD_ASSERT (crc32_p); + + crc = *(unsigned long *) crc32_p; - fd = open (name, O_RDONLY); - if (fd < 0) - return FALSE; + f = _bfd_real_fopen (name, FOPEN_RB); + if (f == NULL) + return false; - while ((count = read (fd, buffer, sizeof (buffer))) > 0) + while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0) file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count); - close (fd); + fclose (f); return crc == file_crc; } +/* +INTERNAL_FUNCTION + separate_alt_debug_file_exists + +SYNOPSIS + bool separate_alt_debug_file_exists + (char *name, void *unused); + +DESCRIPTION + Checks to see if @var{name} is a file. +*/ + +static bool +separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED) +{ + FILE *f; + + BFD_ASSERT (name); + + f = _bfd_real_fopen (name, FOPEN_RB); + if (f == NULL) + return false; + + fclose (f); + + return true; +} /* INTERNAL_FUNCTION find_separate_debug_file SYNOPSIS - char *find_separate_debug_file (bfd *abfd); + char *find_separate_debug_file + (bfd *abfd, const char *dir, bool include_dirs, + get_func_type get, check_func_type check, void *data); DESCRIPTION - Searches @var{abfd} for a reference to separate debugging - information, scans various locations in the filesystem, including - the file tree rooted at @var{debug_file_directory}, and returns a - filename of such debugging information if the file is found and has - matching CRC32. Returns NULL if no reference to debugging file - exists, or file cannot be found. + Searches for a debug information file corresponding to @var{abfd}. + + The name of the separate debug info file is returned by the + @var{get} function. This function scans various fixed locations + in the filesystem, including the file tree rooted at @var{dir}. + If the @var{include_dirs} parameter is true then the directory + components of @var{abfd}'s filename will be included in the + searched locations. + + @var{data} is passed unmodified to the @var{get} and @var{check} + functions. It is generally used to implement build-id-like + matching in the callback functions. + +RETURNS + Returns the filename of the first file to be found which + receives a TRUE result from the @var{check} function. + Returns NULL if no valid file could be found. */ +typedef char * (*get_func_type) (bfd *, void *); +typedef bool (*check_func_type) (const char *, void *); + static char * -find_separate_debug_file (bfd *abfd, const char *debug_file_directory) +find_separate_debug_file (bfd *abfd, + const char *debug_file_directory, + bool include_dirs, + get_func_type get_func, + check_func_type check_func, + void *func_data) { - char *basename; + char *base; char *dir; char *debugfile; - unsigned long crc32; - int i; + char *canon_dir; + size_t dirlen; + size_t canon_dirlen; BFD_ASSERT (abfd); if (debug_file_directory == NULL) debug_file_directory = "."; /* BFD may have been opened from a stream. */ - if (! abfd->filename) - return NULL; + if (bfd_get_filename (abfd) == NULL) + { + bfd_set_error (bfd_error_invalid_operation); + return NULL; + } + + base = get_func (abfd, func_data); - basename = get_debug_link_info (abfd, & crc32); - if (basename == NULL) + if (base == NULL) return NULL; - if (strlen (basename) < 1) + if (base[0] == '\0') { - free (basename); + free (base); + bfd_set_error (bfd_error_no_debug_section); return NULL; } - dir = strdup (abfd->filename); - if (dir == NULL) + if (include_dirs) { - free (basename); - return NULL; + const char *fname = bfd_get_filename (abfd); + for (dirlen = strlen (fname); dirlen > 0; dirlen--) + if (IS_DIR_SEPARATOR (fname[dirlen - 1])) + break; + + dir = (char *) bfd_malloc (dirlen + 1); + if (dir == NULL) + { + free (base); + return NULL; + } + memcpy (dir, fname, dirlen); + dir[dirlen] = '\0'; + } + else + { + dir = (char *) bfd_malloc (1); + * dir = 0; + dirlen = 0; } - BFD_ASSERT (strlen (dir) != 0); - /* Strip off filename part. */ - for (i = strlen (dir) - 1; i >= 0; i--) - if (IS_DIR_SEPARATOR (dir[i])) + /* Compute the canonical name of the bfd object with all symbolic links + resolved, for use in the global debugfile directory. */ + canon_dir = lrealpath (bfd_get_filename (abfd)); + for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--) + if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1])) break; + canon_dir[canon_dirlen] = '\0'; - dir[i + 1] = '\0'; - BFD_ASSERT (dir[i] == '/' || dir[0] == '\0'); +#ifndef EXTRA_DEBUG_ROOT1 +#define EXTRA_DEBUG_ROOT1 "/usr/lib/debug" +#endif +#ifndef EXTRA_DEBUG_ROOT2 +#define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr" +#endif - debugfile = malloc (strlen (debug_file_directory) + 1 - + strlen (dir) - + strlen (".debug/") - + strlen (basename) - + 1); + debugfile = (char *) + bfd_malloc (strlen (debug_file_directory) + 1 + + (canon_dirlen > dirlen ? canon_dirlen : dirlen) + + strlen (".debug/") +#ifdef EXTRA_DEBUG_ROOT1 + + strlen (EXTRA_DEBUG_ROOT1) +#endif +#ifdef EXTRA_DEBUG_ROOT2 + + strlen (EXTRA_DEBUG_ROOT2) +#endif + + strlen (base) + + 1); if (debugfile == NULL) - { - free (basename); - free (dir); - return NULL; - } + goto found; /* Actually this returns NULL. */ - /* First try in the same directory as the original file: */ - strcpy (debugfile, dir); - strcat (debugfile, basename); + /* First try in the same directory as the original file. - if (separate_debug_file_exists (debugfile, crc32)) - { - free (basename); - free (dir); - return debugfile; - } + FIXME: Strictly speaking if we are using the build-id method, + (ie include_dirs == FALSE) then we should only check absolute + paths, not relative ones like this one (and the next one). + The check is left in however as this allows the binutils + testsuite to exercise this feature without having to install + a file into the root filesystem. (See binutils/testsuite/ + binutils-all/objdump.exp for the test). */ + sprintf (debugfile, "%s%s", dir, base); + if (check_func (debugfile, func_data)) + goto found; /* Then try in a subdirectory called .debug. */ - strcpy (debugfile, dir); - strcat (debugfile, ".debug/"); - strcat (debugfile, basename); + sprintf (debugfile, "%s.debug/%s", dir, base); + if (check_func (debugfile, func_data)) + goto found; + +#ifdef EXTRA_DEBUG_ROOT1 + /* Try the first extra debug file root. */ + sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1, + include_dirs ? canon_dir : "/", base); + if (check_func (debugfile, func_data)) + goto found; +#endif - if (separate_debug_file_exists (debugfile, crc32)) - { - free (basename); - free (dir); - return debugfile; - } +#ifdef EXTRA_DEBUG_ROOT2 + /* Try the second extra debug file root. */ + sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2, + include_dirs ? canon_dir : "/", base); + if (check_func (debugfile, func_data)) + goto found; +#endif /* Then try in the global debugfile directory. */ strcpy (debugfile, debug_file_directory); - i = strlen (debug_file_directory) - 1; - if (i > 0 - && debug_file_directory[i] != '/' - && dir[0] != '/') - strcat (debugfile, "/"); - strcat (debugfile, dir); - strcat (debugfile, basename); - - if (separate_debug_file_exists (debugfile, crc32)) + dirlen = strlen (debug_file_directory) - 1; + if (include_dirs) { - free (basename); - free (dir); - return debugfile; + if (dirlen > 0 + && debug_file_directory[dirlen] != '/' + && canon_dir[0] != '/') + strcat (debugfile, "/"); + strcat (debugfile, canon_dir); } + else + { + if (dirlen > 0 && debug_file_directory[dirlen] != '/') + strcat (debugfile, "/"); + } + strcat (debugfile, base); + + if (check_func (debugfile, func_data)) + goto found; + /* Failed to find the file. */ free (debugfile); - free (basename); + debugfile = NULL; + + found: + free (base); free (dir); - return NULL; + free (canon_dir); + return debugfile; } - /* FUNCTION bfd_follow_gnu_debuglink @@ -1200,7 +1599,6 @@ SYNOPSIS char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); DESCRIPTION - Takes a BFD and searches it for a .gnu_debuglink section. If this section is found, it examines the section for the name and checksum of a '.debug' file containing auxiliary debugging information. It @@ -1208,9 +1606,8 @@ DESCRIPTION locations, including the directory tree rooted at @var{dir}, and if found returns the full filename. - If @var{dir} is NULL, it will search a default path configured into - libbfd at build time. [XXX this feature is not currently - implemented]. + If @var{dir} is NULL, the search will take place starting at + the current directory. RETURNS <> on any errors or failure to locate the .debug file, @@ -1221,7 +1618,59 @@ RETURNS char * bfd_follow_gnu_debuglink (bfd *abfd, const char *dir) { - return find_separate_debug_file (abfd, dir); + unsigned long crc32; + + return find_separate_debug_file (abfd, dir, true, + bfd_get_debug_link_info_1, + separate_debug_file_exists, &crc32); +} + +/* Helper for bfd_follow_gnu_debugaltlink. It just returns the name + of the separate debug file. */ + +static char * +get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED) +{ + bfd_size_type len; + bfd_byte *buildid = NULL; + char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid); + + free (buildid); + + return result; +} + +/* +FUNCTION + bfd_follow_gnu_debugaltlink + +SYNOPSIS + char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir); + +DESCRIPTION + Takes a BFD and searches it for a .gnu_debugaltlink section. If this + section is found, it examines the section for the name of a file + containing auxiliary debugging information. It then searches the + filesystem for this file in a set of standard locations, including + the directory tree rooted at @var{dir}, and if found returns the + full filename. + + If @var{dir} is NULL, the search will take place starting at + the current directory. + +RETURNS + <> on any errors or failure to locate the debug file, + otherwise a pointer to a heap-allocated string containing the + filename. The caller is responsible for freeing this string. +*/ + +char * +bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir) +{ + return find_separate_debug_file (abfd, dir, true, + get_alt_debug_link_info_shim, + separate_alt_debug_file_exists, + NULL); } /* @@ -1233,13 +1682,13 @@ SYNOPSIS (bfd *abfd, const char *filename); DESCRIPTION - - Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized - to be big enough to contain a link to the specified @var{filename}. + Takes a @var{BFD} and adds a .gnu_debuglink section to it. The + section is sized to be big enough to contain a link to the specified + @var{filename}. RETURNS - A pointer to the new section is returned if all is ok. Otherwise <> is - returned and bfd_error is set. + A pointer to the new section is returned if all is ok. Otherwise + <> is returned and bfd_error is set. */ asection * @@ -1247,6 +1696,7 @@ bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename) { asection *sect; bfd_size_type debuglink_size; + flagword flags; if (abfd == NULL || filename == NULL) { @@ -1265,25 +1715,27 @@ bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename) return NULL; } - sect = bfd_make_section (abfd, GNU_DEBUGLINK); + flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING; + sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags); if (sect == NULL) return NULL; - if (! bfd_set_section_flags (abfd, sect, - SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING)) - /* XXX Should we delete the section from the bfd ? */ - return NULL; - - + /* Compute the size of the section. Allow for the CRC after the filename, + and padding so that it will start on a 4-byte boundary. */ debuglink_size = strlen (filename) + 1; debuglink_size += 3; debuglink_size &= ~3; debuglink_size += 4; - if (! bfd_set_section_size (abfd, sect, debuglink_size)) + if (!bfd_set_section_size (sect, debuglink_size)) /* XXX Should we delete the section from the bfd ? */ return NULL; + /* PR 21193: Ensure that the section has 4-byte alignment for the CRC. + Note - despite the name of the function being called, we are + setting an alignment power, not a byte alignment value. */ + bfd_set_section_alignment (sect, 2); + return sect; } @@ -1293,11 +1745,10 @@ FUNCTION bfd_fill_in_gnu_debuglink_section SYNOPSIS - bfd_boolean bfd_fill_in_gnu_debuglink_section + bool bfd_fill_in_gnu_debuglink_section (bfd *abfd, struct bfd_section *sect, const char *filename); DESCRIPTION - Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT} and fills in the contents of the section to contain a link to the specified @var{filename}. The filename should be relative to the @@ -1308,7 +1759,7 @@ RETURNS and bfd_error is set. */ -bfd_boolean +bool bfd_fill_in_gnu_debuglink_section (bfd *abfd, struct bfd_section *sect, const char *filename) @@ -1318,13 +1769,14 @@ bfd_fill_in_gnu_debuglink_section (bfd *abfd, char * contents; bfd_size_type crc_offset; FILE * handle; - static unsigned char buffer[8 * 1024]; + unsigned char buffer[8 * 1024]; size_t count; + size_t filelen; if (abfd == NULL || sect == NULL || filename == NULL) { bfd_set_error (bfd_error_invalid_operation); - return FALSE; + return false; } /* Make sure that we can read the file. @@ -1333,11 +1785,11 @@ bfd_fill_in_gnu_debuglink_section (bfd *abfd, .gnu_debuglink section, we insist upon the user providing us with a correct-for-section-creation-time path, but this need not conform to the gdb location algorithm. */ - handle = fopen (filename, FOPEN_RB); + handle = _bfd_real_fopen (filename, FOPEN_RB); if (handle == NULL) { bfd_set_error (bfd_error_system_call); - return FALSE; + return false; } crc32 = 0; @@ -1349,21 +1801,22 @@ bfd_fill_in_gnu_debuglink_section (bfd *abfd, now that we no longer need them. */ filename = lbasename (filename); - debuglink_size = strlen (filename) + 1; + filelen = strlen (filename); + debuglink_size = filelen + 1; debuglink_size += 3; debuglink_size &= ~3; debuglink_size += 4; - contents = malloc (debuglink_size); + contents = (char *) bfd_malloc (debuglink_size); if (contents == NULL) { /* XXX Should we delete the section from the bfd ? */ - bfd_set_error (bfd_error_no_memory); - return FALSE; + return false; } - strcpy (contents, filename); crc_offset = debuglink_size - 4; + memcpy (contents, filename, filelen); + memset (contents + filelen, 0, crc_offset - filelen); bfd_put_32 (abfd, crc32, contents + crc_offset); @@ -1371,8 +1824,311 @@ bfd_fill_in_gnu_debuglink_section (bfd *abfd, { /* XXX Should we delete the section from the bfd ? */ free (contents); - return FALSE; + return false; + } + + return true; +} + +/* +INTERNAL_FUNCTION + get_build_id + +SYNOPSIS + struct bfd_build_id * get_build_id (bfd *abfd); + +DESCRIPTION + Finds the build-id associated with @var{abfd}. If the build-id is + extracted from the note section then a build-id structure is built + for it, using memory allocated to @var{abfd}, and this is then + attached to the @var{abfd}. + +RETURNS + Returns a pointer to the build-id structure if a build-id could be + found. If no build-id is found NULL is returned and error code is + set. +*/ + +static struct bfd_build_id * +get_build_id (bfd *abfd) +{ + struct bfd_build_id *build_id; + Elf_Internal_Note inote; + Elf_External_Note *enote; + bfd_byte *contents; + asection *sect; + bfd_size_type size; + + BFD_ASSERT (abfd); + + if (abfd->build_id && abfd->build_id->size > 0) + /* Save some time by using the already computed build-id. */ + return (struct bfd_build_id *) abfd->build_id; + + sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id"); + if (sect == NULL) + { + bfd_set_error (bfd_error_no_debug_section); + return NULL; + } + + size = bfd_section_size (sect); + /* FIXME: Should we support smaller build-id notes ? */ + if (size < 0x24) + { + bfd_set_error (bfd_error_invalid_operation); + return NULL; } - return TRUE; + if (!bfd_malloc_and_get_section (abfd, sect, & contents)) + { + free (contents); + return NULL; + } + + /* FIXME: Paranoia - allow for compressed build-id sections. + Maybe we should complain if this size is different from + the one obtained above... */ + size = bfd_section_size (sect); + if (size < sizeof (Elf_External_Note)) + { + bfd_set_error (bfd_error_invalid_operation); + free (contents); + return NULL; + } + + enote = (Elf_External_Note *) contents; + inote.type = H_GET_32 (abfd, enote->type); + inote.namesz = H_GET_32 (abfd, enote->namesz); + inote.namedata = enote->name; + inote.descsz = H_GET_32 (abfd, enote->descsz); + inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4); + /* FIXME: Should we check for extra notes in this section ? */ + + if (inote.descsz <= 0 + || inote.type != NT_GNU_BUILD_ID + || inote.namesz != 4 /* sizeof "GNU" */ + || !startswith (inote.namedata, "GNU") + || inote.descsz > 0x7ffffffe + || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz)) + { + free (contents); + bfd_set_error (bfd_error_invalid_operation); + return NULL; + } + + build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz); + if (build_id == NULL) + { + free (contents); + return NULL; + } + + build_id->size = inote.descsz; + memcpy (build_id->data, inote.descdata, inote.descsz); + abfd->build_id = build_id; + free (contents); + + return build_id; +} + +/* +INTERNAL_FUNCTION + get_build_id_name + +SYNOPSIS + char * get_build_id_name (bfd *abfd, void *build_id_out_p) + +DESCRIPTION + Searches @var{abfd} for a build-id, and then constructs a pathname + from it. The path is computed as .build-id/NN/NN+NN.debug where + NNNN+NN is the build-id value as a hexadecimal string. + +RETURNS + Returns the constructed filename or NULL upon error. + It is the caller's responsibility to free the memory used to hold the + filename. + If a filename is returned then the @var{build_id_out_p} + parameter (which points to a @code{struct bfd_build_id} + pointer) is set to a pointer to the build_id structure. +*/ + +static char * +get_build_id_name (bfd *abfd, void *build_id_out_p) +{ + struct bfd_build_id **build_id_out = build_id_out_p; + struct bfd_build_id *build_id; + char *name; + char *n; + bfd_size_type s; + bfd_byte *d; + + if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL) + { + bfd_set_error (bfd_error_invalid_operation); + return NULL; + } + + build_id = get_build_id (abfd); + if (build_id == NULL) + return NULL; + + /* Compute the debug pathname corresponding to the build-id. */ + name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug")); + if (name == NULL) + { + bfd_set_error (bfd_error_no_memory); + return NULL; + } + n = name; + d = build_id->data; + s = build_id->size; + + n += sprintf (n, ".build-id/"); + n += sprintf (n, "%02x", (unsigned) *d++); s--; + n += sprintf (n, "/"); + while (s--) + n += sprintf (n, "%02x", (unsigned) *d++); + n += sprintf (n, ".debug"); + + *build_id_out = build_id; + return name; +} + +/* +INTERNAL_FUNCTION + check_build_id_file + +SYNOPSIS + bool check_build_id_file (char *name, void *buildid_p); + +DESCRIPTION + Checks to see if @var{name} is a readable file and if its build-id + matches @var{buildid}. + +RETURNS + Returns TRUE if the file exists, is readable, and contains a + build-id which matches the build-id pointed at by + @var{build_id_p} (which is really a @code{struct bfd_build_id **}). +*/ + +static bool +check_build_id_file (const char *name, void *buildid_p) +{ + struct bfd_build_id *orig_build_id; + struct bfd_build_id *build_id; + bfd * file; + bool result; + + BFD_ASSERT (name); + BFD_ASSERT (buildid_p); + + file = bfd_openr (name, NULL); + if (file == NULL) + return false; + + /* If the file is an archive, process all of its elements. */ + if (! bfd_check_format (file, bfd_object)) + { + bfd_close (file); + return false; + } + + build_id = get_build_id (file); + if (build_id == NULL) + { + bfd_close (file); + return false; + } + + orig_build_id = *(struct bfd_build_id **) buildid_p; + + result = build_id->size == orig_build_id->size + && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0; + + (void) bfd_close (file); + + return result; +} + +/* +FUNCTION + bfd_follow_build_id_debuglink + +SYNOPSIS + char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir); + +DESCRIPTION + Takes @var{abfd} and searches it for a .note.gnu.build-id section. + If this section is found, it extracts the value of the NT_GNU_BUILD_ID + note, which should be a hexadecimal value @var{NNNN+NN} (for + 32+ hex digits). It then searches the filesystem for a file named + @var{.build-id/NN/NN+NN.debug} in a set of standard locations, + including the directory tree rooted at @var{dir}. The filename + of the first matching file to be found is returned. A matching + file should contain a .note.gnu.build-id section with the same + @var{NNNN+NN} note as @var{abfd}, although this check is currently + not implemented. + + If @var{dir} is NULL, the search will take place starting at + the current directory. + +RETURNS + <> on any errors or failure to locate the debug file, + otherwise a pointer to a heap-allocated string containing the + filename. The caller is responsible for freeing this string. +*/ + +char * +bfd_follow_build_id_debuglink (bfd *abfd, const char *dir) +{ + struct bfd_build_id *build_id; + + return find_separate_debug_file (abfd, dir, false, + get_build_id_name, + check_build_id_file, &build_id); +} + +/* +FUNCTION + bfd_set_filename + +SYNOPSIS + const char *bfd_set_filename (bfd *abfd, const char *filename); + +DESCRIPTION + Set the filename of @var{abfd}, copying the FILENAME parameter to + bfd_alloc'd memory owned by @var{abfd}. Returns a pointer the + newly allocated name, or NULL if the allocation failed. +*/ + +const char * +bfd_set_filename (bfd *abfd, const char *filename) +{ + size_t len = strlen (filename) + 1; + char *n = bfd_alloc (abfd, len); + + if (n == NULL) + return NULL; + + if (abfd->filename != NULL) + { + /* PR 29389. If we attempt to rename a file that has been closed due + to caching, then we will not be able to reopen it later on. */ + if (abfd->iostream == NULL && (abfd->flags & BFD_CLOSED_BY_CACHE)) + { + bfd_set_error (bfd_error_invalid_operation); + return NULL; + } + + /* Similarly if we attempt to close a renamed file because the + cache is now full, we will not be able to reopen it later on. */ + if (abfd->iostream != NULL) + abfd->cacheable = 0; + } + + memcpy (n, filename, len); + abfd->filename = n; + + return n; }