forked from Imagelibrary/binutils-gdb
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
This commit is contained in:
Alan Modra
308
bfd/ecoff.c
308
bfd/ecoff.c
@@ -65,7 +65,7 @@ static boolean ecoff_compute_section_file_positions PARAMS ((bfd *abfd));
|
||||
static bfd_size_type ecoff_compute_reloc_file_positions PARAMS ((bfd *abfd));
|
||||
static boolean ecoff_get_extr PARAMS ((asymbol *, EXTR *));
|
||||
static void ecoff_set_index PARAMS ((asymbol *, bfd_size_type));
|
||||
static unsigned int ecoff_armap_hash PARAMS ((CONST char *s,
|
||||
static unsigned int ecoff_armap_hash PARAMS ((const char *s,
|
||||
unsigned int *rehash,
|
||||
unsigned int size,
|
||||
unsigned int hlog));
|
||||
@@ -78,7 +78,7 @@ static asection bfd_debug_section =
|
||||
"*DEBUG*", 0, 0, NULL, 0, 0, 0,
|
||||
/* linker_mark, linker_has_input, gc_mark, segment_mark, */
|
||||
0, 0, 0, 0,
|
||||
/* vma, lma, _cooked_size, _raw_size, */
|
||||
/* vma, lma, _cooked_size, _raw_size, */
|
||||
0, 0, 0, 0,
|
||||
/* output_offset, output_section, alignment_power, */
|
||||
0, NULL, 0,
|
||||
@@ -104,8 +104,8 @@ boolean
|
||||
_bfd_ecoff_mkobject (abfd)
|
||||
bfd *abfd;
|
||||
{
|
||||
abfd->tdata.ecoff_obj_data = ((struct ecoff_tdata *)
|
||||
bfd_zalloc (abfd, sizeof (ecoff_data_type)));
|
||||
bfd_size_type amt = sizeof (ecoff_data_type);
|
||||
abfd->tdata.ecoff_obj_data = (struct ecoff_tdata *) bfd_zalloc (abfd, amt);
|
||||
if (abfd->tdata.ecoff_obj_data == NULL)
|
||||
return false;
|
||||
|
||||
@@ -474,13 +474,12 @@ ecoff_slurp_symbolic_header (abfd)
|
||||
}
|
||||
|
||||
/* Read the symbolic information header. */
|
||||
raw = (PTR) bfd_malloc ((size_t) external_hdr_size);
|
||||
raw = (PTR) bfd_malloc (external_hdr_size);
|
||||
if (raw == NULL)
|
||||
goto error_return;
|
||||
|
||||
if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
|
||||
|| (bfd_read (raw, external_hdr_size, 1, abfd)
|
||||
!= external_hdr_size))
|
||||
if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) != 0
|
||||
|| bfd_bread (raw, external_hdr_size, abfd) != external_hdr_size)
|
||||
goto error_return;
|
||||
internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
|
||||
(*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
|
||||
@@ -525,6 +524,8 @@ _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
|
||||
struct fdr *fdr_ptr;
|
||||
bfd_size_type raw_end;
|
||||
bfd_size_type cb_end;
|
||||
bfd_size_type amt;
|
||||
file_ptr pos;
|
||||
|
||||
BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info);
|
||||
|
||||
@@ -583,11 +584,11 @@ _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
|
||||
raw = (PTR) bfd_alloc (abfd, raw_size);
|
||||
if (raw == NULL)
|
||||
return false;
|
||||
if (bfd_seek (abfd,
|
||||
(ecoff_data (abfd)->sym_filepos
|
||||
+ backend->debug_swap.external_hdr_size),
|
||||
SEEK_SET) != 0
|
||||
|| bfd_read (raw, raw_size, 1, abfd) != raw_size)
|
||||
|
||||
pos = ecoff_data (abfd)->sym_filepos;
|
||||
pos += backend->debug_swap.external_hdr_size;
|
||||
if (bfd_seek (abfd, pos, SEEK_SET) != 0
|
||||
|| bfd_bread (raw, raw_size, abfd) != raw_size)
|
||||
{
|
||||
bfd_release (abfd, raw);
|
||||
return false;
|
||||
@@ -624,9 +625,9 @@ _bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
|
||||
|
||||
We need to look at the fdr to deal with a lot of information in
|
||||
the symbols, so we swap them here. */
|
||||
debug->fdr = (struct fdr *) bfd_alloc (abfd,
|
||||
(internal_symhdr->ifdMax *
|
||||
sizeof (struct fdr)));
|
||||
amt = internal_symhdr->ifdMax;
|
||||
amt *= sizeof (struct fdr);
|
||||
debug->fdr = (struct fdr *) bfd_alloc (abfd, amt);
|
||||
if (debug->fdr == NULL)
|
||||
return false;
|
||||
external_fdr_size = backend->debug_swap.external_fdr_size;
|
||||
@@ -658,8 +659,9 @@ _bfd_ecoff_make_empty_symbol (abfd)
|
||||
bfd *abfd;
|
||||
{
|
||||
ecoff_symbol_type *new;
|
||||
bfd_size_type amt = sizeof (ecoff_symbol_type);
|
||||
|
||||
new = (ecoff_symbol_type *) bfd_alloc (abfd, sizeof (ecoff_symbol_type));
|
||||
new = (ecoff_symbol_type *) bfd_alloc (abfd, amt);
|
||||
if (new == (ecoff_symbol_type *) NULL)
|
||||
return (asymbol *) NULL;
|
||||
memset ((PTR) new, 0, sizeof *new);
|
||||
@@ -858,6 +860,7 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak)
|
||||
asection *section;
|
||||
arelent_chain *reloc_chain;
|
||||
unsigned int bitsize;
|
||||
bfd_size_type amt;
|
||||
|
||||
/* Get a section with the same name as the symbol (usually
|
||||
__CTOR_LIST__ or __DTOR_LIST__). FIXME: gcc uses the
|
||||
@@ -877,7 +880,8 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak)
|
||||
{
|
||||
char *copy;
|
||||
|
||||
copy = (char *) bfd_alloc (abfd, strlen (name) + 1);
|
||||
amt = strlen (name) + 1;
|
||||
copy = (char *) bfd_alloc (abfd, amt);
|
||||
if (!copy)
|
||||
return false;
|
||||
strcpy (copy, name);
|
||||
@@ -885,8 +889,8 @@ ecoff_set_symbol_info (abfd, ecoff_sym, asym, ext, weak)
|
||||
}
|
||||
|
||||
/* Build a reloc pointing to this constructor. */
|
||||
reloc_chain =
|
||||
(arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain));
|
||||
amt = sizeof (arelent_chain);
|
||||
reloc_chain = (arelent_chain *) bfd_alloc (abfd, amt);
|
||||
if (!reloc_chain)
|
||||
return false;
|
||||
reloc_chain->relent.sym_ptr_ptr =
|
||||
@@ -958,7 +962,8 @@ _bfd_ecoff_slurp_symbol_table (abfd)
|
||||
if (bfd_get_symcount (abfd) == 0)
|
||||
return true;
|
||||
|
||||
internal_size = bfd_get_symcount (abfd) * sizeof (ecoff_symbol_type);
|
||||
internal_size = bfd_get_symcount (abfd);
|
||||
internal_size *= sizeof (ecoff_symbol_type);
|
||||
internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
|
||||
if (internal == NULL)
|
||||
return false;
|
||||
@@ -1663,7 +1668,7 @@ ecoff_slurp_reloc_table (abfd, section, symbols)
|
||||
const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
|
||||
arelent *internal_relocs;
|
||||
bfd_size_type external_reloc_size;
|
||||
bfd_size_type external_relocs_size;
|
||||
bfd_size_type amt;
|
||||
char *external_relocs;
|
||||
arelent *rptr;
|
||||
unsigned int i;
|
||||
@@ -1676,19 +1681,19 @@ ecoff_slurp_reloc_table (abfd, section, symbols)
|
||||
if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
|
||||
return false;
|
||||
|
||||
internal_relocs = (arelent *) bfd_alloc (abfd,
|
||||
(sizeof (arelent)
|
||||
* section->reloc_count));
|
||||
amt = section->reloc_count;
|
||||
amt *= sizeof (arelent);
|
||||
internal_relocs = (arelent *) bfd_alloc (abfd, amt);
|
||||
|
||||
external_reloc_size = backend->external_reloc_size;
|
||||
external_relocs_size = external_reloc_size * section->reloc_count;
|
||||
external_relocs = (char *) bfd_alloc (abfd, external_relocs_size);
|
||||
amt = external_reloc_size * section->reloc_count;
|
||||
external_relocs = (char *) bfd_alloc (abfd, amt);
|
||||
if (internal_relocs == (arelent *) NULL
|
||||
|| external_relocs == (char *) NULL)
|
||||
return false;
|
||||
if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
|
||||
return false;
|
||||
if (bfd_read (external_relocs, 1, external_relocs_size, abfd)
|
||||
!= external_relocs_size)
|
||||
if (bfd_bread (external_relocs, amt, abfd) != amt)
|
||||
return false;
|
||||
|
||||
for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
|
||||
@@ -1717,7 +1722,7 @@ ecoff_slurp_reloc_table (abfd, section, symbols)
|
||||
}
|
||||
else
|
||||
{
|
||||
CONST char *sec_name;
|
||||
const char *sec_name;
|
||||
asection *sec;
|
||||
|
||||
/* r_symndx is a section key. */
|
||||
@@ -1814,8 +1819,8 @@ _bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset,
|
||||
asection *section;
|
||||
asymbol **ignore_symbols ATTRIBUTE_UNUSED;
|
||||
bfd_vma offset;
|
||||
CONST char **filename_ptr;
|
||||
CONST char **functionname_ptr;
|
||||
const char **filename_ptr;
|
||||
const char **functionname_ptr;
|
||||
unsigned int *retline_ptr;
|
||||
{
|
||||
const struct ecoff_debug_swap * const debug_swap
|
||||
@@ -1830,9 +1835,9 @@ _bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset,
|
||||
|
||||
if (ecoff_data (abfd)->find_line_info == NULL)
|
||||
{
|
||||
ecoff_data (abfd)->find_line_info =
|
||||
((struct ecoff_find_line *)
|
||||
bfd_zalloc (abfd, sizeof (struct ecoff_find_line)));
|
||||
bfd_size_type amt = sizeof (struct ecoff_find_line);
|
||||
ecoff_data (abfd)->find_line_info
|
||||
= (struct ecoff_find_line *) bfd_zalloc (abfd, amt);
|
||||
if (ecoff_data (abfd)->find_line_info == NULL)
|
||||
return false;
|
||||
}
|
||||
@@ -2057,13 +2062,15 @@ ecoff_compute_section_file_positions (abfd)
|
||||
boolean rdata_in_text;
|
||||
boolean first_data, first_nonalloc;
|
||||
const bfd_vma round = ecoff_backend (abfd)->round;
|
||||
bfd_size_type amt;
|
||||
|
||||
sofar = _bfd_ecoff_sizeof_headers (abfd, false);
|
||||
file_sofar = sofar;
|
||||
|
||||
/* Sort the sections by VMA. */
|
||||
sorted_hdrs = (asection **) bfd_malloc (abfd->section_count
|
||||
* sizeof (asection *));
|
||||
amt = abfd->section_count;
|
||||
amt *= sizeof (asection *);
|
||||
sorted_hdrs = (asection **) bfd_malloc (amt);
|
||||
if (sorted_hdrs == NULL)
|
||||
return false;
|
||||
for (current = abfd->sections, i = 0;
|
||||
@@ -2257,6 +2264,8 @@ _bfd_ecoff_set_section_contents (abfd, section, location, offset, count)
|
||||
file_ptr offset;
|
||||
bfd_size_type count;
|
||||
{
|
||||
file_ptr pos;
|
||||
|
||||
/* This must be done first, because bfd_set_section_contents is
|
||||
going to set output_has_begun to true. */
|
||||
if (abfd->output_has_begun == false)
|
||||
@@ -2285,8 +2294,9 @@ _bfd_ecoff_set_section_contents (abfd, section, location, offset, count)
|
||||
if (count == 0)
|
||||
return true;
|
||||
|
||||
if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
|
||||
|| bfd_write (location, 1, count, abfd) != count)
|
||||
pos = section->filepos + offset;
|
||||
if (bfd_seek (abfd, pos, SEEK_SET) != 0
|
||||
|| bfd_bwrite (location, count, abfd) != count)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
@@ -2513,7 +2523,7 @@ _bfd_ecoff_write_object_contents (abfd)
|
||||
siz = filhsz;
|
||||
if (siz < aoutsz)
|
||||
siz = aoutsz;
|
||||
buff = (PTR) bfd_malloc ((size_t) siz);
|
||||
buff = (PTR) bfd_malloc (siz);
|
||||
if (buff == NULL)
|
||||
goto error_return;
|
||||
}
|
||||
@@ -2573,7 +2583,7 @@ _bfd_ecoff_write_object_contents (abfd)
|
||||
current->flags);
|
||||
|
||||
if (bfd_coff_swap_scnhdr_out (abfd, (PTR) §ion, buff) == 0
|
||||
|| bfd_write (buff, 1, scnhsz, abfd) != scnhsz)
|
||||
|| bfd_bwrite (buff, scnhsz, abfd) != scnhsz)
|
||||
goto error_return;
|
||||
|
||||
if ((section.s_flags & STYP_TEXT) != 0
|
||||
@@ -2724,11 +2734,11 @@ _bfd_ecoff_write_object_contents (abfd)
|
||||
goto error_return;
|
||||
|
||||
bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, buff);
|
||||
if (bfd_write (buff, 1, filhsz, abfd) != filhsz)
|
||||
if (bfd_bwrite (buff, filhsz, abfd) != filhsz)
|
||||
goto error_return;
|
||||
|
||||
bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, buff);
|
||||
if (bfd_write (buff, 1, aoutsz, abfd) != aoutsz)
|
||||
if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz)
|
||||
goto error_return;
|
||||
|
||||
/* Build the external symbol information. This must be done before
|
||||
@@ -2756,12 +2766,13 @@ _bfd_ecoff_write_object_contents (abfd)
|
||||
arelent **reloc_ptr_ptr;
|
||||
arelent **reloc_end;
|
||||
char *out_ptr;
|
||||
bfd_size_type amt;
|
||||
|
||||
if (current->reloc_count == 0)
|
||||
continue;
|
||||
|
||||
reloc_buff =
|
||||
bfd_alloc (abfd, current->reloc_count * external_reloc_size);
|
||||
amt = current->reloc_count * external_reloc_size;
|
||||
reloc_buff = bfd_alloc (abfd, amt);
|
||||
if (reloc_buff == NULL)
|
||||
goto error_return;
|
||||
|
||||
@@ -2792,7 +2803,7 @@ _bfd_ecoff_write_object_contents (abfd)
|
||||
}
|
||||
else
|
||||
{
|
||||
CONST char *name;
|
||||
const char *name;
|
||||
|
||||
name = bfd_get_section_name (abfd, bfd_get_section (sym));
|
||||
if (strcmp (name, ".text") == 0)
|
||||
@@ -2837,9 +2848,8 @@ _bfd_ecoff_write_object_contents (abfd)
|
||||
|
||||
if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0)
|
||||
goto error_return;
|
||||
if (bfd_write (reloc_buff,
|
||||
external_reloc_size, current->reloc_count, abfd)
|
||||
!= external_reloc_size * current->reloc_count)
|
||||
amt = current->reloc_count * external_reloc_size;
|
||||
if (bfd_bwrite (reloc_buff, amt, abfd) != amt)
|
||||
goto error_return;
|
||||
bfd_release (abfd, reloc_buff);
|
||||
reloc_buff = NULL;
|
||||
@@ -2869,12 +2879,12 @@ _bfd_ecoff_write_object_contents (abfd)
|
||||
if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
|
||||
SEEK_SET) != 0)
|
||||
goto error_return;
|
||||
if (bfd_read (&c, 1, 1, abfd) == 0)
|
||||
if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0)
|
||||
c = 0;
|
||||
if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1,
|
||||
SEEK_SET) != 0)
|
||||
goto error_return;
|
||||
if (bfd_write (&c, 1, 1, abfd) != 1)
|
||||
if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1)
|
||||
goto error_return;
|
||||
}
|
||||
|
||||
@@ -2942,7 +2952,7 @@ _bfd_ecoff_write_object_contents (abfd)
|
||||
|
||||
static unsigned int
|
||||
ecoff_armap_hash (s, rehash, size, hlog)
|
||||
CONST char *s;
|
||||
const char *s;
|
||||
unsigned int *rehash;
|
||||
unsigned int size;
|
||||
unsigned int hlog;
|
||||
@@ -2975,9 +2985,10 @@ _bfd_ecoff_slurp_armap (abfd)
|
||||
char *raw_ptr;
|
||||
struct symdef *symdef_ptr;
|
||||
char *stringbase;
|
||||
bfd_size_type amt;
|
||||
|
||||
/* Get the name of the first element. */
|
||||
i = bfd_read ((PTR) nextname, 1, 16, abfd);
|
||||
i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd);
|
||||
if (i == 0)
|
||||
return true;
|
||||
if (i != 16)
|
||||
@@ -3032,7 +3043,7 @@ _bfd_ecoff_slurp_armap (abfd)
|
||||
if (raw_armap == (char *) NULL)
|
||||
return false;
|
||||
|
||||
if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
|
||||
if (bfd_bread ((PTR) raw_armap, parsed_size, abfd) != parsed_size)
|
||||
{
|
||||
if (bfd_get_error () != bfd_error_system_call)
|
||||
bfd_set_error (bfd_error_malformed_archive);
|
||||
@@ -3042,7 +3053,7 @@ _bfd_ecoff_slurp_armap (abfd)
|
||||
|
||||
ardata->tdata = (PTR) raw_armap;
|
||||
|
||||
count = bfd_h_get_32 (abfd, (PTR) raw_armap);
|
||||
count = H_GET_32 (abfd, raw_armap);
|
||||
|
||||
ardata->symdef_count = 0;
|
||||
ardata->cache = (struct ar_cache *) NULL;
|
||||
@@ -3069,8 +3080,8 @@ _bfd_ecoff_slurp_armap (abfd)
|
||||
unsigned int name_offset, file_offset;
|
||||
unsigned int hash, rehash, srch;
|
||||
|
||||
name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
|
||||
file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
|
||||
name_offset = H_GET_32 (abfd, raw_ptr);
|
||||
file_offset = H_GET_32 (abfd, (raw_ptr + 4));
|
||||
if (file_offset == 0)
|
||||
continue;
|
||||
hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count,
|
||||
@@ -3082,8 +3093,7 @@ _bfd_ecoff_slurp_armap (abfd)
|
||||
for (srch = (hash + rehash) & (count - 1);
|
||||
srch != hash && srch != i;
|
||||
srch = (srch + rehash) & (count - 1))
|
||||
BFD_ASSERT (bfd_h_get_32 (abfd, (PTR) (raw_armap + 8 + srch * 8))
|
||||
!= 0);
|
||||
BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0);
|
||||
BFD_ASSERT (srch == i);
|
||||
}
|
||||
}
|
||||
@@ -3092,12 +3102,12 @@ _bfd_ecoff_slurp_armap (abfd)
|
||||
|
||||
raw_ptr = raw_armap + 4;
|
||||
for (i = 0; i < count; i++, raw_ptr += 8)
|
||||
if (bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4)) != 0)
|
||||
if (H_GET_32 (abfd, (raw_ptr + 4)) != 0)
|
||||
++ardata->symdef_count;
|
||||
|
||||
symdef_ptr = ((struct symdef *)
|
||||
bfd_alloc (abfd,
|
||||
ardata->symdef_count * sizeof (struct symdef)));
|
||||
amt = ardata->symdef_count;
|
||||
amt *= sizeof (struct symdef);
|
||||
symdef_ptr = (struct symdef *) bfd_alloc (abfd, amt);
|
||||
if (!symdef_ptr)
|
||||
return false;
|
||||
|
||||
@@ -3108,10 +3118,10 @@ _bfd_ecoff_slurp_armap (abfd)
|
||||
{
|
||||
unsigned int name_offset, file_offset;
|
||||
|
||||
file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
|
||||
file_offset = H_GET_32 (abfd, (raw_ptr + 4));
|
||||
if (file_offset == 0)
|
||||
continue;
|
||||
name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
|
||||
name_offset = H_GET_32 (abfd, raw_ptr);
|
||||
symdef_ptr->s.name = stringbase + name_offset;
|
||||
symdef_ptr->file_offset = file_offset;
|
||||
++symdef_ptr;
|
||||
@@ -3137,7 +3147,7 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
|
||||
int stridx;
|
||||
{
|
||||
unsigned int hashsize, hashlog;
|
||||
unsigned int symdefsize;
|
||||
bfd_size_type symdefsize;
|
||||
int padit;
|
||||
unsigned int stringsize;
|
||||
unsigned int mapsize;
|
||||
@@ -3210,12 +3220,12 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
|
||||
if (((char *) (&hdr))[i] == '\0')
|
||||
(((char *) (&hdr))[i]) = ' ';
|
||||
|
||||
if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
|
||||
if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd)
|
||||
!= sizeof (struct ar_hdr))
|
||||
return false;
|
||||
|
||||
bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
|
||||
if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
|
||||
H_PUT_32 (abfd, hashsize, temp);
|
||||
if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
|
||||
return false;
|
||||
|
||||
hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
|
||||
@@ -3230,7 +3240,7 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
|
||||
|
||||
/* Advance firstreal to the file position of this archive
|
||||
element. */
|
||||
if (((bfd *) map[i].pos) != last_elt)
|
||||
if (map[i].u.abfd != last_elt)
|
||||
{
|
||||
do
|
||||
{
|
||||
@@ -3238,13 +3248,13 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
|
||||
firstreal += firstreal % 2;
|
||||
current = current->next;
|
||||
}
|
||||
while (current != (bfd *) map[i].pos);
|
||||
while (current != map[i].u.abfd);
|
||||
}
|
||||
|
||||
last_elt = current;
|
||||
|
||||
hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog);
|
||||
if (bfd_h_get_32 (abfd, (PTR) (hashtable + (hash * 8) + 4)) != 0)
|
||||
if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0)
|
||||
{
|
||||
unsigned int srch;
|
||||
|
||||
@@ -3252,7 +3262,7 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
|
||||
for (srch = (hash + rehash) & (hashsize - 1);
|
||||
srch != hash;
|
||||
srch = (srch + rehash) & (hashsize - 1))
|
||||
if (bfd_h_get_32 (abfd, (PTR) (hashtable + (srch * 8) + 4)) == 0)
|
||||
if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0)
|
||||
break;
|
||||
|
||||
BFD_ASSERT (srch != hash);
|
||||
@@ -3260,27 +3270,25 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
|
||||
hash = srch;
|
||||
}
|
||||
|
||||
bfd_h_put_32 (abfd, (bfd_vma) map[i].namidx,
|
||||
(PTR) (hashtable + hash * 8));
|
||||
bfd_h_put_32 (abfd, (bfd_vma) firstreal,
|
||||
(PTR) (hashtable + hash * 8 + 4));
|
||||
H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8));
|
||||
H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4));
|
||||
}
|
||||
|
||||
if (bfd_write ((PTR) hashtable, 1, symdefsize, abfd) != symdefsize)
|
||||
if (bfd_bwrite ((PTR) hashtable, symdefsize, abfd) != symdefsize)
|
||||
return false;
|
||||
|
||||
bfd_release (abfd, hashtable);
|
||||
|
||||
/* Now write the strings. */
|
||||
bfd_h_put_32 (abfd, (bfd_vma) stringsize, temp);
|
||||
if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
|
||||
H_PUT_32 (abfd, stringsize, temp);
|
||||
if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
|
||||
return false;
|
||||
for (i = 0; i < orl_count; i++)
|
||||
{
|
||||
bfd_size_type len;
|
||||
|
||||
len = strlen (*map[i].name) + 1;
|
||||
if (bfd_write ((PTR) (*map[i].name), 1, len, abfd) != len)
|
||||
if (bfd_bwrite ((PTR) (*map[i].name), len, abfd) != len)
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -3288,7 +3296,7 @@ _bfd_ecoff_write_armap (abfd, elength, map, orl_count, stridx)
|
||||
bug-compatible for DECstation ar we use a null. */
|
||||
if (padit)
|
||||
{
|
||||
if (bfd_write ("", 1, 1, abfd) != 1)
|
||||
if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1)
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -3304,10 +3312,11 @@ _bfd_ecoff_archive_p (abfd)
|
||||
{
|
||||
struct artdata *tdata_hold;
|
||||
char armag[SARMAG + 1];
|
||||
bfd_size_type amt;
|
||||
|
||||
tdata_hold = abfd->tdata.aout_ar_data;
|
||||
|
||||
if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG)
|
||||
if (bfd_bread ((PTR) armag, (bfd_size_type) SARMAG, abfd) != SARMAG)
|
||||
{
|
||||
if (bfd_get_error () != bfd_error_system_call)
|
||||
bfd_set_error (bfd_error_wrong_format);
|
||||
@@ -3323,8 +3332,8 @@ _bfd_ecoff_archive_p (abfd)
|
||||
/* We are setting bfd_ardata(abfd) here, but since bfd_ardata
|
||||
involves a cast, we can't do it as the left operand of
|
||||
assignment. */
|
||||
abfd->tdata.aout_ar_data =
|
||||
(struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
|
||||
amt = sizeof (struct artdata);
|
||||
abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
|
||||
|
||||
if (bfd_ardata (abfd) == (struct artdata *) NULL)
|
||||
{
|
||||
@@ -3441,9 +3450,9 @@ _bfd_ecoff_bfd_link_hash_table_create (abfd)
|
||||
bfd *abfd;
|
||||
{
|
||||
struct ecoff_link_hash_table *ret;
|
||||
bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
|
||||
|
||||
ret = ((struct ecoff_link_hash_table *)
|
||||
bfd_alloc (abfd, sizeof (struct ecoff_link_hash_table)));
|
||||
ret = (struct ecoff_link_hash_table *) bfd_alloc (abfd, amt);
|
||||
if (ret == NULL)
|
||||
return NULL;
|
||||
if (! _bfd_link_hash_table_init (&ret->root, abfd,
|
||||
@@ -3533,7 +3542,7 @@ ecoff_link_add_archive_symbols (abfd, info)
|
||||
return (_bfd_generic_link_add_archive_symbols
|
||||
(abfd, info, ecoff_link_check_archive_element));
|
||||
|
||||
armap_count = bfd_h_get_32 (abfd, raw_armap);
|
||||
armap_count = H_GET_32 (abfd, raw_armap);
|
||||
|
||||
armap_log = 0;
|
||||
for (i = 1; i < armap_count; i <<= 1)
|
||||
@@ -3586,7 +3595,7 @@ ecoff_link_add_archive_symbols (abfd, info)
|
||||
hash = ecoff_armap_hash (h->root.string, &rehash, armap_count,
|
||||
armap_log);
|
||||
|
||||
file_offset = bfd_h_get_32 (abfd, hashtable + (hash * 8) + 4);
|
||||
file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4);
|
||||
if (file_offset == 0)
|
||||
{
|
||||
/* Nothing in this slot. */
|
||||
@@ -3594,7 +3603,7 @@ ecoff_link_add_archive_symbols (abfd, info)
|
||||
continue;
|
||||
}
|
||||
|
||||
name = stringbase + bfd_h_get_32 (abfd, hashtable + (hash * 8));
|
||||
name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8));
|
||||
if (name[0] != h->root.string[0]
|
||||
|| strcmp (name, h->root.string) != 0)
|
||||
{
|
||||
@@ -3607,10 +3616,10 @@ ecoff_link_add_archive_symbols (abfd, info)
|
||||
srch != hash;
|
||||
srch = (srch + rehash) & (armap_count - 1))
|
||||
{
|
||||
file_offset = bfd_h_get_32 (abfd, hashtable + (srch * 8) + 4);
|
||||
file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4);
|
||||
if (file_offset == 0)
|
||||
break;
|
||||
name = stringbase + bfd_h_get_32 (abfd, hashtable + (srch * 8));
|
||||
name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8));
|
||||
if (name[0] == h->root.string[0]
|
||||
&& strcmp (name, h->root.string) == 0)
|
||||
{
|
||||
@@ -3628,7 +3637,7 @@ ecoff_link_add_archive_symbols (abfd, info)
|
||||
hash = srch;
|
||||
}
|
||||
|
||||
element = (*backend->get_elt_at_filepos) (abfd, file_offset);
|
||||
element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset);
|
||||
if (element == (bfd *) NULL)
|
||||
return false;
|
||||
|
||||
@@ -3664,7 +3673,7 @@ ecoff_link_check_archive_element (abfd, info, pneeded)
|
||||
HDRR *symhdr;
|
||||
bfd_size_type external_ext_size;
|
||||
PTR external_ext = NULL;
|
||||
size_t esize;
|
||||
bfd_size_type esize;
|
||||
char *ssext = NULL;
|
||||
char *ext_ptr;
|
||||
char *ext_end;
|
||||
@@ -3687,17 +3696,17 @@ ecoff_link_check_archive_element (abfd, info, pneeded)
|
||||
if (external_ext == NULL && esize != 0)
|
||||
goto error_return;
|
||||
|
||||
if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
|
||||
|| bfd_read (external_ext, 1, esize, abfd) != esize)
|
||||
if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
|
||||
|| bfd_bread (external_ext, esize, abfd) != esize)
|
||||
goto error_return;
|
||||
|
||||
ssext = (char *) bfd_malloc (symhdr->issExtMax);
|
||||
ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
|
||||
if (ssext == NULL && symhdr->issExtMax != 0)
|
||||
goto error_return;
|
||||
|
||||
if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
|
||||
|| (bfd_read (ssext, 1, symhdr->issExtMax, abfd) !=
|
||||
(bfd_size_type) symhdr->issExtMax))
|
||||
if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
|
||||
|| (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
|
||||
!= (bfd_size_type) symhdr->issExtMax))
|
||||
goto error_return;
|
||||
|
||||
/* Look through the external symbols to see if they define some
|
||||
@@ -3787,7 +3796,7 @@ ecoff_link_add_object_symbols (abfd, info)
|
||||
HDRR *symhdr;
|
||||
bfd_size_type external_ext_size;
|
||||
PTR external_ext = NULL;
|
||||
size_t esize;
|
||||
bfd_size_type esize;
|
||||
char *ssext = NULL;
|
||||
boolean result;
|
||||
|
||||
@@ -3807,16 +3816,16 @@ ecoff_link_add_object_symbols (abfd, info)
|
||||
if (external_ext == NULL && esize != 0)
|
||||
goto error_return;
|
||||
|
||||
if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0
|
||||
|| bfd_read (external_ext, 1, esize, abfd) != esize)
|
||||
if (bfd_seek (abfd, (file_ptr) symhdr->cbExtOffset, SEEK_SET) != 0
|
||||
|| bfd_bread (external_ext, esize, abfd) != esize)
|
||||
goto error_return;
|
||||
|
||||
ssext = (char *) bfd_malloc (symhdr->issExtMax);
|
||||
ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
|
||||
if (ssext == NULL && symhdr->issExtMax != 0)
|
||||
goto error_return;
|
||||
|
||||
if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0
|
||||
|| (bfd_read (ssext, 1, symhdr->issExtMax, abfd)
|
||||
if (bfd_seek (abfd, (file_ptr) symhdr->cbSsExtOffset, SEEK_SET) != 0
|
||||
|| (bfd_bread (ssext, (bfd_size_type) symhdr->issExtMax, abfd)
|
||||
!= (bfd_size_type) symhdr->issExtMax))
|
||||
goto error_return;
|
||||
|
||||
@@ -3857,12 +3866,13 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext)
|
||||
struct ecoff_link_hash_entry **sym_hash;
|
||||
char *ext_ptr;
|
||||
char *ext_end;
|
||||
bfd_size_type amt;
|
||||
|
||||
ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
|
||||
|
||||
sym_hash = ((struct ecoff_link_hash_entry **)
|
||||
bfd_alloc (abfd,
|
||||
ext_count * sizeof (struct bfd_link_hash_entry *)));
|
||||
amt = ext_count;
|
||||
amt *= sizeof (struct bfd_link_hash_entry *);
|
||||
sym_hash = (struct ecoff_link_hash_entry **) bfd_alloc (abfd, amt);
|
||||
if (!sym_hash)
|
||||
return false;
|
||||
ecoff_data (abfd)->sym_hashes = sym_hash;
|
||||
@@ -3999,7 +4009,7 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext)
|
||||
h = NULL;
|
||||
if (! (_bfd_generic_link_add_one_symbol
|
||||
(info, abfd, name,
|
||||
esym.weakext ? BSF_WEAK : BSF_GLOBAL,
|
||||
(flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL),
|
||||
section, value, (const char *) NULL, true, true,
|
||||
(struct bfd_link_hash_entry **) &h)))
|
||||
return false;
|
||||
@@ -4288,25 +4298,24 @@ ecoff_final_link_debug_accumulate (output_bfd, input_bfd, info, handle)
|
||||
HDRR *symhdr = &debug->symbolic_header;
|
||||
boolean ret;
|
||||
|
||||
#define READ(ptr, offset, count, size, type) \
|
||||
if (symhdr->count == 0) \
|
||||
debug->ptr = NULL; \
|
||||
else \
|
||||
{ \
|
||||
debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
|
||||
if (debug->ptr == NULL) \
|
||||
{ \
|
||||
ret = false; \
|
||||
goto return_something; \
|
||||
} \
|
||||
if ((bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) \
|
||||
!= 0) \
|
||||
|| (bfd_read (debug->ptr, size, symhdr->count, \
|
||||
input_bfd) != size * symhdr->count)) \
|
||||
{ \
|
||||
ret = false; \
|
||||
goto return_something; \
|
||||
} \
|
||||
#define READ(ptr, offset, count, size, type) \
|
||||
if (symhdr->count == 0) \
|
||||
debug->ptr = NULL; \
|
||||
else \
|
||||
{ \
|
||||
bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
|
||||
debug->ptr = (type) bfd_malloc (amt); \
|
||||
if (debug->ptr == NULL) \
|
||||
{ \
|
||||
ret = false; \
|
||||
goto return_something; \
|
||||
} \
|
||||
if (bfd_seek (input_bfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
|
||||
|| bfd_bread (debug->ptr, amt, input_bfd) != amt) \
|
||||
{ \
|
||||
ret = false; \
|
||||
goto return_something; \
|
||||
} \
|
||||
}
|
||||
|
||||
/* If raw_syments is not NULL, then the data was already by read by
|
||||
@@ -4528,6 +4537,7 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
|
||||
bfd_size_type external_reloc_size;
|
||||
bfd_size_type external_relocs_size;
|
||||
PTR external_relocs = NULL;
|
||||
bfd_size_type amt;
|
||||
|
||||
BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
|
||||
|
||||
@@ -4549,10 +4559,9 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
|
||||
|
||||
/* Get the section contents. We allocate memory for the larger of
|
||||
the size before relocating and the size after relocating. */
|
||||
contents = (bfd_byte *) bfd_malloc (raw_size >= cooked_size
|
||||
? (size_t) raw_size
|
||||
: (size_t) cooked_size);
|
||||
if (contents == NULL && raw_size != 0)
|
||||
amt = raw_size >= cooked_size ? raw_size : cooked_size;
|
||||
contents = (bfd_byte *) bfd_malloc (amt);
|
||||
if (contents == NULL && amt != 0)
|
||||
goto error_return;
|
||||
|
||||
/* If we are relaxing, the contents may have already been read into
|
||||
@@ -4579,12 +4588,12 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
|
||||
external_relocs = section_tdata->external_relocs;
|
||||
else
|
||||
{
|
||||
external_relocs = (PTR) bfd_malloc ((size_t) external_relocs_size);
|
||||
external_relocs = (PTR) bfd_malloc (external_relocs_size);
|
||||
if (external_relocs == NULL && external_relocs_size != 0)
|
||||
goto error_return;
|
||||
|
||||
if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
|
||||
|| (bfd_read (external_relocs, 1, external_relocs_size, input_bfd)
|
||||
|| (bfd_bread (external_relocs, external_relocs_size, input_bfd)
|
||||
!= external_relocs_size))
|
||||
goto error_return;
|
||||
}
|
||||
@@ -4599,7 +4608,7 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
|
||||
if (! bfd_set_section_contents (output_bfd,
|
||||
output_section,
|
||||
(PTR) contents,
|
||||
input_section->output_offset,
|
||||
(file_ptr) input_section->output_offset,
|
||||
cooked_size))
|
||||
goto error_return;
|
||||
|
||||
@@ -4609,11 +4618,10 @@ ecoff_indirect_link_order (output_bfd, info, output_section, link_order)
|
||||
have output so far. */
|
||||
if (info->relocateable)
|
||||
{
|
||||
if (bfd_seek (output_bfd,
|
||||
(output_section->rel_filepos +
|
||||
output_section->reloc_count * external_reloc_size),
|
||||
SEEK_SET) != 0
|
||||
|| (bfd_write (external_relocs, 1, external_relocs_size, output_bfd)
|
||||
file_ptr pos = (output_section->rel_filepos
|
||||
+ output_section->reloc_count * external_reloc_size);
|
||||
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
|
||||
|| (bfd_bwrite (external_relocs, external_relocs_size, output_bfd)
|
||||
!= external_relocs_size))
|
||||
goto error_return;
|
||||
output_section->reloc_count += input_section->reloc_count;
|
||||
@@ -4653,6 +4661,7 @@ ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
|
||||
bfd_size_type external_reloc_size;
|
||||
bfd_byte *rbuf;
|
||||
boolean ok;
|
||||
file_ptr pos;
|
||||
|
||||
type = link_order->type;
|
||||
section = NULL;
|
||||
@@ -4712,13 +4721,13 @@ ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
|
||||
bfd_size_type size;
|
||||
bfd_reloc_status_type rstat;
|
||||
bfd_byte *buf;
|
||||
boolean ok;
|
||||
|
||||
size = bfd_get_reloc_size (rel.howto);
|
||||
buf = (bfd_byte *) bfd_zmalloc (size);
|
||||
if (buf == (bfd_byte *) NULL)
|
||||
return false;
|
||||
rstat = _bfd_relocate_contents (rel.howto, output_bfd, addend, buf);
|
||||
rstat = _bfd_relocate_contents (rel.howto, output_bfd,
|
||||
(bfd_vma) addend, buf);
|
||||
switch (rstat)
|
||||
{
|
||||
case bfd_reloc_ok:
|
||||
@@ -4777,7 +4786,7 @@ ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
|
||||
}
|
||||
else
|
||||
{
|
||||
CONST char *name;
|
||||
const char *name;
|
||||
|
||||
name = bfd_get_section_name (output_bfd, section);
|
||||
if (strcmp (name, ".text") == 0)
|
||||
@@ -4820,17 +4829,16 @@ ecoff_reloc_link_order (output_bfd, info, output_section, link_order)
|
||||
|
||||
/* Get some memory and swap out the reloc. */
|
||||
external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
|
||||
rbuf = (bfd_byte *) bfd_malloc ((size_t) external_reloc_size);
|
||||
rbuf = (bfd_byte *) bfd_malloc (external_reloc_size);
|
||||
if (rbuf == (bfd_byte *) NULL)
|
||||
return false;
|
||||
|
||||
(*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (PTR) rbuf);
|
||||
|
||||
ok = (bfd_seek (output_bfd,
|
||||
(output_section->rel_filepos +
|
||||
output_section->reloc_count * external_reloc_size),
|
||||
SEEK_SET) == 0
|
||||
&& (bfd_write ((PTR) rbuf, 1, external_reloc_size, output_bfd)
|
||||
pos = (output_section->rel_filepos
|
||||
+ output_section->reloc_count * external_reloc_size);
|
||||
ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0
|
||||
&& (bfd_bwrite ((PTR) rbuf, external_reloc_size, output_bfd)
|
||||
== external_reloc_size));
|
||||
|
||||
if (ok)
|
||||
|
||||
Reference in New Issue
Block a user