/* BFD back-end for archive files (libraries).
- Copyright (C) 1990-2018 Free Software Foundation, Inc.
+ Copyright (C) 1990-2023 Free Software Foundation, Inc.
Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault.
This file is part of BFD, the Binary File Descriptor library.
void
_bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
{
- static char buf[20];
+ char buf[20];
size_t len;
snprintf (buf, sizeof (buf), fmt, val);
memcpy (p, buf, n);
}
-bfd_boolean
+bool
_bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
{
- static char buf[21];
+ char buf[21];
size_t len;
- snprintf (buf, sizeof (buf), "%-10" BFD_VMA_FMT "u", size);
+ snprintf (buf, sizeof (buf), "%-10" PRIu64, (uint64_t) size);
len = strlen (buf);
if (len > n)
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ return false;
}
if (len < n)
{
}
else
memcpy (p, buf, n);
- return TRUE;
+ return true;
}
\f
-bfd_boolean
+bool
_bfd_generic_mkarchive (bfd *abfd)
{
- bfd_size_type amt = sizeof (struct artdata);
+ size_t amt = sizeof (struct artdata);
abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
if (bfd_ardata (abfd) == NULL)
- return FALSE;
+ return false;
/* Already cleared by bfd_zalloc above.
bfd_ardata (abfd)->cache = NULL;
bfd_ardata (abfd)->extended_names_size = 0;
bfd_ardata (abfd)->tdata = NULL; */
- return TRUE;
+ return true;
}
/*
bfd_set_archive_head
SYNOPSIS
- bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
+ bool bfd_set_archive_head (bfd *output, bfd *new_head);
DESCRIPTION
Set the head of the chain of
BFDs contained in the archive @var{output} to @var{new_head}.
*/
-bfd_boolean
+bool
bfd_set_archive_head (bfd *output_archive, bfd *new_head)
{
output_archive->archive_head = new_head;
- return TRUE;
+ return true;
}
bfd *
/* Kind of stupid to call cons for each one, but we don't do too many. */
-bfd_boolean
+bool
_bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
{
struct ar_cache *cache;
hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
NULL, _bfd_calloc_wrapper, free);
if (hash_table == NULL)
- return FALSE;
+ return false;
bfd_ardata (arch_bfd)->cache = hash_table;
}
arch_eltdata (new_elt)->parent_cache = hash_table;
arch_eltdata (new_elt)->key = filepos;
- return TRUE;
+ return true;
}
\f
static bfd *
bfd *abfd;
/* PR 15140: Don't allow a nested archive pointing to itself. */
- if (filename_cmp (filename, arch_bfd->filename) == 0)
+ if (filename_cmp (filename, bfd_get_filename (arch_bfd)) == 0)
{
bfd_set_error (bfd_error_malformed_archive);
return NULL;
abfd != NULL;
abfd = abfd->archive_next)
{
- if (filename_cmp (filename, abfd->filename) == 0)
+ if (filename_cmp (filename, bfd_get_filename (abfd)) == 0)
return abfd;
}
abfd = open_nested_file (filename, arch_bfd);
{
struct ar_hdr hdr;
char *hdrp = (char *) &hdr;
- bfd_size_type parsed_size;
+ uint64_t parsed_size;
struct areltdata *ared;
char *filename = NULL;
+ ufile_ptr filesize;
bfd_size_type namelen = 0;
bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
char *allocptr = 0;
errno = 0;
fmag_save = hdr.ar_fmag[0];
hdr.ar_fmag[0] = 0;
- scan = sscanf (hdr.ar_size, "%" BFD_VMA_FMT "u", &parsed_size);
+ scan = sscanf (hdr.ar_size, "%" SCNu64, &parsed_size);
hdr.ar_fmag[0] = fmag_save;
if (scan != 1)
{
{
/* BSD-4.4 extended name */
namelen = atoi (&hdr.ar_name[3]);
+ filesize = bfd_get_file_size (abfd);
+ if (namelen > parsed_size
+ || namelen > -allocsize - 2
+ || (filesize != 0 && namelen > filesize))
+ {
+ bfd_set_error (bfd_error_malformed_archive);
+ return NULL;
+ }
allocsize += namelen + 1;
parsed_size -= namelen;
extra_size = namelen;
- allocptr = (char *) bfd_zmalloc (allocsize);
+ allocptr = (char *) bfd_malloc (allocsize);
if (allocptr == NULL)
return NULL;
filename = (allocptr
if (!allocptr)
{
- allocptr = (char *) bfd_zmalloc (allocsize);
+ allocptr = (char *) bfd_malloc (allocsize);
if (allocptr == NULL)
return NULL;
}
+ memset (allocptr, 0, sizeof (struct areltdata));
ared = (struct areltdata *) allocptr;
-
ared->arch_header = allocptr + sizeof (struct areltdata);
memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
ared->parsed_size = parsed_size;
char *
_bfd_append_relative_path (bfd *arch, char *elt_name)
{
- const char *arch_name = arch->filename;
+ const char *arch_name = bfd_get_filename (arch);
const char *base_name = lbasename (arch_name);
size_t prefix_len;
char *filename;
element, since it handles the bookkeeping so nicely for us. */
bfd *
-_bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
+_bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos,
+ struct bfd_link_info *info)
{
struct areltdata *new_areldata;
bfd *n_bfd;
free (new_areldata);
return NULL;
}
- n_bfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin);
+ n_bfd = _bfd_get_elt_at_filepos (ext_arch,
+ new_areldata->origin, info);
if (n_bfd == NULL)
{
free (new_areldata);
return NULL;
}
n_bfd->proxy_origin = bfd_tell (archive);
+
+ /* Copy BFD_COMPRESS, BFD_DECOMPRESS and BFD_COMPRESS_GABI
+ flags. */
+ n_bfd->flags |= archive->flags & (BFD_COMPRESS
+ | BFD_DECOMPRESS
+ | BFD_COMPRESS_GABI);
+
return n_bfd;
}
/* It's not an element of a nested archive;
open the external file as a bfd. */
+ bfd_set_error (bfd_error_no_error);
n_bfd = open_nested_file (filename, archive);
if (n_bfd == NULL)
- bfd_set_error (bfd_error_malformed_archive);
+ {
+ switch (bfd_get_error ())
+ {
+ default:
+ break;
+ case bfd_error_no_error:
+ bfd_set_error (bfd_error_malformed_archive);
+ break;
+ case bfd_error_system_call:
+ if (info != NULL)
+ {
+ info->callbacks->einfo
+ (_("%F%P: %pB(%s): error opening thin archive member: %E\n"),
+ archive, filename);
+ break;
+ }
+ break;
+ }
+ }
}
else
{
else
{
n_bfd->origin = n_bfd->proxy_origin;
- n_bfd->filename = xstrdup (filename);
+ if (!bfd_set_filename (n_bfd, filename))
+ goto out;
}
n_bfd->arelt_data = new_areldata;
/* Copy is_linker_input. */
n_bfd->is_linker_input = archive->is_linker_input;
- if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_bfd))
+ if (archive->no_element_cache
+ || _bfd_add_bfd_to_archive_cache (archive, filepos, n_bfd))
return n_bfd;
+ out:
free (new_areldata);
n_bfd->arelt_data = NULL;
+ bfd_close (n_bfd);
return NULL;
}
carsym *entry;
entry = bfd_ardata (abfd)->symdefs + sym_index;
- return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
+ return _bfd_get_elt_at_filepos (abfd, entry->file_offset, NULL);
}
bfd *
}
}
- return _bfd_get_elt_at_filepos (archive, filestart);
+ return _bfd_get_elt_at_filepos (archive, filestart, NULL);
}
bfd *
return (bfd *) _bfd_ptr_bfd_null_error (archive);
}
-const bfd_target *
+bfd_cleanup
bfd_generic_archive_p (bfd *abfd)
{
struct artdata *tdata_hold;
char armag[SARMAG + 1];
- bfd_size_type amt;
+ size_t amt;
if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
{
return NULL;
}
- bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0);
+ bfd_set_thin_archive (abfd, strncmp (armag, ARMAGT, SARMAG) == 0);
if (strncmp (armag, ARMAG, SARMAG) != 0
- && strncmp (armag, ARMAGB, SARMAG) != 0
&& ! bfd_is_thin_archive (abfd))
{
bfd_set_error (bfd_error_wrong_format);
- if (abfd->format == bfd_archive)
- abfd->format = bfd_unknown;
return NULL;
}
if (abfd->target_defaulted && bfd_has_map (abfd))
{
bfd *first;
+ unsigned int save;
/* This archive has a map, so we may presume that the contents
are object files. Make sure that if the first file in the
normal archive, regardless of the format of the object files.
We do accept an empty archive. */
+ save = abfd->no_element_cache;
+ abfd->no_element_cache = 1;
first = bfd_openr_next_archived_file (abfd, NULL);
+ abfd->no_element_cache = save;
if (first != NULL)
{
- first->target_defaulted = FALSE;
+ first->target_defaulted = false;
if (bfd_check_format (first, bfd_object)
&& first->xvec != abfd->xvec)
bfd_set_error (bfd_error_wrong_object_format);
- /* And we ought to close `first' here too. */
+ bfd_close (first);
}
}
- return abfd->xvec;
+ return _bfd_no_cleanup;
}
/* Some constants for a 32 bit BSD archive structure. We do not
/* Read a BSD-style archive symbol table. Returns FALSE on error,
TRUE otherwise. */
-static bfd_boolean
+static bool
do_slurp_bsd_armap (bfd *abfd)
{
struct areltdata *mapdata;
- unsigned int counter;
+ size_t counter;
bfd_byte *raw_armap, *rbase;
struct artdata *ardata = bfd_ardata (abfd);
char *stringbase;
- bfd_size_type parsed_size, amt;
+ bfd_size_type parsed_size;
+ size_t amt, string_size;
carsym *set;
mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
if (mapdata == NULL)
- return FALSE;
+ return false;
parsed_size = mapdata->parsed_size;
free (mapdata);
/* PR 17512: file: 883ff754. */
/* PR 17512: file: 0458885f. */
- if (parsed_size < 4)
- return FALSE;
-
- raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
- if (raw_armap == NULL)
- return FALSE;
-
- if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
+ if (parsed_size < BSD_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
{
- if (bfd_get_error () != bfd_error_system_call)
- bfd_set_error (bfd_error_malformed_archive);
- byebye:
- bfd_release (abfd, raw_armap);
- return FALSE;
+ bfd_set_error (bfd_error_malformed_archive);
+ return false;
}
- ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
- if (ardata->symdef_count * BSD_SYMDEF_SIZE >
- parsed_size - BSD_SYMDEF_COUNT_SIZE)
+ raw_armap = (bfd_byte *) _bfd_alloc_and_read (abfd, parsed_size, parsed_size);
+ if (raw_armap == NULL)
+ return false;
+
+ parsed_size -= BSD_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE;
+ amt = H_GET_32 (abfd, raw_armap);
+ if (amt > parsed_size
+ || amt % BSD_SYMDEF_SIZE != 0)
{
/* Probably we're using the wrong byte ordering. */
bfd_set_error (bfd_error_wrong_format);
- goto byebye;
+ goto release_armap;
}
- ardata->cache = 0;
rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
- stringbase = ((char *) rbase
- + ardata->symdef_count * BSD_SYMDEF_SIZE
- + BSD_STRING_COUNT_SIZE);
- amt = ardata->symdef_count * sizeof (carsym);
+ stringbase = (char *) rbase + amt + BSD_STRING_COUNT_SIZE;
+ string_size = parsed_size - amt;
+
+ ardata->symdef_count = amt / BSD_SYMDEF_SIZE;
+ if (_bfd_mul_overflow (ardata->symdef_count, sizeof (carsym), &amt))
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto release_armap;
+ }
ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
if (!ardata->symdefs)
- return FALSE;
+ goto release_armap;
for (counter = 0, set = ardata->symdefs;
counter < ardata->symdef_count;
counter++, set++, rbase += BSD_SYMDEF_SIZE)
{
- set->name = H_GET_32 (abfd, rbase) + stringbase;
+ unsigned nameoff = H_GET_32 (abfd, rbase);
+ if (nameoff >= string_size)
+ {
+ bfd_set_error (bfd_error_malformed_archive);
+ goto release_armap;
+ }
+ set->name = stringbase + nameoff;
set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
}
/* FIXME, we should provide some way to free raw_ardata when
we are done using the strings from it. For now, it seems
to be allocated on an objalloc anyway... */
- bfd_has_map (abfd) = TRUE;
- return TRUE;
+ abfd->has_armap = true;
+ return true;
+
+ release_armap:
+ ardata->symdef_count = 0;
+ ardata->symdefs = NULL;
+ bfd_release (abfd, raw_armap);
+ return false;
}
/* Read a COFF archive symbol table. Returns FALSE on error, TRUE
otherwise. */
-static bfd_boolean
+static bool
do_slurp_coff_armap (bfd *abfd)
{
struct areltdata *mapdata;
int *raw_armap, *rawptr;
struct artdata *ardata = bfd_ardata (abfd);
char *stringbase;
+ char *stringend;
bfd_size_type stringsize;
bfd_size_type parsed_size;
+ ufile_ptr filesize;
+ size_t nsymz, carsym_size, ptrsize, i;
carsym *carsyms;
- bfd_size_type nsymz; /* Number of symbols in armap. */
bfd_vma (*swap) (const void *);
- char int_buf[sizeof (long)];
- bfd_size_type carsym_size, ptrsize;
- unsigned int i;
+ char int_buf[4];
+ struct areltdata *tmp;
mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
if (mapdata == NULL)
- return FALSE;
+ return false;
parsed_size = mapdata->parsed_size;
free (mapdata);
if (bfd_bread (int_buf, 4, abfd) != 4)
- {
- if (bfd_get_error () != bfd_error_system_call)
- bfd_set_error (bfd_error_malformed_archive);
- return FALSE;
- }
+ return false;
+
/* It seems that all numeric information in a coff archive is always
- in big endian format, nomatter the host or target. */
+ in big endian format, no matter the host or target. */
swap = bfd_getb32;
nsymz = bfd_getb32 (int_buf);
- stringsize = parsed_size - (4 * nsymz) - 4;
- /* ... except that some archive formats are broken, and it may be our
- fault - the i960 little endian coff sometimes has big and sometimes
- little, because our tools changed. Here's a horrible hack to clean
- up the crap. */
+ /* The coff armap must be read sequentially. So we construct a
+ bsd-style one in core all at once, for simplicity. */
- if (stringsize > 0xfffff
- && bfd_get_arch (abfd) == bfd_arch_i960
- && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
+ if (_bfd_mul_overflow (nsymz, sizeof (carsym), &carsym_size))
{
- /* This looks dangerous, let's do it the other way around. */
- nsymz = bfd_getl32 (int_buf);
- stringsize = parsed_size - (4 * nsymz) - 4;
- swap = bfd_getl32;
+ bfd_set_error (bfd_error_no_memory);
+ return false;
}
- /* The coff armap must be read sequentially. So we construct a
- bsd-style one in core all at once, for simplicity. */
-
- if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
- return FALSE;
+ filesize = bfd_get_file_size (abfd);
+ ptrsize = 4 * nsymz;
+ if ((filesize != 0 && parsed_size > filesize)
+ || parsed_size < 4
+ || parsed_size - 4 < ptrsize)
+ {
+ bfd_set_error (bfd_error_malformed_archive);
+ return false;
+ }
- carsym_size = (nsymz * sizeof (carsym));
- ptrsize = (4 * nsymz);
+ stringsize = parsed_size - ptrsize - 4;
if (carsym_size + stringsize + 1 <= carsym_size)
- return FALSE;
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
- ardata->symdefs = (struct carsym *) bfd_zalloc (abfd,
- carsym_size + stringsize + 1);
+ /* Allocate and read in the raw offsets. */
+ raw_armap = (int *) _bfd_malloc_and_read (abfd, ptrsize, ptrsize);
+ if (raw_armap == NULL)
+ return false;
+
+ ardata->symdefs = (struct carsym *) bfd_alloc (abfd,
+ carsym_size + stringsize + 1);
if (ardata->symdefs == NULL)
- return FALSE;
+ goto free_armap;
carsyms = ardata->symdefs;
stringbase = ((char *) ardata->symdefs) + carsym_size;
- /* Allocate and read in the raw offsets. */
- raw_armap = (int *) bfd_alloc (abfd, ptrsize);
- if (raw_armap == NULL)
+ if (bfd_bread (stringbase, stringsize, abfd) != stringsize)
goto release_symdefs;
- if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
- || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
- {
- if (bfd_get_error () != bfd_error_system_call)
- bfd_set_error (bfd_error_malformed_archive);
- goto release_raw_armap;
- }
/* OK, build the carsyms. */
- for (i = 0; i < nsymz && stringsize > 0; i++)
+ stringend = stringbase + stringsize;
+ *stringend = 0;
+ for (i = 0; i < nsymz; i++)
{
- bfd_size_type len;
-
rawptr = raw_armap + i;
carsyms->file_offset = swap ((bfd_byte *) rawptr);
carsyms->name = stringbase;
- /* PR 17512: file: 4a1d50c1. */
- len = strnlen (stringbase, stringsize);
- if (len < stringsize)
- len ++;
- stringbase += len;
- stringsize -= len;
+ stringbase += strlen (stringbase);
+ if (stringbase != stringend)
+ ++stringbase;
carsyms++;
}
- *stringbase = 0;
ardata->symdef_count = nsymz;
ardata->first_file_filepos = bfd_tell (abfd);
/* Pad to an even boundary if you have to. */
ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
+ if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) != 0)
+ goto release_symdefs;
- bfd_has_map (abfd) = TRUE;
- bfd_release (abfd, raw_armap);
+ abfd->has_armap = true;
+ free (raw_armap);
/* Check for a second archive header (as used by PE). */
- {
- struct areltdata *tmp;
-
- bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
- tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
- if (tmp != NULL)
- {
- if (tmp->arch_header[0] == '/'
- && tmp->arch_header[1] == ' ')
- {
- ardata->first_file_filepos +=
- (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
- }
- free (tmp);
- }
- }
+ tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+ if (tmp != NULL)
+ {
+ if (tmp->arch_header[0] == '/'
+ && tmp->arch_header[1] == ' ')
+ ardata->first_file_filepos
+ += (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
+ free (tmp);
+ }
- return TRUE;
+ return true;
-release_raw_armap:
- bfd_release (abfd, raw_armap);
-release_symdefs:
+ release_symdefs:
bfd_release (abfd, (ardata)->symdefs);
- return FALSE;
+ free_armap:
+ free (raw_armap);
+ return false;
}
/* This routine can handle either coff-style or bsd-style armaps
(archive symbol table). Returns FALSE on error, TRUE otherwise */
-bfd_boolean
+bool
bfd_slurp_armap (bfd *abfd)
{
char nextname[17];
int i = bfd_bread (nextname, 16, abfd);
if (i == 0)
- return TRUE;
+ return true;
if (i != 16)
- return FALSE;
+ return false;
if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
- return FALSE;
+ return false;
- if (CONST_STRNEQ (nextname, "__.SYMDEF ")
- || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
+ if (startswith (nextname, "__.SYMDEF ")
+ || startswith (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
return do_slurp_bsd_armap (abfd);
- else if (CONST_STRNEQ (nextname, "/ "))
+ else if (startswith (nextname, "/ "))
return do_slurp_coff_armap (abfd);
- else if (CONST_STRNEQ (nextname, "/SYM64/ "))
+ else if (startswith (nextname, "/SYM64/ "))
{
/* 64bit (Irix 6) archive. */
#ifdef BFD64
return _bfd_archive_64_bit_slurp_armap (abfd);
#else
bfd_set_error (bfd_error_wrong_format);
- return FALSE;
+ return false;
#endif
}
- else if (CONST_STRNEQ (nextname, "#1/20 "))
+ else if (startswith (nextname, "#1/20 "))
{
/* Mach-O has a special name for armap when the map is sorted by name.
However because this name has a space it is slightly more difficult
char extname[21];
if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
- return FALSE;
+ return false;
/* Read the extended name. We know its length. */
if (bfd_bread (extname, 20, abfd) != 20)
- return FALSE;
+ return false;
if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
- return FALSE;
+ return false;
extname[20] = 0;
- if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
- || CONST_STRNEQ (extname, "__.SYMDEF"))
+ if (startswith (extname, "__.SYMDEF SORTED")
+ || startswith (extname, "__.SYMDEF"))
return do_slurp_bsd_armap (abfd);
}
- bfd_has_map (abfd) = FALSE;
- return TRUE;
-}
-\f
-/* Returns FALSE on error, TRUE otherwise. */
-/* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
- header is in a slightly different order and the map name is '/'.
- This flavour is used by hp300hpux. */
-
-#define HPUX_SYMDEF_COUNT_SIZE 2
-
-bfd_boolean
-bfd_slurp_bsd_armap_f2 (bfd *abfd)
-{
- struct areltdata *mapdata;
- char nextname[17];
- unsigned int counter;
- bfd_byte *raw_armap, *rbase;
- struct artdata *ardata = bfd_ardata (abfd);
- char *stringbase;
- unsigned int stringsize;
- unsigned int left;
- bfd_size_type amt;
- carsym *set;
- int i = bfd_bread (nextname, 16, abfd);
-
- if (i == 0)
- return TRUE;
- if (i != 16)
- return FALSE;
-
- /* The archive has at least 16 bytes in it. */
- if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
- return FALSE;
-
- if (CONST_STRNEQ (nextname, "__.SYMDEF ")
- || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
- return do_slurp_bsd_armap (abfd);
-
- if (! CONST_STRNEQ (nextname, "/ "))
- {
- bfd_has_map (abfd) = FALSE;
- return TRUE;
- }
-
- mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
- if (mapdata == NULL)
- return FALSE;
-
- if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
- {
- free (mapdata);
- wrong_format:
- bfd_set_error (bfd_error_wrong_format);
- byebye:
- return FALSE;
- }
- left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE;
-
- amt = mapdata->parsed_size;
- free (mapdata);
-
- raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
- if (raw_armap == NULL)
- goto byebye;
-
- if (bfd_bread (raw_armap, amt, abfd) != amt)
- {
- if (bfd_get_error () != bfd_error_system_call)
- bfd_set_error (bfd_error_malformed_archive);
- goto byebye;
- }
-
- ardata->symdef_count = H_GET_16 (abfd, raw_armap);
-
- ardata->cache = 0;
-
- stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
- if (stringsize > left)
- goto wrong_format;
- left -= stringsize;
-
- /* Skip sym count and string sz. */
- stringbase = ((char *) raw_armap
- + HPUX_SYMDEF_COUNT_SIZE
- + BSD_STRING_COUNT_SIZE);
- rbase = (bfd_byte *) stringbase + stringsize;
- amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
- if (amt > left)
- goto wrong_format;
-
- ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
- if (!ardata->symdefs)
- return FALSE;
-
- for (counter = 0, set = ardata->symdefs;
- counter < ardata->symdef_count;
- counter++, set++, rbase += BSD_SYMDEF_SIZE)
- {
- set->name = H_GET_32 (abfd, rbase) + stringbase;
- set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
- }
-
- ardata->first_file_filepos = bfd_tell (abfd);
- /* Pad to an even boundary if you have to. */
- ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
- /* FIXME, we should provide some way to free raw_ardata when
- we are done using the strings from it. For now, it seems
- to be allocated on an objalloc anyway... */
- bfd_has_map (abfd) = TRUE;
- return TRUE;
+ abfd->has_armap = false;
+ return true;
}
\f
/** Extended name table.
/* Returns FALSE on error, TRUE otherwise. */
-bfd_boolean
+bool
_bfd_slurp_extended_name_table (bfd *abfd)
{
char nextname[17];
- struct areltdata *namedata;
- bfd_size_type amt;
/* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
we probably don't want to return TRUE. */
if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)
- return FALSE;
+ return false;
if (bfd_bread (nextname, 16, abfd) == 16)
{
+ struct areltdata *namedata;
+ bfd_size_type amt;
+ ufile_ptr filesize;
+
if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
- return FALSE;
+ return false;
- if (! CONST_STRNEQ (nextname, "ARFILENAMES/ ")
- && ! CONST_STRNEQ (nextname, "// "))
+ if (! startswith (nextname, "ARFILENAMES/ ")
+ && ! startswith (nextname, "// "))
{
bfd_ardata (abfd)->extended_names = NULL;
bfd_ardata (abfd)->extended_names_size = 0;
- return TRUE;
+ return true;
}
namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
if (namedata == NULL)
- return FALSE;
+ return false;
+ filesize = bfd_get_file_size (abfd);
amt = namedata->parsed_size;
- if (amt + 1 == 0)
- goto byebye;
+ if (amt + 1 == 0 || (filesize != 0 && amt > filesize))
+ {
+ bfd_set_error (bfd_error_malformed_archive);
+ goto byebye;
+ }
bfd_ardata (abfd)->extended_names_size = amt;
- bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1);
+ bfd_ardata (abfd)->extended_names = (char *) bfd_alloc (abfd, amt + 1);
if (bfd_ardata (abfd)->extended_names == NULL)
{
byebye:
free (namedata);
bfd_ardata (abfd)->extended_names = NULL;
bfd_ardata (abfd)->extended_names_size = 0;
- return FALSE;
+ return false;
}
if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
bfd_ardata (abfd)->extended_names = NULL;
goto byebye;
}
+ bfd_ardata (abfd)->extended_names[amt] = 0;
/* Since the archive is supposed to be printable if it contains
text, the entries in the list are newline-padded, not null
free (namedata);
}
- return TRUE;
+ return true;
}
#ifdef VMS
const char *last;
char *copy;
+ if (abfd->flags & BFD_ARCHIVE_FULL_PATH)
+ return file;
+
first = file + strlen (file) - 1;
last = first + 1;
#else
static const char *
-normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
+normalize (bfd *abfd, const char *file)
{
+ if (abfd->flags & BFD_ARCHIVE_FULL_PATH)
+ return file;
return lbasename (file);
}
#endif
if (len > pathbuf_len)
{
- if (pathbuf != NULL)
- free (pathbuf);
+ free (pathbuf);
pathbuf_len = 0;
pathbuf = (char *) bfd_malloc (len);
if (pathbuf == NULL)
/* Build a BFD style extended name table. */
-bfd_boolean
+bool
_bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
char **tabloc,
bfd_size_type *tablen,
const char **name)
{
*name = "ARFILENAMES/";
- return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
+ return _bfd_construct_extended_name_table (abfd, false, tabloc, tablen);
}
/* Build an SVR4 style extended name table. */
-bfd_boolean
+bool
_bfd_archive_coff_construct_extended_name_table (bfd *abfd,
char **tabloc,
bfd_size_type *tablen,
const char **name)
{
*name = "//";
- return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
+ return _bfd_construct_extended_name_table (abfd, true, tabloc, tablen);
}
-bfd_boolean
+bool
_bfd_noarchive_construct_extended_name_table (bfd *abfd ATTRIBUTE_UNUSED,
char **tabloc ATTRIBUTE_UNUSED,
bfd_size_type *len ATTRIBUTE_UNUSED,
const char **name ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
/* Follows archive_head and produces an extended name table if
something went wrong. A successful return may still involve a
zero-length tablen! */
-bfd_boolean
+bool
_bfd_construct_extended_name_table (bfd *abfd,
- bfd_boolean trailing_slash,
+ bool trailing_slash,
char **tabloc,
bfd_size_type *tablen)
{
if (bfd_is_thin_archive (abfd))
{
- const char *filename = current->filename;
+ const char *filename = bfd_get_filename (current);
/* If the element being added is a member of another archive
(i.e., we are flattening), use the containing archive's name. */
if (current->my_archive
&& ! bfd_is_thin_archive (current->my_archive))
- filename = current->my_archive->filename;
+ filename = bfd_get_filename (current->my_archive);
/* If the path is the same as the previous path seen,
reuse it. This can happen when flattening a thin
/* If the path is relative, adjust it relative to
the containing archive. */
if (! IS_ABSOLUTE_PATH (filename)
- && ! IS_ABSOLUTE_PATH (abfd->filename))
- normal = adjust_relative_path (filename, abfd->filename);
+ && ! IS_ABSOLUTE_PATH (bfd_get_filename (abfd)))
+ normal = adjust_relative_path (filename, bfd_get_filename (abfd));
else
normal = filename;
continue;
}
- normal = normalize (current, current->filename);
+ normal = normalize (abfd, bfd_get_filename (current));
if (normal == NULL)
- return FALSE;
+ return false;
thislen = strlen (normal);
}
if (total_namelen == 0)
- return TRUE;
+ return true;
- *tabloc = (char *) bfd_zalloc (abfd, total_namelen);
+ *tabloc = (char *) bfd_alloc (abfd, total_namelen);
if (*tabloc == NULL)
- return FALSE;
+ return false;
*tablen = total_namelen;
strptr = *tabloc;
const char *normal;
unsigned int thislen;
long stroff;
- const char *filename = current->filename;
+ const char *filename = bfd_get_filename (current);
if (bfd_is_thin_archive (abfd))
{
(i.e., we are flattening), use the containing archive's name. */
if (current->my_archive
&& ! bfd_is_thin_archive (current->my_archive))
- filename = current->my_archive->filename;
+ filename = bfd_get_filename (current->my_archive);
/* If the path is the same as the previous path seen,
reuse it. This can happen when flattening a thin
archive that contains other archives.
if (last_filename && filename_cmp (last_filename, filename) == 0)
normal = last_filename;
else if (! IS_ABSOLUTE_PATH (filename)
- && ! IS_ABSOLUTE_PATH (abfd->filename))
- normal = adjust_relative_path (filename, abfd->filename);
+ && ! IS_ABSOLUTE_PATH (bfd_get_filename (abfd)))
+ normal = adjust_relative_path (filename, bfd_get_filename (abfd));
else
normal = filename;
}
else
{
- normal = normalize (current, filename);
+ normal = normalize (abfd, filename);
if (normal == NULL)
- return FALSE;
+ return false;
}
thislen = strlen (normal);
stroff = last_stroff;
else
{
- strcpy (strptr, normal);
- if (! trailing_slash)
- strptr[thislen] = ARFMAG[1];
- else
- {
- strptr[thislen] = '/';
- strptr[thislen + 1] = ARFMAG[1];
- }
+ last_filename = filename;
stroff = strptr - *tabloc;
last_stroff = stroff;
+ memcpy (strptr, normal, thislen);
+ strptr += thislen;
+ if (trailing_slash)
+ *strptr++ = '/';
+ *strptr++ = ARFMAG[1];
}
hdr->ar_name[0] = ar_padchar (current);
if (bfd_is_thin_archive (abfd) && current->origin > 0)
}
else
_bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
- if (normal != last_filename)
- {
- strptr += thislen + 1;
- if (trailing_slash)
- ++strptr;
- last_filename = filename;
- }
}
}
- return TRUE;
+ return true;
}
/* Do not construct an extended name table but transforms name field into
its extended form. */
-bfd_boolean
+bool
_bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
char **tabloc,
bfd_size_type *tablen,
current != NULL;
current = current->archive_next)
{
- const char *normal = normalize (current, current->filename);
+ const char *normal = normalize (abfd, bfd_get_filename (current));
int has_space = 0;
unsigned int len;
if (normal == NULL)
- return FALSE;
+ return false;
for (len = 0; normal[len]; len++)
if (normal[len] == ' ')
}
}
- return TRUE;
+ return true;
}
\f
/* Write an archive header. */
-bfd_boolean
+bool
_bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
{
struct ar_hdr *hdr = arch_hdr (abfd);
if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
- return FALSE;
- return TRUE;
+ return false;
+ return true;
}
/* Write an archive header using BSD4.4 convention. */
-bfd_boolean
+bool
_bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
{
struct ar_hdr *hdr = arch_hdr (abfd);
if (is_bsd44_extended_name (hdr->ar_name))
{
/* This is a BSD 4.4 extended name. */
- const char *fullname = normalize (abfd, abfd->filename);
+ const char *fullname = normalize (abfd, bfd_get_filename (abfd));
unsigned int len = strlen (fullname);
unsigned int padded_len = (len + 3) & ~3;
if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size),
arch_eltdata (abfd)->parsed_size + padded_len))
- return FALSE;
+ return false;
if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
- return FALSE;
+ return false;
if (bfd_bwrite (fullname, len, archive) != len)
- return FALSE;
+ return false;
if (len & 3)
{
len = 4 - (len & 3);
if (bfd_bwrite (pad, len, archive) != len)
- return FALSE;
+ return false;
}
}
else
{
if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-bfd_boolean
+bool
_bfd_noarchive_write_ar_hdr (bfd *archive, bfd *abfd ATTRIBUTE_UNUSED)
{
return _bfd_bool_bfd_false_error (archive);
}
#endif /* HPUX_LARGE_AR_IDS */
-#ifndef HAVE_GETUID
-#define getuid() 0
-#endif
-
-#ifndef HAVE_GETGID
-#define getgid() 0
-#endif
-
/* Takes a filename, returns an arelt_data for it, or NULL if it can't
make one. The filename must refer to a filename in the filesystem.
The filename field of the ar_hdr will NOT be initialized. If member
struct stat status;
struct areltdata *ared;
struct ar_hdr *hdr;
- bfd_size_type amt;
+ size_t amt;
if (member && (member->flags & BFD_IN_MEMORY) != 0)
{
\f
/* The BFD is open for write and has its format set to bfd_archive. */
-bfd_boolean
+bool
_bfd_write_archive_contents (bfd *arch)
{
bfd *current;
char *etable = NULL;
bfd_size_type elength = 0;
const char *ename = NULL;
- bfd_boolean makemap = bfd_has_map (arch);
+ bool makemap = bfd_has_map (arch);
/* If no .o's, don't bother to make a map. */
- bfd_boolean hasobjects = FALSE;
+ bool hasobjects = false;
bfd_size_type wrote;
int tries;
char *armag;
if (!current->arelt_data)
{
current->arelt_data =
- bfd_ar_hdr_from_filesystem (arch, current->filename, current);
+ bfd_ar_hdr_from_filesystem (arch, bfd_get_filename (current),
+ current);
if (!current->arelt_data)
goto input_err;
/* Put in the file name. */
BFD_SEND (arch, _bfd_truncate_arname,
- (arch, current->filename, (char *) arch_hdr (current)));
+ (arch, bfd_get_filename (current),
+ (char *) arch_hdr (current)));
}
if (makemap && ! hasobjects)
{ /* Don't bother if we won't make a map! */
if ((bfd_check_format (current, bfd_object)))
- hasobjects = TRUE;
+ hasobjects = true;
}
}
if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
(arch, &etable, &elength, &ename)))
- return FALSE;
+ return false;
if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
- return FALSE;
+ return false;
armag = ARMAG;
if (bfd_is_thin_archive (arch))
armag = ARMAGT;
wrote = bfd_bwrite (armag, SARMAG, arch);
if (wrote != SARMAG)
- return FALSE;
+ return false;
if (makemap && hasobjects)
{
if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
- return FALSE;
+ return false;
}
if (elength != 0)
/* Round size up to even number in archive header. */
if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size),
(elength + 1) & ~(bfd_size_type) 1))
- return FALSE;
+ return false;
memcpy (hdr.ar_fmag, ARFMAG, 2);
if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
!= sizeof (struct ar_hdr))
|| bfd_bwrite (etable, elength, arch) != elength)
- return FALSE;
+ return false;
if ((elength % 2) == 1)
{
if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
- return FALSE;
+ return false;
}
}
/* Write ar header. */
if (!_bfd_write_ar_hdr (arch, current))
- return FALSE;
+ return false;
if (bfd_is_thin_archive (arch))
continue;
if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
while (remaining)
{
- unsigned int amt = DEFAULT_BUFFERSIZE;
+ size_t amt = DEFAULT_BUFFERSIZE;
if (amt > remaining)
amt = remaining;
errno = 0;
if (bfd_bread (buffer, amt, current) != amt)
- {
- if (bfd_get_error () != bfd_error_system_call)
- bfd_set_error (bfd_error_file_truncated);
- goto input_err;
- }
+ goto input_err;
if (bfd_bwrite (buffer, amt, arch) != amt)
- return FALSE;
+ return false;
remaining -= amt;
}
if ((arelt_size (current) % 2) == 1)
{
if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
- return FALSE;
+ return false;
}
}
if (bfd_update_armap_timestamp (arch))
break;
_bfd_error_handler
- (_("Warning: writing archive was slow: rewriting timestamp\n"));
+ (_("warning: writing archive was slow: rewriting timestamp"));
}
while (++tries < 6);
}
- return TRUE;
+ return true;
input_err:
bfd_set_input_error (current, bfd_get_error ());
- return FALSE;
+ return false;
}
\f
/* Note that the namidx for the first symbol is 0. */
-bfd_boolean
+bool
_bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
{
char *first_name = NULL;
int stridx = 0;
asymbol **syms = NULL;
long syms_max = 0;
- bfd_boolean ret;
- bfd_size_type amt;
+ bool ret;
+ size_t amt;
+ static bool report_plugin_err = true;
/* Dunno if this is the best place for this info... */
if (elength != 0)
/* Drop all the files called __.SYMDEF, we're going to make our own. */
while (arch->archive_head
- && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
+ && strcmp (bfd_get_filename (arch->archive_head), "__.SYMDEF") == 0)
arch->archive_head = arch->archive_head->archive_next;
/* Map over each element. */
long symcount;
long src_count;
+ if (current->lto_slim_object && report_plugin_err)
+ {
+ report_plugin_err = false;
+ _bfd_error_handler
+ (_("%pB: plugin needed to handle lto object"),
+ current);
+ }
+
storage = bfd_get_symtab_upper_bound (current);
if (storage < 0)
goto error_return;
{
if (storage > syms_max)
{
- if (syms_max > 0)
- free (syms);
+ free (syms);
syms_max = storage;
syms = (asymbol **) bfd_malloc (syms_max);
if (syms == NULL)
map = new_map;
}
- if (syms[src_count]->name[0] == '_'
+ if (syms[src_count]->name != NULL
+ && syms[src_count]->name[0] == '_'
&& syms[src_count]->name[1] == '_'
&& strcmp (syms[src_count]->name
+ (syms[src_count]->name[2] == '_'),
- "__gnu_lto_slim") == 0)
- _bfd_error_handler
- (_("%pB: plugin needed to handle lto object"),
- current);
+ "__gnu_lto_slim") == 0
+ && report_plugin_err)
+ {
+ report_plugin_err = false;
+ _bfd_error_handler
+ (_("%pB: plugin needed to handle lto object"),
+ current);
+ }
namelen = strlen (syms[src_count]->name);
amt = sizeof (char *);
map[orl_count].name = (char **) bfd_alloc (arch, amt);
ret = BFD_SEND (arch, write_armap,
(arch, elength, map, orl_count, stridx));
- if (syms_max > 0)
- free (syms);
- if (map != NULL)
- free (map);
+ free (syms);
+ free (map);
if (first_name != NULL)
bfd_release (arch, first_name);
return ret;
error_return:
- if (syms_max > 0)
- free (syms);
- if (map != NULL)
- free (map);
+ free (syms);
+ free (map);
if (first_name != NULL)
bfd_release (arch, first_name);
- return FALSE;
+ return false;
}
-bfd_boolean
+bool
_bfd_bsd_write_armap (bfd *arch,
unsigned int elength,
struct orl *map,
{
struct stat statbuf;
- if (stat (arch->filename, &statbuf) == 0)
+ if (stat (bfd_get_filename (arch), &statbuf) == 0)
bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
+ ARMAP_TIME_OFFSET);
uid = getuid();
_bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
_bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
- return FALSE;
+ return false;
memcpy (hdr.ar_fmag, ARFMAG, 2);
if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
!= sizeof (struct ar_hdr))
- return FALSE;
+ return false;
H_PUT_32 (arch, ranlibsize, temp);
if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
- return FALSE;
+ return false;
firstreal = first;
current = arch->archive_head;
if (firstreal != (file_ptr) offset)
{
bfd_set_error (bfd_error_file_truncated);
- return FALSE;
+ return false;
}
last_elt = current;
H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
!= BSD_SYMDEF_SIZE)
- return FALSE;
+ return false;
}
/* Now write the strings themselves. */
H_PUT_32 (arch, stringsize, temp);
if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
- return FALSE;
+ return false;
for (count = 0; count < orl_count; count++)
{
size_t len = strlen (*map[count].name) + 1;
if (bfd_bwrite (*map[count].name, len, arch) != len)
- return FALSE;
+ return false;
}
/* The spec sez this should be a newline. But in order to be
if (padit)
{
if (bfd_bwrite ("", 1, arch) != 1)
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* At the end of archive file handling, update the timestamp in the
Return TRUE if the timestamp was OK, or an unusual problem happened.
Return FALSE if we updated the timestamp. */
-bfd_boolean
+bool
_bfd_archive_bsd_update_armap_timestamp (bfd *arch)
{
struct stat archstat;
/* If creating deterministic archives, just leave the timestamp as-is. */
if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
- return TRUE;
+ return true;
/* Flush writes, get last-write timestamp from file, and compare it
to the timestamp IN the file. */
bfd_perror (_("Reading archive file mod timestamp"));
/* Can't read mod time for some reason. */
- return TRUE;
+ return true;
}
if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
/* OK by the linker's rules. */
- return TRUE;
+ return true;
/* Update the timestamp. */
bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
bfd_perror (_("Writing updated armap timestamp"));
/* Some error while writing. */
- return TRUE;
+ return true;
}
/* We updated the timestamp successfully. */
- return FALSE;
+ return false;
}
\f
/* A coff armap looks like :
symbol name n-1 */
-bfd_boolean
+bool
_bfd_coff_write_armap (bfd *arch,
unsigned int elength,
struct orl *map,
memset (&hdr, ' ', sizeof (struct ar_hdr));
hdr.ar_name[0] = '/';
if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
- return FALSE;
+ return false;
_bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
? time (NULL) : 0));
/* Write the ar header for this item and the number of symbols. */
if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
!= sizeof (struct ar_hdr))
- return FALSE;
+ return false;
if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
- return FALSE;
+ return false;
/* Two passes, first write the file offsets for each symbol -
remembering that each offset is on a two byte boundary. */
if (archive_member_file_ptr != (file_ptr) offset)
{
bfd_set_error (bfd_error_file_truncated);
- return FALSE;
+ return false;
}
if (!bfd_write_bigendian_4byte_int (arch, offset))
- return FALSE;
+ return false;
count++;
}
archive_member_file_ptr += sizeof (struct ar_hdr);
size_t len = strlen (*map[count].name) + 1;
if (bfd_bwrite (*map[count].name, len, arch) != len)
- return FALSE;
+ return false;
}
/* The spec sez this should be a newline. But in order to be
if (padit)
{
if (bfd_bwrite ("", 1, arch) != 1)
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-bfd_boolean
+bool
_bfd_noarchive_write_armap
(bfd *arch ATTRIBUTE_UNUSED,
unsigned int elength ATTRIBUTE_UNUSED,
unsigned int orl_count ATTRIBUTE_UNUSED,
int stridx ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
static int
return 1;
}
-bfd_boolean
+void
+_bfd_unlink_from_archive_parent (bfd *abfd)
+{
+ if (arch_eltdata (abfd) != NULL)
+ {
+ struct areltdata *ared = arch_eltdata (abfd);
+ htab_t htab = (htab_t) ared->parent_cache;
+
+ if (htab)
+ {
+ struct ar_cache ent;
+ void **slot;
+
+ ent.ptr = ared->key;
+ slot = htab_find_slot (htab, &ent, NO_INSERT);
+ if (slot != NULL)
+ {
+ BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd);
+ htab_clear_slot (htab, slot);
+ }
+ }
+ }
+}
+
+bool
_bfd_archive_close_and_cleanup (bfd *abfd)
{
if (bfd_read_p (abfd) && abfd->format == bfd_archive)
htab_delete (htab);
bfd_ardata (abfd)->cache = NULL;
}
+
+ /* Close the archive plugin file descriptor if needed. */
+ if (abfd->archive_plugin_fd > 0)
+ close (abfd->archive_plugin_fd);
}
- if (arch_eltdata (abfd) != NULL)
- {
- struct areltdata *ared = arch_eltdata (abfd);
- htab_t htab = (htab_t) ared->parent_cache;
- if (htab)
- {
- struct ar_cache ent;
- void **slot;
+ _bfd_unlink_from_archive_parent (abfd);
- ent.ptr = ared->key;
- slot = htab_find_slot (htab, &ent, NO_INSERT);
- if (slot != NULL)
- {
- BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd);
- htab_clear_slot (htab, slot);
- }
- }
- }
if (abfd->is_linker_output)
(*abfd->link.hash->hash_table_free) (abfd);
- return TRUE;
+ return true;
}