/* SEC_MERGE support.
- Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
- Free Software Foundation, Inc.
+ Copyright (C) 2001-2017 Free Software Foundation, Inc.
Written by Jakub Jelinek <jakub@redhat.com>.
This file is part of BFD, the Binary File Descriptor library.
#include "sysdep.h"
#include "bfd.h"
+#include "elf-bfd.h"
#include "libbfd.h"
#include "hashtab.h"
#include "libiberty.h"
/* 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;
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;
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)
{
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;
}
{
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, alignment, TRUE);
if (entry == NULL)
}
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;
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;
}
len = -off & (entry->alignment - 1);
if (len != 0)
{
- if (bfd_bwrite (pad, len, abfd) != 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)
+ if (contents)
+ {
+ memcpy (contents + offset, str, len);
+ offset += len;
+ }
+ else if (bfd_bwrite (str, len, abfd) != len)
goto err;
off += len;
/* Trailing alignment needed? */
off = sec->size - off;
- if (off != 0
- && bfd_bwrite (pad, off, abfd) != off)
- goto err;
+ if (off != 0)
+ {
+ if (contents)
+ memcpy (contents + offset, pad, off);
+ else if (bfd_bwrite (pad, off, abfd) != off)
+ goto err;
+ }
if (pad != NULL)
free (pad);
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;
/* 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;
with _bfd_merge_section. */
bfd_boolean
-_bfd_merge_sections (bfd *abfd ATTRIBUTE_UNUSED,
+_bfd_merge_sections (bfd *abfd,
struct bfd_link_info *info ATTRIBUTE_UNUSED,
void *xsinfo,
void (*remove_hook) (bfd *, asection *))
{
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;
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 */
+ (_("%B: access beyond end of merged section (%ld)"),
+ sec->owner, (long) offset);
return secinfo->first_str ? sec->size : 0;
}
*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);
+ }
+}
projects / deliverable / binutils-gdb.git / blobdiff