X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fmerge.c;h=0c6f7a10d3d8c67946e26be3880d1f2e1c75e531;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=eb8ec667ead44ca0cc5e57b6e40c2c1866ffc80d;hpb=eea6121ac0cb22524c627017191ca09825e3d702;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/merge.c b/bfd/merge.c index eb8ec667ea..0c6f7a10d3 100644 --- a/bfd/merge.c +++ b/bfd/merge.c @@ -1,12 +1,12 @@ /* SEC_MERGE support. - Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 2001-2020 Free Software Foundation, Inc. Written by Jakub Jelinek . This file is part of BFD, the Binary File Descriptor library. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,13 +16,17 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + /* This file contains support for merging duplicate entities within sections, as used in ELF SHF_MERGE. */ -#include "bfd.h" #include "sysdep.h" +#include +#include "bfd.h" +#include "elf-bfd.h" #include "libbfd.h" #include "hashtab.h" #include "libiberty.h" @@ -105,7 +109,8 @@ sec_merge_hash_newfunc (struct bfd_hash_entry *entry, /* Allocate the structure if it has not already been allocated by a subclass. */ if (entry == NULL) - entry = bfd_hash_allocate (table, sizeof (struct sec_merge_hash_entry)); + entry = (struct bfd_hash_entry *) + bfd_hash_allocate (table, sizeof (struct sec_merge_hash_entry)); if (entry == NULL) return NULL; @@ -132,12 +137,12 @@ static struct sec_merge_hash_entry * sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string, unsigned int alignment, bfd_boolean create) { - register const unsigned char *s; - register unsigned long hash; - register unsigned int c; + const unsigned char *s; + unsigned long hash; + unsigned int c; struct sec_merge_hash_entry *hashp; unsigned int len, i; - unsigned int index; + unsigned int _index; hash = 0; len = 0; @@ -188,8 +193,8 @@ sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string, len = table->entsize; } - index = hash % table->table.size; - for (hashp = (struct sec_merge_hash_entry *) table->table.table[index]; + _index = hash % table->table.size; + for (hashp = (struct sec_merge_hash_entry *) table->table.table[_index]; hashp != NULL; hashp = (struct sec_merge_hash_entry *) hashp->root.next) { @@ -217,16 +222,11 @@ sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string, return NULL; hashp = ((struct sec_merge_hash_entry *) - sec_merge_hash_newfunc (NULL, &table->table, string)); + bfd_hash_insert (&table->table, string, hash)); if (hashp == NULL) return NULL; - hashp->root.string = string; - hashp->root.hash = hash; hashp->len = len; hashp->alignment = alignment; - hashp->root.next = table->table.table[index]; - table->table.table[index] = (struct bfd_hash_entry *) hashp; - return hashp; } @@ -237,11 +237,12 @@ sec_merge_init (unsigned int entsize, bfd_boolean strings) { struct sec_merge_hash *table; - table = bfd_malloc (sizeof (struct sec_merge_hash)); + table = (struct sec_merge_hash *) bfd_malloc (sizeof (struct sec_merge_hash)); if (table == NULL) return NULL; - if (! bfd_hash_table_init (&table->table, sec_merge_hash_newfunc)) + if (! bfd_hash_table_init_n (&table->table, sec_merge_hash_newfunc, + sizeof (struct sec_merge_hash_entry), 16699)) { free (table); return NULL; @@ -263,7 +264,7 @@ static struct sec_merge_hash_entry * sec_merge_add (struct sec_merge_hash *tab, const char *str, unsigned int alignment, struct sec_merge_sec_info *secinfo) { - register struct sec_merge_hash_entry *entry; + struct sec_merge_hash_entry *entry; entry = sec_merge_hash_lookup (tab, str, alignment, TRUE); if (entry == NULL) @@ -284,44 +285,75 @@ sec_merge_add (struct sec_merge_hash *tab, const char *str, } static bfd_boolean -sec_merge_emit (bfd *abfd, struct sec_merge_hash_entry *entry) +sec_merge_emit (bfd *abfd, struct sec_merge_hash_entry *entry, + unsigned char *contents, file_ptr offset) { struct sec_merge_sec_info *secinfo = entry->secinfo; asection *sec = secinfo->sec; - char *pad = ""; + char *pad = NULL; bfd_size_type off = 0; - int alignment_power = sec->output_section->alignment_power; + unsigned int opb = bfd_octets_per_byte (abfd, sec); + int alignment_power = sec->output_section->alignment_power * opb; + bfd_size_type pad_len; /* Octets. */ + + /* FIXME: If alignment_power is 0 then really we should scan the + entry list for the largest required alignment and use that. */ + pad_len = alignment_power ? ((bfd_size_type) 1 << alignment_power) : 16; - if (alignment_power) - pad = bfd_zmalloc ((bfd_size_type) 1 << alignment_power); + pad = (char *) bfd_zmalloc (pad_len); + if (pad == NULL) + return FALSE; for (; entry != NULL && entry->secinfo == secinfo; entry = entry->next) { - register const char *str; - register size_t len; + const char *str; + bfd_size_type len; - len = off & (entry->alignment - 1); - if (len) + len = -off & (entry->alignment - 1); + if (len != 0) { - len = entry->alignment - len; - if (bfd_bwrite (pad, len, abfd) != len) - break; + BFD_ASSERT (len <= pad_len); + if (contents) + { + memcpy (contents + offset, pad, len); + offset += len; + } + else if (bfd_bwrite (pad, len, abfd) != len) + goto err; off += len; } str = entry->root.string; len = entry->len; - if (bfd_bwrite (str, len, abfd) != len) - break; + if (contents) + { + memcpy (contents + offset, str, len); + offset += len; + } + else if (bfd_bwrite (str, len, abfd) != len) + goto err; off += len; } - if (alignment_power) - free (pad); + /* Trailing alignment needed? */ + off = sec->size - off; + if (off != 0) + { + BFD_ASSERT (off <= pad_len); + if (contents) + memcpy (contents + offset, pad, off); + else if (bfd_bwrite (pad, off, abfd) != off) + goto err; + } + + free (pad); + return TRUE; - return entry == NULL || entry->secinfo != secinfo; + err: + free (pad); + return FALSE; } /* Register a SEC_MERGE section as a candidate for merging. @@ -333,8 +365,11 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec, { struct sec_merge_info *sinfo; struct sec_merge_sec_info *secinfo; - unsigned int align; + unsigned int alignment_power; /* Octets. */ + unsigned int align; /* Octets. */ bfd_size_type amt; + bfd_byte *contents; + unsigned int opb = bfd_octets_per_byte (abfd, sec); if ((abfd->flags & DYNAMIC) != 0 || (sec->flags & SEC_MERGE) == 0) @@ -345,18 +380,28 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec, || sec->entsize == 0) return TRUE; + if (sec->size % sec->entsize != 0) + return TRUE; + if ((sec->flags & SEC_RELOC) != 0) { /* We aren't prepared to handle relocations in merged sections. */ return TRUE; } - align = sec->alignment_power; - if ((sec->entsize < (unsigned) 1 << align +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + alignment_power = sec->alignment_power * opb; + if (alignment_power >= sizeof (align) * CHAR_BIT) + return TRUE; + + align = 1u << alignment_power; + if ((sec->entsize < align && ((sec->entsize & (sec->entsize - 1)) || !(sec->flags & SEC_STRINGS))) - || (sec->entsize > (unsigned) 1 << align - && (sec->entsize & (((unsigned) 1 << align) - 1)))) + || (sec->entsize > align + && (sec->entsize & (align - 1)))) { /* Sanity check. If string character size is smaller than alignment, then we require character size to be a power @@ -378,7 +423,8 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec, if (sinfo == NULL) { /* Initialize the information we need to keep track of. */ - sinfo = bfd_alloc (abfd, sizeof (struct sec_merge_info)); + sinfo = (struct sec_merge_info *) + bfd_alloc (abfd, sizeof (struct sec_merge_info)); if (sinfo == NULL) goto error_return; sinfo->next = (struct sec_merge_info *) *psinfo; @@ -391,7 +437,12 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec, /* Read the section from abfd. */ - amt = sizeof (struct sec_merge_sec_info) + sec->size - 1; + amt = sizeof (struct sec_merge_sec_info) - 1 + sec->size; + if (sec->flags & SEC_STRINGS) + /* Some versions of gcc may emit a string without a zero terminator. + See http://gcc.gnu.org/ml/gcc-patches/2006-06/msg01004.html + Allocate space for an extra zero. */ + amt += sec->entsize; *psecinfo = bfd_alloc (abfd, amt); if (*psecinfo == NULL) goto error_return; @@ -411,8 +462,10 @@ _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec, secinfo->first_str = NULL; sec->rawsize = sec->size; - if (! bfd_get_section_contents (sec->owner, sec, secinfo->contents, - 0, sec->size)) + if (sec->flags & SEC_STRINGS) + memset (secinfo->contents + sec->size, 0, sec->entsize); + contents = secinfo->contents; + if (! bfd_get_full_section_contents (sec->owner, sec, &contents)) goto error_return; return TRUE; @@ -446,7 +499,8 @@ record_section (struct sec_merge_info *sinfo, eltalign = ((eltalign ^ (eltalign - 1)) + 1) >> 1; if (!eltalign || eltalign > mask) eltalign = mask + 1; - entry = sec_merge_add (sinfo->htab, p, (unsigned) eltalign, secinfo); + entry = sec_merge_add (sinfo->htab, (char *) p, (unsigned) eltalign, + secinfo); if (! entry) goto error_return; p += entry->len; @@ -477,7 +531,7 @@ record_section (struct sec_merge_info *sinfo, if (!nul && !((p - secinfo->contents) & mask)) { nul = TRUE; - entry = sec_merge_add (sinfo->htab, p, + entry = sec_merge_add (sinfo->htab, (char *) p, (unsigned) mask + 1, secinfo); if (! entry) goto error_return; @@ -491,7 +545,7 @@ record_section (struct sec_merge_info *sinfo, { for (p = secinfo->contents; p < end; p += sec->entsize) { - entry = sec_merge_add (sinfo->htab, p, 1, secinfo); + entry = sec_merge_add (sinfo->htab, (char *) p, 1, secinfo); if (! entry) goto error_return; } @@ -499,12 +553,15 @@ record_section (struct sec_merge_info *sinfo, return TRUE; -error_return: + error_return: for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next) *secinfo->psecinfo = NULL; return FALSE; } +/* qsort comparison function. Won't ever return zero as all entries + differ, so there is no issue with qsort stability here. */ + static int strrevcmp (const void *a, const void *b) { @@ -512,8 +569,8 @@ strrevcmp (const void *a, const void *b) struct sec_merge_hash_entry *B = *(struct sec_merge_hash_entry **) b; unsigned int lenA = A->len; unsigned int lenB = B->len; - const unsigned char *s = A->root.string + lenA - 1; - const unsigned char *t = B->root.string + lenB - 1; + const unsigned char *s = (const unsigned char *) A->root.string + lenA - 1; + const unsigned char *t = (const unsigned char *) B->root.string + lenB - 1; int l = lenA < lenB ? lenA : lenB; while (l) @@ -537,8 +594,8 @@ strrevcmp_align (const void *a, const void *b) struct sec_merge_hash_entry *B = *(struct sec_merge_hash_entry **) b; unsigned int lenA = A->len; unsigned int lenB = B->len; - const unsigned char *s = A->root.string + lenA - 1; - const unsigned char *t = B->root.string + lenB - 1; + const unsigned char *s = (const unsigned char *) A->root.string + lenA - 1; + const unsigned char *t = (const unsigned char *) B->root.string + lenB - 1; int l = lenA < lenB ? lenA : lenB; int tail_align = (lenA & (A->alignment - 1)) - (lenB & (A->alignment - 1)); @@ -571,7 +628,7 @@ is_suffix (const struct sec_merge_hash_entry *A, /* This is a helper function for _bfd_merge_sections. It attempts to merge strings matching suffixes of longer strings. */ -static void +static struct sec_merge_sec_info * merge_strings (struct sec_merge_info *sinfo) { struct sec_merge_hash_entry **array, **a, *e; @@ -581,9 +638,9 @@ merge_strings (struct sec_merge_info *sinfo) /* Now sort the strings */ amt = sinfo->htab->size * sizeof (struct sec_merge_hash_entry *); - array = bfd_malloc (amt); + array = (struct sec_merge_hash_entry **) bfd_malloc (amt); if (array == NULL) - goto alloc_failure; + return NULL; for (e = sinfo->htab->first, a = array; e; e = e->next) if (e->alignment) @@ -628,9 +685,7 @@ merge_strings (struct sec_merge_info *sinfo) } } -alloc_failure: - if (array) - free (array); + free (array); /* Now assign positions to the strings we want to keep. */ size = 0; @@ -671,20 +726,24 @@ alloc_failure: e->u.index = e->u.suffix->u.index + (e->u.suffix->len - e->len); } } + return secinfo; } /* This function is called once after all SEC_MERGE sections are registered with _bfd_merge_section. */ bfd_boolean -_bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info, - void *xsinfo, void (*remove_hook) (bfd *, asection *)) +_bfd_merge_sections (bfd *abfd, + struct bfd_link_info *info ATTRIBUTE_UNUSED, + void *xsinfo, + void (*remove_hook) (bfd *, asection *)) { struct sec_merge_info *sinfo; for (sinfo = (struct sec_merge_info *) xsinfo; sinfo; sinfo = sinfo->next) { - struct sec_merge_sec_info * secinfo; + struct sec_merge_sec_info *secinfo; + bfd_size_type align; /* Bytes. */ if (! sinfo->chain) continue; @@ -695,6 +754,7 @@ _bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info, secinfo->next = NULL; /* Record the sections into the hash table. */ + align = 1; for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next) if (secinfo->sec->flags & SEC_EXCLUDE) { @@ -702,21 +762,33 @@ _bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info, if (remove_hook) (*remove_hook) (abfd, secinfo->sec); } - else if (! record_section (sinfo, secinfo)) - break; - - if (secinfo) - continue; + else + { + if (!record_section (sinfo, secinfo)) + return FALSE; + if (align) + { + unsigned int opb = bfd_octets_per_byte (abfd, secinfo->sec); + + align = (bfd_size_type) 1 << secinfo->sec->alignment_power; + if (((secinfo->sec->size / opb) & (align - 1)) != 0) + align = 0; + } + } if (sinfo->htab->first == NULL) continue; if (sinfo->htab->strings) - merge_strings (sinfo); + { + secinfo = merge_strings (sinfo); + if (!secinfo) + return FALSE; + } else { struct sec_merge_hash_entry *e; - bfd_size_type size = 0; + bfd_size_type size = 0; /* Octets. */ /* Things are much simpler for non-strings. Just assign them slots in the section. */ @@ -730,8 +802,7 @@ _bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info, e->secinfo->first_str = e; size = 0; } - size = (size + e->alignment - 1) - & ~((bfd_vma) e->alignment - 1); + size = (size + e->alignment - 1) & ~((bfd_vma) e->alignment - 1); e->u.index = size; size += e->len; secinfo = e->secinfo; @@ -739,11 +810,16 @@ _bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info, secinfo->sec->size = size; } - /* Finally remove all input sections which have not made it into - the hash table at all. */ - for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next) - if (secinfo->first_str == NULL) - _bfd_strip_section_from_output (info, secinfo->sec); + /* If the input sections were padded according to their alignments, + then pad the output too. */ + if (align) + secinfo->sec->size = (secinfo->sec->size + align - 1) & -align; + + /* Finally remove all input sections which have not made it into + the hash table at all. */ + for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next) + if (secinfo->first_str == NULL) + secinfo->sec->flags |= SEC_EXCLUDE | SEC_KEEP; } return TRUE; @@ -756,17 +832,38 @@ _bfd_write_merged_section (bfd *output_bfd, asection *sec, void *psecinfo) { struct sec_merge_sec_info *secinfo; file_ptr pos; + unsigned char *contents; + Elf_Internal_Shdr *hdr; secinfo = (struct sec_merge_sec_info *) psecinfo; + if (!secinfo) + return FALSE; + if (secinfo->first_str == NULL) return TRUE; - pos = sec->output_section->filepos + sec->output_offset; - if (bfd_seek (output_bfd, pos, SEEK_SET) != 0) - return FALSE; + /* FIXME: octets_per_byte. */ + hdr = &elf_section_data (sec->output_section)->this_hdr; + if (hdr->sh_offset == (file_ptr) -1) + { + /* We must compress this section. Write output to the + buffer. */ + contents = hdr->contents; + if ((sec->output_section->flags & SEC_ELF_COMPRESS) == 0 + || contents == NULL) + abort (); + } + else + { + contents = NULL; + pos = sec->output_section->filepos + sec->output_offset; + if (bfd_seek (output_bfd, pos, SEEK_SET) != 0) + return FALSE; + } - if (! sec_merge_emit (output_bfd, secinfo->first_str)) + if (! sec_merge_emit (output_bfd, secinfo->first_str, contents, + sec->output_offset)) return FALSE; return TRUE; @@ -787,14 +884,16 @@ _bfd_merged_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, asection **psec, secinfo = (struct sec_merge_sec_info *) psecinfo; + if (!secinfo) + return offset; + if (offset >= sec->rawsize) { if (offset > sec->rawsize) - { - (*_bfd_error_handler) - (_("%s: access beyond end of merged section (%ld)"), - bfd_get_filename (sec->owner), (long) offset); - } + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB: access beyond end of merged section (%" PRId64 ")"), + sec->owner, (int64_t) offset); return secinfo->first_str ? sec->size : 0; } @@ -829,7 +928,7 @@ _bfd_merged_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, asection **psec, { p = secinfo->contents + (offset / sec->entsize) * sec->entsize; } - entry = sec_merge_hash_lookup (secinfo->htab, p, 0, FALSE); + entry = sec_merge_hash_lookup (secinfo->htab, (char *) p, 0, FALSE); if (!entry) { if (! secinfo->htab->strings) @@ -848,3 +947,17 @@ _bfd_merged_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, asection **psec, *psec = entry->secinfo->sec; return entry->u.index + (secinfo->contents + offset - p); } + +/* Tidy up when done. */ + +void +_bfd_merge_sections_free (void *xsinfo) +{ + struct sec_merge_info *sinfo; + + for (sinfo = (struct sec_merge_info *) xsinfo; sinfo; sinfo = sinfo->next) + { + bfd_hash_table_free (&sinfo->htab->table); + free (sinfo->htab); + } +}