/* Support for the generic parts of COFF, for BFD.
- Copyright (C) 1990-2021 Free Software Foundation, Inc.
+ Copyright (C) 1990-2024 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
#include "libbfd.h"
#include "coff/internal.h"
#include "libcoff.h"
+#include "hashtab.h"
+
+/* Extract a long section name at STRINDEX and copy it to the bfd objstack.
+ Return NULL in case of error. */
+
+static char *
+extract_long_section_name(bfd *abfd, unsigned long strindex)
+{
+ const char *strings;
+ char *name;
+
+ strings = _bfd_coff_read_string_table (abfd);
+ if (strings == NULL)
+ return NULL;
+ if ((bfd_size_type)(strindex + 2) >= obj_coff_strings_len (abfd))
+ return NULL;
+ strings += strindex;
+ name = (char *) bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
+ if (name == NULL)
+ return NULL;
+ strcpy (name, strings);
+
+ return name;
+}
+
+/* Decode a base 64 coded string at STR of length LEN, and write the result
+ to RES. Return true on success.
+ Return false in case of invalid character or overflow. */
+
+static bool
+decode_base64 (const char *str, unsigned len, uint32_t *res)
+{
+ unsigned i;
+ uint32_t val;
+
+ val = 0;
+ for (i = 0; i < len; i++)
+ {
+ char c = str[i];
+ unsigned d;
+
+ if (c >= 'A' && c <= 'Z')
+ d = c - 'A';
+ else if (c >= 'a' && c <= 'z')
+ d = c - 'a' + 26;
+ else if (c >= '0' && c <= '9')
+ d = c - '0' + 52;
+ else if (c == '+')
+ d = 62;
+ else if (c == '/')
+ d = 63;
+ else
+ return false;
+
+ /* Check for overflow. */
+ if ((val >> 26) != 0)
+ return false;
+
+ val = (val << 6) + d;
+ }
+
+ *res = val;
+ return true;
+}
/* Take a section header read from a coff file (in HOST byte order),
and make a BFD "section" out of it. This is used by ECOFF. */
struct internal_scnhdr *hdr,
unsigned int target_index)
{
- asection *return_section;
+ asection *newsect;
char *name;
bool result = true;
flagword flags;
if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))
&& hdr->s_name[0] == '/')
{
- char buf[SCNNMLEN];
- long strindex;
- char *p;
- 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);
- buf[SCNNMLEN - 1] = '\0';
- strindex = strtol (buf, &p, 10);
- if (*p == '\0' && strindex >= 0)
+
+ if (hdr->s_name[1] == '/')
{
- strings = _bfd_coff_read_string_table (abfd);
- if (strings == NULL)
- return false;
- if ((bfd_size_type)(strindex + 2) >= obj_coff_strings_len (abfd))
+ /* LLVM extension: the '/' is followed by another '/' and then by
+ the index in the strtab encoded in base64 without NUL at the
+ end. */
+ uint32_t strindex;
+
+ /* Decode the index. No overflow is expected as the string table
+ length is at most 2^32 - 1 (the length is written on the first
+ four bytes).
+ Also, contrary to RFC 4648, all the characters must be decoded,
+ there is no padding. */
+ if (!decode_base64 (hdr->s_name + 2, SCNNMLEN - 2, &strindex))
return false;
- strings += strindex;
- name = (char *) bfd_alloc (abfd,
- (bfd_size_type) strlen (strings) + 1 + 1);
+
+ name = extract_long_section_name (abfd, strindex);
if (name == NULL)
return false;
- strcpy (name, strings);
+ }
+ else
+ {
+ /* PE classic long section name. The '/' is followed by the index
+ in the strtab. The index is formatted as a decimal string. */
+ char buf[SCNNMLEN];
+ long strindex;
+ char *p;
+
+ memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
+ buf[SCNNMLEN - 1] = '\0';
+ strindex = strtol (buf, &p, 10);
+ if (*p == '\0' && strindex >= 0)
+ {
+ name = extract_long_section_name (abfd, strindex);
+ if (name == NULL)
+ return false;
+ }
}
}
name[sizeof (hdr->s_name)] = 0;
}
- return_section = bfd_make_section_anyway (abfd, name);
- if (return_section == NULL)
+ newsect = bfd_make_section_anyway (abfd, name);
+ if (newsect == NULL)
return false;
- return_section->vma = hdr->s_vaddr;
- return_section->lma = hdr->s_paddr;
- return_section->size = hdr->s_size;
- return_section->filepos = hdr->s_scnptr;
- return_section->rel_filepos = hdr->s_relptr;
- return_section->reloc_count = hdr->s_nreloc;
+ newsect->vma = hdr->s_vaddr;
+ newsect->lma = hdr->s_paddr;
+ newsect->size = hdr->s_size;
+ newsect->filepos = hdr->s_scnptr;
+ newsect->rel_filepos = hdr->s_relptr;
+ newsect->reloc_count = hdr->s_nreloc;
- bfd_coff_set_alignment_hook (abfd, return_section, hdr);
+ bfd_coff_set_alignment_hook (abfd, newsect, hdr);
- return_section->line_filepos = hdr->s_lnnoptr;
+ newsect->line_filepos = hdr->s_lnnoptr;
- return_section->lineno_count = hdr->s_nlnno;
- return_section->userdata = NULL;
- return_section->next = NULL;
- return_section->target_index = target_index;
+ newsect->lineno_count = hdr->s_nlnno;
+ newsect->userdata = NULL;
+ newsect->next = NULL;
+ newsect->target_index = target_index;
- if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
- & flags))
+ if (!bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, newsect, &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)
- return_section->lineno_count = 0;
+ if ((flags & SEC_COFF_SHARED_LIBRARY) != 0)
+ newsect->lineno_count = 0;
if (hdr->s_nreloc != 0)
- return_section->flags |= SEC_RELOC;
+ flags |= SEC_RELOC;
/* FIXME: should this check 'hdr->s_size > 0'. */
if (hdr->s_scnptr != 0)
- return_section->flags |= SEC_HAS_CONTENTS;
+ flags |= SEC_HAS_CONTENTS;
+
+ newsect->flags = flags;
- /* Compress/decompress DWARF debug sections with names: .debug_* and
- .zdebug_*, after the section flags is set. */
- if ((flags & SEC_DEBUGGING)
- && strlen (name) > 7
- && ((name[1] == 'd' && name[6] == '_')
- || (strlen (name) > 8 && name[1] == 'z' && name[7] == '_')))
+ /* Compress/decompress DWARF debug sections. */
+ if ((flags & SEC_DEBUGGING) != 0
+ && (flags & SEC_HAS_CONTENTS) != 0
+ && (startswith (name, ".debug_")
+ || startswith (name, ".zdebug_")
+ || startswith (name, ".gnu.debuglto_.debug_")
+ || startswith (name, ".gnu.linkonce.wi.")))
{
enum { nothing, compress, decompress } action = nothing;
- char *new_name = NULL;
- if (bfd_is_section_compressed (abfd, return_section))
+ if (bfd_is_section_compressed (abfd, newsect))
{
/* Compressed section. Check if we should decompress. */
if ((abfd->flags & BFD_DECOMPRESS))
action = decompress;
}
- else if (!bfd_is_section_compressed (abfd, return_section))
+ else
{
/* Normal section. Check if we should compress. */
- if ((abfd->flags & BFD_COMPRESS) && return_section->size != 0)
+ if ((abfd->flags & BFD_COMPRESS) && newsect->size != 0)
action = compress;
}
- switch (action)
+ if (action == compress)
{
- case nothing:
- break;
- case compress:
- if (!bfd_init_section_compress_status (abfd, return_section))
+ if (!bfd_init_section_compress_status (abfd, newsect))
{
_bfd_error_handler
- /* xgettext: c-format */
- (_("%pB: unable to initialize compress status for section %s"),
- abfd, name);
+ /* xgettext:c-format */
+ (_("%pB: unable to compress section %s"), abfd, name);
return false;
}
- if (return_section->compress_status == COMPRESS_SECTION_DONE)
- {
- if (name[1] != 'z')
- {
- unsigned int len = strlen (name);
-
- new_name = bfd_alloc (abfd, len + 2);
- if (new_name == NULL)
- return false;
- new_name[0] = '.';
- new_name[1] = 'z';
- memcpy (new_name + 2, name + 1, len);
- }
- }
- break;
- case decompress:
- if (!bfd_init_section_decompress_status (abfd, return_section))
+ }
+ else if (action == decompress)
+ {
+ if (!bfd_init_section_decompress_status (abfd, newsect))
{
_bfd_error_handler
- /* xgettext: c-format */
- (_("%pB: unable to initialize decompress status for section %s"),
- abfd, name);
+ /* xgettext:c-format */
+ (_("%pB: unable to decompress section %s"), abfd, name);
return false;
}
- if (name[1] == 'z')
+ if (abfd->is_linker_input
+ && name[1] == 'z')
{
- unsigned int len = strlen (name);
-
- new_name = bfd_alloc (abfd, len);
+ /* Rename section from .zdebug_* to .debug_* so that ld
+ scripts will see this section as a debug section. */
+ char *new_name = bfd_zdebug_name_to_debug (abfd, name);
if (new_name == NULL)
return false;
- new_name[0] = '.';
- memcpy (new_name + 1, name + 2, len - 1);
+ bfd_rename_section (newsect, new_name);
}
- break;
}
- if (new_name != NULL)
- bfd_rename_section (return_section, new_name);
}
return result;
}
+void
+coff_object_cleanup (bfd *abfd)
+{
+ struct coff_tdata *td = coff_data (abfd);
+ if (td != NULL)
+ {
+ if (td->section_by_index)
+ htab_delete (td->section_by_index);
+ if (td->section_by_target_index)
+ htab_delete (td->section_by_target_index);
+ if (obj_pe (abfd) && pe_data (abfd)->comdat_hash)
+ htab_delete (pe_data (abfd)->comdat_hash);
+ }
+}
+
/* Read in a COFF object and make it into a BFD. This is used by
ECOFF as well. */
bfd_cleanup
-coff_real_object_p (bfd *,
- unsigned,
- struct internal_filehdr *,
- struct internal_aouthdr *);
-bfd_cleanup
coff_real_object_p (bfd *abfd,
unsigned nscns,
struct internal_filehdr *internal_f,
}
_bfd_coff_free_symbols (abfd);
- return _bfd_no_cleanup;
+ return coff_object_cleanup;
fail:
+ coff_object_cleanup (abfd);
_bfd_coff_free_symbols (abfd);
bfd_release (abfd, tdata);
fail2:
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
+ only read in f_opthdr bytes in the call to bfd_read. 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)
: (struct internal_aouthdr *) NULL));
}
+static hashval_t
+htab_hash_section_target_index (const void * entry)
+{
+ const struct bfd_section * sec = entry;
+ return sec->target_index;
+}
+
+static int
+htab_eq_section_target_index (const void * e1, const void * e2)
+{
+ const struct bfd_section * sec1 = e1;
+ const struct bfd_section * sec2 = e2;
+ return sec1->target_index == sec2->target_index;
+}
+
/* Get the BFD section from a COFF symbol section number. */
asection *
coff_section_from_bfd_index (bfd *abfd, int section_index)
{
- struct bfd_section *answer = abfd->sections;
-
if (section_index == N_ABS)
return bfd_abs_section_ptr;
if (section_index == N_UNDEF)
if (section_index == N_DEBUG)
return bfd_abs_section_ptr;
- while (answer)
+ struct bfd_section *answer;
+ htab_t table = coff_data (abfd)->section_by_target_index;
+
+ if (!table)
{
- if (answer->target_index == section_index)
- return answer;
- answer = answer->next;
+ table = htab_create (10, htab_hash_section_target_index,
+ htab_eq_section_target_index, NULL);
+ if (table == NULL)
+ return bfd_und_section_ptr;
+ coff_data (abfd)->section_by_target_index = table;
+ }
+
+ if (htab_elements (table) == 0)
+ {
+ for (answer = abfd->sections; answer; answer = answer->next)
+ {
+ void **slot = htab_find_slot (table, answer, INSERT);
+ if (slot == NULL)
+ return bfd_und_section_ptr;
+ *slot = answer;
+ }
}
+ struct bfd_section needle;
+ needle.target_index = section_index;
+
+ answer = htab_find (table, &needle);
+ if (answer != NULL)
+ return answer;
+
+ /* Cover the unlikely case of sections added after the first call to
+ this function. */
+ for (answer = abfd->sections; answer; answer = answer->next)
+ if (answer->target_index == section_index)
+ {
+ void **slot = htab_find_slot (table, answer, INSERT);
+ if (slot != NULL)
+ *slot = answer;
+ return answer;
+ }
+
/* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
has a bad symbol table in biglitpow.o. */
return bfd_und_section_ptr;
if (strings == NULL)
return NULL;
}
- /* PR 17910: Only check for string overflow if the length has been set.
- Some DLLs, eg those produced by Visual Studio, may not set the length field. */
- if (obj_coff_strings_len (abfd) > 0
- && sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))
+ if (sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))
return NULL;
return strings + sym->_n._n_n._n_offset;
}
}
if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
- || bfd_bread (external_relocs, amt, abfd) != amt)
+ || bfd_read (external_relocs, amt, abfd) != amt)
goto error_return;
if (internal_relocs == NULL)
{
asymbol *q_maybe = *p;
- if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
+ if (bfd_asymbol_bfd (q_maybe) != NULL
+ && bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
{
coff_symbol_type *q = coffsymbol (q_maybe);
{
/* FIXME: We should use a union here. */
s->u.syment.n_value =
- (bfd_hostptr_t) ((combined_entry_type *)
- ((bfd_hostptr_t) s->u.syment.n_value))->offset;
+ (uintptr_t) ((combined_entry_type *)
+ (uintptr_t) s->u.syment.n_value)->offset;
s->fix_value = 0;
}
if (s->fix_line)
BFD_ASSERT (! a->is_sym);
if (a->fix_tag)
{
- a->u.auxent.x_sym.x_tagndx.l =
+ a->u.auxent.x_sym.x_tagndx.u32 =
a->u.auxent.x_sym.x_tagndx.p->offset;
a->fix_tag = 0;
}
if (a->fix_end)
{
- a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
+ a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32 =
a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
a->fix_end = 0;
}
if (a->fix_scnlen)
{
- a->u.auxent.x_csect.x_scnlen.l =
+ a->u.auxent.x_csect.x_scnlen.u64 =
a->u.auxent.x_csect.x_scnlen.p->offset;
a->fix_scnlen = 0;
}
}
}
-static void
+static bool
coff_write_auxent_fname (bfd *abfd,
char *str,
union internal_auxent *auxent,
- bfd_size_type *string_size_p)
+ struct bfd_strtab_hash *strtab,
+ bool hash)
{
unsigned int str_length = strlen (str);
unsigned int filnmlen = bfd_coff_filnmlen (abfd);
strncpy (auxent->x_file.x_n.x_fname, str, filnmlen);
else
{
- auxent->x_file.x_n.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
+ bfd_size_type indx = _bfd_stringtab_add (strtab, str, hash, false);
+
+ if (indx == (bfd_size_type) -1)
+ return false;
+
+ auxent->x_file.x_n.x_n.x_offset = STRING_SIZE_SIZE + indx;
auxent->x_file.x_n.x_n.x_zeroes = 0;
- *string_size_p += str_length + 1;
}
}
else
if (str_length > filnmlen)
str[filnmlen] = '\0';
}
+
+ return true;
}
-static void
+static bool
coff_fix_symbol_name (bfd *abfd,
asymbol *symbol,
combined_entry_type *native,
- bfd_size_type *string_size_p,
+ struct bfd_strtab_hash *strtab,
+ bool hash,
asection **debug_string_section_p,
bfd_size_type *debug_string_size_p)
{
unsigned int name_length;
char *name = (char *) (symbol->name);
+ bfd_size_type indx;
if (name == NULL)
{
{
if (bfd_coff_force_symnames_in_strings (abfd))
{
- native->u.syment._n._n_n._n_offset =
- (*string_size_p + STRING_SIZE_SIZE);
+ indx = _bfd_stringtab_add (strtab, ".file", hash, false);
+ if (indx == (bfd_size_type) -1)
+ return false;
+
+ native->u.syment._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
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);
BFD_ASSERT (! (native + 1)->is_sym);
- coff_write_auxent_fname (abfd, name, &(native + 1)->u.auxent,
- string_size_p);
+ if (!coff_write_auxent_fname (abfd, name, &(native + 1)->u.auxent,
+ strtab, hash))
+ return false;
}
else
{
else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
{
- native->u.syment._n._n_n._n_offset = (*string_size_p
- + STRING_SIZE_SIZE);
+ indx = _bfd_stringtab_add (strtab, name, hash, false);
+ if (indx == (bfd_size_type) -1)
+ return false;
+
+ native->u.syment._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
native->u.syment._n._n_n._n_zeroes = 0;
- *string_size_p += name_length + 1;
}
else
{
*debug_string_size_p += name_length + 1 + prefix_len;
}
}
+
+ return true;
}
/* We need to keep track of the symbol index so that when we write out
asymbol *symbol,
combined_entry_type *native,
bfd_vma *written,
- bfd_size_type *string_size_p,
+ struct bfd_strtab_hash *strtab,
+ bool hash,
asection **debug_string_section_p,
bfd_size_type *debug_string_size_p)
{
native->u.syment.n_scnum =
output_section->target_index;
- coff_fix_symbol_name (abfd, symbol, native, string_size_p,
- debug_string_section_p, debug_string_size_p);
+ if (!coff_fix_symbol_name (abfd, symbol, native, strtab, hash,
+ debug_string_section_p, debug_string_size_p))
+ return false;
symesz = bfd_coff_symesz (abfd);
buf = bfd_alloc (abfd, symesz);
if (!buf)
return false;
bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
- if (bfd_bwrite (buf, symesz, abfd) != symesz)
+ if (bfd_write (buf, symesz, abfd) != symesz)
return false;
bfd_release (abfd, buf);
/* Adjust auxent only if this isn't the filename
auxiliary entry. */
if (native->u.syment.n_sclass == C_FILE
- && (native + j + 1)->u.auxent.x_file.x_ftype)
+ && (native + j + 1)->u.auxent.x_file.x_ftype
+ && (native + j + 1)->extrap)
coff_write_auxent_fname (abfd, (char *) (native + j + 1)->extrap,
- &(native + j + 1)->u.auxent, string_size_p);
+ &(native + j + 1)->u.auxent, strtab, hash);
bfd_coff_swap_aux_out (abfd,
&((native + j + 1)->u.auxent),
type, n_sclass, (int) j,
native->u.syment.n_numaux,
buf);
- if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
+ if (bfd_write (buf, auxesz, abfd) != auxesz)
return false;
}
bfd_release (abfd, buf);
coff_write_alien_symbol (bfd *abfd,
asymbol *symbol,
struct internal_syment *isym,
- union internal_auxent *iaux,
bfd_vma *written,
- bfd_size_type *string_size_p,
+ struct bfd_strtab_hash *strtab,
+ bool hash,
asection **debug_string_section_p,
bfd_size_type *debug_string_size_p)
{
memset (isym, 0, sizeof (*isym));
return true;
}
+ memset (dummy, 0, sizeof dummy);
native = dummy;
native->is_sym = true;
native[1].is_sym = false;
else
native->u.syment.n_sclass = C_EXT;
- ret = coff_write_symbol (abfd, symbol, native, written, string_size_p,
+ ret = coff_write_symbol (abfd, symbol, native, written, strtab, hash,
debug_string_section_p, debug_string_size_p);
if (isym != NULL)
*isym = native->u.syment;
- if (iaux != NULL && native->u.syment.n_numaux)
- *iaux = native[1].u.auxent;
return ret;
}
coff_write_native_symbol (bfd *abfd,
coff_symbol_type *symbol,
bfd_vma *written,
- bfd_size_type *string_size_p,
+ struct bfd_strtab_hash *strtab,
asection **debug_string_section_p,
bfd_size_type *debug_string_size_p)
{
}
return coff_write_symbol (abfd, &(symbol->symbol), native, written,
- string_size_p, debug_string_section_p,
+ strtab, true, debug_string_section_p,
debug_string_size_p);
}
bool
coff_write_symbols (bfd *abfd)
{
- bfd_size_type string_size;
+ struct bfd_strtab_hash *strtab;
asection *debug_string_section;
bfd_size_type debug_string_size;
unsigned int i;
bfd_vma written = 0;
asymbol **p;
- string_size = 0;
debug_string_section = NULL;
debug_string_size = 0;
+ strtab = _bfd_stringtab_init ();
+ if (strtab == NULL)
+ return false;
+
/* 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. */
+ coff_write_object_contents. This is why we pass hash as FALSE below. */
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;
- }
+ if (strlen (o->name) > SCNNMLEN
+ && _bfd_stringtab_add (strtab, o->name, false, false)
+ == (bfd_size_type) -1)
+ return false;
}
/* Seek to the right place. */
if (c_symbol == (coff_symbol_type *) NULL
|| c_symbol->native == (combined_entry_type *) NULL)
{
- if (!coff_write_alien_symbol (abfd, symbol, NULL, NULL, &written,
- &string_size, &debug_string_section,
+ if (!coff_write_alien_symbol (abfd, symbol, NULL, &written,
+ strtab, true, &debug_string_section,
&debug_string_size))
return false;
}
}
if (!coff_write_native_symbol (abfd, c_symbol, &written,
- &string_size, &debug_string_section,
+ strtab, &debug_string_section,
&debug_string_size))
return false;
}
obj_raw_syment_count (abfd) = written;
- /* Now write out strings. */
- if (string_size != 0)
- {
- unsigned int size = string_size + STRING_SIZE_SIZE;
- bfd_byte buffer[STRING_SIZE_SIZE];
+ /* Now write out strings.
+
+ We would normally not write anything here if there are no strings, but
+ we'll write out 4 so that any stupid coff reader which tries to read the
+ string table even when there isn't one won't croak. */
+ {
+ bfd_byte buffer[STRING_SIZE_SIZE];
#if STRING_SIZE_SIZE == 4
- H_PUT_32 (abfd, size, buffer);
+ H_PUT_32 (abfd, _bfd_stringtab_size (strtab) + STRING_SIZE_SIZE, buffer);
#else
#error Change H_PUT_32
#endif
- if (bfd_bwrite ((void *) 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++)
- {
- asymbol *q = *p;
- size_t name_length = strlen (q->name);
- coff_symbol_type *c_symbol = coff_symbol_from (q);
- size_t maxlen;
- bool is_c_file = false;
-
- /* Figure out whether the symbol name should go in the string
- table. Symbol names that are short enough are stored
- directly in the syment structure. File names permit a
- different, longer, length in the syment structure. On
- XCOFF, some symbol names are stored in the .debug section
- rather than in the string table. */
-
- if (c_symbol == NULL
- || c_symbol->native == NULL)
- /* This is not a COFF symbol, so it certainly is not a
- file name, nor does it go in the .debug section. */
- maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
-
- else if (! c_symbol->native->is_sym)
- maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
-
- else if (bfd_coff_symname_in_debug (abfd,
- &c_symbol->native->u.syment))
- /* This symbol name is in the XCOFF .debug section.
- Don't write it into the string table. */
- maxlen = name_length;
-
- else if (c_symbol->native->u.syment.n_sclass == C_FILE
- && c_symbol->native->u.syment.n_numaux > 0)
- {
- is_c_file=true;
- 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 = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
-
- if (name_length > maxlen)
- {
- if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1,
- abfd) != name_length + 1)
- return false;
- }
-
- /* Add strings for C_FILE aux entries. */
- if (is_c_file
- && c_symbol->native->u.syment.n_numaux > 1)
- {
- for (int j = 1; j < c_symbol->native->u.syment.n_numaux; j++)
- {
- char *str;
- size_t str_length;
-
- /* Add strings from aux entries only if this isn't the
- filename auxiliary entry. */
- if (!c_symbol->native[j + 1].u.auxent.x_file.x_ftype)
- continue;
-
- if (c_symbol->native[j + 1].u.auxent.x_file.x_n.x_fname[0] != 0)
- continue;
-
- str = (char *) c_symbol->native[j + 1].extrap;
- str_length = strlen (str);
- if (str_length > maxlen)
- {
- if (bfd_bwrite ((void *) (str), (bfd_size_type) str_length + 1,
- abfd) != str_length + 1)
- return false;
- }
+ if (bfd_write (buffer, sizeof (buffer), abfd) != sizeof (buffer))
+ return false;
- }
- }
- }
- }
- else
- {
- /* We would normally not write anything here, but we'll write
- out 4 so that any stupid coff reader which tries to read the
- string table even when there isn't one won't croak. */
- unsigned int size = STRING_SIZE_SIZE;
- bfd_byte buffer[STRING_SIZE_SIZE];
+ if (! _bfd_stringtab_emit (abfd, strtab))
+ return false;
+ }
-#if STRING_SIZE_SIZE == 4
- H_PUT_32 (abfd, size, buffer);
-#else
- #error Change H_PUT_32
-#endif
- if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
- != STRING_SIZE_SIZE)
- return false;
- }
+ _bfd_stringtab_free (strtab);
/* Make sure the .debug section was created to be the correct size.
We should create it ourselves on the fly, but we don't because
out.l_lnno = 0;
out.l_addr.l_symndx = l->u.offset;
bfd_coff_swap_lineno_out (abfd, &out, buff);
- if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
- != linesz)
+ if (bfd_write (buff, 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_bwrite (buff, (bfd_size_type) linesz, abfd)
- != linesz)
+ if (bfd_write (buff, linesz, abfd) != linesz)
return false;
l++;
}
combined_entry_type *table_base,
combined_entry_type *symbol,
unsigned int indaux,
- combined_entry_type *auxent,
- combined_entry_type *table_end)
+ combined_entry_type *auxent)
{
unsigned int type = symbol->u.syment.n_type;
unsigned int n_sclass = symbol->u.syment.n_sclass;
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
- < (long) obj_raw_syment_count (abfd)
- && table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l
- < table_end)
+ && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32 > 0
+ && (auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32
+ < obj_raw_syment_count (abfd)))
{
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.u32;
auxent->fix_end = 1;
}
/* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
generate one, so we must be careful to ignore it. */
- if ((unsigned long) auxent->u.auxent.x_sym.x_tagndx.l
- < obj_raw_syment_count (abfd)
- && table_base + auxent->u.auxent.x_sym.x_tagndx.l < table_end)
+ if (auxent->u.auxent.x_sym.x_tagndx.u32 < obj_raw_syment_count (abfd))
{
auxent->u.auxent.x_sym.x_tagndx.p =
- table_base + auxent->u.auxent.x_sym.x_tagndx.l;
+ table_base + auxent->u.auxent.x_sym.x_tagndx.u32;
auxent->fix_tag = 1;
}
}
return NULL;
sec_size = sect->size;
- debug_section = (char *) _bfd_alloc_and_read (abfd, sec_size, sec_size);
+ debug_section = (char *) _bfd_alloc_and_read (abfd, sec_size + 1, sec_size);
if (debug_section == NULL)
return NULL;
+ debug_section[sec_size] = 0;
if (bfd_seek (abfd, position, SEEK_SET) != 0)
return NULL;
size_t symesz;
size_t size;
void * syms;
+ ufile_ptr filesize;
if (obj_coff_external_syms (abfd) != NULL)
return true;
if (size == 0)
return true;
+ filesize = bfd_get_file_size (abfd);
+ if (filesize != 0
+ && ((ufile_ptr) obj_sym_filepos (abfd) > filesize
+ || size > filesize - obj_sym_filepos (abfd)))
+ {
+ bfd_set_error (bfd_error_file_truncated);
+ return false;
+ }
+
if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
return false;
syms = _bfd_malloc_and_read (abfd, size, size);
if (bfd_seek (abfd, pos + size, SEEK_SET) != 0)
return NULL;
- if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
- != sizeof extstrsize)
+ if (bfd_read (extstrsize, sizeof extstrsize, abfd) != sizeof extstrsize)
{
if (bfd_get_error () != bfd_error_file_truncated)
return NULL;
they are zero. */
memset (strings, 0, STRING_SIZE_SIZE);
- if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
+ if (bfd_read (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
!= strsize - STRING_SIZE_SIZE)
{
free (strings);
{
combined_entry_type *internal;
combined_entry_type *internal_ptr;
- combined_entry_type *symbol_ptr;
- combined_entry_type *internal_end;
size_t symesz;
char *raw_src;
char *raw_end;
internal = (combined_entry_type *) bfd_zalloc (abfd, size);
if (internal == NULL && size != 0)
return NULL;
- internal_end = internal + obj_raw_syment_count (abfd);
raw_src = (char *) obj_coff_external_syms (abfd);
bfd_coff_swap_sym_in (abfd, (void *) raw_src,
(void *) & internal_ptr->u.syment);
- symbol_ptr = internal_ptr;
internal_ptr->is_sym = true;
+ combined_entry_type *sym = internal_ptr;
/* PR 17512: Prevent buffer overrun. */
- if (symbol_ptr->u.syment.n_numaux > ((raw_end - 1) - raw_src) / symesz)
- {
- bfd_release (abfd, internal);
- return NULL;
- }
+ if (sym->u.syment.n_numaux > ((raw_end - 1) - raw_src) / symesz)
+ return NULL;
- for (i = 0;
- i < symbol_ptr->u.syment.n_numaux;
- i++)
+ for (i = 0; i < sym->u.syment.n_numaux; i++)
{
internal_ptr++;
raw_src += symesz;
bfd_coff_swap_aux_in (abfd, (void *) raw_src,
- symbol_ptr->u.syment.n_type,
- symbol_ptr->u.syment.n_sclass,
- (int) i, symbol_ptr->u.syment.n_numaux,
+ sym->u.syment.n_type,
+ sym->u.syment.n_sclass,
+ (int) i, sym->u.syment.n_numaux,
&(internal_ptr->u.auxent));
internal_ptr->is_sym = false;
- coff_pointerize_aux (abfd, internal, symbol_ptr, i,
- internal_ptr, internal_end);
+ coff_pointerize_aux (abfd, internal, sym, i, internal_ptr);
}
- }
-
- /* Free the raw symbols. */
- if (obj_coff_external_syms (abfd) != NULL
- && ! obj_coff_keep_syms (abfd))
- {
- free (obj_coff_external_syms (abfd));
- obj_coff_external_syms (abfd) = NULL;
- }
- for (internal_ptr = internal; internal_ptr < internal_end;
- internal_ptr++)
- {
- BFD_ASSERT (internal_ptr->is_sym);
-
- if (internal_ptr->u.syment.n_sclass == C_FILE
- && internal_ptr->u.syment.n_numaux > 0)
+ if (sym->u.syment.n_sclass == C_FILE
+ && sym->u.syment.n_numaux > 0)
{
- combined_entry_type * aux = internal_ptr + 1;
+ combined_entry_type * aux = sym + 1;
/* Make a file symbol point to the name in the auxent, since
the text ".file" is redundant. */
return NULL;
}
- if ((bfd_size_type)(aux->u.auxent.x_file.x_n.x_n.x_offset)
+ if ((bfd_size_type) aux->u.auxent.x_file.x_n.x_n.x_offset
>= obj_coff_strings_len (abfd))
- internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
+ sym->u.syment._n._n_n._n_offset =
+ (uintptr_t) _("<corrupt>");
else
- internal_ptr->u.syment._n._n_n._n_offset =
- (bfd_hostptr_t) (string_table + (aux->u.auxent.x_file.x_n.x_n.x_offset));
+ sym->u.syment._n._n_n._n_offset =
+ (uintptr_t) (string_table
+ + aux->u.auxent.x_file.x_n.x_n.x_offset);
}
else
{
/* 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 =
- (bfd_hostptr_t)
- copy_name (abfd,
- aux->u.auxent.x_file.x_n.x_fname,
- internal_ptr->u.syment.n_numaux * symesz);
+ size_t len;
+ char *src;
+ if (sym->u.syment.n_numaux > 1 && obj_pe (abfd))
+ {
+ len = sym->u.syment.n_numaux * symesz;
+ src = raw_src - (len - symesz);
+ }
else
- internal_ptr->u.syment._n._n_n._n_offset =
- ((bfd_hostptr_t)
- copy_name (abfd,
- aux->u.auxent.x_file.x_n.x_fname,
- (size_t) bfd_coff_filnmlen (abfd)));
+ {
+ len = bfd_coff_filnmlen (abfd);
+ src = aux->u.auxent.x_file.x_n.x_fname;
+ }
+ sym->u.syment._n._n_n._n_offset =
+ (uintptr_t) copy_name (abfd, src, len);
}
/* Normalize other strings available in C_FILE aux entries. */
- if (!coff_data (abfd)->pe)
- for (int numaux = 1; numaux < internal_ptr->u.syment.n_numaux; numaux++)
+ if (!obj_pe (abfd))
+ for (int numaux = 1;
+ numaux < sym->u.syment.n_numaux;
+ numaux++)
{
- aux = internal_ptr + numaux + 1;
+ aux = sym + numaux + 1;
BFD_ASSERT (! aux->is_sym);
if (aux->u.auxent.x_file.x_n.x_n.x_zeroes == 0)
{
- /* The string information is a long one, point into the string table. */
+ /* The string information is a long one, point
+ into the string table. */
if (string_table == NULL)
{
string_table = _bfd_coff_read_string_table (abfd);
return NULL;
}
- if ((bfd_size_type)(aux->u.auxent.x_file.x_n.x_n.x_offset)
+ if ((bfd_size_type) aux->u.auxent.x_file.x_n.x_n.x_offset
>= obj_coff_strings_len (abfd))
- aux->u.auxent.x_file.x_n.x_n.x_offset = (bfd_hostptr_t) _("<corrupt>");
+ aux->u.auxent.x_file.x_n.x_n.x_offset =
+ (uintptr_t) _("<corrupt>");
else
aux->u.auxent.x_file.x_n.x_n.x_offset =
- (bfd_hostptr_t) (string_table + (aux->u.auxent.x_file.x_n.x_n.x_offset));
+ (uintptr_t) (string_table
+ + aux->u.auxent.x_file.x_n.x_n.x_offset);
}
else
aux->u.auxent.x_file.x_n.x_n.x_offset =
- ((bfd_hostptr_t)
+ ((uintptr_t)
copy_name (abfd,
aux->u.auxent.x_file.x_n.x_fname,
- (size_t) bfd_coff_filnmlen (abfd)));
+ bfd_coff_filnmlen (abfd)));
}
}
else
{
- if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
+ if (sym->u.syment._n._n_n._n_zeroes != 0)
{
/* This is a "short" name. Make it long. */
- 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')
+ for (i = 0; i < SYMNMLEN; ++i)
+ if (sym->u.syment._n._n_name[i] == '\0')
break;
- newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
+ newstring = bfd_alloc (abfd, i + 1);
if (newstring == NULL)
return NULL;
- 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_zeroes = 0;
+ memcpy (newstring, sym->u.syment._n._n_name, i);
+ newstring[i] = 0;
+ sym->u.syment._n._n_n._n_offset = (uintptr_t) newstring;
+ sym->u.syment._n._n_n._n_zeroes = 0;
}
- else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
- internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
- else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
+ else if (sym->u.syment._n._n_n._n_offset == 0)
+ sym->u.syment._n._n_n._n_offset = (uintptr_t) "";
+ else if (!bfd_coff_symname_in_debug (abfd, &sym->u.syment))
{
/* Long name already. Point symbol at the string in the
table. */
if (string_table == NULL)
return NULL;
}
- if (internal_ptr->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd)
- || string_table + internal_ptr->u.syment._n._n_n._n_offset < string_table)
- internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
+ if (sym->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd))
+ sym->u.syment._n._n_n._n_offset =
+ (uintptr_t) _("<corrupt>");
else
- internal_ptr->u.syment._n._n_n._n_offset =
- ((bfd_hostptr_t)
- (string_table
- + internal_ptr->u.syment._n._n_n._n_offset));
+ sym->u.syment._n._n_n._n_offset =
+ (uintptr_t) (string_table
+ + sym->u.syment._n._n_n._n_offset);
}
else
{
/* Long name in debug section. Very similar. */
if (debug_sec_data == NULL)
- debug_sec_data = build_debug_section (abfd, & debug_sec);
- if (debug_sec_data != NULL)
{
- BFD_ASSERT (debug_sec != NULL);
- /* PR binutils/17512: Catch out of range offsets into the debug data. */
- if (internal_ptr->u.syment._n._n_n._n_offset > debug_sec->size
- || debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset < debug_sec_data)
- internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
- else
- internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t)
- (debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset);
+ debug_sec_data = build_debug_section (abfd, &debug_sec);
+ if (debug_sec_data == NULL)
+ return NULL;
}
+ /* PR binutils/17512: Catch out of range offsets into
+ the debug data. */
+ if (sym->u.syment._n._n_n._n_offset >= debug_sec->size)
+ sym->u.syment._n._n_n._n_offset =
+ (uintptr_t) _("<corrupt>");
else
- internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
+ sym->u.syment._n._n_n._n_offset =
+ (uintptr_t) (debug_sec_data
+ + sym->u.syment._n._n_n._n_offset);
}
}
- internal_ptr += internal_ptr->u.syment.n_numaux;
+ }
+
+ /* Free the raw symbols. */
+ if (obj_coff_external_syms (abfd) != NULL
+ && ! obj_coff_keep_syms (abfd))
+ {
+ free (obj_coff_external_syms (abfd));
+ obj_coff_external_syms (abfd) = NULL;
}
obj_raw_syments (abfd) = internal;
BFD_ASSERT (obj_raw_syment_count (abfd)
- == (unsigned int) (internal_ptr - internal));
+ == (size_t) (internal_ptr - internal));
return internal;
}
long
coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
{
- if (bfd_get_format (abfd) != bfd_object)
+ size_t count, raw;
+
+ count = asect->reloc_count;
+ if (count >= LONG_MAX / sizeof (arelent *)
+ || _bfd_mul_overflow (count, bfd_coff_relsz (abfd), &raw))
{
- bfd_set_error (bfd_error_invalid_operation);
+ bfd_set_error (bfd_error_file_too_big);
return -1;
}
-#if SIZEOF_LONG == SIZEOF_INT
- if (asect->reloc_count >= LONG_MAX / sizeof (arelent *))
+ if (!bfd_write_p (abfd))
{
- bfd_set_error (bfd_error_file_too_big);
- return -1;
+ ufile_ptr filesize = bfd_get_file_size (abfd);
+ if (filesize != 0 && raw > filesize)
+ {
+ bfd_set_error (bfd_error_file_truncated);
+ return -1;
+ }
}
-#endif
- return (asect->reloc_count + 1L) * sizeof (arelent *);
+ return (count + 1) * sizeof (arelent *);
}
asymbol *
/* Make a debugging symbol. */
asymbol *
-coff_bfd_make_debug_symbol (bfd *abfd,
- void * ptr ATTRIBUTE_UNUSED,
- unsigned long sz ATTRIBUTE_UNUSED)
+coff_bfd_make_debug_symbol (bfd *abfd)
{
size_t amt = sizeof (coff_symbol_type);
coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
if (coffsymbol (symbol)->native != NULL
&& coffsymbol (symbol)->native->fix_value
&& coffsymbol (symbol)->native->is_sym)
- ret->value =
- ((coffsymbol (symbol)->native->u.syment.n_value -
- (bfd_hostptr_t) obj_raw_syments (abfd))
- / sizeof (combined_entry_type));
+ ret->value
+ = (((uintptr_t) coffsymbol (symbol)->native->u.syment.n_value
+ - (uintptr_t) obj_raw_syments (abfd))
+ / sizeof (combined_entry_type));
}
/* Print out information about COFF symbol. */
if (! combined->fix_value)
val = (bfd_vma) combined->u.syment.n_value;
else
- val = ((combined->u.syment.n_value - (bfd_hostptr_t) root)
+ val = (((uintptr_t) combined->u.syment.n_value - (uintptr_t) root)
/ sizeof (combined_entry_type));
- fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
+ fprintf (file, "(sec %2d)(fl 0x%02x)(ty %4x)(scl %3d) (nx %d) 0x",
combined->u.syment.n_scnum,
combined->u.syment.n_flags,
combined->u.syment.n_type,
if (auxp->fix_tag)
tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
else
- tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
+ tagndx = auxp->u.auxent.x_sym.x_tagndx.u32;
fprintf (file, "\n");
break;
case C_DWARF:
- fprintf (file, "AUX scnlen 0x%lx nreloc %ld",
- (unsigned long) auxp->u.auxent.x_sect.x_scnlen,
+ fprintf (file, "AUX scnlen %#" PRIx64 " nreloc %" PRId64,
+ auxp->u.auxent.x_sect.x_scnlen,
auxp->u.auxent.x_sect.x_nreloc);
break;
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",
+ fprintf (file, " checksum 0x%x 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);
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;
+ next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32;
llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
fprintf (file,
"AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
}
if (sec_data != NULL && sec_data->saved_bias)
- bias = sec_data->saved_bias;
+ bias = sec_data->bias;
else if (symbols)
{
bias = _bfd_dwarf2_find_symbol_bias (symbols,
record indicating that if the weak symbol is not resolved,
another external symbol is used instead. */
struct coff_link_hash_entry *h2 =
- h->auxbfd->tdata.coff_obj_data->sym_hashes[
- h->aux->x_sym.x_tagndx.l];
+ h->auxbfd->tdata.coff_obj_data->sym_hashes
+ [h->aux->x_sym.x_tagndx.u32];
if (h2 && h2->root.type != bfd_link_hash_undefined)
return h2->root.u.def.section;
}
bool
-_bfd_coff_close_and_cleanup (bfd *abfd)
+_bfd_coff_free_cached_info (bfd *abfd)
{
- struct coff_tdata *tdata = coff_data (abfd);
+ struct coff_tdata *tdata;
- if (tdata != NULL)
+ if (bfd_family_coff (abfd)
+ && (bfd_get_format (abfd) == bfd_object
+ || bfd_get_format (abfd) == bfd_core)
+ && (tdata = coff_data (abfd)) != NULL)
{
+ if (tdata->section_by_index)
+ {
+ htab_delete (tdata->section_by_index);
+ tdata->section_by_index = NULL;
+ }
+
+ if (tdata->section_by_target_index)
+ {
+ htab_delete (tdata->section_by_target_index);
+ tdata->section_by_target_index = NULL;
+ }
+
+ if (obj_pe (abfd) && pe_data (abfd)->comdat_hash)
+ {
+ htab_delete (pe_data (abfd)->comdat_hash);
+ pe_data (abfd)->comdat_hash = NULL;
+ }
+
+ _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
+ _bfd_stab_cleanup (abfd, &tdata->line_info);
+
/* PR 25447:
Do not clear the keep_syms and keep_strings flags.
These may have been set by pe_ILF_build_a_bfd() indicating
that the syms and strings pointers are not to be freed. */
- if (bfd_get_format (abfd) == bfd_object
- && bfd_family_coff (abfd)
- && !_bfd_coff_free_symbols (abfd))
+ if (!_bfd_coff_free_symbols (abfd))
return false;
-
- if (bfd_get_format (abfd) == bfd_object
- || bfd_get_format (abfd) == bfd_core)
- _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
}
- return _bfd_generic_close_and_cleanup (abfd);
+
+ return _bfd_generic_bfd_free_cached_info (abfd);
}
projects / thirdparty / binutils-gdb.git / blobdiff