static char *build_debug_section
PARAMS ((bfd *));
static char *copy_name
- PARAMS ((bfd *, char *, int));
+ PARAMS ((bfd *, char *, size_t));
#define STRING_SIZE_SIZE (4)
strindex does not run us past the end, but right now we
don't know the length of the string table. */
strings += strindex;
- name = bfd_alloc (abfd, strlen (strings) + 1);
+ name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
if (name == NULL)
return false;
strcpy (name, strings);
if (name == NULL)
{
/* Assorted wastage to null-terminate the name, thanks AT&T! */
- name = bfd_alloc (abfd, sizeof (hdr->s_name) + 1);
+ name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1);
if (name == NULL)
return false;
strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
& flags))
result = false;
-
+
return_section->flags = flags;
/* At least on i386-coff, the line number count for a shared library
flagword oflags = abfd->flags;
bfd_vma ostart = bfd_get_start_address (abfd);
PTR tdata;
- size_t readsize; /* length of file_info */
+ bfd_size_type readsize; /* length of file_info */
unsigned int scnhsz;
char *external_sections;
return 0;
scnhsz = bfd_coff_scnhsz (abfd);
- readsize = nscns * scnhsz;
+ readsize = (bfd_size_type) nscns * scnhsz;
external_sections = (char *) bfd_alloc (abfd, readsize);
if (!external_sections)
goto fail;
- if (bfd_read ((PTR) external_sections, 1, readsize, abfd) != readsize)
+ if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize)
goto fail;
/* Set the arch/mach *before* swapping in sections; section header swapping
coff_object_p (abfd)
bfd *abfd;
{
- unsigned int filhsz;
- unsigned int aoutsz;
- int nscns;
+ bfd_size_type filhsz;
+ bfd_size_type aoutsz;
+ unsigned int nscns;
PTR filehdr;
struct internal_filehdr internal_f;
struct internal_aouthdr internal_a;
filehdr = bfd_alloc (abfd, filhsz);
if (filehdr == NULL)
return 0;
- if (bfd_read (filehdr, 1, filhsz, abfd) != filhsz)
+ if (bfd_bread (filehdr, filhsz, abfd) != filhsz)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
opthdr = bfd_alloc (abfd, aoutsz);
if (opthdr == NULL)
return 0;;
- if (bfd_read (opthdr, 1, internal_f.f_opthdr, abfd)
+ if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
!= internal_f.f_opthdr)
{
return 0;
bfd_byte *erel;
bfd_byte *erel_end;
struct internal_reloc *irel;
+ bfd_size_type amt;
if (coff_section_data (abfd, sec) != NULL
&& coff_section_data (abfd, sec)->relocs != NULL)
relsz = bfd_coff_relsz (abfd);
+ amt = sec->reloc_count * relsz;
if (external_relocs == NULL)
{
- free_external = (bfd_byte *) bfd_malloc (sec->reloc_count * relsz);
+ free_external = (bfd_byte *) bfd_malloc (amt);
if (free_external == NULL && sec->reloc_count > 0)
goto error_return;
external_relocs = free_external;
}
if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
- || (bfd_read (external_relocs, relsz, sec->reloc_count, abfd)
- != relsz * sec->reloc_count))
+ || bfd_bread (external_relocs, amt, abfd) != amt)
goto error_return;
if (internal_relocs == NULL)
{
- free_internal = ((struct internal_reloc *)
- bfd_malloc (sec->reloc_count
- * sizeof (struct internal_reloc)));
+ amt = sec->reloc_count;
+ amt *= sizeof (struct internal_reloc);
+ free_internal = (struct internal_reloc *) bfd_malloc (amt);
if (free_internal == NULL && sec->reloc_count > 0)
goto error_return;
internal_relocs = free_internal;
{
if (coff_section_data (abfd, sec) == NULL)
{
- sec->used_by_bfd =
- (PTR) bfd_zalloc (abfd,
- sizeof (struct coff_section_tdata));
+ amt = sizeof (struct coff_section_tdata);
+ sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
if (sec->used_by_bfd == NULL)
goto error_return;
coff_section_data (abfd, sec)->contents = NULL;
{
asymbol **newsyms;
unsigned int i;
+ bfd_size_type amt;
- newsyms = (asymbol **) bfd_alloc (bfd_ptr,
- sizeof (asymbol *) * (symbol_count + 1));
+ amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
+ newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
if (!newsyms)
return false;
bfd_ptr->outsymbols = newsyms;
if (s->fix_value)
{
/* FIXME: We should use a union here. */
- s->u.syment.n_value =
- (bfd_vma)((combined_entry_type *)
+ s->u.syment.n_value =
+ (bfd_vma)((combined_entry_type *)
((unsigned long) s->u.syment.n_value))->offset;
s->fix_value = 0;
}
}
else
{
- long filepos;
+ file_ptr filepos;
bfd_byte buf[4];
int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
*debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
filepos = bfd_tell (abfd);
if (prefix_len == 4)
- bfd_put_32 (abfd, name_length + 1, buf);
+ bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
else
- bfd_put_16 (abfd, name_length + 1, buf);
+ bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
if (!bfd_set_section_contents (abfd,
*debug_string_section_p,
|| !bfd_set_section_contents (abfd,
*debug_string_section_p,
(PTR) symbol->name,
- ((file_ptr) *debug_string_size_p
- + prefix_len),
+ (file_ptr) (*debug_string_size_p
+ + prefix_len),
(bfd_size_type) name_length + 1))
abort ();
if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
if (!buf)
return false;
bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
- if (bfd_write (buf, 1, symesz, abfd) != symesz)
+ if (bfd_bwrite (buf, symesz, abfd) != symesz)
return false;
bfd_release (abfd, buf);
&((native + j + 1)->u.auxent),
type,
class,
- j,
+ (int) j,
native->u.syment.n_numaux,
buf);
- if (bfd_write (buf, 1, auxesz, abfd) != auxesz)
+ if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
return false;
}
bfd_release (abfd, buf);
bfd_byte buffer[STRING_SIZE_SIZE];
#if STRING_SIZE_SIZE == 4
- bfd_h_put_32 (abfd, size, buffer);
+ H_PUT_32 (abfd, size, buffer);
#else
- #error Change bfd_h_put_32
+ #error Change H_PUT_32
#endif
- if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
+ if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd)
+ != sizeof (buffer))
return false;
/* Handle long section names. This code must handle section
len = strlen (o->name);
if (len > SCNNMLEN)
{
- if (bfd_write (o->name, 1, len + 1, abfd) != len + 1)
+ if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
+ != len + 1)
return false;
}
}
&& c_symbol->native->u.syment.n_numaux > 0)
{
if (bfd_coff_force_symnames_in_strings (abfd))
- bfd_write (".file", 1, 6, abfd);
+ {
+ if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
+ return false;
+ }
maxlen = bfd_coff_filnmlen (abfd);
}
else
if (name_length > maxlen)
{
- if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
- != name_length + 1)
+ if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1,
+ abfd) != name_length + 1)
return false;
}
}
bfd_byte buffer[STRING_SIZE_SIZE];
#if STRING_SIZE_SIZE == 4
- bfd_h_put_32 (abfd, size, buffer);
+ H_PUT_32 (abfd, size, buffer);
#else
- #error Change bfd_h_put_32
+ #error Change H_PUT_32
#endif
- if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
+ if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
!= STRING_SIZE_SIZE)
return false;
}
out.l_lnno = 0;
out.l_addr.l_symndx = l->u.offset;
bfd_coff_swap_lineno_out (abfd, &out, buff);
- if (bfd_write (buff, 1, linesz, abfd) != linesz)
+ if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
+ != linesz)
return false;
l++;
while (l->line_number)
out.l_lnno = l->line_number;
out.l_addr.l_symndx = l->u.offset;
bfd_coff_swap_lineno_out (abfd, &out, buff);
- if (bfd_write (buff, 1, linesz, abfd) != linesz)
+ if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
+ != linesz)
return false;
l++;
}
combined_entry_type e[10];
};
struct foo *f;
- f = (struct foo *) bfd_alloc (abfd, sizeof (*f));
+ f = (struct foo *) bfd_alloc (abfd, (bfd_size_type) sizeof (*f));
if (!f)
{
bfd_set_error (bfd_error_no_error);
bfd *abfd;
{
char *debug_section;
- long position;
+ file_ptr position;
+ bfd_size_type sec_size;
asection *sect = bfd_get_section_by_name (abfd, ".debug");
return NULL;
}
- debug_section = (PTR) bfd_alloc (abfd,
- bfd_get_section_size_before_reloc (sect));
+ sec_size = bfd_get_section_size_before_reloc (sect);
+ debug_section = (PTR) bfd_alloc (abfd, sec_size);
if (debug_section == NULL)
return NULL;
position = bfd_tell (abfd);
if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
- || (bfd_read (debug_section,
- bfd_get_section_size_before_reloc (sect), 1, abfd)
- != bfd_get_section_size_before_reloc (sect))
+ || bfd_bread (debug_section, sec_size, abfd) != sec_size
|| bfd_seek (abfd, position, SEEK_SET) != 0)
return NULL;
return debug_section;
copy_name (abfd, name, maxlen)
bfd *abfd;
char *name;
- int maxlen;
+ size_t maxlen;
{
- int len;
+ size_t len;
char *newname;
for (len = 0; len < maxlen; ++len)
}
}
- if ((newname = (PTR) bfd_alloc (abfd, len + 1)) == NULL)
+ if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
return (NULL);
strncpy (newname, name, len);
newname[len] = '\0';
bfd *abfd;
{
bfd_size_type symesz;
- size_t size;
+ bfd_size_type size;
PTR syms;
if (obj_coff_external_syms (abfd) != NULL)
return false;
if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
- || bfd_read (syms, size, 1, abfd) != size)
+ || bfd_bread (syms, size, abfd) != size)
{
if (syms != NULL)
free (syms);
bfd *abfd;
{
char extstrsize[STRING_SIZE_SIZE];
- size_t strsize;
+ bfd_size_type strsize;
char *strings;
+ file_ptr pos;
if (obj_coff_strings (abfd) != NULL)
return obj_coff_strings (abfd);
return NULL;
}
- if (bfd_seek (abfd,
- (obj_sym_filepos (abfd)
- + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd)),
- SEEK_SET) != 0)
+ pos = obj_sym_filepos (abfd);
+ pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
+ if (bfd_seek (abfd, pos, SEEK_SET) != 0)
return NULL;
- if (bfd_read (extstrsize, sizeof extstrsize, 1, abfd) != sizeof extstrsize)
+ if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
+ != sizeof extstrsize)
{
if (bfd_get_error () != bfd_error_file_truncated)
return NULL;
else
{
#if STRING_SIZE_SIZE == 4
- strsize = bfd_h_get_32 (abfd, (bfd_byte *) extstrsize);
+ strsize = H_GET_32 (abfd, extstrsize);
#else
- #error Change bfd_h_get_32
+ #error Change H_GET_32
#endif
}
if (strings == NULL)
return NULL;
- if (bfd_read (strings + STRING_SIZE_SIZE,
- strsize - STRING_SIZE_SIZE, 1, abfd)
+ if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
!= strsize - STRING_SIZE_SIZE)
{
free (strings);
combined_entry_type *internal_ptr;
combined_entry_type *symbol_ptr;
combined_entry_type *internal_end;
- bfd_size_type symesz;
+ size_t symesz;
char *raw_src;
char *raw_end;
const char *string_table = NULL;
char *debug_section = NULL;
- unsigned long size;
+ bfd_size_type size;
if (obj_raw_syments (abfd) != NULL)
return obj_raw_syments (abfd);
bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
symbol_ptr->u.syment.n_type,
symbol_ptr->u.syment.n_sclass,
- i, symbol_ptr->u.syment.n_numaux,
+ (int) i, symbol_ptr->u.syment.n_numaux,
&(internal_ptr->u.auxent));
coff_pointerize_aux (abfd, internal, symbol_ptr, i,
internal_ptr);
((long)
copy_name (abfd,
(internal_ptr + 1)->u.auxent.x_file.x_fname,
- bfd_coff_filnmlen (abfd)));
+ (size_t) bfd_coff_filnmlen (abfd)));
}
}
}
if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
{
/* This is a "short" name. Make it long. */
- unsigned long i = 0;
- char *newstring = NULL;
+ size_t i;
+ char *newstring;
/* find the length of this string without walking into memory
that isn't ours. */
for (i = 0; i < 8; ++i)
- {
- if (internal_ptr->u.syment._n._n_name[i] == '\0')
- {
- break;
- } /* if end of string */
- } /* possible lengths of this string. */
+ if (internal_ptr->u.syment._n._n_name[i] == '\0')
+ break;
- if ((newstring = (PTR) bfd_alloc (abfd, ++i)) == NULL)
+ newstring = (PTR) bfd_alloc (abfd, (bfd_size_type) (i + 1));
+ if (newstring == NULL)
return (NULL);
- memset (newstring, 0, i);
- strncpy (newstring, internal_ptr->u.syment._n._n_name, i - 1);
+ memset (newstring, 0, i + 1);
+ strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
internal_ptr->u.syment._n._n_n._n_zeroes = 0;
}
coff_make_empty_symbol (abfd)
bfd *abfd;
{
- coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
+ bfd_size_type amt = sizeof (coff_symbol_type);
+ coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
if (new == NULL)
return (NULL);
memset (new, 0, sizeof *new);
PTR ptr ATTRIBUTE_UNUSED;
unsigned long sz ATTRIBUTE_UNUSED;
{
- coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
+ bfd_size_type amt = sizeof (coff_symbol_type);
+ coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
if (new == NULL)
return (NULL);
/* @@ The 10 is a guess at a plausible maximum number of aux entries
(but shouldn't be a constant). */
- new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
+ amt = sizeof (combined_entry_type) * 10;
+ new->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
if (!new->native)
return (NULL);
new->symbol.section = bfd_abs_section_ptr;
*psyment = csym->native->u.syment;
if (csym->native->fix_value)
- psyment->n_value = psyment->n_value -
+ psyment->n_value = psyment->n_value -
(unsigned long) obj_raw_syments (abfd);
/* FIXME: We should handle fix_line here. */
asection *section;
asymbol **symbols;
bfd_vma offset;
- CONST char **filename_ptr;
- CONST char **functionname_ptr;
+ const char **filename_ptr;
+ const char **functionname_ptr;
unsigned int *line_ptr;
{
boolean found;
combined_entry_type *pend;
alent *l;
struct coff_section_tdata *sec_data;
+ bfd_size_type amt;
/* Before looking through the symbol table, try to use a .stab
section to find the information. */
/* Cache the results for the next call. */
if (sec_data == NULL && section->owner == abfd)
{
- section->used_by_bfd =
- ((PTR) bfd_zalloc (abfd,
- sizeof (struct coff_section_tdata)));
+ amt = sizeof (struct coff_section_tdata);
+ section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
sec_data = (struct coff_section_tdata *) section->used_by_bfd;
}
if (sec_data != NULL)
coff_write_alien_symbol(). */
combined_entry_type * native;
+ bfd_size_type amt = sizeof (* native);
- native = (combined_entry_type *) bfd_alloc (abfd, sizeof (* native));
+ native = (combined_entry_type *) bfd_alloc (abfd, amt);
if (native == NULL)
return false;
projects / deliverable / binutils-gdb.git / blobdiff