| Line 1... |
Line 1... |
/* Support for the generic parts of COFF, for BFD.
|
/* Support for the generic parts of COFF, for BFD.
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
2000, 2001, 2002, 2003, 2004, 2005, 2007
|
2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Written by Cygnus Support.
|
Written by Cygnus Support.
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
| Line 57... |
Line 57... |
bfd_boolean result = TRUE;
|
bfd_boolean result = TRUE;
|
flagword flags;
|
flagword flags;
|
|
|
name = NULL;
|
name = NULL;
|
|
|
/* Handle long section names as in PE. */
|
/* Handle long section names as in PE. On reading, we want to
|
if (bfd_coff_long_section_names (abfd)
|
accept long names if the format permits them at all, regardless
|
|
of the current state of the flag that dictates if we would generate
|
|
them in outputs; this construct checks if that is the case by
|
|
attempting to set the flag, without changing its state; the call
|
|
will fail for formats that do not support long names at all. */
|
|
if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))
|
&& hdr->s_name[0] == '/')
|
&& hdr->s_name[0] == '/')
|
{
|
{
|
char buf[SCNNMLEN];
|
char buf[SCNNMLEN];
|
long strindex;
|
long strindex;
|
char *p;
|
char *p;
|
const char *strings;
|
const char *strings;
|
|
|
|
/* Flag that this BFD uses long names, even though the format might
|
|
expect them to be off by default. This won't directly affect the
|
|
format of any output BFD created from this one, but the information
|
|
can be used to decide what to do. */
|
|
bfd_coff_set_long_section_names (abfd, TRUE);
|
memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
|
memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
|
buf[SCNNMLEN - 1] = '\0';
|
buf[SCNNMLEN - 1] = '\0';
|
strindex = strtol (buf, &p, 10);
|
strindex = strtol (buf, &p, 10);
|
if (*p == '\0' && strindex >= 0)
|
if (*p == '\0' && strindex >= 0)
|
{
|
{
|
| Line 78... |
Line 88... |
return FALSE;
|
return FALSE;
|
/* FIXME: For extra safety, we should make sure that
|
/* FIXME: For extra safety, we should make sure that
|
strindex does not run us past the end, but right now we
|
strindex does not run us past the end, but right now we
|
don't know the length of the string table. */
|
don't know the length of the string table. */
|
strings += strindex;
|
strings += strindex;
|
name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
|
name = (char *) bfd_alloc (abfd,
|
|
(bfd_size_type) strlen (strings) + 1);
|
if (name == NULL)
|
if (name == NULL)
|
return FALSE;
|
return FALSE;
|
strcpy (name, strings);
|
strcpy (name, strings);
|
}
|
}
|
}
|
}
|
|
|
if (name == NULL)
|
if (name == NULL)
|
{
|
{
|
/* Assorted wastage to null-terminate the name, thanks AT&T! */
|
/* Assorted wastage to null-terminate the name, thanks AT&T! */
|
name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1);
|
name = (char *) bfd_alloc (abfd,
|
|
(bfd_size_type) sizeof (hdr->s_name) + 1);
|
if (name == NULL)
|
if (name == NULL)
|
return FALSE;
|
return FALSE;
|
strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
|
strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
|
name[sizeof (hdr->s_name)] = 0;
|
name[sizeof (hdr->s_name)] = 0;
|
}
|
}
|
| Line 183... |
Line 195... |
if (tdata == NULL)
|
if (tdata == NULL)
|
goto fail2;
|
goto fail2;
|
|
|
scnhsz = bfd_coff_scnhsz (abfd);
|
scnhsz = bfd_coff_scnhsz (abfd);
|
readsize = (bfd_size_type) nscns * scnhsz;
|
readsize = (bfd_size_type) nscns * scnhsz;
|
external_sections = bfd_alloc (abfd, readsize);
|
external_sections = (char *) bfd_alloc (abfd, readsize);
|
if (!external_sections)
|
if (!external_sections)
|
goto fail;
|
goto fail;
|
|
|
if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)
|
if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)
|
goto fail;
|
goto fail;
|
| Line 425... |
Line 437... |
relsz = bfd_coff_relsz (abfd);
|
relsz = bfd_coff_relsz (abfd);
|
|
|
amt = sec->reloc_count * relsz;
|
amt = sec->reloc_count * relsz;
|
if (external_relocs == NULL)
|
if (external_relocs == NULL)
|
{
|
{
|
free_external = bfd_malloc (amt);
|
free_external = (bfd_byte *) bfd_malloc (amt);
|
if (free_external == NULL)
|
if (free_external == NULL)
|
goto error_return;
|
goto error_return;
|
external_relocs = free_external;
|
external_relocs = free_external;
|
}
|
}
|
|
|
| Line 439... |
Line 451... |
|
|
if (internal_relocs == NULL)
|
if (internal_relocs == NULL)
|
{
|
{
|
amt = sec->reloc_count;
|
amt = sec->reloc_count;
|
amt *= sizeof (struct internal_reloc);
|
amt *= sizeof (struct internal_reloc);
|
free_internal = bfd_malloc (amt);
|
free_internal = (struct internal_reloc *) bfd_malloc (amt);
|
if (free_internal == NULL)
|
if (free_internal == NULL)
|
goto error_return;
|
goto error_return;
|
internal_relocs = free_internal;
|
internal_relocs = free_internal;
|
}
|
}
|
|
|
| Line 639... |
Line 651... |
asymbol **newsyms;
|
asymbol **newsyms;
|
unsigned int i;
|
unsigned int i;
|
bfd_size_type amt;
|
bfd_size_type amt;
|
|
|
amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
|
amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
|
newsyms = bfd_alloc (bfd_ptr, amt);
|
newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
|
if (!newsyms)
|
if (!newsyms)
|
return FALSE;
|
return FALSE;
|
bfd_ptr->outsymbols = newsyms;
|
bfd_ptr->outsymbols = newsyms;
|
for (i = 0; i < symbol_count; i++)
|
for (i = 0; i < symbol_count; i++)
|
if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
|
if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
|
| Line 900... |
Line 912... |
asection **debug_string_section_p,
|
asection **debug_string_section_p,
|
bfd_size_type *debug_string_size_p)
|
bfd_size_type *debug_string_size_p)
|
{
|
{
|
unsigned int numaux = native->u.syment.n_numaux;
|
unsigned int numaux = native->u.syment.n_numaux;
|
int type = native->u.syment.n_type;
|
int type = native->u.syment.n_type;
|
int class = native->u.syment.n_sclass;
|
int n_sclass = (int) native->u.syment.n_sclass;
|
void * buf;
|
void * buf;
|
bfd_size_type symesz;
|
bfd_size_type symesz;
|
|
|
if (native->u.syment.n_sclass == C_FILE)
|
if (native->u.syment.n_sclass == C_FILE)
|
symbol->flags |= BSF_DEBUGGING;
|
symbol->flags |= BSF_DEBUGGING;
|
| Line 946... |
Line 958... |
return FALSE;
|
return FALSE;
|
for (j = 0; j < native->u.syment.n_numaux; j++)
|
for (j = 0; j < native->u.syment.n_numaux; j++)
|
{
|
{
|
bfd_coff_swap_aux_out (abfd,
|
bfd_coff_swap_aux_out (abfd,
|
&((native + j + 1)->u.auxent),
|
&((native + j + 1)->u.auxent),
|
type, class, (int) j,
|
type, n_sclass, (int) j,
|
native->u.syment.n_numaux,
|
native->u.syment.n_numaux,
|
buf);
|
buf);
|
if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
|
if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
|
return FALSE;
|
return FALSE;
|
}
|
}
|
| Line 1080... |
Line 1092... |
return coff_write_symbol (abfd, &(symbol->symbol), native, written,
|
return coff_write_symbol (abfd, &(symbol->symbol), native, written,
|
string_size_p, debug_string_section_p,
|
string_size_p, debug_string_section_p,
|
debug_string_size_p);
|
debug_string_size_p);
|
}
|
}
|
|
|
|
static void
|
|
null_error_handler (const char * fmt ATTRIBUTE_UNUSED, ...)
|
|
{
|
|
}
|
|
|
/* Write out the COFF symbols. */
|
/* Write out the COFF symbols. */
|
|
|
bfd_boolean
|
bfd_boolean
|
coff_write_symbols (bfd *abfd)
|
coff_write_symbols (bfd *abfd)
|
{
|
{
|
| Line 1136... |
Line 1153... |
&debug_string_size))
|
&debug_string_size))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
else
|
else
|
{
|
{
|
|
if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL)
|
|
{
|
|
bfd_error_handler_type current_error_handler;
|
|
enum coff_symbol_classification sym_class;
|
|
unsigned char *n_sclass;
|
|
|
|
/* Suppress error reporting by bfd_coff_classify_symbol.
|
|
Error messages can be generated when we are processing a local
|
|
symbol which has no associated section and we do not have to
|
|
worry about this, all we need to know is that it is local. */
|
|
current_error_handler = bfd_set_error_handler (null_error_handler);
|
|
sym_class = bfd_coff_classify_symbol (abfd,
|
|
&c_symbol->native->u.syment);
|
|
(void) bfd_set_error_handler (current_error_handler);
|
|
|
|
n_sclass = &c_symbol->native->u.syment.n_sclass;
|
|
|
|
/* If the symbol class has been changed (eg objcopy/ld script/etc)
|
|
we cannot retain the existing sclass from the original symbol.
|
|
Weak symbols only have one valid sclass, so just set it always.
|
|
If it is not local class and should be, set it C_STAT.
|
|
If it is global and not classified as global, or if it is
|
|
weak (which is also classified as global), set it C_EXT. */
|
|
|
|
if (symbol->flags & BSF_WEAK)
|
|
*n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
|
|
else if (symbol->flags & BSF_LOCAL && sym_class != COFF_SYMBOL_LOCAL)
|
|
*n_sclass = C_STAT;
|
|
else if (symbol->flags & BSF_GLOBAL
|
|
&& (sym_class != COFF_SYMBOL_GLOBAL
|
|
#ifdef COFF_WITH_PE
|
|
|| *n_sclass == C_NT_WEAK
|
|
#endif
|
|
|| *n_sclass == C_WEAKEXT))
|
|
c_symbol->native->u.syment.n_sclass = C_EXT;
|
|
}
|
|
|
if (!coff_write_native_symbol (abfd, c_symbol, &written,
|
if (!coff_write_native_symbol (abfd, c_symbol, &written,
|
&string_size, &debug_string_section,
|
&string_size, &debug_string_section,
|
&debug_string_size))
|
&debug_string_size))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
| Line 1337... |
Line 1391... |
combined_entry_type *symbol,
|
combined_entry_type *symbol,
|
unsigned int indaux,
|
unsigned int indaux,
|
combined_entry_type *auxent)
|
combined_entry_type *auxent)
|
{
|
{
|
unsigned int type = symbol->u.syment.n_type;
|
unsigned int type = symbol->u.syment.n_type;
|
unsigned int class = symbol->u.syment.n_sclass;
|
unsigned int n_sclass = symbol->u.syment.n_sclass;
|
|
|
if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
|
if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
|
{
|
{
|
if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
|
if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
|
(abfd, table_base, symbol, indaux, auxent))
|
(abfd, table_base, symbol, indaux, auxent))
|
return;
|
return;
|
}
|
}
|
|
|
/* Don't bother if this is a file or a section. */
|
/* Don't bother if this is a file or a section. */
|
if (class == C_STAT && type == T_NULL)
|
if (n_sclass == C_STAT && type == T_NULL)
|
return;
|
return;
|
if (class == C_FILE)
|
if (n_sclass == C_FILE)
|
return;
|
return;
|
|
|
/* Otherwise patch up. */
|
/* Otherwise patch up. */
|
#define N_TMASK coff_data (abfd)->local_n_tmask
|
#define N_TMASK coff_data (abfd)->local_n_tmask
|
#define N_BTSHFT coff_data (abfd)->local_n_btshft
|
#define N_BTSHFT coff_data (abfd)->local_n_btshft
|
|
|
if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN)
|
if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK
|
|
|| n_sclass == 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.l > 0)
|
{
|
{
|
auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
|
auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
|
table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
|
table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
|
auxent->fix_end = 1;
|
auxent->fix_end = 1;
|
| Line 1393... |
Line 1448... |
bfd_set_error (bfd_error_no_debug_section);
|
bfd_set_error (bfd_error_no_debug_section);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
sec_size = sect->size;
|
sec_size = sect->size;
|
debug_section = bfd_alloc (abfd, sec_size);
|
debug_section = (char *) bfd_alloc (abfd, sec_size);
|
if (debug_section == NULL)
|
if (debug_section == NULL)
|
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.
|
Save the current position first; it is needed by our caller.
|
| Line 1423... |
Line 1478... |
|
|
for (len = 0; len < maxlen; ++len)
|
for (len = 0; len < maxlen; ++len)
|
if (name[len] == '\0')
|
if (name[len] == '\0')
|
break;
|
break;
|
|
|
if ((newname = bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
|
if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
|
return NULL;
|
return NULL;
|
|
|
strncpy (newname, name, len);
|
strncpy (newname, name, len);
|
newname[len] = '\0';
|
newname[len] = '\0';
|
return newname;
|
return newname;
|
| Line 1518... |
Line 1573... |
(_("%B: bad string table size %lu"), abfd, (unsigned long) strsize);
|
(_("%B: bad string table size %lu"), abfd, (unsigned long) strsize);
|
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
strings = bfd_malloc (strsize);
|
strings = (char *) bfd_malloc (strsize);
|
if (strings == NULL)
|
if (strings == NULL)
|
return NULL;
|
return NULL;
|
|
|
if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
|
if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
|
!= strsize - STRING_SIZE_SIZE)
|
!= strsize - STRING_SIZE_SIZE)
|
| Line 1577... |
Line 1632... |
|
|
if (obj_raw_syments (abfd) != NULL)
|
if (obj_raw_syments (abfd) != NULL)
|
return obj_raw_syments (abfd);
|
return obj_raw_syments (abfd);
|
|
|
size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
|
size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
|
internal = bfd_zalloc (abfd, size);
|
internal = (combined_entry_type *) bfd_zalloc (abfd, size);
|
if (internal == NULL && size != 0)
|
if (internal == NULL && size != 0)
|
return NULL;
|
return NULL;
|
internal_end = internal + obj_raw_syment_count (abfd);
|
internal_end = internal + obj_raw_syment_count (abfd);
|
|
|
if (! _bfd_coff_get_external_symbols (abfd))
|
if (! _bfd_coff_get_external_symbols (abfd))
|
| Line 1683... |
Line 1738... |
that isn't ours. */
|
that isn't ours. */
|
for (i = 0; i < 8; ++i)
|
for (i = 0; i < 8; ++i)
|
if (internal_ptr->u.syment._n._n_name[i] == '\0')
|
if (internal_ptr->u.syment._n._n_name[i] == '\0')
|
break;
|
break;
|
|
|
newstring = bfd_zalloc (abfd, (bfd_size_type) (i + 1));
|
newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
|
if (newstring == NULL)
|
if (newstring == NULL)
|
return NULL;
|
return NULL;
|
strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
|
strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
|
internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
|
internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
|
internal_ptr->u.syment._n._n_n._n_zeroes = 0;
|
internal_ptr->u.syment._n._n_n._n_zeroes = 0;
|
| Line 1741... |
Line 1796... |
|
|
asymbol *
|
asymbol *
|
coff_make_empty_symbol (bfd *abfd)
|
coff_make_empty_symbol (bfd *abfd)
|
{
|
{
|
bfd_size_type amt = sizeof (coff_symbol_type);
|
bfd_size_type amt = sizeof (coff_symbol_type);
|
coff_symbol_type *new = bfd_zalloc (abfd, amt);
|
coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
|
|
|
if (new == NULL)
|
if (new_symbol == NULL)
|
return NULL;
|
return NULL;
|
new->symbol.section = 0;
|
new_symbol->symbol.section = 0;
|
new->native = 0;
|
new_symbol->native = 0;
|
new->lineno = NULL;
|
new_symbol->lineno = NULL;
|
new->done_lineno = FALSE;
|
new_symbol->done_lineno = FALSE;
|
new->symbol.the_bfd = abfd;
|
new_symbol->symbol.the_bfd = abfd;
|
|
|
return & new->symbol;
|
return & new_symbol->symbol;
|
}
|
}
|
|
|
/* Make a debugging symbol. */
|
/* Make a debugging symbol. */
|
|
|
asymbol *
|
asymbol *
|
coff_bfd_make_debug_symbol (bfd *abfd,
|
coff_bfd_make_debug_symbol (bfd *abfd,
|
void * ptr ATTRIBUTE_UNUSED,
|
void * ptr ATTRIBUTE_UNUSED,
|
unsigned long sz ATTRIBUTE_UNUSED)
|
unsigned long sz ATTRIBUTE_UNUSED)
|
{
|
{
|
bfd_size_type amt = sizeof (coff_symbol_type);
|
bfd_size_type amt = sizeof (coff_symbol_type);
|
coff_symbol_type *new = bfd_alloc (abfd, amt);
|
coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
|
|
|
if (new == NULL)
|
if (new_symbol == NULL)
|
return NULL;
|
return NULL;
|
/* @@ The 10 is a guess at a plausible maximum number of aux entries
|
/* @@ The 10 is a guess at a plausible maximum number of aux entries
|
(but shouldn't be a constant). */
|
(but shouldn't be a constant). */
|
amt = sizeof (combined_entry_type) * 10;
|
amt = sizeof (combined_entry_type) * 10;
|
new->native = bfd_zalloc (abfd, amt);
|
new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
|
if (!new->native)
|
if (!new_symbol->native)
|
return NULL;
|
return NULL;
|
new->symbol.section = bfd_abs_section_ptr;
|
new_symbol->symbol.section = bfd_abs_section_ptr;
|
new->symbol.flags = BSF_DEBUGGING;
|
new_symbol->symbol.flags = BSF_DEBUGGING;
|
new->lineno = NULL;
|
new_symbol->lineno = NULL;
|
new->done_lineno = FALSE;
|
new_symbol->done_lineno = FALSE;
|
new->symbol.the_bfd = abfd;
|
new_symbol->symbol.the_bfd = abfd;
|
|
|
return & new->symbol;
|
return & new_symbol->symbol;
|
}
|
}
|
|
|
void
|
void
|
coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
|
coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
|
{
|
{
|
| Line 1906... |
Line 1961... |
combined->u.syment.n_scnum,
|
combined->u.syment.n_scnum,
|
combined->u.syment.n_flags,
|
combined->u.syment.n_flags,
|
combined->u.syment.n_type,
|
combined->u.syment.n_type,
|
combined->u.syment.n_sclass,
|
combined->u.syment.n_sclass,
|
combined->u.syment.n_numaux);
|
combined->u.syment.n_numaux);
|
#ifdef BFD64
|
bfd_fprintf_vma (abfd, file, val);
|
/* fprintf_vma() on a 64-bit enabled host will always print a 64-bit
|
|
value, but really we want to display the address in the target's
|
|
address size. Since we do not have a field in the bfd structure
|
|
to tell us this, we take a guess, based on the target's name. */
|
|
if (strstr (bfd_get_target (abfd), "64") == NULL)
|
|
fprintf (file, "%08lx", (unsigned long) (val & 0xffffffff));
|
|
else
|
|
#endif
|
|
fprintf_vma (file, val);
|
|
fprintf (file, " %s", symbol->name);
|
fprintf (file, " %s", symbol->name);
|
|
|
for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
|
for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
|
{
|
{
|
combined_entry_type *auxp = combined + aux + 1;
|
combined_entry_type *auxp = combined + aux + 1;
|
| Line 1944... |
Line 1990... |
case C_STAT:
|
case C_STAT:
|
if (combined->u.syment.n_type == T_NULL)
|
if (combined->u.syment.n_type == T_NULL)
|
/* Probably a section symbol ? */
|
/* Probably a section symbol ? */
|
{
|
{
|
fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
|
fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
|
(long) auxp->u.auxent.x_scn.x_scnlen,
|
(unsigned long) auxp->u.auxent.x_scn.x_scnlen,
|
auxp->u.auxent.x_scn.x_nreloc,
|
auxp->u.auxent.x_scn.x_nreloc,
|
auxp->u.auxent.x_scn.x_nlinno);
|
auxp->u.auxent.x_scn.x_nlinno);
|
if (auxp->u.auxent.x_scn.x_checksum != 0
|
if (auxp->u.auxent.x_scn.x_checksum != 0
|
|| auxp->u.auxent.x_scn.x_associated != 0
|
|| auxp->u.auxent.x_scn.x_associated != 0
|
|| auxp->u.auxent.x_scn.x_comdat != 0)
|
|| auxp->u.auxent.x_scn.x_comdat != 0)
|
| Line 1958... |
Line 2004... |
auxp->u.auxent.x_scn.x_comdat);
|
auxp->u.auxent.x_scn.x_comdat);
|
break;
|
break;
|
}
|
}
|
/* Otherwise fall through. */
|
/* Otherwise fall through. */
|
case C_EXT:
|
case C_EXT:
|
|
case C_AIX_WEAKEXT:
|
if (ISFCN (combined->u.syment.n_type))
|
if (ISFCN (combined->u.syment.n_type))
|
{
|
{
|
long next, llnos;
|
long next, llnos;
|
|
|
if (auxp->fix_end)
|
if (auxp->fix_end)
|
| Line 1970... |
Line 2017... |
else
|
else
|
next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
|
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;
|
llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
|
fprintf (file,
|
fprintf (file,
|
"AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
|
"AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
|
tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize,
|
tagndx,
|
|
(unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
|
llnos, next);
|
llnos, next);
|
break;
|
break;
|
}
|
}
|
/* Otherwise fall through. */
|
/* Otherwise fall through. */
|
default:
|
default:
|
| Line 1996... |
Line 2044... |
fprintf (file, "\n%s :", l->u.sym->name);
|
fprintf (file, "\n%s :", l->u.sym->name);
|
l++;
|
l++;
|
while (l->line_number)
|
while (l->line_number)
|
{
|
{
|
fprintf (file, "\n%4d : ", l->line_number);
|
fprintf (file, "\n%4d : ", l->line_number);
|
fprintf_vma (file, l->u.offset + symbol->section->vma);
|
bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma);
|
l++;
|
l++;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
| Line 2142... |
Line 2190... |
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Now wander though the raw linenumbers of the section. */
|
/* Now wander though the raw linenumbers of the section. */
|
/* If we have been called on this section before, and th. e offset we
|
/* If we have been called on this section before, and the offset we
|
want is further down then we can prime the lookup loop. */
|
want is further down then we can prime the lookup loop. */
|
sec_data = coff_section_data (abfd, section);
|
sec_data = coff_section_data (abfd, section);
|
if (sec_data != NULL
|
if (sec_data != NULL
|
&& sec_data->i > 0
|
&& sec_data->i > 0
|
&& offset >= sec_data->offset)
|
&& offset >= sec_data->offset)
|
| Line 2229... |
Line 2277... |
sec_data = (struct coff_section_tdata *) section->used_by_bfd;
|
sec_data = (struct coff_section_tdata *) section->used_by_bfd;
|
}
|
}
|
if (sec_data != NULL)
|
if (sec_data != NULL)
|
{
|
{
|
sec_data->offset = offset;
|
sec_data->offset = offset;
|
sec_data->i = i;
|
sec_data->i = i - 1;
|
sec_data->function = *functionname_ptr;
|
sec_data->function = *functionname_ptr;
|
sec_data->line_base = line_base;
|
sec_data->line_base = line_base;
|
}
|
}
|
|
|
return TRUE;
|
return TRUE;
|
| Line 2270... |
Line 2318... |
/* Change the class of a coff symbol held by BFD. */
|
/* Change the class of a coff symbol held by BFD. */
|
|
|
bfd_boolean
|
bfd_boolean
|
bfd_coff_set_symbol_class (bfd * abfd,
|
bfd_coff_set_symbol_class (bfd * abfd,
|
asymbol * symbol,
|
asymbol * symbol,
|
unsigned int class)
|
unsigned int symbol_class)
|
{
|
{
|
coff_symbol_type * csym;
|
coff_symbol_type * csym;
|
|
|
csym = coff_symbol_from (abfd, symbol);
|
csym = coff_symbol_from (abfd, symbol);
|
if (csym == NULL)
|
if (csym == NULL)
|
| Line 2290... |
Line 2338... |
coff_write_alien_symbol(). */
|
coff_write_alien_symbol(). */
|
|
|
combined_entry_type * native;
|
combined_entry_type * native;
|
bfd_size_type amt = sizeof (* native);
|
bfd_size_type amt = sizeof (* native);
|
|
|
native = bfd_zalloc (abfd, amt);
|
native = (combined_entry_type *) bfd_zalloc (abfd, amt);
|
if (native == NULL)
|
if (native == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
native->u.syment.n_type = T_NULL;
|
native->u.syment.n_type = T_NULL;
|
native->u.syment.n_sclass = class;
|
native->u.syment.n_sclass = symbol_class;
|
|
|
if (bfd_is_und_section (symbol->section))
|
if (bfd_is_und_section (symbol->section))
|
{
|
{
|
native->u.syment.n_scnum = N_UNDEF;
|
native->u.syment.n_scnum = N_UNDEF;
|
native->u.syment.n_value = symbol->value;
|
native->u.syment.n_value = symbol->value;
|
| Line 2324... |
Line 2372... |
}
|
}
|
|
|
csym->native = native;
|
csym->native = native;
|
}
|
}
|
else
|
else
|
csym->native->u.syment.n_sclass = class;
|
csym->native->u.syment.n_sclass = symbol_class;
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
struct coff_comdat_info *
|
struct coff_comdat_info *
|
