/* Generic ECOFF (Extended-COFF) routines.
Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ Free Software Foundation, Inc.
Original version by Per Bothner.
Full support added by Ian Lance Taylor, ian@cygnus.com.
{
/* name, id, index, next, prev, flags, user_set_vma, */
"*DEBUG*", 0, 0, NULL, NULL, 0, 0,
- /* linker_mark, linker_has_input, gc_mark, gc_mark_from_eh, */
- 0, 0, 1, 0,
+ /* linker_mark, linker_has_input, gc_mark, */
+ 0, 0, 1,
/* segment_mark, sec_info_type, use_rela_p, has_tls_reloc, */
0, 0, 0, 0,
- /* has_gp_reloc, need_finalize_relax, reloc_done, */
- 0, 0, 0,
- /* vma, lma, size, rawsize, */
- 0, 0, 0, 0,
+ /* has_tls_get_addr_call, has_gp_reloc, need_finalize_relax, */
+ 0, 0, 0,
+ /* reloc_done, vma, lma, size, rawsize, relax, relax_count, */
+ 0, 0, 0, 0, 0, 0, 0,
/* output_offset, output_section, alignment_power, */
0, NULL, 0,
/* relocation, orelocation, reloc_count, filepos, rel_filepos, */
{
bfd_size_type amt = sizeof (ecoff_data_type);
- abfd->tdata.ecoff_obj_data = bfd_zalloc (abfd, amt);
+ abfd->tdata.ecoff_obj_data = (struct ecoff_tdata *) bfd_zalloc (abfd, amt);
if (abfd->tdata.ecoff_obj_data == NULL)
return FALSE;
bfd_boolean
_bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr)
{
- struct internal_filehdr *internal_f = filehdr;
+ struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
enum bfd_architecture arch;
unsigned long mach;
return bfd_default_set_arch_mach (abfd, arch, mach);
}
+bfd_boolean
+_bfd_ecoff_no_long_sections (abfd, enable)
+ bfd *abfd;
+ int enable;
+{
+ (void) abfd;
+ (void) enable;
+ return FALSE;
+}
+
/* Get the magic number to use based on the architecture and machine.
This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */
asection *section ATTRIBUTE_UNUSED,
flagword * flags_ptr)
{
- struct internal_scnhdr *internal_s = hdr;
+ struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
long styp_flags = internal_s->s_flags;
flagword sec_flags = 0;
the symbols, so we swap them here. */
amt = internal_symhdr->ifdMax;
amt *= sizeof (struct fdr);
- debug->fdr = bfd_alloc (abfd, amt);
+ debug->fdr = (FDR *) bfd_alloc (abfd, amt);
if (debug->fdr == NULL)
return FALSE;
external_fdr_size = backend->debug_swap.external_fdr_size;
asymbol *
_bfd_ecoff_make_empty_symbol (bfd *abfd)
{
- ecoff_symbol_type *new;
+ ecoff_symbol_type *new_symbol;
bfd_size_type amt = sizeof (ecoff_symbol_type);
- new = bfd_zalloc (abfd, amt);
- if (new == NULL)
+ new_symbol = (ecoff_symbol_type *) bfd_zalloc (abfd, amt);
+ if (new_symbol == NULL)
return NULL;
- new->symbol.section = NULL;
- new->fdr = NULL;
- new->local = FALSE;
- new->native = NULL;
- new->symbol.the_bfd = abfd;
- return &new->symbol;
+ new_symbol->symbol.section = NULL;
+ new_symbol->fdr = NULL;
+ new_symbol->local = FALSE;
+ new_symbol->native = NULL;
+ new_symbol->symbol.the_bfd = abfd;
+ return &new_symbol->symbol;
}
/* Set the BFD flags and section for an ECOFF symbol. */
internal_size = bfd_get_symcount (abfd);
internal_size *= sizeof (ecoff_symbol_type);
- internal = bfd_alloc (abfd, internal_size);
+ internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
if (internal == NULL)
return FALSE;
sprintf (string,
"%s %s { ifd = %u, index = %lu }",
which, name, ifd,
- ((long) indx
+ ((unsigned long) indx
+ debug_info->symbolic_header.iextMax));
}
amt = section->reloc_count;
amt *= sizeof (arelent);
- internal_relocs = bfd_alloc (abfd, amt);
+ internal_relocs = (arelent *) bfd_alloc (abfd, amt);
external_reloc_size = backend->external_reloc_size;
amt = external_reloc_size * section->reloc_count;
- external_relocs = bfd_alloc (abfd, amt);
+ external_relocs = (char *) bfd_alloc (abfd, amt);
if (internal_relocs == NULL || external_relocs == NULL)
return FALSE;
if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
{
bfd_size_type amt = sizeof (struct ecoff_find_line);
- ecoff_data (abfd)->find_line_info = bfd_zalloc (abfd, amt);
+ ecoff_data (abfd)->find_line_info =
+ (struct ecoff_find_line *) bfd_zalloc (abfd, amt);
if (ecoff_data (abfd)->find_line_info == NULL)
return FALSE;
}
/* Sort the sections by VMA. */
amt = abfd->section_count;
amt *= sizeof (asection *);
- sorted_hdrs = bfd_malloc (amt);
+ sorted_hdrs = (asection **) bfd_malloc (amt);
if (sorted_hdrs == NULL)
return FALSE;
for (current = abfd->sections, i = 0;
parsed_size = mapdata->parsed_size;
bfd_release (abfd, (void *) mapdata);
- raw_armap = bfd_alloc (abfd, parsed_size);
+ raw_armap = (char *) bfd_alloc (abfd, parsed_size);
if (raw_armap == NULL)
return FALSE;
amt = ardata->symdef_count;
amt *= sizeof (struct symdef);
- symdef_ptr = bfd_alloc (abfd, amt);
+ symdef_ptr = (struct symdef *) bfd_alloc (abfd, amt);
if (!symdef_ptr)
return FALSE;
if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
return FALSE;
- hashtable = bfd_zalloc (abfd, symdefsize);
+ hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
if (!hashtable)
return FALSE;
return TRUE;
}
-
-/* See whether this BFD is an archive. If it is, read in the armap
- and the extended name table. */
-
-const bfd_target *
-_bfd_ecoff_archive_p (bfd *abfd)
-{
- struct artdata *tdata_hold;
- char armag[SARMAG + 1];
- bfd_size_type amt;
-
- if (bfd_bread ((void *) armag, (bfd_size_type) SARMAG, abfd) != SARMAG)
- {
- if (bfd_get_error () != bfd_error_system_call)
- bfd_set_error (bfd_error_wrong_format);
- return NULL;
- }
-
- if (! strneq (armag, ARMAG, SARMAG))
- {
- bfd_set_error (bfd_error_wrong_format);
- return NULL;
- }
-
- tdata_hold = bfd_ardata (abfd);
-
- amt = sizeof (struct artdata);
- bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
- if (bfd_ardata (abfd) == NULL)
- {
- bfd_ardata (abfd) = tdata_hold;
- return NULL;
- }
-
- bfd_ardata (abfd)->first_file_filepos = SARMAG;
- /* Already cleared by bfd_zalloc above.
- bfd_ardata (abfd)->cache = NULL;
- bfd_ardata (abfd)->archive_head = NULL;
- bfd_ardata (abfd)->symdefs = NULL;
- bfd_ardata (abfd)->extended_names = NULL;
- bfd_ardata (abfd)->extended_names_size = 0;
- bfd_ardata (abfd)->tdata = NULL; */
-
- if (! _bfd_ecoff_slurp_armap (abfd)
- || ! _bfd_ecoff_slurp_extended_name_table (abfd))
- {
- bfd_release (abfd, bfd_ardata (abfd));
- bfd_ardata (abfd) = tdata_hold;
- return NULL;
- }
-
- if (bfd_has_map (abfd))
- {
- bfd *first;
-
- /* This archive has a map, so we may presume that the contents
- are object files. Make sure that if the first file in the
- archive can be recognized as an object file, it is for this
- target. If not, assume that this is the wrong format. If
- the first file is not an object file, somebody is doing
- something weird, and we permit it so that ar -t will work. */
-
- first = bfd_openr_next_archived_file (abfd, NULL);
- if (first != NULL)
- {
- first->target_defaulted = FALSE;
- if (bfd_check_format (first, bfd_object)
- && first->xvec != abfd->xvec)
- {
- /* We ought to close `first' here, but we can't, because
- we have no way to remove it from the archive cache.
- It's almost impossible to figure out when we can
- release bfd_ardata. FIXME. */
- bfd_set_error (bfd_error_wrong_object_format);
- bfd_ardata (abfd) = tdata_hold;
- return NULL;
- }
- /* And we ought to close `first' here too. */
- }
- }
-
- return abfd->xvec;
-}
\f
/* ECOFF linker code. */
struct ecoff_link_hash_table *ret;
bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
- ret = bfd_malloc (amt);
+ ret = (struct ecoff_link_hash_table *) bfd_malloc (amt);
if (ret == NULL)
return NULL;
if (!_bfd_link_hash_table_init (&ret->root, abfd,
amt = ext_count;
amt *= sizeof (struct bfd_link_hash_entry *);
- sym_hash = bfd_alloc (abfd, amt);
+ sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt);
if (!sym_hash)
return FALSE;
ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
/* If we are building an ECOFF hash table, save the external
symbol information. */
- if (info->hash->creator->flavour == bfd_get_flavour (abfd))
+ if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
{
if (h->abfd == NULL
|| (! bfd_is_und_section (section)
|| bfd_bread (external_ext, esize, abfd) != esize)
goto error_return;
- ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
+ ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
if (ssext == NULL && symhdr->issExtMax != 0)
goto error_return;
|| bfd_bread (external_ext, esize, abfd) != esize)
goto error_return;
- ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
+ ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
if (ssext == NULL && symhdr->issExtMax != 0)
goto error_return;
else \
{ \
bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
- debug->ptr = bfd_malloc (amt); \
+ debug->ptr = (type) bfd_malloc (amt); \
if (debug->ptr == NULL) \
{ \
ret = FALSE; \
bfd_byte *buf;
size = bfd_get_reloc_size (rel.howto);
- buf = bfd_zmalloc (size);
+ buf = (bfd_byte *) bfd_zmalloc (size);
if (buf == NULL)
return FALSE;
rstat = _bfd_relocate_contents (rel.howto, output_bfd,
/* Get some memory and swap out the reloc. */
external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
- rbuf = bfd_malloc (external_reloc_size);
+ rbuf = (bfd_byte *) bfd_malloc (external_reloc_size);
if (rbuf == NULL)
return FALSE;