/* BFD back-end for archive files (libraries).
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002
+ 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault.
#define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
#define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
-#define arch_hdr(bfd) ((struct ar_hdr *)arch_eltdata(bfd)->arch_header)
-
-static char *get_extended_arelt_filename
- PARAMS ((bfd *arch, const char *name));
-static bfd_boolean do_slurp_bsd_armap
- PARAMS ((bfd *abfd));
-static bfd_boolean do_slurp_coff_armap
- PARAMS ((bfd *abfd));
-bfd_boolean bfd_elf64_archive_slurp_armap
- PARAMS ((bfd *abfd));
-static const char *normalize
- PARAMS ((bfd *, const char *file));
-static struct areltdata *bfd_ar_hdr_from_filesystem
- PARAMS ((bfd *abfd, const char *, bfd *member));
+#define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata(bfd)->arch_header)
+
\f
bfd_boolean
-_bfd_generic_mkarchive (abfd)
- bfd *abfd;
+_bfd_generic_mkarchive (bfd *abfd)
{
bfd_size_type amt = sizeof (struct artdata);
- abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
+ abfd->tdata.aout_ar_data = bfd_zalloc (abfd, amt);
if (bfd_ardata (abfd) == NULL)
return FALSE;
bfd_get_next_mapent
SYNOPSIS
- symindex bfd_get_next_mapent(bfd *abfd, symindex previous, carsym **sym);
+ symindex bfd_get_next_mapent
+ (bfd *abfd, symindex previous, carsym **sym);
DESCRIPTION
Step through archive @var{abfd}'s symbol table (if it
*/
symindex
-bfd_get_next_mapent (abfd, prev, entry)
- bfd *abfd;
- symindex prev;
- carsym **entry;
+bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
{
if (!bfd_has_map (abfd))
{
/* To be called by backends only */
bfd *
-_bfd_create_empty_archive_element_shell (obfd)
- bfd *obfd;
+_bfd_create_empty_archive_element_shell (bfd *obfd)
{
return _bfd_new_bfd_contained_in (obfd);
}
bfd_set_archive_head
SYNOPSIS
- bfd_boolean bfd_set_archive_head(bfd *output, bfd *new_head);
+ bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
DESCRIPTION
Set the head of the chain of
*/
bfd_boolean
-bfd_set_archive_head (output_archive, new_head)
- bfd *output_archive;
- bfd *new_head;
+bfd_set_archive_head (bfd *output_archive, bfd *new_head)
{
-
output_archive->archive_head = new_head;
return TRUE;
}
bfd *
-_bfd_look_for_bfd_in_cache (arch_bfd, filepos)
- bfd *arch_bfd;
- file_ptr filepos;
+_bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
{
struct ar_cache *current;
/* Kind of stupid to call cons for each one, but we don't do too many */
bfd_boolean
-_bfd_add_bfd_to_archive_cache (arch_bfd, filepos, new_elt)
- bfd *arch_bfd, *new_elt;
- file_ptr filepos;
+_bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
{
bfd_size_type amt = sizeof (struct ar_cache);
- struct ar_cache *new_cache = (struct ar_cache *) bfd_zalloc (arch_bfd, amt);
+ struct ar_cache *new_cache = bfd_zalloc (arch_bfd, amt);
if (new_cache == NULL)
return FALSE;
new_cache->ptr = filepos;
new_cache->arelt = new_elt;
- new_cache->next = (struct ar_cache *) NULL;
+ new_cache->next = NULL;
if (bfd_ardata (arch_bfd)->cache == NULL)
bfd_ardata (arch_bfd)->cache = new_cache;
else
the string table. */
static char *
-get_extended_arelt_filename (arch, name)
- bfd *arch;
- const char *name;
+get_extended_arelt_filename (bfd *arch, const char *name)
{
unsigned long index = 0;
could have been moved arbitrarily.
*/
-PTR
-_bfd_generic_read_ar_hdr (abfd)
- bfd *abfd;
+void *
+_bfd_generic_read_ar_hdr (bfd *abfd)
{
- return _bfd_generic_read_ar_hdr_mag (abfd, (const char *) NULL);
+ return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
}
/* Alpha ECOFF uses an optional different ARFMAG value, so we have a
variant of _bfd_generic_read_ar_hdr which accepts a magic string. */
-PTR
-_bfd_generic_read_ar_hdr_mag (abfd, mag)
- bfd *abfd;
- const char *mag;
+void *
+_bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
{
struct ar_hdr hdr;
char *hdrp = (char *) &hdr;
bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
char *allocptr = 0;
- if (bfd_bread ((PTR) hdrp, (bfd_size_type) sizeof (struct ar_hdr), abfd)
- != sizeof (struct ar_hdr))
+ if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_no_more_archived_files);
spaces, so only look for ' ' if we don't find '/'. */
char *e;
- e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
+ e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
if (e == NULL)
{
- e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
+ e = memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
if (e == NULL)
- e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
+ e = memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
}
if (e != NULL)
ared = (struct areltdata *) allocptr;
ared->arch_header = allocptr + sizeof (struct areltdata);
- memcpy ((char *) ared->arch_header, (char *) &hdr, sizeof (struct ar_hdr));
+ memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
ared->parsed_size = parsed_size;
if (filename != NULL)
ared->filename = allocptr + (sizeof (struct areltdata) +
sizeof (struct ar_hdr));
if (namelen)
- memcpy (ared->filename, hdr.ar_name, (size_t) namelen);
+ memcpy (ared->filename, hdr.ar_name, namelen);
ared->filename[namelen] = '\0';
}
- return (PTR) ared;
+ return ared;
}
\f
/* This is an internal function; it's mainly used when indexing
element, since it handles the bookkeeping so nicely for us. */
bfd *
-_bfd_get_elt_at_filepos (archive, filepos)
- bfd *archive;
- file_ptr filepos;
+_bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
{
struct areltdata *new_areldata;
bfd *n_nfd;
if (0 > bfd_seek (archive, filepos, SEEK_SET))
return NULL;
- if ((new_areldata = (struct areltdata *) _bfd_read_ar_hdr (archive)) == NULL)
+ if ((new_areldata = _bfd_read_ar_hdr (archive)) == NULL)
return NULL;
n_nfd = _bfd_create_empty_archive_element_shell (archive);
if (n_nfd == NULL)
{
- bfd_release (archive, (PTR) new_areldata);
+ bfd_release (archive, new_areldata);
return NULL;
}
n_nfd->origin = bfd_tell (archive);
- n_nfd->arelt_data = (PTR) new_areldata;
+ n_nfd->arelt_data = new_areldata;
n_nfd->filename = new_areldata->filename;
if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
return n_nfd;
/* Huh? */
- bfd_release (archive, (PTR) n_nfd);
- bfd_release (archive, (PTR) new_areldata);
+ bfd_release (archive, n_nfd);
+ bfd_release (archive, new_areldata);
return NULL;
}
INDEX. INDEX should have been returned by bfd_get_next_mapent. */
bfd *
-_bfd_generic_get_elt_at_index (abfd, index)
- bfd *abfd;
- symindex index;
+_bfd_generic_get_elt_at_index (bfd *abfd, symindex index)
{
carsym *entry;
bfd_openr_next_archived_file
SYNOPSIS
- bfd *bfd_openr_next_archived_file(bfd *archive, bfd *previous);
+ bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
DESCRIPTION
Provided a BFD, @var{archive}, containing an archive and NULL, open
*/
bfd *
-bfd_openr_next_archived_file (archive, last_file)
- bfd *archive;
- bfd *last_file;
+bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
{
if ((bfd_get_format (archive) != bfd_archive) ||
(archive->direction == write_direction))
}
return BFD_SEND (archive,
- openr_next_archived_file,
- (archive,
- last_file));
+ openr_next_archived_file, (archive, last_file));
}
bfd *
-bfd_generic_openr_next_archived_file (archive, last_file)
- bfd *archive;
- bfd *last_file;
+bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
{
file_ptr filestart;
}
const bfd_target *
-bfd_generic_archive_p (abfd)
- bfd *abfd;
+bfd_generic_archive_p (bfd *abfd)
{
struct artdata *tdata_hold;
char armag[SARMAG + 1];
bfd_size_type amt;
- if (bfd_bread ((PTR) armag, (bfd_size_type) SARMAG, abfd) != SARMAG)
+ if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
tdata_hold = bfd_ardata (abfd);
amt = sizeof (struct artdata);
- bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
+ bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
if (bfd_ardata (abfd) == NULL)
{
bfd_ardata (abfd) = tdata_hold;
normal archive, regardless of the format of the object files.
We do accept an empty archive. */
- first = bfd_openr_next_archived_file (abfd, (bfd *) NULL);
+ first = bfd_openr_next_archived_file (abfd, NULL);
if (first != NULL)
{
bfd_boolean fail;
we have no way to remove it from the archive cache.
It's close to impossible to figure out when we can
release bfd_ardata. FIXME. */
- (void) bfd_close (first);
+ bfd_close (first);
bfd_release (abfd, bfd_ardata (abfd));
#endif
bfd_set_error (bfd_error_wrong_object_format);
/* Returns FALSE on error, TRUE otherwise */
static bfd_boolean
-do_slurp_bsd_armap (abfd)
- bfd *abfd;
+do_slurp_bsd_armap (bfd *abfd)
{
struct areltdata *mapdata;
unsigned int counter;
bfd_size_type parsed_size, amt;
carsym *set;
- mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+ mapdata = _bfd_read_ar_hdr (abfd);
if (mapdata == NULL)
return FALSE;
parsed_size = mapdata->parsed_size;
- bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */
+ bfd_release (abfd, mapdata); /* Don't need it any more. */
- raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
- if (raw_armap == (bfd_byte *) NULL)
+ raw_armap = bfd_zalloc (abfd, parsed_size);
+ if (raw_armap == NULL)
return FALSE;
- if (bfd_bread ((PTR) raw_armap, parsed_size, abfd) != parsed_size)
+ if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_malformed_archive);
byebye:
- bfd_release (abfd, (PTR) raw_armap);
+ bfd_release (abfd, raw_armap);
return FALSE;
}
stringbase = ((char *) rbase
+ ardata->symdef_count * BSD_SYMDEF_SIZE
+ BSD_STRING_COUNT_SIZE);
- amt = (bfd_size_type) ardata->symdef_count * sizeof (carsym);
- ardata->symdefs = (carsym *) bfd_alloc (abfd, amt);
+ amt = ardata->symdef_count * sizeof (carsym);
+ ardata->symdefs = bfd_alloc (abfd, amt);
if (!ardata->symdefs)
return FALSE;
/* Returns FALSE on error, TRUE otherwise. */
static bfd_boolean
-do_slurp_coff_armap (abfd)
- bfd *abfd;
+do_slurp_coff_armap (bfd *abfd)
{
struct areltdata *mapdata;
int *raw_armap, *rawptr;
unsigned int parsed_size;
carsym *carsyms;
bfd_size_type nsymz; /* Number of symbols in armap. */
- bfd_vma (*swap) PARAMS ((const bfd_byte *));
+ bfd_vma (*swap) (const bfd_byte *);
char int_buf[sizeof (long)];
bfd_size_type carsym_size, ptrsize;
unsigned int i;
- mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+ mapdata = _bfd_read_ar_hdr (abfd);
if (mapdata == NULL)
return FALSE;
parsed_size = mapdata->parsed_size;
- bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */
+ bfd_release (abfd, mapdata); /* Don't need it any more. */
- if (bfd_bread ((PTR) int_buf, (bfd_size_type) 4, abfd) != 4)
+ if (bfd_bread (int_buf, 4, abfd) != 4)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_malformed_archive);
/* It seems that all numeric information in a coff archive is always
in big endian format, nomatter the host or target. */
swap = bfd_getb32;
- nsymz = bfd_getb32 ((PTR) int_buf);
+ nsymz = bfd_getb32 (int_buf);
stringsize = parsed_size - (4 * nsymz) - 4;
#if 1
&& bfd_get_flavour (abfd) == bfd_target_coff_flavour)
{
/* This looks dangerous, let's do it the other way around. */
- nsymz = bfd_getl32 ((PTR) int_buf);
+ nsymz = bfd_getl32 (int_buf);
stringsize = parsed_size - (4 * nsymz) - 4;
swap = bfd_getl32;
}
carsym_size = (nsymz * sizeof (carsym));
ptrsize = (4 * nsymz);
- ardata->symdefs = (carsym *) bfd_zalloc (abfd, carsym_size + stringsize + 1);
+ ardata->symdefs = bfd_zalloc (abfd, carsym_size + stringsize + 1);
if (ardata->symdefs == NULL)
return FALSE;
carsyms = ardata->symdefs;
stringbase = ((char *) ardata->symdefs) + carsym_size;
/* Allocate and read in the raw offsets. */
- raw_armap = (int *) bfd_alloc (abfd, ptrsize);
+ raw_armap = bfd_alloc (abfd, ptrsize);
if (raw_armap == NULL)
goto release_symdefs;
- if (bfd_bread ((PTR) raw_armap, ptrsize, abfd) != ptrsize
- || (bfd_bread ((PTR) stringbase, stringsize, abfd) != stringsize))
+ 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);
for (i = 0; i < nsymz; i++)
{
rawptr = raw_armap + i;
- carsyms->file_offset = swap ((PTR) rawptr);
+ carsyms->file_offset = swap ((bfd_byte *) rawptr);
carsyms->name = stringbase;
stringbase += strlen (stringbase) + 1;
carsyms++;
ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
bfd_has_map (abfd) = TRUE;
- bfd_release (abfd, (PTR) raw_armap);
+ bfd_release (abfd, 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);
+ tmp = _bfd_read_ar_hdr (abfd);
if (tmp != NULL)
{
if (tmp->arch_header[0] == '/'
return TRUE;
release_raw_armap:
- bfd_release (abfd, (PTR) raw_armap);
+ bfd_release (abfd, raw_armap);
release_symdefs:
- bfd_release (abfd, (PTR) (ardata)->symdefs);
+ bfd_release (abfd, (ardata)->symdefs);
return FALSE;
}
Returns FALSE on error, TRUE otherwise */
bfd_boolean
-bfd_slurp_armap (abfd)
- bfd *abfd;
+bfd_slurp_armap (bfd *abfd)
{
char nextname[17];
- int i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd);
+ int i = bfd_bread (nextname, 16, abfd);
if (i == 0)
return TRUE;
{
/* 64bit ELF (Irix 6) archive. */
#ifdef BFD64
+ extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
return bfd_elf64_archive_slurp_armap (abfd);
#else
bfd_set_error (bfd_error_wrong_format);
#define HPUX_SYMDEF_COUNT_SIZE 2
bfd_boolean
-bfd_slurp_bsd_armap_f2 (abfd)
- bfd *abfd;
+bfd_slurp_bsd_armap_f2 (bfd *abfd)
{
struct areltdata *mapdata;
char nextname[17];
unsigned int stringsize;
bfd_size_type amt;
carsym *set;
- int i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd);
+ int i = bfd_bread (nextname, 16, abfd);
if (i == 0)
return TRUE;
return TRUE;
}
- mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+ mapdata = _bfd_read_ar_hdr (abfd);
if (mapdata == NULL)
return FALSE;
amt = mapdata->parsed_size;
- raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
+ raw_armap = bfd_zalloc (abfd, amt);
if (raw_armap == NULL)
{
byebye:
- bfd_release (abfd, (PTR) mapdata);
+ bfd_release (abfd, mapdata);
return FALSE;
}
- if (bfd_bread ((PTR) raw_armap, amt, abfd) != amt)
+ if (bfd_bread (raw_armap, amt, abfd) != amt)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_malformed_archive);
byebyebye:
- bfd_release (abfd, (PTR) raw_armap);
+ bfd_release (abfd, raw_armap);
goto byebye;
}
- ardata->symdef_count = H_GET_16 (abfd, (PTR) raw_armap);
+ ardata->symdef_count = H_GET_16 (abfd, raw_armap);
if (ardata->symdef_count * BSD_SYMDEF_SIZE
> mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
+ HPUX_SYMDEF_COUNT_SIZE
+ BSD_STRING_COUNT_SIZE);
rbase = (bfd_byte *) stringbase + stringsize;
- amt = (bfd_size_type) ardata->symdef_count * BSD_SYMDEF_SIZE;
- ardata->symdefs = (carsym *) bfd_alloc (abfd, amt);
+ amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
+ ardata->symdefs = bfd_alloc (abfd, amt);
if (!ardata->symdefs)
return FALSE;
/* Returns FALSE on error, TRUE otherwise. */
bfd_boolean
-_bfd_slurp_extended_name_table (abfd)
- bfd *abfd;
+_bfd_slurp_extended_name_table (bfd *abfd)
{
char nextname[17];
struct areltdata *namedata;
/* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
we probably don't want to return TRUE. */
bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET);
- if (bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd) == 16)
+ if (bfd_bread (nextname, 16, abfd) == 16)
{
if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
return FALSE;
return TRUE;
}
- namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+ namedata = _bfd_read_ar_hdr (abfd);
if (namedata == NULL)
return FALSE;
if (bfd_ardata (abfd)->extended_names == NULL)
{
byebye:
- bfd_release (abfd, (PTR) namedata);
+ bfd_release (abfd, namedata);
return FALSE;
}
- if (bfd_bread ((PTR) bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
+ if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_malformed_archive);
- bfd_release (abfd, (PTR) (bfd_ardata (abfd)->extended_names));
+ bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
bfd_ardata (abfd)->extended_names = NULL;
goto byebye;
}
semicolon. */
static const char *
-normalize (abfd, file)
- bfd *abfd;
- const char *file;
+normalize (bfd *abfd, const char *file)
{
const char *first;
const char *last;
first--;
}
- copy = (char *) bfd_alloc (abfd, (bfd_size_type) (last - first + 1));
+ copy = bfd_alloc (abfd, last - first + 1);
if (copy == NULL)
return NULL;
#else
static const char *
-normalize (abfd, file)
- bfd *abfd ATTRIBUTE_UNUSED;
- const char *file;
+normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
{
const char *filename = strrchr (file, '/');
filename = file + 1;
}
#endif
- if (filename != (char *) NULL)
+ if (filename != NULL)
filename++;
else
filename = file;
/* Build a BFD style extended name table. */
bfd_boolean
-_bfd_archive_bsd_construct_extended_name_table (abfd, tabloc, tablen, name)
- bfd *abfd;
- char **tabloc;
- bfd_size_type *tablen;
- const char **name;
+_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);
/* Build an SVR4 style extended name table. */
bfd_boolean
-_bfd_archive_coff_construct_extended_name_table (abfd, tabloc, tablen, name)
- bfd *abfd;
- char **tabloc;
- bfd_size_type *tablen;
- const char **name;
+_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);
zero-length tablen! */
bfd_boolean
-_bfd_construct_extended_name_table (abfd, trailing_slash, tabloc, tablen)
- bfd *abfd;
- bfd_boolean trailing_slash;
- char **tabloc;
- bfd_size_type *tablen;
+_bfd_construct_extended_name_table (bfd *abfd,
+ bfd_boolean trailing_slash,
+ char **tabloc,
+ bfd_size_type *tablen)
{
unsigned int maxname = abfd->xvec->ar_max_namelen;
bfd_size_type total_namelen = 0;
/* Function to encode large UID/GID values according to HP. */
static void
-hpux_uid_gid_encode (str, id)
- char str[6];
- long int id;
+hpux_uid_gid_encode (char str[6], long int id)
{
int cnt;
is set, and it's an in-memory bfd, we fake it. */
static struct areltdata *
-bfd_ar_hdr_from_filesystem (abfd, filename, member)
- bfd *abfd;
- const char *filename;
- bfd *member;
+bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
{
struct stat status;
struct areltdata *ared;
if (member && (member->flags & BFD_IN_MEMORY) != 0)
{
/* Assume we just "made" the member, and fake it. */
- struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream;
+ struct bfd_in_memory *bim = member->iostream;
time (&status.st_mtime);
status.st_uid = getuid ();
status.st_gid = getgid ();
}
amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
- ared = (struct areltdata *) bfd_zalloc (abfd, amt);
+ ared = bfd_zalloc (abfd, amt);
if (ared == NULL)
return NULL;
hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
/* ar headers are space padded, not null padded! */
- memset ((PTR) hdr, ' ', sizeof (struct ar_hdr));
+ memset (hdr, ' ', sizeof (struct ar_hdr));
strncpy (hdr->ar_fmag, ARFMAG, 2);
a strong stomach to write this, and it does, but it takes even a
stronger stomach to try to code around such a thing! */
-struct ar_hdr *bfd_special_undocumented_glue
- PARAMS ((bfd *, const char *));
+struct ar_hdr *bfd_special_undocumented_glue (bfd *, const char *);
struct ar_hdr *
-bfd_special_undocumented_glue (abfd, filename)
- bfd *abfd;
- const char *filename;
+bfd_special_undocumented_glue (bfd *abfd, const char *filename)
{
struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0);
if (ar_elt == NULL)
/* Analogous to stat call. */
int
-bfd_generic_stat_arch_elt (abfd, buf)
- bfd *abfd;
- struct stat *buf;
+bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
{
struct ar_hdr *hdr;
char *aloser;
}
void
-bfd_dont_truncate_arname (abfd, pathname, arhdr)
- bfd *abfd;
- const char *pathname;
- char *arhdr;
+bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
{
/* FIXME: This interacts unpleasantly with ar's quick-append option.
Fortunately ic960 users will never use that option. Fixing this
}
void
-bfd_bsd_truncate_arname (abfd, pathname, arhdr)
- bfd *abfd;
- const char *pathname;
- char *arhdr;
+bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
{
struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
size_t length;
bsd ar. */
void
-bfd_gnu_truncate_arname (abfd, pathname, arhdr)
- bfd *abfd;
- const char *pathname;
- char *arhdr;
+bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
{
struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
size_t length;
/* The BFD is open for write and has its format set to bfd_archive. */
bfd_boolean
-_bfd_write_archive_contents (arch)
- bfd *arch;
+_bfd_write_archive_contents (bfd *arch)
{
bfd *current;
char *etable = NULL;
if (!current->arelt_data)
{
current->arelt_data =
- (PTR) bfd_ar_hdr_from_filesystem (arch, current->filename, current);
+ bfd_ar_hdr_from_filesystem (arch, current->filename, current);
if (!current->arelt_data)
return FALSE;
/* Put in the file name. */
- BFD_SEND (arch, _bfd_truncate_arname, (arch,
- current->filename,
- (char *) arch_hdr (current)));
+ BFD_SEND (arch, _bfd_truncate_arname,
+ (arch, current->filename, (char *) arch_hdr (current)));
}
if (makemap && ! hasobjects)
if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
return FALSE;
#ifdef GNU960
- wrote = bfd_bwrite (BFD_GNU960_ARMAG (arch), (bfd_size_type) SARMAG, arch);
+ wrote = bfd_bwrite (BFD_GNU960_ARMAG (arch), SARMAG, arch);
#else
- wrote = bfd_bwrite (ARMAG, (bfd_size_type) SARMAG, arch);
+ wrote = bfd_bwrite (ARMAG, SARMAG, arch);
#endif
if (wrote != SARMAG)
return FALSE;
{
struct ar_hdr hdr;
- memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
+ memset (&hdr, 0, sizeof (struct ar_hdr));
strcpy (hdr.ar_name, ename);
/* Round size up to even number in archive header. */
sprintf (&(hdr.ar_size[0]), "%-10d",
for (i = 0; i < sizeof (struct ar_hdr); i++)
if (((char *) (&hdr))[i] == '\0')
(((char *) (&hdr))[i]) = ' ';
- if ((bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
+ if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
!= sizeof (struct ar_hdr))
|| bfd_bwrite (etable, elength, arch) != elength)
return FALSE;
if ((elength % 2) == 1)
{
- if (bfd_bwrite ("\012", (bfd_size_type) 1, arch) != 1)
+ if (bfd_bwrite ("\012", 1, arch) != 1)
return FALSE;
}
}
struct ar_hdr *hdr = arch_hdr (current);
/* Write ar header. */
- if (bfd_bwrite ((PTR) hdr, (bfd_size_type) sizeof (*hdr), arch)
+ if (bfd_bwrite (hdr, sizeof (*hdr), arch)
!= sizeof (*hdr))
return FALSE;
if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
if (amt > remaining)
amt = remaining;
errno = 0;
- if (bfd_bread (buffer, (bfd_size_type) amt, current) != amt)
+ if (bfd_bread (buffer, amt, current) != amt)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_malformed_archive);
return FALSE;
}
- if (bfd_bwrite (buffer, (bfd_size_type) amt, arch) != amt)
+ if (bfd_bwrite (buffer, amt, arch) != amt)
return FALSE;
remaining -= amt;
}
if ((arelt_size (current) % 2) == 1)
{
- if (bfd_bwrite ("\012", (bfd_size_type) 1, arch) != 1)
+ if (bfd_bwrite ("\012", 1, arch) != 1)
return FALSE;
}
}
/* Note that the namidx for the first symbol is 0. */
bfd_boolean
-_bfd_compute_and_write_armap (arch, elength)
- bfd *arch;
- unsigned int elength;
+_bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
{
char *first_name = NULL;
bfd *current;
elength += sizeof (struct ar_hdr);
elength += elength % 2;
- amt = (bfd_size_type) orl_max * sizeof (struct orl);
- map = (struct orl *) bfd_malloc (amt);
+ amt = orl_max * sizeof (struct orl);
+ map = bfd_malloc (amt);
if (map == NULL)
goto error_return;
/* We put the symbol names on the arch objalloc, and then discard
them when done. */
- first_name = bfd_alloc (arch, (bfd_size_type) 1);
+ first_name = bfd_alloc (arch, 1);
if (first_name == NULL)
goto error_return;
/* Map over each element. */
for (current = arch->archive_head;
- current != (bfd *) NULL;
+ current != NULL;
current = current->next, elt_no++)
{
if (bfd_check_format (current, bfd_object)
if (syms_max > 0)
free (syms);
syms_max = storage;
- syms = (asymbol **) bfd_malloc ((bfd_size_type) syms_max);
+ syms = bfd_malloc (syms_max);
if (syms == NULL)
goto error_return;
}
if (orl_count == orl_max)
{
orl_max *= 2;
- amt = (bfd_size_type) orl_max * sizeof (struct orl);
- new_map = (struct orl *) bfd_realloc (map, amt);
- if (new_map == (struct orl *) NULL)
+ amt = orl_max * sizeof (struct orl);
+ new_map = bfd_realloc (map, amt);
+ if (new_map == NULL)
goto error_return;
map = new_map;
namelen = strlen (syms[src_count]->name);
amt = sizeof (char *);
- map[orl_count].name = (char **) bfd_alloc (arch, amt);
+ map[orl_count].name = bfd_alloc (arch, amt);
if (map[orl_count].name == NULL)
goto error_return;
*(map[orl_count].name) = bfd_alloc (arch, namelen + 1);
}
bfd_boolean
-bsd_write_armap (arch, elength, map, orl_count, stridx)
- bfd *arch;
- unsigned int elength;
- struct orl *map;
- unsigned int orl_count;
- int stridx;
+bsd_write_armap (bfd *arch,
+ unsigned int elength,
+ struct orl *map,
+ unsigned int orl_count,
+ int stridx)
{
int padit = stridx & 1;
unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
stat (arch->filename, &statbuf);
- memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
+ memset (&hdr, 0, sizeof (struct ar_hdr));
sprintf (hdr.ar_name, RANLIBMAG);
/* Remember the timestamp, to keep it holy. But fudge it a little. */
bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
for (i = 0; i < sizeof (struct ar_hdr); i++)
if (((char *) (&hdr))[i] == '\0')
(((char *) (&hdr))[i]) = ' ';
- if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
+ if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
!= sizeof (struct ar_hdr))
return FALSE;
H_PUT_32 (arch, ranlibsize, temp);
- if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), arch) != sizeof (temp))
+ if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
return FALSE;
for (count = 0; count < orl_count; count++)
last_elt = current;
H_PUT_32 (arch, map[count].namidx, buf);
H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
- if (bfd_bwrite (buf, (bfd_size_type) BSD_SYMDEF_SIZE, arch)
+ if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
!= BSD_SYMDEF_SIZE)
return FALSE;
}
/* Now write the strings themselves. */
H_PUT_32 (arch, stringsize, temp);
- if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), arch) != sizeof (temp))
+ if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
return FALSE;
for (count = 0; count < orl_count; count++)
{
size_t len = strlen (*map[count].name) + 1;
- if (bfd_bwrite (*map[count].name, (bfd_size_type) len, arch) != len)
+ if (bfd_bwrite (*map[count].name, len, arch) != len)
return FALSE;
}
bug-compatible for sun's ar we use a null. */
if (padit)
{
- if (bfd_bwrite ("", (bfd_size_type) 1, arch) != 1)
+ if (bfd_bwrite ("", 1, arch) != 1)
return FALSE;
}
Return FALSE if we updated the timestamp. */
bfd_boolean
-_bfd_archive_bsd_update_armap_timestamp (arch)
- bfd *arch;
+_bfd_archive_bsd_update_armap_timestamp (bfd *arch)
{
struct stat archstat;
struct ar_hdr hdr;
bfd_ardata (arch)->armap_datepos = (SARMAG
+ offsetof (struct ar_hdr, ar_date[0]));
if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
- || (bfd_bwrite (hdr.ar_date, (bfd_size_type) sizeof (hdr.ar_date), arch)
+ || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
!= sizeof (hdr.ar_date)))
{
bfd_perror (_("Writing updated armap timestamp"));
*/
bfd_boolean
-coff_write_armap (arch, elength, map, symbol_count, stridx)
- bfd *arch;
- unsigned int elength;
- struct orl *map;
- unsigned int symbol_count;
- int stridx;
+coff_write_armap (bfd *arch,
+ unsigned int elength,
+ struct orl *map,
+ unsigned int symbol_count,
+ int stridx)
{
/* The size of the ranlib is the number of exported symbols in the
archive * the number of bytes in an int, + an int for the count. */
+ sizeof (struct ar_hdr)
+ SARMAG);
- memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
+ memset (&hdr, 0, sizeof (struct ar_hdr));
hdr.ar_name[0] = '/';
sprintf (hdr.ar_size, "%-10d", (int) mapsize);
sprintf (hdr.ar_date, "%ld", (long) time (NULL));
/* Write the ar header for this item and the number of symbols. */
- if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
+ if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
!= sizeof (struct ar_hdr))
return FALSE;
current = arch->archive_head;
count = 0;
- while (current != (bfd *) NULL && count < symbol_count)
+ while (current != NULL && count < symbol_count)
{
/* For each symbol which is used defined in this object, write
out the object file's address in the archive. */
count++;
}
/* Add size of this archive entry. */
- archive_member_file_ptr += (arelt_size (current)
- + sizeof (struct ar_hdr));
+ archive_member_file_ptr += arelt_size (current) + sizeof (struct ar_hdr);
/* Remember aboout the even alignment. */
archive_member_file_ptr += archive_member_file_ptr % 2;
current = current->next;
{
size_t len = strlen (*map[count].name) + 1;
- if (bfd_bwrite (*map[count].name, (bfd_size_type) len, arch) != len)
+ if (bfd_bwrite (*map[count].name, len, arch) != len)
return FALSE;
}
bug-compatible for arc960 we use a null. */
if (padit)
{
- if (bfd_bwrite ("", (bfd_size_type) 1, arch) != 1)
+ if (bfd_bwrite ("", 1, arch) != 1)
return FALSE;
}
projects / deliverable / binutils-gdb.git / blobdiff