/* Support for the generic parts of COFF, for BFD.
- Copyright 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ 2000, 2001
+ Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *,
asection **, bfd_size_type *));
static boolean coff_write_symbol
- PARAMS ((bfd *, asymbol *, combined_entry_type *, unsigned int *,
+ PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *,
bfd_size_type *, asection **, bfd_size_type *));
static boolean coff_write_alien_symbol
- PARAMS ((bfd *, asymbol *, unsigned int *, bfd_size_type *,
+ PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *,
asection **, bfd_size_type *));
static boolean coff_write_native_symbol
- PARAMS ((bfd *, coff_symbol_type *, unsigned int *, bfd_size_type *,
+ PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *,
asection **, bfd_size_type *));
static void coff_pointerize_aux
PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
unsigned int, combined_entry_type *));
+static boolean make_a_section_from_file
+ PARAMS ((bfd *, struct internal_scnhdr *, unsigned int));
+static const bfd_target *coff_real_object_p
+ PARAMS ((bfd *, unsigned, struct internal_filehdr *,
+ struct internal_aouthdr *));
+static void fixup_symbol_value
+ PARAMS ((bfd *, coff_symbol_type *, struct internal_syment *));
+static char *build_debug_section
+ PARAMS ((bfd *));
+static char *copy_name
+ PARAMS ((bfd *, char *, size_t));
#define STRING_SIZE_SIZE (4)
{
asection *return_section;
char *name;
+ boolean result = true;
+ flagword flags;
+
+ name = NULL;
+
+ /* Handle long section names as in PE. */
+ if (bfd_coff_long_section_names (abfd)
+ && hdr->s_name[0] == '/')
+ {
+ char buf[SCNNMLEN];
+ long strindex;
+ char *p;
+ const char *strings;
+
+ memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
+ buf[SCNNMLEN - 1] = '\0';
+ strindex = strtol (buf, &p, 10);
+ if (*p == '\0' && strindex >= 0)
+ {
+ strings = _bfd_coff_read_string_table (abfd);
+ if (strings == NULL)
+ return false;
+ /* FIXME: For extra safety, we should make sure that
+ 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, (bfd_size_type) strlen (strings) + 1);
+ if (name == NULL)
+ return false;
+ strcpy (name, strings);
+ }
+ }
- /* Assorted wastage to null-terminate the name, thanks AT&T! */
- name = bfd_alloc (abfd, sizeof (hdr->s_name) + 1);
if (name == NULL)
{
- bfd_set_error (bfd_error_no_memory);
- return false;
+ /* Assorted wastage to null-terminate the name, thanks AT&T! */
+ 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));
+ name[sizeof (hdr->s_name)] = 0;
}
- strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
- name[sizeof (hdr->s_name)] = 0;
return_section = bfd_make_section_anyway (abfd, name);
if (return_section == NULL)
return false;
- /* s_paddr is presumed to be = to s_vaddr */
-
return_section->vma = hdr->s_vaddr;
- return_section->lma = return_section->vma;
+ return_section->lma = hdr->s_paddr;
return_section->_raw_size = hdr->s_size;
return_section->filepos = hdr->s_scnptr;
return_section->rel_filepos = hdr->s_relptr;
return_section->lineno_count = hdr->s_nlnno;
return_section->userdata = NULL;
return_section->next = (asection *) NULL;
- return_section->flags = bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name);
-
return_section->target_index = target_index;
+ 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
section must be ignored. */
if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
/* FIXME: should this check 'hdr->s_size > 0' */
if (hdr->s_scnptr != 0)
return_section->flags |= SEC_HAS_CONTENTS;
- return true;
+
+ return result;
}
/* Read in a COFF object and make it into a BFD. This is used by
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)
- {
- bfd_set_error (bfd_error_no_memory);
- goto fail;
- }
+ 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
+ may depend on arch/mach info. */
+ if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
goto fail;
/* Now copy data as required; construct all asections etc */
bfd_coff_swap_scnhdr_in (abfd,
(PTR) (external_sections + i * scnhsz),
(PTR) & tmp);
- make_a_section_from_file (abfd, &tmp, i + 1);
+ if (! make_a_section_from_file (abfd, &tmp, i + 1))
+ goto fail;
}
}
/* make_abs_section (abfd); */
- if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
- goto fail;
-
return abfd->xvec;
fail:
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);
bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
bfd_release (abfd, filehdr);
- if (bfd_coff_bad_format_hook (abfd, &internal_f) == false)
+ /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
+ (less than aoutsz) used in object files and AOUTSZ (equal to
+ aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
+ expects this header to be aoutsz bytes in length, so we use that
+ value in the call to bfd_alloc below. But we must be careful to
+ only read in f_opthdr bytes in the call to bfd_bread. We should
+ also attempt to catch corrupt or non-COFF binaries with a strange
+ value for f_opthdr. */
+ if (bfd_coff_bad_format_hook (abfd, &internal_f) == false
+ || internal_f.f_opthdr > aoutsz)
{
bfd_set_error (bfd_error_wrong_format);
return 0;
opthdr = bfd_alloc (abfd, aoutsz);
if (opthdr == NULL)
- return 0;;
- if (bfd_read (opthdr, 1, aoutsz, abfd) != aoutsz)
+ return 0;
+ if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
+ != internal_f.f_opthdr)
{
return 0;
}
- bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) & internal_a);
+ bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a);
}
- /* Seek past the opt hdr stuff */
- if (bfd_seek (abfd, (file_ptr) (internal_f.f_opthdr + filhsz), SEEK_SET)
- != 0)
- return NULL;
-
return coff_real_object_p (abfd, nscns, &internal_f,
(internal_f.f_opthdr != 0
? &internal_a
return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
}
-
/* Canonicalize a COFF symbol table. */
long
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 *) malloc (sec->reloc_count * relsz);
+ free_external = (bfd_byte *) bfd_malloc (amt);
if (free_external == NULL && sec->reloc_count > 0)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ 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 *)
- 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)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ 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)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ goto error_return;
coff_section_data (abfd, sec)->contents = NULL;
}
coff_section_data (abfd, sec)->relocs = free_internal;
{
asymbol *q_maybe = *p;
- if (bfd_asymbol_flavour (q_maybe) == bfd_target_coff_flavour)
+ if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
{
coff_symbol_type *q = coffsymbol (q_maybe);
section's linenumber count. */
alent *l = q->lineno;
- ++q->symbol.section->output_section->lineno_count;
- ++total;
- ++l;
- while (l->line_number != 0)
+ do
{
+ asection * sec = q->symbol.section->output_section;
+
+ /* Do not try to update fields in read-only sections. */
+ if (! bfd_is_const_section (sec))
+ sec->lineno_count ++;
+
++total;
- ++q->symbol.section->output_section->lineno_count;
++l;
}
+ while (l->line_number != 0);
}
}
}
/* Takes a bfd and a symbol, returns a pointer to the coff specific
area of the symbol if there is one. */
-/*ARGSUSED*/
coff_symbol_type *
coff_symbol_from (ignore_abfd, symbol)
- bfd *ignore_abfd;
+ bfd *ignore_abfd ATTRIBUTE_UNUSED;
asymbol *symbol;
{
- if (bfd_asymbol_flavour (symbol) != bfd_target_coff_flavour)
+ if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))
return (coff_symbol_type *) NULL;
if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)
}
static void
-fixup_symbol_value (coff_symbol_ptr, syment)
+fixup_symbol_value (abfd, coff_symbol_ptr, syment)
+ bfd *abfd;
coff_symbol_type *coff_symbol_ptr;
struct internal_syment *syment;
{
syment->n_scnum = N_UNDEF;
syment->n_value = coff_symbol_ptr->symbol.value;
}
- else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING)
+ else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
+ && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
{
syment->n_value = coff_symbol_ptr->symbol.value;
}
syment->n_scnum = N_UNDEF;
syment->n_value = 0;
}
+ /* FIXME: Do we need to handle the absolute section here? */
else
{
if (coff_symbol_ptr->symbol.section)
syment->n_scnum =
coff_symbol_ptr->symbol.section->output_section->target_index;
- syment->n_value =
- coff_symbol_ptr->symbol.value +
- coff_symbol_ptr->symbol.section->output_offset +
- coff_symbol_ptr->symbol.section->output_section->vma;
+ syment->n_value = (coff_symbol_ptr->symbol.value
+ + coff_symbol_ptr->symbol.section->output_offset);
+ if (! obj_pe (abfd))
+ {
+ syment->n_value += (syment->n_sclass == C_STATLAB)
+ ? coff_symbol_ptr->symbol.section->output_section->lma
+ : coff_symbol_ptr->symbol.section->output_section->vma;
+ }
}
else
{
{
asymbol **newsyms;
unsigned int i;
+ bfd_size_type amt;
- newsyms = (asymbol **) bfd_alloc_by_size_t (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)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
bfd_ptr->outsymbols = newsyms;
for (i = 0; i < symbol_count; i++)
if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
|| (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
- && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_FUNCTION))
- != BSF_GLOBAL)))
+ && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
+ && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
+ || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
+ == 0))))
*newsyms++ = symbol_ptr_ptr[i];
for (i = 0; i < symbol_count; i++)
- if (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
- && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL
- | BSF_NOT_AT_END
- | BSF_FUNCTION))
- == BSF_GLOBAL))
+ if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
+ && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
+ && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
+ || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
+ && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
+ != 0))))
*newsyms++ = symbol_ptr_ptr[i];
*first_undef = newsyms - bfd_ptr->outsymbols;
for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
{
coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
- symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
+ symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
if (coff_symbol_ptr && coff_symbol_ptr->native)
{
combined_entry_type *s = coff_symbol_ptr->native;
/* Modify the symbol values according to their section and
type */
- fixup_symbol_value (coff_symbol_ptr, &(s->u.syment));
+ fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
}
for (i = 0; i < s->u.syment.n_numaux + 1; i++)
s[i].offset = native_index++;
{
/* FIXME: We should use a union here. */
s->u.syment.n_value =
- ((combined_entry_type *) s->u.syment.n_value)->offset;
+ (bfd_vma)((combined_entry_type *)
+ ((unsigned long) s->u.syment.n_value))->offset;
s->fix_value = 0;
}
if (s->fix_line)
if (native->u.syment.n_sclass == C_FILE
&& native->u.syment.n_numaux > 0)
{
- strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
+ unsigned int filnmlen;
+
+ if (bfd_coff_force_symnames_in_strings (abfd))
+ {
+ native->u.syment._n._n_n._n_offset =
+ (*string_size_p + STRING_SIZE_SIZE);
+ native->u.syment._n._n_n._n_zeroes = 0;
+ *string_size_p += 6; /* strlen(".file") + 1 */
+ }
+ else
+ strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
+
auxent = &(native + 1)->u.auxent;
+ filnmlen = bfd_coff_filnmlen (abfd);
+
if (bfd_coff_long_filenames (abfd))
{
- if (name_length <= FILNMLEN)
+ if (name_length <= filnmlen)
{
- strncpy (auxent->x_file.x_fname, name, FILNMLEN);
+ strncpy (auxent->x_file.x_fname, name, filnmlen);
}
else
{
}
else
{
- strncpy (auxent->x_file.x_fname, name, FILNMLEN);
- if (name_length > FILNMLEN)
- {
- name[FILNMLEN] = '\0';
- }
+ strncpy (auxent->x_file.x_fname, name, filnmlen);
+ if (name_length > filnmlen)
+ name[filnmlen] = '\0';
}
}
else
{
- if (name_length <= SYMNMLEN)
+ if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
{
/* This name will fit into the symbol neatly */
strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
}
else
{
- long filepos;
- bfd_byte buf[2];
+ file_ptr filepos;
+ bfd_byte buf[4];
+ int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
/* This name should be written into the .debug section. For
some reason each name is preceded by a two byte length
if (*debug_string_section_p == (asection *) NULL)
*debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
filepos = bfd_tell (abfd);
- bfd_put_16 (abfd, name_length + 1, buf);
+ if (prefix_len == 4)
+ bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
+ else
+ bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
+
if (!bfd_set_section_contents (abfd,
*debug_string_section_p,
(PTR) buf,
(file_ptr) *debug_string_size_p,
- (bfd_size_type) 2)
+ (bfd_size_type) prefix_len)
|| !bfd_set_section_contents (abfd,
*debug_string_section_p,
(PTR) symbol->name,
- ((file_ptr) *debug_string_size_p
- + 2),
+ (file_ptr) (*debug_string_size_p
+ + prefix_len),
(bfd_size_type) name_length + 1))
abort ();
if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
abort ();
- native->u.syment._n._n_n._n_offset = *debug_string_size_p + 2;
+ native->u.syment._n._n_n._n_offset =
+ *debug_string_size_p + prefix_len;
native->u.syment._n._n_n._n_zeroes = 0;
- *debug_string_size_p += name_length + 3;
+ *debug_string_size_p += name_length + 1 + prefix_len;
}
}
}
bfd *abfd;
asymbol *symbol;
combined_entry_type *native;
- unsigned int *written;
+ bfd_vma *written;
bfd_size_type *string_size_p;
asection **debug_string_section_p;
bfd_size_type *debug_string_size_p;
symesz = bfd_coff_symesz (abfd);
buf = bfd_alloc (abfd, symesz);
if (!buf)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ 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);
auxesz = bfd_coff_auxesz (abfd);
buf = bfd_alloc (abfd, auxesz);
if (!buf)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
for (j = 0; j < native->u.syment.n_numaux; j++)
{
bfd_coff_swap_aux_out (abfd,
&((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);
debug_string_section_p, debug_string_size_p)
bfd *abfd;
asymbol *symbol;
- unsigned int *written;
+ bfd_vma *written;
bfd_size_type *string_size_p;
asection **debug_string_section_p;
bfd_size_type *debug_string_size_p;
native->u.syment.n_scnum =
symbol->section->output_section->target_index;
native->u.syment.n_value = (symbol->value
- + symbol->section->output_section->vma
+ symbol->section->output_offset);
+ if (! obj_pe (abfd))
+ native->u.syment.n_value += symbol->section->output_section->vma;
- /* Copy the any flags from the the file header into the symbol.
+ /* Copy the any flags from the file header into the symbol.
FIXME: Why? */
{
coff_symbol_type *c = coff_symbol_from (abfd, symbol);
native->u.syment.n_type = 0;
if (symbol->flags & BSF_LOCAL)
native->u.syment.n_sclass = C_STAT;
+ else if (symbol->flags & BSF_WEAK)
+ native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
else
native->u.syment.n_sclass = C_EXT;
native->u.syment.n_numaux = 0;
debug_string_section_p, debug_string_size_p)
bfd *abfd;
coff_symbol_type *symbol;
- unsigned int *written;
+ bfd_vma *written;
bfd_size_type *string_size_p;
asection **debug_string_section_p;
bfd_size_type *debug_string_size_p;
while (lineno[count].line_number != 0)
{
#if 0
- /* 13 april 92. sac
+ /* 13 april 92. sac
I've been told this, but still need proof:
> The second bug is also in `bfd/coffcode.h'. This bug
> causes the linker to screw up the pc-relocations for
}
symbol->done_lineno = true;
- symbol->symbol.section->output_section->moving_line_filepos +=
- count * bfd_coff_linesz (abfd);
+ if (! bfd_is_const_section (symbol->symbol.section->output_section))
+ symbol->symbol.section->output_section->moving_line_filepos +=
+ count * bfd_coff_linesz (abfd);
}
return coff_write_symbol (abfd, &(symbol->symbol), native, written,
bfd_size_type debug_string_size;
unsigned int i;
unsigned int limit = bfd_get_symcount (abfd);
- unsigned int written = 0;
+ bfd_signed_vma written = 0;
asymbol **p;
string_size = 0;
debug_string_section = NULL;
debug_string_size = 0;
+ /* If this target supports long section names, they must be put into
+ the string table. This is supported by PE. This code must
+ handle section names just as they are handled in
+ coff_write_object_contents. */
+ if (bfd_coff_long_section_names (abfd))
+ {
+ asection *o;
+
+ for (o = abfd->sections; o != NULL; o = o->next)
+ {
+ size_t len;
+
+ len = strlen (o->name);
+ if (len > SCNNMLEN)
+ string_size += len + 1;
+ }
+ }
+
/* Seek to the right place */
if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
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, 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
+ names just as they are handled in coff_write_object_contents. */
+ if (bfd_coff_long_section_names (abfd))
+ {
+ asection *o;
+
+ for (o = abfd->sections; o != NULL; o = o->next)
+ {
+ size_t len;
+
+ len = strlen (o->name);
+ if (len > SCNNMLEN)
+ {
+ if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
+ != len + 1)
+ return false;
+ }
+ }
+ }
+
for (p = abfd->outsymbols, i = 0;
i < limit;
i++, p++)
{
/* This is not a COFF symbol, so it certainly is not a
file name, nor does it go in the .debug section. */
- maxlen = SYMNMLEN;
+ maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
}
else if (bfd_coff_symname_in_debug (abfd,
&c_symbol->native->u.syment))
}
else if (c_symbol->native->u.syment.n_sclass == C_FILE
&& c_symbol->native->u.syment.n_numaux > 0)
- maxlen = FILNMLEN;
+ {
+ if (bfd_coff_force_symnames_in_strings (abfd))
+ {
+ if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
+ return false;
+ }
+ maxlen = bfd_coff_filnmlen (abfd);
+ }
else
- maxlen = SYMNMLEN;
+ maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
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;
}
linesz = bfd_coff_linesz (abfd);
buff = bfd_alloc (abfd, linesz);
if (!buff)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
for (s = abfd->sections; s != (asection *) NULL; s = s->next)
{
if (s->lineno_count)
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++;
}
return true;
}
-/*ARGSUSED */
alent *
coff_get_lineno (ignore_abfd, symbol)
- bfd *ignore_abfd;
+ bfd *ignore_abfd ATTRIBUTE_UNUSED;
asymbol *symbol;
{
return coffsymbol (symbol)->lineno;
}
+#if 0
+
+/* This is only called from coff_add_missing_symbols, which has been
+ disabled. */
+
asymbol *
coff_section_symbol (abfd, name)
bfd *abfd;
combined_entry_type e[10];
};
struct foo *f;
- f = (struct foo *) bfd_alloc_by_size_t (abfd, sizeof (*f));
+ f = (struct foo *) bfd_alloc (abfd, (bfd_size_type) sizeof (*f));
if (!f)
{
bfd_set_error (bfd_error_no_error);
return sym;
}
+#endif /* 0 */
+
/* This function transforms the offsets into the symbol table into
pointers to syments. */
unsigned int indaux;
combined_entry_type *auxent;
{
- int type = symbol->u.syment.n_type;
- int class = symbol->u.syment.n_sclass;
+ unsigned int type = symbol->u.syment.n_type;
+ unsigned int class = symbol->u.syment.n_sclass;
if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
{
/* Otherwise patch up */
#define N_TMASK coff_data (abfd)->local_n_tmask
#define N_BTSHFT coff_data (abfd)->local_n_btshft
- if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK)
+ if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN)
&& auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
{
auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
/* Allocate space for the ".debug" section, and read it.
We did not read the debug section until now, because
- we didn't want to go to the trouble until someone needed it. */
+ we didn't want to go to the trouble until someone needed it. */
static char *
build_debug_section (abfd)
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)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
- /* Seek to the beginning of the `.debug' section and read it.
+ /* Seek to the beginning of the `.debug' section and read it.
Save the current position first; it is needed by our caller.
Then read debug section and reset the file pointer. */
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;
}
-
/* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
\0-terminated, but will not exceed 'maxlen' characters. The copy *will*
be \0-terminated. */
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)
- {
- bfd_set_error (bfd_error_no_memory);
- return (NULL);
- }
+ if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
+ return (NULL);
strncpy (newname, name, len);
newname[len] = '\0';
return newname;
bfd *abfd;
{
bfd_size_type symesz;
- size_t size;
+ bfd_size_type size;
PTR syms;
if (obj_coff_external_syms (abfd) != NULL)
size = obj_raw_syment_count (abfd) * symesz;
- syms = malloc (size);
+ syms = (PTR) bfd_malloc (size);
if (syms == NULL && size != 0)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ 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);
- if (bfd_seek (abfd,
- (obj_sym_filepos (abfd)
- + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd)),
- SEEK_SET) != 0)
+ if (obj_sym_filepos (abfd) == 0)
+ {
+ bfd_set_error (bfd_error_no_symbols);
+ return NULL;
+ }
+
+ 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
}
- strings = malloc (strsize);
- if (strings == NULL)
+ if (strsize < STRING_SIZE_SIZE)
{
- bfd_set_error (bfd_error_no_memory);
+ (*_bfd_error_handler)
+ (_("%s: bad string table size %lu"), bfd_archive_filename (abfd),
+ (unsigned long) strsize);
+ bfd_set_error (bfd_error_bad_value);
return NULL;
}
- if (bfd_read (strings + STRING_SIZE_SIZE,
- strsize - STRING_SIZE_SIZE, 1, abfd)
+ strings = (char *) bfd_malloc (strsize);
+ if (strings == NULL)
+ return NULL;
+
+ 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);
size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
- internal = (combined_entry_type *) bfd_alloc (abfd, size);
+ internal = (combined_entry_type *) bfd_zalloc (abfd, size);
if (internal == NULL && size != 0)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
internal_end = internal + obj_raw_syment_count (abfd);
if (! _bfd_coff_get_external_symbols (abfd))
unsigned int i;
bfd_coff_swap_sym_in (abfd, (PTR) raw_src,
(PTR) & internal_ptr->u.syment);
- internal_ptr->fix_value = 0;
- internal_ptr->fix_tag = 0;
- internal_ptr->fix_end = 0;
- internal_ptr->fix_scnlen = 0;
symbol_ptr = internal_ptr;
for (i = 0;
{
internal_ptr++;
raw_src += symesz;
-
- internal_ptr->fix_value = 0;
- internal_ptr->fix_tag = 0;
- internal_ptr->fix_end = 0;
- internal_ptr->fix_scnlen = 0;
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);
}
else
{
- /* ordinary short filename, put into memory anyway */
- internal_ptr->u.syment._n._n_n._n_offset = (long)
- copy_name (abfd, (internal_ptr + 1)->u.auxent.x_file.x_fname,
- FILNMLEN);
+ /* Ordinary short filename, put into memory anyway. The
+ Microsoft PE tools sometimes store a filename in
+ multiple AUX entries. */
+ if (internal_ptr->u.syment.n_numaux > 1
+ && coff_data (abfd)->pe)
+ {
+ internal_ptr->u.syment._n._n_n._n_offset =
+ ((long)
+ copy_name (abfd,
+ (internal_ptr + 1)->u.auxent.x_file.x_fname,
+ internal_ptr->u.syment.n_numaux * symesz));
+ }
+ else
+ {
+ internal_ptr->u.syment._n._n_n._n_offset =
+ ((long)
+ copy_name (abfd,
+ (internal_ptr + 1)->u.auxent.x_file.x_fname,
+ (size_t) bfd_coff_filnmlen (abfd)));
+ }
}
}
else
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)
- {
- bfd_set_error (bfd_error_no_memory);
- return (NULL);
- } /* on error */
- memset (newstring, 0, i);
- strncpy (newstring, internal_ptr->u.syment._n._n_name, i - 1);
+ newstring = (PTR) bfd_alloc (abfd, (bfd_size_type) (i + 1));
+ if (newstring == NULL)
+ return (NULL);
+ 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)
- {
- bfd_set_error (bfd_error_no_memory);
- return (NULL);
- } /* on error */
+ return (NULL);
memset (new, 0, sizeof *new);
new->symbol.section = 0;
new->native = 0;
asymbol *
coff_bfd_make_debug_symbol (abfd, ptr, sz)
bfd *abfd;
- PTR ptr;
- unsigned long sz;
+ 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)
- {
- bfd_set_error (bfd_error_no_memory);
- return (NULL);
- } /* on error */
- /* @@ This shouldn't be using a constant multiplier. */
- new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
+ return (NULL);
+ /* @@ The 10 is a guess at a plausible maximum number of aux entries
+ (but shouldn't be a constant). */
+ amt = sizeof (combined_entry_type) * 10;
+ new->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
if (!new->native)
- {
- bfd_set_error (bfd_error_no_memory);
- return (NULL);
- } /* on error */
+ return (NULL);
new->symbol.section = bfd_abs_section_ptr;
new->symbol.flags = BSF_DEBUGGING;
new->lineno = (alent *) NULL;
return &new->symbol;
}
-/*ARGSUSED */
void
coff_get_symbol_info (abfd, symbol, ret)
bfd *abfd;
if (coffsymbol (symbol)->native != NULL
&& coffsymbol (symbol)->native->fix_value)
{
- combined_entry_type *psym;
+ ret->value = coffsymbol (symbol)->native->u.syment.n_value -
+ (unsigned long) obj_raw_syments (abfd);
+ }
+}
+
+/* Return the COFF syment for a symbol. */
+
+boolean
+bfd_coff_get_syment (abfd, symbol, psyment)
+ bfd *abfd;
+ asymbol *symbol;
+ struct internal_syment *psyment;
+{
+ coff_symbol_type *csym;
+
+ csym = coff_symbol_from (abfd, symbol);
+ if (csym == NULL || csym->native == NULL)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
+ }
+
+ *psyment = csym->native->u.syment;
+
+ if (csym->native->fix_value)
+ psyment->n_value = psyment->n_value -
+ (unsigned long) obj_raw_syments (abfd);
+
+ /* FIXME: We should handle fix_line here. */
+
+ return true;
+}
+
+/* Return the COFF auxent for a symbol. */
+
+boolean
+bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
+ bfd *abfd;
+ asymbol *symbol;
+ int indx;
+ union internal_auxent *pauxent;
+{
+ coff_symbol_type *csym;
+ combined_entry_type *ent;
+
+ csym = coff_symbol_from (abfd, symbol);
- psym = ((combined_entry_type *)
- coffsymbol (symbol)->native->u.syment.n_value);
- ret->value = (bfd_vma) (psym - obj_raw_syments (abfd));
+ if (csym == NULL
+ || csym->native == NULL
+ || indx >= csym->native->u.syment.n_numaux)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
}
+
+ ent = csym->native + indx + 1;
+
+ *pauxent = ent->u.auxent;
+
+ if (ent->fix_tag)
+ pauxent->x_sym.x_tagndx.l =
+ ((combined_entry_type *) pauxent->x_sym.x_tagndx.p
+ - obj_raw_syments (abfd));
+
+ if (ent->fix_end)
+ pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l =
+ ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p
+ - obj_raw_syments (abfd));
+
+ if (ent->fix_scnlen)
+ pauxent->x_csect.x_scnlen.l =
+ ((combined_entry_type *) pauxent->x_csect.x_scnlen.p
+ - obj_raw_syments (abfd));
+
+ return true;
}
/* Print out information about COFF symbol. */
case bfd_print_symbol_all:
if (coffsymbol (symbol)->native)
{
- unsigned long val;
+ bfd_vma val;
unsigned int aux;
combined_entry_type *combined = coffsymbol (symbol)->native;
combined_entry_type *root = obj_raw_syments (abfd);
fprintf (file, "[%3ld]", (long) (combined - root));
if (! combined->fix_value)
- val = (unsigned long) combined->u.syment.n_value;
+ val = (bfd_vma) combined->u.syment.n_value;
else
- val = ((unsigned long)
- ((combined_entry_type *) combined->u.syment.n_value
- - root));
+ val = combined->u.syment.n_value - (unsigned long) root;
+#ifndef XCOFF64
fprintf (file,
"(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
combined->u.syment.n_scnum,
combined->u.syment.n_type,
combined->u.syment.n_sclass,
combined->u.syment.n_numaux,
+ (unsigned long) val,
+ symbol->name);
+#else
+ /* Print out the wide, 64 bit, symbol value */
+ fprintf (file,
+ "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
+ combined->u.syment.n_scnum,
+ combined->u.syment.n_flags,
+ combined->u.syment.n_type,
+ combined->u.syment.n_sclass,
+ combined->u.syment.n_numaux,
val,
symbol->name);
+#endif
for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
{
(long) auxp->u.auxent.x_scn.x_scnlen,
auxp->u.auxent.x_scn.x_nreloc,
auxp->u.auxent.x_scn.x_nlinno);
+ if (auxp->u.auxent.x_scn.x_checksum != 0
+ || auxp->u.auxent.x_scn.x_associated != 0
+ || auxp->u.auxent.x_scn.x_comdat != 0)
+ fprintf (file, " checksum 0x%lx assoc %d comdat %d",
+ auxp->u.auxent.x_scn.x_checksum,
+ auxp->u.auxent.x_scn.x_associated,
+ auxp->u.auxent.x_scn.x_comdat);
+ break;
+ }
+ /* else fall through */
+ case C_EXT:
+ if (ISFCN (combined->u.syment.n_type))
+ {
+ long next, llnos;
+
+ if (auxp->fix_end)
+ next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
+ - root);
+ else
+ next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
+ llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
+ fprintf (file,
+ "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
+ tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize,
+ llnos, next);
break;
}
/* else fall through */
-
default:
fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
}
else
{
- bfd_print_symbol_vandf ((PTR) file, symbol);
+ bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
fprintf (file, " %-5s %s %s %s",
symbol->section->name,
coffsymbol (symbol)->native ? "n" : "g",
}
}
-/* Provided a BFD, a section and an offset into the section, calculate
- and return the name of the source file and the line nearest to the
- wanted location. */
+/* Return whether a symbol name implies a local symbol. In COFF,
+ local symbols generally start with ``.L''. Most targets use this
+ function for the is_local_label_name entry point, but some may
+ override it. */
+
+boolean
+_bfd_coff_is_local_label_name (abfd, name)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ const char *name;
+{
+ return name[0] == '.' && name[1] == 'L';
+}
+
+/* Provided a BFD, a section and an offset (in bytes, not octets) into the
+ section, calculate and return the name of the source file and the line
+ nearest to the wanted location. */
-/*ARGSUSED*/
boolean
-coff_find_nearest_line (abfd, section, ignore_symbols, offset, filename_ptr,
+coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
functionname_ptr, line_ptr)
bfd *abfd;
asection *section;
- asymbol **ignore_symbols;
+ 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;
unsigned int i;
unsigned int line_base;
coff_data_type *cof = coff_data (abfd);
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. */
+ if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
+ &found, filename_ptr,
+ functionname_ptr, line_ptr,
+ &coff_data(abfd)->line_info))
+ return false;
+
+ if (found)
+ return true;
+
+ /* Also try examining DWARF2 debugging information. */
+ if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
+ filename_ptr, functionname_ptr,
+ line_ptr, 0,
+ &coff_data(abfd)->dwarf2_find_line_info))
+ return true;
*filename_ptr = 0;
*functionname_ptr = 0;
*line_ptr = 0;
/* Don't try and find line numbers in a non coff file */
- if (abfd->xvec->flavour != bfd_target_coff_flavour)
+ if (!bfd_family_coff (abfd))
return false;
if (cof == NULL)
/* Find the first C_FILE symbol. */
p = cof->raw_syments;
+ if (!p)
+ return false;
+
pend = p + cof->raw_syment_count;
while (p < pend)
{
if (p < pend)
{
+ bfd_vma sec_vma;
bfd_vma maxdiff;
/* Look through the C_FILE symbols to find the best one. */
+ sec_vma = bfd_get_section_vma (abfd, section);
*filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
while (1)
}
}
+ /* We use <= MAXDIFF here so that if we get a zero length
+ file, we actually use the next file entry. */
if (p2 < pend
- && offset >= (bfd_vma) p2->u.syment.n_value
- && offset - (bfd_vma) p2->u.syment.n_value < maxdiff)
+ && offset + sec_vma >= (bfd_vma) p2->u.syment.n_value
+ && offset + sec_vma - (bfd_vma) p2->u.syment.n_value <= maxdiff)
{
*filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
- maxdiff = offset - p2->u.syment.n_value;
+ maxdiff = offset + sec_vma - p2->u.syment.n_value;
}
/* Avoid endless loops on erroneous files by ensuring that
we always move forward in the file. */
- if (p - cof->raw_syments >= p->u.syment.n_value)
+ if (p >= cof->raw_syments + p->u.syment.n_value)
break;
p = cof->raw_syments + p->u.syment.n_value;
line_base = 0;
}
- l = §ion->lineno[i];
-
- for (; i < section->lineno_count; i++)
+ if (section->lineno != NULL)
{
- if (l->line_number == 0)
+ bfd_vma last_value = 0;
+
+ l = §ion->lineno[i];
+
+ for (; i < section->lineno_count; i++)
{
- /* Get the symbol this line number points at */
- coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
- if (coff->symbol.value > offset)
- break;
- *functionname_ptr = coff->symbol.name;
- if (coff->native)
+ if (l->line_number == 0)
{
- combined_entry_type *s = coff->native;
- s = s + 1 + s->u.syment.n_numaux;
-
- /* In XCOFF a debugging symbol can follow the function
- symbol. */
- if (s->u.syment.n_scnum == N_DEBUG)
- s = s + 1 + s->u.syment.n_numaux;
-
- /*
- S should now point to the .bf of the function
- */
- if (s->u.syment.n_numaux)
+ /* Get the symbol this line number points at */
+ coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
+ if (coff->symbol.value > offset)
+ break;
+ *functionname_ptr = coff->symbol.name;
+ last_value = coff->symbol.value;
+ if (coff->native)
{
- /*
- The linenumber is stored in the auxent
- */
- union internal_auxent *a = &((s + 1)->u.auxent);
- line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
- *line_ptr = line_base;
+ combined_entry_type *s = coff->native;
+ s = s + 1 + s->u.syment.n_numaux;
+
+ /* In XCOFF a debugging symbol can follow the
+ function symbol. */
+ if (s->u.syment.n_scnum == N_DEBUG)
+ s = s + 1 + s->u.syment.n_numaux;
+
+ /* S should now point to the .bf of the function. */
+ if (s->u.syment.n_numaux)
+ {
+ /* The linenumber is stored in the auxent. */
+ union internal_auxent *a = &((s + 1)->u.auxent);
+ line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
+ *line_ptr = line_base;
+ }
}
}
+ else
+ {
+ if (l->u.offset > offset)
+ break;
+ *line_ptr = l->line_number + line_base - 1;
+ }
+ l++;
}
- else
+
+ /* If we fell off the end of the loop, then assume that this
+ symbol has no line number info. Otherwise, symbols with no
+ line number info get reported with the line number of the
+ last line of the last symbol which does have line number
+ info. We use 0x100 as a slop to account for cases where the
+ last line has executable code. */
+ if (i >= section->lineno_count
+ && last_value != 0
+ && offset - last_value > 0x100)
{
- if (l->u.offset + bfd_get_section_vma (abfd, section) > offset)
- break;
- *line_ptr = l->line_number + line_base - 1;
+ *functionname_ptr = NULL;
+ *line_ptr = 0;
}
- l++;
}
/* Cache the results for the next call. */
- if (sec_data == NULL)
+ 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)
size += abfd->section_count * bfd_coff_scnhsz (abfd);
return size;
}
+
+/* Change the class of a coff symbol held by BFD. */
+boolean
+bfd_coff_set_symbol_class (abfd, symbol, class)
+ bfd * abfd;
+ asymbol * symbol;
+ unsigned int class;
+{
+ coff_symbol_type * csym;
+
+ csym = coff_symbol_from (abfd, symbol);
+ if (csym == NULL)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
+ }
+ else if (csym->native == NULL)
+ {
+ /* This is an alien symbol which no native coff backend data.
+ We cheat here by creating a fake native entry for it and
+ then filling in the class. This code is based on that in
+ coff_write_alien_symbol(). */
+
+ combined_entry_type * native;
+ bfd_size_type amt = sizeof (* native);
+
+ native = (combined_entry_type *) bfd_alloc (abfd, amt);
+ if (native == NULL)
+ return false;
+
+ memset (native, 0, sizeof (* native));
+
+ native->u.syment.n_type = T_NULL;
+ native->u.syment.n_sclass = class;
+
+ if (bfd_is_und_section (symbol->section))
+ {
+ native->u.syment.n_scnum = N_UNDEF;
+ native->u.syment.n_value = symbol->value;
+ }
+ else if (bfd_is_com_section (symbol->section))
+ {
+ native->u.syment.n_scnum = N_UNDEF;
+ native->u.syment.n_value = symbol->value;
+ }
+ else
+ {
+ native->u.syment.n_scnum =
+ symbol->section->output_section->target_index;
+ native->u.syment.n_value = (symbol->value
+ + symbol->section->output_offset);
+ if (! obj_pe (abfd))
+ native->u.syment.n_value += symbol->section->output_section->vma;
+
+ /* Copy the any flags from the file header into the symbol.
+ FIXME: Why? */
+ native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
+ }
+
+ csym->native = native;
+ }
+ else
+ {
+ csym->native->u.syment.n_sclass = class;
+ }
+
+ return true;
+}
projects / deliverable / binutils-gdb.git / blobdiff