/* opncls.c -- open and close a BFD.
- Copyright (C) 1990-2017 Free Software Foundation, Inc.
+ Copyright (C) 1990-2023 Free Software Foundation, Inc.
Written by Cygnus Support.
#define S_IXOTH 0001 /* Execute by others. */
#endif
+/*
+SECTION
+ Opening and closing BFDs
+
+SUBSECTION
+ Functions for opening and closing
+*/
+
/* Counters used to initialize the bfd identifier. */
static unsigned int bfd_id_counter = 0;
if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
sizeof (struct section_hash_entry), 13))
{
+ objalloc_free ((struct objalloc *) nbfd->memory);
free (nbfd);
return NULL;
}
+ nbfd->archive_plugin_fd = -1;
+
return nbfd;
}
{
bfd *nbfd;
+ /* Nested archives in bims are unsupported. */
+ if ((obfd->flags & BFD_IN_MEMORY) != 0)
+ {
+ bfd_set_error (bfd_error_malformed_archive);
+ return NULL;
+ }
nbfd = _bfd_new_bfd ();
if (nbfd == NULL)
return NULL;
bfd_hash_table_free (&abfd->section_htab);
objalloc_free ((struct objalloc *) abfd->memory);
}
+ else
+ free ((char *) bfd_get_filename (abfd));
- if (abfd->filename)
- free ((char *) abfd->filename);
free (abfd->arelt_data);
free (abfd);
}
/* Free objalloc memory. */
-bfd_boolean
+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->memory = NULL;
}
- return TRUE;
+ return true;
}
-/*
-SECTION
- Opening and closing BFDs
-
-SUBSECTION
- Functions for opening and closing
-*/
-
/*
FUNCTION
bfd_fopen
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}.
nbfd->iostream = fdopen (fd, mode);
else
#endif
- nbfd->iostream = real_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;
}
/* PR 11983: Do not cache the original filename, but
rather make a copy - the original might go away. */
- nbfd->filename = xstrdup (filename);
+ 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. */
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)
- (void) bfd_set_cacheable (nbfd, TRUE);
+ (void) bfd_set_cacheable (nbfd, true);
return nbfd;
}
/*
FUNCTION
- bfd_openstreamr
+ bfd_fdopenw
SYNOPSIS
- bfd *bfd_openstreamr (const char * filename, const char * target, void * stream);
+ bfd *bfd_fdopenw (const char *filename, const char *target, int fd);
DESCRIPTION
+ <<bfd_fdopenw>> is exactly like <<bfd_fdopenr>> 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 <<bfd_close>>, the stream will be closed.
nbfd->iostream = stream;
/* PR 11983: Do not cache the original filename, but
rather make a copy - the original might go away. */
- nbfd->filename = xstrdup (filename);
+ if (!bfd_set_filename (nbfd, filename))
+ {
+ _bfd_delete_bfd (nbfd);
+ return NULL;
+ }
nbfd->direction = read_direction;
if (! bfd_cache_init (nbfd))
bfd_openr_iovec
SYNOPSIS
- 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),
+ 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));
+ 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_func}, accessed using
- @var{pread_func} and destroyed using @var{close_func}.
+ 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 <<bfd_find_target>>, so @var{target} is interpreted as by
that function.
{
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;
/* 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;
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)
+ void **map_addr ATTRIBUTE_UNUSED,
+ bfd_size_type *map_len ATTRIBUTE_UNUSED)
{
return (void *) -1;
}
-static const struct bfd_iovec opncls_iovec = {
+static const struct bfd_iovec opncls_iovec =
+{
&opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
&opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
};
/* PR 11983: Do not cache the original filename, but
rather make a copy - the original might go away. */
- nbfd->filename = xstrdup (filename);
+ if (!bfd_set_filename (nbfd, filename))
+ {
+ _bfd_delete_bfd (nbfd);
+ return NULL;
+ }
nbfd->direction = read_direction;
/* `open_p (...)' would get expanded by an the open(2) syscall macro. */
/* PR 11983: Do not cache the original filename, but
rather make a copy - the original might go away. */
- nbfd->filename = xstrdup (filename);
+ if (!bfd_set_filename (nbfd, filename))
+ {
+ _bfd_delete_bfd (nbfd);
+ return NULL;
+ }
nbfd->direction = write_direction;
if (bfd_open_file (nbfd) == NULL)
{
struct stat buf;
- if (stat (abfd->filename, &buf) == 0
+ 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". */
unsigned int mask = umask (0);
umask (mask);
- chmod (abfd->filename,
+ 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 <<chmod>> is called
The file descriptor associated with the BFD is closed (even
if it was passed in to BFD by <<bfd_fdopenr>>).
-RETURNS
<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
*/
-
-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;
- }
+ bool ret = (!bfd_write_p (abfd)
+ || BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)));
- if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
- return FALSE;
-
- ret = abfd->iovec->bclose (abfd) == 0;
-
- if (ret)
- _maybe_make_executable (abfd);
-
- _bfd_delete_bfd (abfd);
-
- return ret;
+ return bfd_close_all_done (abfd) && ret;
}
/*
bfd_close_all_done
SYNOPSIS
- bfd_boolean bfd_close_all_done (bfd *);
+ bool bfd_close_all_done (bfd *);
DESCRIPTION
Close a BFD. Differs from <<bfd_close>> since it does not
All memory attached to the BFD is released.
-RETURNS
<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
*/
-bfd_boolean
+bool
bfd_close_all_done (bfd *abfd)
{
- bfd_boolean ret;
+ bool ret = BFD_SEND (abfd, _close_and_cleanup, (abfd));
- ret = bfd_cache_close (abfd);
+ if (ret && abfd->iovec != NULL)
+ {
+ ret = abfd->iovec->bclose (abfd) == 0;
- if (ret)
- _maybe_make_executable (abfd);
+ if (ret)
+ _maybe_make_executable (abfd);
+ }
_bfd_delete_bfd (abfd);
return NULL;
/* PR 11983: Do not cache the original filename, but
rather make a copy - the original might go away. */
- nbfd->filename = xstrdup (filename);
+ if (!bfd_set_filename (nbfd, filename))
+ {
+ _bfd_delete_bfd (nbfd);
+ return NULL;
+ }
if (templ)
nbfd->xvec = templ->xvec;
nbfd->direction = no_direction;
bfd_make_writable
SYNOPSIS
- bfd_boolean bfd_make_writable (bfd *abfd);
+ bool bfd_make_writable (bfd *abfd);
DESCRIPTION
Takes a BFD as created by <<bfd_create>> and converts it
by converting the BFD to BFD_IN_MEMORY. It's assumed that
you will call <<bfd_make_readable>> on this bfd later.
-RETURNS
<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
*/
-bfd_boolean
+bool
bfd_make_writable (bfd *abfd)
{
struct bfd_in_memory *bim;
if (abfd->direction != no_direction)
{
bfd_set_error (bfd_error_invalid_operation);
- return FALSE;
+ return false;
}
bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
if (bim == NULL)
- return FALSE; /* bfd_error already set. */
+ return false; /* bfd_error already set. */
abfd->iostream = bim;
/* bfd_bwrite will grow these as needed. */
bim->size = 0;
abfd->direction = write_direction;
abfd->where = 0;
- return TRUE;
+ return true;
}
/*
bfd_make_readable
SYNOPSIS
- bfd_boolean bfd_make_readable (bfd *abfd);
+ bool bfd_make_readable (bfd *abfd);
DESCRIPTION
Takes a BFD as created by <<bfd_create>> and
contents out to the memory buffer, then reversing the
direction.
-RETURNS
<<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
-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;
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->cacheable = false;
abfd->flags |= BFD_IN_MEMORY;
- abfd->mtime_set = FALSE;
+ abfd->mtime_set = false;
- abfd->target_defaulted = TRUE;
+ abfd->target_defaulted = true;
abfd->direction = read_direction;
abfd->sections = 0;
abfd->symcount = 0;
abfd->outsymbols = 0;
abfd->tdata.any = 0;
+ abfd->size = 0;
bfd_section_list_clear (abfd);
bfd_check_format (abfd, bfd_object);
- return TRUE;
+ return true;
}
/*
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
- bfd_alloc2
-
-SYNOPSIS
- void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
-
-DESCRIPTION
- Allocate a block of @var{nmemb} elements of @var{size} bytes each
- of memory attached to <<abfd>> and return a pointer to it.
-*/
-
-void *
-bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
-{
- if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
- && size != 0
- && nmemb > ~(bfd_size_type) 0 / size)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
-
- return bfd_alloc (abfd, size * nmemb);
-}
-
/*
FUNCTION
bfd_zalloc
return res;
}
-/*
-INTERNAL_FUNCTION
- bfd_zalloc2
-
-SYNOPSIS
- void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
-
-DESCRIPTION
- Allocate a block of @var{nmemb} elements of @var{size} bytes each
- of zeroed memory attached to <<abfd>> and return a pointer to it.
-*/
-
-void *
-bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
-{
- void *res;
-
- if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
- && size != 0
- && nmemb > ~(bfd_size_type) 0 / size)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
-
- size *= nmemb;
-
- res = bfd_alloc (abfd, size);
- if (res)
- memset (res, 0, (size_t) size);
- return res;
-}
-
/* Free a block allocated for a BFD.
Note: Also frees all more recently allocated blocks! */
Advances the previously computed @var{crc} value by computing
and adding in the crc32 for @var{len} bytes of @var{buf}.
-RETURNS
Return the updated CRC32 value.
*/
}
-/*
-FUNCTION
- bfd_get_debug_link_info
+/* Extracts the filename and CRC32 value for any separate debug
+ information file associated with @var{abfd}.
-SYNOPSIS
- char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
+ 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.
-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}. The
- returned filename is allocated with @code{malloc}; freeing it
- is the responsibility of the caller.
-*/
+ 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.
-char *
-bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
+ The returned filename is allocated with @code{malloc}; freeing
+ it is the responsibility of the caller. */
+
+static char *
+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;
unsigned int crc_offset;
char *name;
+ bfd_size_type size;
BFD_ASSERT (abfd);
BFD_ASSERT (crc32_out);
sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
- if (sect == NULL)
+ if (sect == NULL || (sect->flags & SEC_HAS_CONTENTS) == 0)
+ return NULL;
+
+ size = bfd_section_size (sect);
+
+ /* PR 22794: Make sure that the section has a reasonable size. */
+ if (size < 8)
return NULL;
if (!bfd_malloc_and_get_section (abfd, sect, &contents))
- {
- if (contents != NULL)
- free (contents);
- return NULL;
- }
+ return NULL;
/* CRC value is stored after the filename, aligned up to 4 bytes. */
name = (char *) contents;
- /* PR 17597: avoid reading off the end of the buffer. */
- crc_offset = strnlen (name, bfd_get_section_size (sect)) + 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 >= bfd_get_section_size (sect))
- return NULL;
-
- crc32 = bfd_get_32 (abfd, contents + crc_offset);
+ if (crc_offset + 4 > size)
+ {
+ free (name);
+ return NULL;
+ }
- *crc32_out = crc32;
+ *crc32 = bfd_get_32 (abfd, contents + crc_offset);
return name;
}
+
+/*
+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);
+ 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.
+ allocated with @code{malloc}; freeing them is the responsibility
+ of the caller.
*/
char *
bfd_byte *contents;
unsigned int buildid_offset;
char *name;
+ bfd_size_type size;
BFD_ASSERT (abfd);
BFD_ASSERT (buildid_len);
sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
- if (sect == NULL)
+ if (sect == NULL || (sect->flags & SEC_HAS_CONTENTS) == 0)
+ return NULL;
+
+ size = bfd_section_size (sect);
+ if (size < 8)
return NULL;
if (!bfd_malloc_and_get_section (abfd, sect, & contents))
- {
- if (contents != NULL)
- free (contents);
- return NULL;
- }
+ return NULL;
/* BuildID value is stored after the filename. */
name = (char *) contents;
- buildid_offset = strnlen (name, bfd_get_section_size (sect)) + 1;
- if (buildid_offset >= bfd_get_section_size (sect))
+ buildid_offset = strnlen (name, size) + 1;
+ if (buildid_offset >= bfd_section_size (sect))
return NULL;
- *buildid_len = bfd_get_section_size (sect) - buildid_offset;
+ *buildid_len = size - buildid_offset;
*buildid_out = bfd_malloc (*buildid_len);
memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
return name;
}
-/*
-INTERNAL_FUNCTION
- separate_debug_file_exists
-
-SYNOPSIS
- bfd_boolean separate_debug_file_exists
- (char *name, unsigned long crc32);
+/* Checks to see if @var{name} is a file and if its contents match
+ @var{crc32}, which is a pointer to an @code{unsigned long}
+ containing a CRC32.
-DESCRIPTION
- Checks to see if @var{name} is a file and if its contents
- match @var{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;
FILE *f;
bfd_size_type count;
+ unsigned long crc;
BFD_ASSERT (name);
+ BFD_ASSERT (crc32_p);
- f = real_fopen (name, FOPEN_RB);
+ crc = *(unsigned long *) crc32_p;
+
+ f = _bfd_real_fopen (name, FOPEN_RB);
if (f == NULL)
- return FALSE;
+ return false;
while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
return crc == file_crc;
}
-/*
-INTERNAL_FUNCTION
- separate_alt_debug_file_exists
+/* Checks to see if @var{name} is a file. */
-SYNOPSIS
- bfd_boolean separate_alt_debug_file_exists
- (char *name, unsigned long buildid);
-
-DESCRIPTION
- Checks to see if @var{name} is a file and if its BuildID
- matches @var{buildid}.
-*/
-
-static bfd_boolean
-separate_alt_debug_file_exists (const char *name,
- const unsigned long buildid ATTRIBUTE_UNUSED)
+static bool
+separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
{
FILE *f;
BFD_ASSERT (name);
- f = real_fopen (name, FOPEN_RB);
+ f = _bfd_real_fopen (name, FOPEN_RB);
if (f == NULL)
- return FALSE;
-
- /* FIXME: Add code to check buildid. */
+ return false;
fclose (f);
- return TRUE;
+ return true;
}
-/*
-INTERNAL_FUNCTION
- find_separate_debug_file
+/* Searches for a debug information file corresponding to @var{abfd}.
-SYNOPSIS
- char *find_separate_debug_file
- (bfd *abfd, const char *dir, bfd_boolean include_dirs,
- get_func_type get, check_func_type check);
+ 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.
-DESCRIPTION
- 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.
-
- 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.
-*/
+ @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 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 *, unsigned long *);
-typedef bfd_boolean (* check_func_type) (const char *, const unsigned long);
+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,
- bfd_boolean include_dirs,
- get_func_type get_func,
- check_func_type check_func)
+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 *base;
char *dir;
char *debugfile;
char *canon_dir;
- unsigned long crc32;
size_t dirlen;
size_t canon_dirlen;
debug_file_directory = ".";
/* BFD may have been opened from a stream. */
- if (abfd->filename == NULL)
+ if (bfd_get_filename (abfd) == NULL)
{
bfd_set_error (bfd_error_invalid_operation);
return NULL;
}
- base = get_func (abfd, & crc32);
+ base = get_func (abfd, func_data);
if (base == NULL)
return NULL;
if (include_dirs)
{
- for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
- if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
+ 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);
free (base);
return NULL;
}
- memcpy (dir, abfd->filename, dirlen);
+ memcpy (dir, fname, dirlen);
dir[dirlen] = '\0';
}
else
/* Compute the canonical name of the bfd object with all symbolic links
resolved, for use in the global debugfile directory. */
- canon_dir = lrealpath (abfd->filename);
+ 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;
#endif
#ifndef EXTRA_DEBUG_ROOT2
#define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
-#endif
+#endif
debugfile = (char *)
bfd_malloc (strlen (debug_file_directory) + 1
- + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
- + strlen (".debug/")
+ + (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);
+ + strlen (base)
+ + 1);
if (debugfile == NULL)
goto found; /* Actually this returns NULL. */
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, crc32))
+ if (check_func (debugfile, func_data))
goto found;
/* Then try in a subdirectory called .debug. */
sprintf (debugfile, "%s.debug/%s", dir, base);
- if (check_func (debugfile, crc32))
+ 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, crc32))
+ if (check_func (debugfile, func_data))
goto found;
#endif
/* Try the second extra debug file root. */
sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2,
include_dirs ? canon_dir : "/", base);
- if (check_func (debugfile, crc32))
+ if (check_func (debugfile, func_data))
goto found;
#endif
-
+
/* Then try in the global debugfile directory. */
strcpy (debugfile, debug_file_directory);
dirlen = strlen (debug_file_directory) - 1;
}
strcat (debugfile, base);
- if (check_func (debugfile, crc32))
+ if (check_func (debugfile, func_data))
goto found;
/* Failed to find the file. */
return debugfile;
}
-
/*
FUNCTION
bfd_follow_gnu_debuglink
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
If @var{dir} is NULL, the search will take place starting at
the current directory.
-RETURNS
- <<NULL>> 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.
+ Returns <<NULL>> 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_debuglink (bfd *abfd, const char *dir)
{
- return find_separate_debug_file (abfd, dir, TRUE,
- bfd_get_debug_link_info,
- separate_debug_file_exists);
+ 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 pretends to return
- a CRC. .gnu_debugaltlink supplies a build-id, which is different,
- but this is ok because separate_alt_debug_file_exists ignores the
- CRC anyway. */
+/* 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, unsigned long *crc32_out)
+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);
- *crc32_out = 0;
free (buildid);
return result;
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
If @var{dir} is NULL, the search will take place starting at
the current directory.
-RETURNS
- <<NULL>> 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.
+ Returns <<NULL>> 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,
+ return find_separate_debug_file (abfd, dir, true,
get_alt_debug_link_info_shim,
- separate_alt_debug_file_exists);
+ separate_alt_debug_file_exists,
+ NULL);
}
/*
(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 <<NULL>> is
- returned and bfd_error is set.
+ A pointer to the new section is returned if all is ok. Otherwise
+ <<NULL>> is returned and bfd_error is set.
*/
asection *
if (sect == NULL)
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;
}
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
- current directory.
+ specified @var{filename}. The filename should be absolute or
+ relative to the current directory.
-RETURNS
<<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
and bfd_error is set.
*/
-bfd_boolean
+bool
bfd_fill_in_gnu_debuglink_section (bfd *abfd,
struct bfd_section *sect,
const char *filename)
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.
- XXX - Should we attempt to locate the debug info file using the same
- algorithm as gdb ? At the moment, since we are creating the
- .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 = real_fopen (filename, FOPEN_RB);
+ /* Open the linked file so that we can compute a CRC. */
+ handle = _bfd_real_fopen (filename, FOPEN_RB);
if (handle == NULL)
{
bfd_set_error (bfd_error_system_call);
- return FALSE;
+ return false;
}
crc32 = 0;
if (contents == NULL)
{
/* XXX Should we delete the section from the bfd ? */
- return FALSE;
+ return false;
}
crc_offset = debuglink_size - 4;
{
/* XXX Should we delete the section from the bfd ? */
free (contents);
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-/*
-INTERNAL_FUNCTION
- get_build_id
-
-SYNOPSIS
- struct bfd_build_id * get_build_id
- (bfd *abfd);
+/* 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}.
-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 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.
-*/
+ 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)
Elf_External_Note *enote;
bfd_byte *contents;
asection *sect;
+ bfd_size_type size;
BFD_ASSERT (abfd);
return (struct bfd_build_id *) abfd->build_id;
sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id");
- if (sect == NULL)
+ if (sect == NULL
+ || (sect->flags & SEC_HAS_CONTENTS) == 0)
{
bfd_set_error (bfd_error_no_debug_section);
return NULL;
}
+ size = bfd_section_size (sect);
/* FIXME: Should we support smaller build-id notes ? */
- if (bfd_get_section_size (sect) < 0x24)
+ if (size < 0x24)
{
bfd_set_error (bfd_error_invalid_operation);
return NULL;
}
if (!bfd_malloc_and_get_section (abfd, sect, & 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))
{
- if (contents != NULL)
- free (contents);
+ bfd_set_error (bfd_error_invalid_operation);
+ free (contents);
return NULL;
}
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
+
+ if (inote.descsz <= 0
|| inote.type != NT_GNU_BUILD_ID
|| inote.namesz != 4 /* sizeof "GNU" */
- || strcmp (inote.namedata, "GNU") != 0)
+ || !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 build_id;
}
-/*
-INTERNAL_FUNCTION
- get_build_id_name
-
-SYNOPSIS
- char * get_build_id_name
- (bfd *abfd, unsigned long *build_id_out)
+/* 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.
-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 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} parameter is
- set to a pointer to the build_id structure.
-*/
+ 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, unsigned long *build_id_out)
+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 || abfd->filename == NULL || build_id_out == NULL)
+ if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL)
{
bfd_set_error (bfd_error_invalid_operation);
return NULL;
n += sprintf (n, "%02x", (unsigned) *d++);
n += sprintf (n, ".debug");
- * build_id_out = (unsigned long) build_id;
+ *build_id_out = build_id;
return name;
}
-/*
-INTERNAL_FUNCTION
- check_build_id_file
+/* Checks to see if @var{name} is a readable file and if its build-id
+ matches @var{buildid}.
-SYNOPSIS
- bfd_boolean check_build_id_file
- (char *name, unsigned long buildid);
-
-DESCRIPTION
- Checks to see if @var{name} is a readable file and if its build-id
- matches @var{buildid}.
-
- Returns TRUE if the file exists, is readable, and contains a build-id
- which matches @var{build-id}.
-*/
+ 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 bfd_boolean
-check_build_id_file (const char *name,
- const unsigned long buildid)
+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;
- bfd_boolean result;
+ bool result;
BFD_ASSERT (name);
- BFD_ASSERT (buildid);
+ BFD_ASSERT (buildid_p);
file = bfd_openr (name, NULL);
if (file == NULL)
- return FALSE;
+ 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;
+ return false;
}
-
+
build_id = get_build_id (file);
if (build_id == NULL)
{
bfd_close (file);
- return FALSE;
+ return false;
}
- orig_build_id = (struct bfd_build_id *) buildid;
+ 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;
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
If @var{dir} is NULL, the search will take place starting at
the current directory.
-RETURNS
- <<NULL>> 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.
+ Returns <<NULL>> 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)
{
- return find_separate_debug_file (abfd, dir, FALSE,
+ struct bfd_build_id *build_id;
+
+ return find_separate_debug_file (abfd, dir, false,
get_build_id_name,
- check_build_id_file);
+ 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;
}