/* SEC_MERGE support.
- Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
- Free Software Foundation, Inc.
+ Copyright (C) 2001-2014 Free Software Foundation, Inc.
Written by Jakub Jelinek <jakub@redhat.com>.
This file is part of BFD, the Binary File Descriptor library.
/* 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;
static struct sec_merge_hash_entry *
sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string,
- const unsigned char *sec_end,
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;
hash += c + (c << 17);
hash ^= hash >> 2;
++len;
- if (sec_end && s >= sec_end)
- return NULL;
}
hash += len + (len << 17);
}
{
for (;;)
{
- if (sec_end && s + table->entsize > sec_end)
- return NULL;
for (i = 0; i < table->entsize; ++i)
if (s[i] != '\0')
break;
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)
{
{
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;
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,
- secinfo->contents + secinfo->sec->size,
- alignment, TRUE);
+ entry = sec_merge_hash_lookup (tab, str, alignment, TRUE);
if (entry == NULL)
return NULL;
if (alignment_power)
{
- pad = bfd_zmalloc ((bfd_size_type) 1 << alignment_power);
+ pad = (char *) bfd_zmalloc ((bfd_size_type) 1 << alignment_power);
if (pad == NULL)
return FALSE;
}
struct sec_merge_sec_info *secinfo;
unsigned int align;
bfd_size_type amt;
+ bfd_byte *contents;
if ((abfd->flags & DYNAMIC) != 0
|| (sec->flags & SEC_MERGE) == 0)
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;
/* 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;
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;
/* Record one section into the hash table. */
static bfd_boolean
-record_section (bfd *abfd,
- struct sec_merge_info *sinfo,
+record_section (struct sec_merge_info *sinfo,
struct sec_merge_sec_info *secinfo)
{
asection *sec = secinfo->sec;
return TRUE;
error_return:
- if (bfd_get_error () != bfd_error_no_memory)
- (*_bfd_error_handler)
- (_("%B: unterminated string in section `%A' marked for merging"),
- abfd, sec);
for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
*secinfo->psecinfo = NULL;
return FALSE;
/* 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;
if (remove_hook)
(*remove_hook) (abfd, secinfo->sec);
}
- else if (! record_section (abfd, sinfo, secinfo))
+ else if (! record_section (sinfo, secinfo))
break;
if (secinfo)
if (secinfo->first_str == NULL)
return TRUE;
+ /* FIXME: octets_per_byte. */
pos = sec->output_section->filepos + sec->output_offset;
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0)
return FALSE;
secinfo = (struct sec_merge_sec_info *) psecinfo;
if (!secinfo)
- return 0;
+ return offset;
if (offset >= sec->rawsize)
{
{
p = secinfo->contents + (offset / sec->entsize) * sec->entsize;
}
- entry = sec_merge_hash_lookup (secinfo->htab, (char *) p, NULL, 0, FALSE);
+ entry = sec_merge_hash_lookup (secinfo->htab, (char *) p, 0, FALSE);
if (!entry)
{
if (! secinfo->htab->strings)
*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);
+ }
+}