struct m68hc11_cgc_link_hash_table*
m68hc11_cgc_hash_table_create (bfd *abfd)
{
struct m68hc11_cgc_link_hash_table *ret;
bfd_size_type amt = sizeof (struct m68hc11_cgc_link_hash_table);
ret = (struct m68hc11_cgc_link_hash_table *) bfd_zmalloc (amt);
if (ret == (struct m68hc11_cgc_link_hash_table *) NULL)
return NULL;
if (!_bfd_cgc_link_hash_table_init (&ret->root, abfd,
_bfd_cgc_link_hash_newfunc,
sizeof (struct cgc_link_hash_entry),
M68HC11_CGC_DATA))
{
free (ret);
return NULL;
}
/* Init the stub hash table too. */
amt = sizeof (struct bfd_hash_table);
ret->stub_hash_table = (struct bfd_hash_table*) bfd_malloc (amt);
if (ret->stub_hash_table == NULL)
{
free (ret);
return NULL;
}
if (!bfd_hash_table_init (ret->stub_hash_table, stub_hash_newfunc,
sizeof (struct cgc32_m68hc11_stub_hash_entry)))
return NULL;
return ret;
}
static struct user *
read_uarea (bfd *abfd, int filepos)
{
struct sco5_core_struct *rawptr;
bfd_size_type amt = sizeof (struct sco5_core_struct);
rawptr = (struct sco5_core_struct *) bfd_zmalloc (amt);
if (rawptr == NULL)
return NULL;
abfd->tdata.sco5_core_data = rawptr;
if (bfd_seek (abfd, (file_ptr) filepos, SEEK_SET) != 0
|| bfd_bread ((void *) &rawptr->u, (bfd_size_type) sizeof rawptr->u,
abfd) != sizeof rawptr->u)
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
/* Sanity check perhaps??? */
if (rawptr->u.u_dsize > 0x1000000) /* Remember, it's in pages... */
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
if (rawptr->u.u_ssize > 0x1000000)
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
return &rawptr->u;
}
bfd_boolean
bfd_get_file_window(bfd *abfd, ufile_ptr offset, bfd_size_type size,
bfd_window *windowp, bfd_boolean writable)
{
bfd_window_internal *i = windowp->i;
if (debug_windows)
fprintf(stderr,
"bfd_get_file_window (%p, %6ld, %6ld, %p<%p,%lx,%p>, %d)",
(void *)abfd, (long)offset, (long)size, (void *)windowp,
windowp->data, (unsigned long)windowp->size,
(void *)windowp->i, writable);
BFD_ASSERT(i == NULL);
if (i == NULL)
{
windowp->i = i = ((bfd_window_internal *)
bfd_zmalloc((bfd_size_type)sizeof(bfd_window_internal)));
if (i == 0)
return FALSE;
i->data = 0;
}
if ((abfd->flags & BFD_IN_MEMORY) != 0)
{
struct bfd_in_memory *bim = (struct bfd_in_memory *)abfd->iostream;
BFD_ASSERT(bim != NULL);
if ((offset > bim->size) || ((bim->size - offset) < size))
{
bfd_set_error(bfd_error_file_truncated);
return FALSE;
}
i->next = NULL;
i->data = (bim->buffer + offset);
i->size = size;
i->refcount = 1;
i->mapped = 2;
windowp->data = i->data;
windowp->size = i->size;
return TRUE;
} else {
#if HAVE_MMAP
if (! _bfd_get_file_window_mmap(abfd, offset, size, windowp, i, writable)) {
return FALSE;
}
#else
if (! _bfd_get_file_window_malloc(abfd, offset, size, windowp, i, writable)) {
return FALSE;
}
#endif /* HAVE_MMAP */
}
return TRUE;
}
bfd *
_bfd_new_bfd (void)
{
bfd *nbfd;
nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
if (nbfd == NULL)
return NULL;
if (bfd_use_reserved_id)
{
nbfd->id = --bfd_reserved_id_counter;
--bfd_use_reserved_id;
}
else
nbfd->id = bfd_id_counter++;
nbfd->memory = objalloc_create ();
if (nbfd->memory == NULL)
{
bfd_set_error (bfd_error_no_memory);
free (nbfd);
return NULL;
}
nbfd->arch_info = &bfd_default_arch_struct;
nbfd->direction = no_direction;
nbfd->iostream = NULL;
nbfd->where = 0;
if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
sizeof (struct section_hash_entry), 13))
{
free (nbfd);
return NULL;
}
nbfd->sections = NULL;
nbfd->section_last = NULL;
nbfd->format = bfd_unknown;
nbfd->my_archive = NULL;
nbfd->origin = 0;
nbfd->opened_once = FALSE;
nbfd->output_has_begun = FALSE;
nbfd->section_count = 0;
nbfd->usrdata = NULL;
nbfd->cacheable = FALSE;
nbfd->flags = BFD_NO_FLAGS;
nbfd->mtime_set = FALSE;
return nbfd;
}
bfd *
_bfd_new_bfd ()
{
bfd *nbfd;
nbfd = (bfd *) bfd_zmalloc ((bfd_size_type) sizeof (bfd));
if (nbfd == NULL)
return NULL;
nbfd->id = _bfd_id_counter++;
nbfd->memory = (PTR) objalloc_create ();
if (nbfd->memory == NULL)
{
bfd_set_error (bfd_error_no_memory);
free (nbfd);
return NULL;
}
nbfd->arch_info = &bfd_default_arch_struct;
nbfd->direction = no_direction;
nbfd->iostream = NULL;
nbfd->where = 0;
if (!bfd_hash_table_init_n (&nbfd->section_htab,
bfd_section_hash_newfunc,
251))
{
free (nbfd);
return NULL;
}
nbfd->sections = (asection *) NULL;
nbfd->section_tail = &nbfd->sections;
nbfd->format = bfd_unknown;
nbfd->my_archive = (bfd *) NULL;
nbfd->origin = 0;
nbfd->opened_once = FALSE;
nbfd->output_has_begun = FALSE;
nbfd->section_count = 0;
nbfd->usrdata = (PTR) NULL;
nbfd->cacheable = FALSE;
nbfd->flags = BFD_NO_FLAGS;
nbfd->mtime_set = FALSE;
return nbfd;
}
static struct bfd_link_hash_table *
linux_link_hash_table_create (bfd *abfd)
{
struct linux_link_hash_table *ret;
bfd_size_type amt = sizeof (struct linux_link_hash_table);
ret = (struct linux_link_hash_table *) bfd_zmalloc (amt);
if (ret == (struct linux_link_hash_table *) NULL)
return (struct bfd_link_hash_table *) NULL;
if (!NAME(aout,link_hash_table_init) (&ret->root, abfd,
linux_link_hash_newfunc,
sizeof (struct linux_link_hash_entry)))
{
free (ret);
return (struct bfd_link_hash_table *) NULL;
}
return &ret->root.root;
}
static struct bfd_link_hash_table *
h8300_coff_link_hash_table_create (bfd *abfd)
{
struct h8300_coff_link_hash_table *ret;
bfd_size_type amt = sizeof (struct h8300_coff_link_hash_table);
ret = (struct h8300_coff_link_hash_table *) bfd_zmalloc (amt);
if (ret == NULL)
return NULL;
if (!_bfd_link_hash_table_init (&ret->root.root, abfd,
_bfd_generic_link_hash_newfunc,
sizeof (struct generic_link_hash_entry)))
{
free (ret);
return NULL;
}
return &ret->root.root;
}
bfd *
_bfd_new_bfd ()
{
bfd *nbfd;
nbfd = (bfd *)bfd_zmalloc (sizeof (bfd));
if (!nbfd)
{
bfd_set_error (bfd_error_no_memory);
return 0;
}
bfd_check_init();
if (!obstack_begin(&nbfd->memory, 128))
{
bfd_set_error (bfd_error_no_memory);
return 0;
}
nbfd->arch_info = &bfd_default_arch_struct;
nbfd->direction = no_direction;
nbfd->iostream = NULL;
nbfd->where = 0;
nbfd->sections = (asection *)NULL;
nbfd->format = bfd_unknown;
nbfd->my_archive = (bfd *)NULL;
nbfd->origin = 0;
nbfd->opened_once = false;
nbfd->output_has_begun = false;
nbfd->section_count = 0;
nbfd->usrdata = (PTR)NULL;
nbfd->cacheable = false;
nbfd->flags = NO_FLAGS;
nbfd->mtime_set = false;
return nbfd;
}
bfd *
_bfd_new_bfd (void)
{
bfd *nbfd;
nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
if (nbfd == NULL)
return NULL;
if (bfd_use_reserved_id)
{
nbfd->id = --bfd_reserved_id_counter;
--bfd_use_reserved_id;
}
else
nbfd->id = bfd_id_counter++;
nbfd->memory = objalloc_create ();
if (nbfd->memory == NULL)
{
bfd_set_error (bfd_error_no_memory);
free (nbfd);
return NULL;
}
nbfd->arch_info = &bfd_default_arch_struct;
if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
sizeof (struct section_hash_entry), 13))
{
free (nbfd);
return NULL;
}
return nbfd;
}
bfd_boolean
bfd_coff_reloc16_relax_section (bfd *abfd,
asection *input_section,
struct bfd_link_info *link_info,
bfd_boolean *again)
{
/* Get enough memory to hold the stuff. */
bfd *input_bfd = input_section->owner;
unsigned *shrinks;
unsigned shrink = 0;
long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
arelent **reloc_vector = NULL;
long reloc_count;
if (bfd_link_relocatable (link_info))
(*link_info->callbacks->einfo)
(_("%P%F: --relax and -r may not be used together\n"));
/* We only do global relaxation once. It is not safe to do it multiple
times (see discussion of the "shrinks" array below). */
*again = FALSE;
if (reloc_size < 0)
return FALSE;
reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
if (!reloc_vector && reloc_size > 0)
return FALSE;
/* Get the relocs and think about them. */
reloc_count =
bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector,
_bfd_generic_link_get_symbols (input_bfd));
if (reloc_count < 0)
{
free (reloc_vector);
return FALSE;
}
/* The reloc16.c and related relaxing code is very simple, the price
for that simplicity is we can only call this function once for
each section.
So, to get the best results within that limitation, we do multiple
relaxing passes over each section here. That involves keeping track
of the "shrink" at each reloc in the section. This allows us to
accurately determine the relative location of two relocs within
this section.
In theory, if we kept the "shrinks" array for each section for the
entire link, we could use the generic relaxing code in the linker
and get better results, particularly for jsr->bsr and 24->16 bit
memory reference relaxations. */
if (reloc_count > 0)
{
int another_pass = 0;
bfd_size_type amt;
/* Allocate and initialize the shrinks array for this section.
The last element is used as an accumulator of shrinks. */
amt = reloc_count + 1;
amt *= sizeof (unsigned);
shrinks = (unsigned *) bfd_zmalloc (amt);
/* Loop until nothing changes in this section. */
do
{
arelent **parent;
unsigned int i;
long j;
another_pass = 0;
for (i = 0, parent = reloc_vector; *parent; parent++, i++)
{
/* Let the target/machine dependent code examine each reloc
in this section and attempt to shrink it. */
shrink = bfd_coff_reloc16_estimate (abfd, input_section, *parent,
shrinks[i], link_info);
/* If it shrunk, note it in the shrinks array and set up for
another pass. */
if (shrink != shrinks[i])
{
another_pass = 1;
for (j = i + 1; j <= reloc_count; j++)
shrinks[j] += shrink - shrinks[i];
}
}
}
while (another_pass);
shrink = shrinks[reloc_count];
free ((char *) shrinks);
}
input_section->rawsize = input_section->size;
input_section->size -= shrink;
free ((char *) reloc_vector);
return TRUE;
}
/* Process GSD/EGSD record.
* Return 0 on success, -1 on error. */
int
_bfd_vms_slurp_gsd(bfd * abfd, int objtype)
{
#if defined(VMS_DEBUG) && VMS_DEBUG
static struct flagdescstruct gpsflagdesc[] =
{
{ "PIC", 0x0001 },
{ "LIB", 0x0002 },
{ "OVR", 0x0004 },
{ "REL", 0x0008 },
{ "GBL", 0x0010 },
{ "SHR", 0x0020 },
{ "EXE", 0x0040 },
{ "RD", 0x0080 },
{ "WRT", 0x0100 },
{ "VEC", 0x0200 },
{ "NOMOD", 0x0400 },
{ "COM", 0x0800 },
{ NULL, 0 }
};
static struct flagdescstruct gsyflagdesc[] =
{
{ "WEAK", 0x0001 },
{ "DEF", 0x0002 },
{ "UNI", 0x0004 },
{ "REL", 0x0008 },
{ "COMM", 0x0010 },
{ "VECEP", 0x0020 },
{ "NORM", 0x0040 },
{ NULL, 0 }
};
#endif /* VMS_DEBUG */
int gsd_type, gsd_size;
asection *section;
unsigned char *vms_rec;
flagword new_flags, old_flags;
char *name;
asymbol *symbol;
vms_symbol_entry *entry;
unsigned long base_addr;
unsigned long align_addr;
static unsigned int psect_idx = 0;
gsd_size = 0;
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug(2, "GSD/EGSD (%d/%x)\n", objtype, objtype);
#endif /* VMS_DEBUG */
switch (objtype)
{
case EOBJ_S_C_EGSD:
PRIV(vms_rec) += 8; /* Skip type, size, l_temp. */
PRIV(rec_size) -= 8;
break;
case OBJ_S_C_GSD:
PRIV(vms_rec) += 1;
PRIV(rec_size) -= 1;
break;
default:
return -1;
}
/* Calculate base address for each section: */
base_addr = 0L;
abfd->symcount = 0;
while (PRIV(rec_size) > 0)
{
vms_rec = PRIV(vms_rec);
if (objtype == OBJ_S_C_GSD)
gsd_type = *vms_rec;
else
{
_bfd_vms_get_header_values(abfd, vms_rec, &gsd_type, &gsd_size);
gsd_type += EVAX_OFFSET;
}
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (3, "gsd_type %d\n", gsd_type);
#endif
switch (gsd_type)
{
case GSD_S_C_PSC:
{
/* Program section definition. */
asection *old_section = 0;
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "GSD_S_C_PSC\n");
#endif
/* If this section isn't a bfd section. */
if (PRIV (is_vax) && (psect_idx < (abfd->section_count-1)))
{
/* Check for temporary section from TIR record. */
if (psect_idx < PRIV (section_count))
old_section = PRIV (sections)[psect_idx];
else
old_section = 0;
}
name = _bfd_vms_save_counted_string (vms_rec + 8);
section = bfd_make_section (abfd, name);
if (!section)
{
(*_bfd_error_handler) (_("bfd_make_section (%s) failed"),
name);
return -1;
}
old_flags = bfd_getl16 (vms_rec + 2);
section->size = bfd_getl32 (vms_rec + 4); /* allocation */
new_flags = vms_secflag_by_name (abfd, vax_section_flags, name,
section->size > 0);
if (old_flags & EGPS_S_V_REL)
new_flags |= SEC_RELOC;
if (old_flags & GPS_S_M_OVR)
new_flags |= SEC_IS_COMMON;
if (!bfd_set_section_flags (abfd, section, new_flags))
{
(*_bfd_error_handler)
(_("bfd_set_section_flags (%s, %x) failed"),
name, new_flags);
return -1;
}
section->alignment_power = vms_rec[1];
align_addr = (1 << section->alignment_power);
if ((base_addr % align_addr) != 0)
base_addr += (align_addr - (base_addr % align_addr));
section->vma = (bfd_vma)base_addr;
base_addr += section->size;
/* Global section is common symbol. */
if (old_flags & GPS_S_M_GBL)
{
entry = _bfd_vms_enter_symbol (abfd, name);
if (entry == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
symbol = entry->symbol;
symbol->value = 0;
symbol->section = section;
symbol->flags = (BSF_GLOBAL | BSF_SECTION_SYM | BSF_OLD_COMMON);
}
/* Copy saved contents if old_section set. */
if (old_section != 0)
{
section->contents = old_section->contents;
if (section->size < old_section->size)
{
(*_bfd_error_handler)
(_("Size mismatch section %s=%lx, %s=%lx"),
old_section->name,
(unsigned long) old_section->size,
section->name,
(unsigned long) section->size);
return -1;
}
else if (section->size > old_section->size)
{
section->contents = (unsigned char *)bfd_realloc(old_section->contents,
section->size);
if (section->contents == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
}
}
else
{
section->contents = (unsigned char *)bfd_zmalloc(section->size);
if (section->contents == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
}
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd psc %d (%s, flags %04x=%s) ",
section->index, name, old_flags, flag2str (gpsflagdesc, old_flags));
vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n",
section->size, section->vma, section->contents);
#endif /* VMS_DEBUG */
gsd_size = vms_rec[8] + 9;
psect_idx++;
}
break;
case GSD_S_C_EPM:
case GSD_S_C_EPMW:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd epm\n");
#endif
/* Fall through. */
case GSD_S_C_SYM:
case GSD_S_C_SYMW:
{
int name_offset = 0, value_offset = 0;
/* Symbol specification (definition or reference). */
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug(4, "GSD_S_C_SYM(W)\n");
#endif
old_flags = bfd_getl16 (vms_rec + 2);
new_flags = BSF_NO_FLAGS;
if (old_flags & GSY_S_M_WEAK)
new_flags |= BSF_WEAK;
switch (gsd_type) {
case GSD_S_C_EPM:
name_offset = 11;
value_offset = 5;
new_flags |= BSF_FUNCTION;
break;
case GSD_S_C_EPMW:
name_offset = 12;
value_offset = 6;
new_flags |= BSF_FUNCTION;
break;
case GSD_S_C_SYM:
if (old_flags & GSY_S_M_DEF) /* Symbol definition. */
name_offset = 9;
else
name_offset = 4;
value_offset = 5;
break;
case GSD_S_C_SYMW:
if (old_flags & GSY_S_M_DEF) /* Symbol definition. */
name_offset = 10;
else
name_offset = 5;
value_offset = 6;
break;
default:
break;
} /* end "switch (gsd_type)" */
/* Save symbol in vms_symbol_table: */
entry
= _bfd_vms_enter_symbol(abfd,
_bfd_vms_save_counted_string(vms_rec + name_offset));
if (entry == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
symbol = entry->symbol;
if (old_flags & GSY_S_M_DEF)
{
/* Symbol definition. */
int psect;
symbol->value = bfd_getl32 (vms_rec + value_offset);
if ((gsd_type == GSD_S_C_SYMW)
|| (gsd_type == GSD_S_C_EPMW))
psect = bfd_getl16 (vms_rec + value_offset - 2);
else
psect = vms_rec[value_offset-1];
symbol->section = (asection *) (size_t) psect;
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd sym def #%d (%s, %d [%p], %04x=%s)\n", abfd->symcount,
symbol->name, (int)symbol->section, symbol->section, old_flags, flag2str (gsyflagdesc, old_flags));
#endif
}
else
{
/* Symbol reference. */
symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd sym ref #%d (%s, %s [%p], %04x=%s)\n",
abfd->symcount, symbol->name, symbol->section->name,
symbol->section, old_flags, flag2str (gsyflagdesc, old_flags));
#endif
}
gsd_size = vms_rec[name_offset] + name_offset + 1;
symbol->flags = new_flags;
}
break;
case GSD_S_C_PRO:
case GSD_S_C_PROW:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd pro\n");
#endif
break;
case GSD_S_C_IDC:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd idc\n");
#endif
break;
case GSD_S_C_ENV:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd env\n");
#endif
break;
case GSD_S_C_LSY:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd lsy\n");
#endif
break;
case GSD_S_C_LEPM:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd lepm\n");
#endif
break;
case GSD_S_C_LPRO:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd lpro\n");
#endif
break;
case GSD_S_C_SPSC:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd spsc\n");
#endif
break;
case GSD_S_C_SYMV:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd symv\n");
#endif
break;
case GSD_S_C_EPMV:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd epmv\n");
#endif
break;
case GSD_S_C_PROV:
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "gsd prov\n");
#endif
break;
case EGSD_S_C_PSC + EVAX_OFFSET:
{
/* Program section definition. */
name = _bfd_vms_save_counted_string (vms_rec + 12);
section = bfd_make_section (abfd, name);
if (!section)
return -1;
old_flags = bfd_getl16 (vms_rec + 6);
section->size = bfd_getl32 (vms_rec + 8); /* Allocation. */
new_flags = vms_secflag_by_name (abfd, evax_section_flags, name,
section->size > 0);
if (old_flags & EGPS_S_V_REL)
new_flags |= SEC_RELOC;
if (!bfd_set_section_flags (abfd, section, new_flags))
return -1;
section->alignment_power = vms_rec[4];
align_addr = (1 << section->alignment_power);
if ((base_addr % align_addr) != 0)
base_addr += (align_addr - (base_addr % align_addr));
section->vma = (bfd_vma)base_addr;
base_addr += section->size;
section->contents = (unsigned char *)bfd_zmalloc(section->size);
if (section->contents == NULL)
return -1;
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "egsd psc %d (%s, flags %04x=%s) ",
section->index, name, old_flags, flag2str (gpsflagdesc, old_flags));
vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n",
section->size, section->vma, section->contents);
#endif
}
break;
case EGSD_S_C_SYM + EVAX_OFFSET:
{
/* Symbol specification (definition or reference). */
symbol = bfd_make_empty_symbol (abfd);
if (symbol == 0)
return -1;
old_flags = bfd_getl16 (vms_rec + 6);
new_flags = BSF_NO_FLAGS;
if (old_flags & EGSY_S_V_WEAK)
new_flags |= BSF_WEAK;
if (vms_rec[6] & EGSY_S_V_DEF)
{
/* Symbol definition. */
symbol->name = _bfd_vms_save_counted_string (vms_rec + 32);
if (old_flags & EGSY_S_V_NORM)
/* Proc def. */
new_flags |= BSF_FUNCTION;
symbol->value = bfd_getl64 (vms_rec + 8);
symbol->section = (asection *) ((unsigned long) bfd_getl32 (vms_rec + 28));
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "egsd sym def #%d (%s, %d, %04x=%s)\n", abfd->symcount,
symbol->name, (int) symbol->section, old_flags,
flag2str (gsyflagdesc, old_flags));
#endif
}
else
{
/* Symbol reference. */
symbol->name = _bfd_vms_save_counted_string (vms_rec + 8);
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug (4, "egsd sym ref #%d (%s, %04x=%s)\n", abfd->symcount,
symbol->name, old_flags, flag2str (gsyflagdesc, old_flags));
#endif
symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME);
}
symbol->flags = new_flags;
/* Save symbol in vms_symbol_table: */
entry = (vms_symbol_entry *)bfd_hash_lookup(PRIV(vms_symbol_table),
symbol->name,
TRUE, FALSE);
if (entry == NULL)
{
bfd_set_error(bfd_error_no_memory);
return -1;
}
if (entry->symbol != NULL)
{
/* FIXME ?, DEC C generates this. */
#if defined(VMS_DEBUG) && VMS_DEBUG
vms_debug(4, "EGSD_S_C_SYM: duplicate \"%s\"\n", symbol->name);
#endif /* VMS_DEBUG */
}
else
{
entry->symbol = symbol;
PRIV(gsd_sym_count)++;
abfd->symcount++;
}
}
break;
case EGSD_S_C_IDC + EVAX_OFFSET:
break;
default:
(*_bfd_error_handler)(_("unknown gsd/egsd subtype %d"), gsd_type);
bfd_set_error(bfd_error_bad_value);
return -1;
}
PRIV(rec_size) -= gsd_size;
PRIV(vms_rec) += gsd_size;
}
if (abfd->symcount > 0)
abfd->flags |= HAS_SYMS;
return 0;
}
static const bfd_target *
trad_unix_core_file_p (bfd *abfd)
{
int val;
struct user u;
struct trad_core_struct *rawptr;
bfd_size_type amt;
flagword flags;
#ifdef TRAD_CORE_USER_OFFSET
/* If defined, this macro is the file position of the user struct. */
if (bfd_seek (abfd, (file_ptr) TRAD_CORE_USER_OFFSET, SEEK_SET) != 0)
return 0;
#endif
val = bfd_bread ((void *) &u, (bfd_size_type) sizeof u, abfd);
if (val != sizeof u)
{
/* Too small to be a core file */
bfd_set_error (bfd_error_wrong_format);
return 0;
}
/* Sanity check perhaps??? */
if (u.u_dsize > 0x1000000) /* Remember, it's in pages... */
{
bfd_set_error (bfd_error_wrong_format);
return 0;
}
if (u.u_ssize > 0x1000000)
{
bfd_set_error (bfd_error_wrong_format);
return 0;
}
/* Check that the size claimed is no greater than the file size. */
{
struct stat statbuf;
if (bfd_stat (abfd, &statbuf) < 0)
return 0;
if ((ufile_ptr) NBPG * (UPAGES + u.u_dsize
#ifdef TRAD_CORE_DSIZE_INCLUDES_TSIZE
- u.u_tsize
#endif
+ u.u_ssize)
> (ufile_ptr) statbuf.st_size)
{
bfd_set_error (bfd_error_wrong_format);
return 0;
}
#ifndef TRAD_CORE_ALLOW_ANY_EXTRA_SIZE
if (((ufile_ptr) NBPG * (UPAGES + u.u_dsize + u.u_ssize)
#ifdef TRAD_CORE_EXTRA_SIZE_ALLOWED
/* Some systems write the file too big. */
+ TRAD_CORE_EXTRA_SIZE_ALLOWED
#endif
)
< (ufile_ptr) statbuf.st_size)
{
/* The file is too big. Maybe it's not a core file
or we otherwise have bad values for u_dsize and u_ssize). */
bfd_set_error (bfd_error_wrong_format);
return 0;
}
#endif
}
/* OK, we believe you. You're a core file (sure, sure). */
/* Allocate both the upage and the struct core_data at once, so
a single free() will free them both. */
amt = sizeof (struct trad_core_struct);
rawptr = (struct trad_core_struct *) bfd_zmalloc (amt);
if (rawptr == NULL)
return 0;
abfd->tdata.trad_core_data = rawptr;
rawptr->u = u; /*Copy the uarea into the tdata part of the bfd */
/* Create the sections. */
flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
core_stacksec(abfd) = bfd_make_section_anyway_with_flags (abfd, ".stack",
flags);
if (core_stacksec (abfd) == NULL)
goto fail;
core_datasec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".data",
flags);
if (core_datasec (abfd) == NULL)
goto fail;
core_regsec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".reg",
SEC_HAS_CONTENTS);
if (core_regsec (abfd) == NULL)
goto fail;
core_datasec (abfd)->size = NBPG * u.u_dsize
#ifdef TRAD_CORE_DSIZE_INCLUDES_TSIZE
- NBPG * u.u_tsize
#endif
;
core_stacksec (abfd)->size = NBPG * u.u_ssize;
core_regsec (abfd)->size = NBPG * UPAGES; /* Larger than sizeof struct u */
/* What a hack... we'd like to steal it from the exec file,
since the upage does not seem to provide it. FIXME. */
#ifdef HOST_DATA_START_ADDR
core_datasec (abfd)->vma = HOST_DATA_START_ADDR;
#else
core_datasec (abfd)->vma = HOST_TEXT_START_ADDR + (NBPG * u.u_tsize);
#endif
#ifdef HOST_STACK_START_ADDR
core_stacksec (abfd)->vma = HOST_STACK_START_ADDR;
#else
core_stacksec (abfd)->vma = HOST_STACK_END_ADDR - (NBPG * u.u_ssize);
#endif
/* This is tricky. As the "register section", we give them the entire
upage and stack. u.u_ar0 points to where "register 0" is stored.
There are two tricks with this, though. One is that the rest of the
registers might be at positive or negative (or both) displacements
from *u_ar0. The other is that u_ar0 is sometimes an absolute address
in kernel memory, and on other systems it is an offset from the beginning
of the `struct user'.
As a practical matter, we don't know where the registers actually are,
so we have to pass the whole area to GDB. We encode the value of u_ar0
by setting the .regs section up so that its virtual memory address
0 is at the place pointed to by u_ar0 (by setting the vma of the start
of the section to -u_ar0). GDB uses this info to locate the regs,
using minor trickery to get around the offset-or-absolute-addr problem. */
core_regsec (abfd)->vma = - (bfd_vma) (unsigned long) u.u_ar0;
core_datasec (abfd)->filepos = NBPG * UPAGES;
core_stacksec (abfd)->filepos = (NBPG * UPAGES) + NBPG * u.u_dsize
#ifdef TRAD_CORE_DSIZE_INCLUDES_TSIZE
- NBPG * u.u_tsize
#endif
;
core_regsec (abfd)->filepos = 0; /* Register segment is the upage */
/* Align to word at least */
core_stacksec (abfd)->alignment_power = 2;
core_datasec (abfd)->alignment_power = 2;
core_regsec (abfd)->alignment_power = 2;
return abfd->xvec;
fail:
bfd_release (abfd, abfd->tdata.any);
abfd->tdata.any = NULL;
bfd_section_list_clear (abfd);
return NULL;
}
static bfd_boolean
wasm_scan (bfd *abfd)
{
bfd_boolean error = FALSE;
/* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes
with actual data addresses. */
bfd_vma vma = 0x80000000;
int section_code;
unsigned int bytes_read;
char *name = NULL;
asection *bfdsec;
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
goto error_return;
if (! wasm_read_header (abfd, &error))
goto error_return;
while ((section_code = wasm_read_byte (abfd, &error)) != EOF)
{
if (section_code != 0)
{
const char *sname = wasm_section_code_to_name (section_code);
if (! sname)
goto error_return;
name = strdup (sname);
bfdsec = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
if (bfdsec == NULL)
goto error_return;
name = NULL;
bfdsec->vma = vma;
bfdsec->lma = vma;
bfdsec->size = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE);
if (error)
goto error_return;
bfdsec->filepos = bfd_tell (abfd);
bfdsec->alignment_power = 0;
}
else
{
bfd_vma payload_len;
file_ptr section_start;
bfd_vma namelen;
char *prefix = WASM_SECTION_PREFIX;
char *p;
int ret;
payload_len = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE);
if (error)
goto error_return;
section_start = bfd_tell (abfd);
namelen = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE);
if (error || namelen > payload_len)
goto error_return;
name = bfd_zmalloc (namelen + strlen (prefix) + 1);
if (! name)
goto error_return;
p = name;
ret = sprintf (p, "%s", prefix);
if (ret < 0 || (bfd_vma) ret != strlen (prefix))
goto error_return;
p += ret;
if (bfd_bread (p, namelen, abfd) != namelen)
goto error_return;
bfdsec = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
if (bfdsec == NULL)
goto error_return;
name = NULL;
bfdsec->vma = vma;
bfdsec->lma = vma;
bfdsec->filepos = bfd_tell (abfd);
bfdsec->size = section_start + payload_len - bfdsec->filepos;
bfdsec->alignment_power = 0;
}
if (bfdsec->size != 0)
{
bfdsec->contents = bfd_zalloc (abfd, bfdsec->size);
if (! bfdsec->contents)
goto error_return;
if (bfd_bread (bfdsec->contents, bfdsec->size, abfd) != bfdsec->size)
goto error_return;
}
vma += bfdsec->size;
}
/* Make sure we're at actual EOF. There's no indication in the
WebAssembly format of how long the file is supposed to be. */
if (error)
goto error_return;
return TRUE;
error_return:
if (name)
free (name);
for (bfdsec = abfd->sections; bfdsec; bfdsec = bfdsec->next)
free ((void *) bfdsec->name);
return FALSE;
}
int
_bfd_vms_slurp_gsd (bfd * abfd, int objtype)
{
int gsd_type, gsd_size;
asection *section;
unsigned char *vms_rec;
flagword new_flags, old_flags;
char *name;
asymbol *symbol;
vms_symbol_entry *entry;
unsigned long base_addr;
unsigned long align_addr;
static unsigned int psect_idx = 0;
#if VMS_DEBUG
vms_debug (2, "GSD/EGSD (%d/%x)\n", objtype, objtype);
#endif
switch (objtype)
{
case EOBJ_S_C_EGSD:
PRIV (vms_rec) += 8; /* Skip type, size, l_temp. */
PRIV (rec_size) -= 8;
break;
case OBJ_S_C_GSD:
PRIV (vms_rec) += 1;
PRIV (rec_size) -= 1;
break;
default:
return -1;
}
/* Calculate base address for each section. */
base_addr = 0L;
abfd->symcount = 0;
while (PRIV (rec_size) > 0)
{
vms_rec = PRIV (vms_rec);
if (objtype == OBJ_S_C_GSD)
gsd_type = vms_rec[0];
else
{
_bfd_vms_get_header_values (abfd, vms_rec, &gsd_type, &gsd_size);
gsd_type += EVAX_OFFSET;
}
#if VMS_DEBUG
vms_debug (3, "gsd_type %d\n", gsd_type);
#endif
switch (gsd_type)
{
case GSD_S_C_PSC:
{
/* Program section definition. */
asection *old_section = 0;
#if VMS_DEBUG
vms_debug (4, "GSD_S_C_PSC\n");
#endif
/* If this section isn't a bfd section. */
if (PRIV (is_vax) && (psect_idx < (abfd->section_count - 1)))
{
/* Check for temporary section from TIR record. */
if (psect_idx < PRIV (section_count))
old_section = PRIV (sections)[psect_idx];
else
old_section = 0;
}
name = _bfd_vms_save_counted_string (vms_rec + 8);
section = bfd_make_section (abfd, name);
if (!section)
{
(*_bfd_error_handler) (_("bfd_make_section (%s) failed"),
name);
return -1;
}
old_flags = bfd_getl16 (vms_rec + 2);
section->size = bfd_getl32 (vms_rec + 4); /* allocation */
new_flags = vms_secflag_by_name (abfd, vax_section_flags, name,
section->size > 0);
if (old_flags & EGPS_S_V_REL)
new_flags |= SEC_RELOC;
if (old_flags & GPS_S_M_OVR)
new_flags |= SEC_IS_COMMON;
if (!bfd_set_section_flags (abfd, section, new_flags))
{
(*_bfd_error_handler)
(_("bfd_set_section_flags (%s, %x) failed"),
name, new_flags);
return -1;
}
section->alignment_power = vms_rec[1];
align_addr = (1 << section->alignment_power);
if ((base_addr % align_addr) != 0)
base_addr += (align_addr - (base_addr % align_addr));
section->vma = (bfd_vma)base_addr;
base_addr += section->size;
/* Global section is common symbol. */
if (old_flags & GPS_S_M_GBL)
{
entry = _bfd_vms_enter_symbol (abfd, name);
if (entry == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
symbol = entry->symbol;
symbol->value = 0;
symbol->section = section;
symbol->flags = (BSF_GLOBAL | BSF_SECTION_SYM | BSF_OLD_COMMON);
}
/* Copy saved contents if old_section set. */
if (old_section != 0)
{
section->contents = old_section->contents;
if (section->size < old_section->size)
{
(*_bfd_error_handler)
(_("Size mismatch section %s=%lx, %s=%lx"),
old_section->name,
(unsigned long) old_section->size,
section->name,
(unsigned long) section->size);
return -1;
}
else if (section->size > old_section->size)
{
section->contents = bfd_realloc (old_section->contents,
section->size);
if (section->contents == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
}
}
else
{
section->contents = bfd_zmalloc (section->size);
if (section->contents == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
}
#if VMS_DEBUG
vms_debug (4, "gsd psc %d (%s, flags %04x=%s) ",
section->index, name, old_flags, flag2str (gpsflagdesc, old_flags));
vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n",
section->size, section->vma, section->contents);
#endif
gsd_size = vms_rec[8] + 9;
psect_idx++;
}
break;
case GSD_S_C_EPM:
case GSD_S_C_EPMW:
#if VMS_DEBUG
vms_debug (4, "gsd epm\n");
#endif
/* Fall through. */
case GSD_S_C_SYM:
case GSD_S_C_SYMW:
{
int name_offset = 0, value_offset = 0;
/* Symbol specification (definition or reference). */
#if VMS_DEBUG
vms_debug (4, "GSD_S_C_SYM(W)\n");
#endif
old_flags = bfd_getl16 (vms_rec + 2);
new_flags = BSF_NO_FLAGS;
if (old_flags & GSY_S_M_WEAK)
new_flags |= BSF_WEAK;
switch (gsd_type)
{
case GSD_S_C_EPM:
name_offset = 11;
value_offset = 5;
new_flags |= BSF_FUNCTION;
break;
case GSD_S_C_EPMW:
name_offset = 12;
value_offset = 6;
new_flags |= BSF_FUNCTION;
break;
case GSD_S_C_SYM:
if (old_flags & GSY_S_M_DEF) /* Symbol definition. */
name_offset = 9;
else
name_offset = 4;
value_offset = 5;
break;
case GSD_S_C_SYMW:
if (old_flags & GSY_S_M_DEF) /* Symbol definition. */
name_offset = 10;
else
name_offset = 5;
value_offset = 6;
break;
}
/* Save symbol in vms_symbol_table. */
entry = _bfd_vms_enter_symbol
(abfd, _bfd_vms_save_counted_string (vms_rec + name_offset));
if (entry == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
symbol = entry->symbol;
if (old_flags & GSY_S_M_DEF)
{
/* Symbol definition. */
int psect;
symbol->value = bfd_getl32 (vms_rec + value_offset);
if ((gsd_type == GSD_S_C_SYMW)
|| (gsd_type == GSD_S_C_EPMW))
psect = bfd_getl16 (vms_rec + value_offset - 2);
else
psect = vms_rec[value_offset-1];
symbol->section = (asection *)(unsigned long)psect;
#if VMS_DEBUG
vms_debug (4, "gsd sym def #%d (%s, %ld, %04x=%s)\n", abfd->symcount,
symbol->name, (long)symbol->section, old_flags, flag2str(gsyflagdesc, old_flags));
#endif
}
else
{
/* Symbol reference. */
#if VMS_DEBUG
vms_debug (4, "gsd sym ref #%d (%s, %04x=%s)\n", abfd->symcount,
symbol->name, old_flags, flag2str (gsyflagdesc, old_flags));
#endif
symbol->section = (asection *)(unsigned long)-1;
}
gsd_size = vms_rec[name_offset] + name_offset + 1;
symbol->flags = new_flags;
}
break;
case GSD_S_C_PRO:
case GSD_S_C_PROW:
#if VMS_DEBUG
vms_debug (4, "gsd pro\n");
#endif
break;
case GSD_S_C_IDC:
#if VMS_DEBUG
vms_debug (4, "gsd idc\n");
#endif
break;
case GSD_S_C_ENV:
#if VMS_DEBUG
vms_debug (4, "gsd env\n");
#endif
break;
case GSD_S_C_LSY:
#if VMS_DEBUG
vms_debug (4, "gsd lsy\n");
#endif
break;
case GSD_S_C_LEPM:
#if VMS_DEBUG
vms_debug (4, "gsd lepm\n");
#endif
break;
case GSD_S_C_LPRO:
#if VMS_DEBUG
vms_debug (4, "gsd lpro\n");
#endif
break;
case GSD_S_C_SPSC:
#if VMS_DEBUG
vms_debug (4, "gsd spsc\n");
#endif
break;
case GSD_S_C_SYMV:
#if VMS_DEBUG
vms_debug (4, "gsd symv\n");
#endif
break;
case GSD_S_C_EPMV:
#if VMS_DEBUG
vms_debug (4, "gsd epmv\n");
#endif
break;
case GSD_S_C_PROV:
#if VMS_DEBUG
vms_debug (4, "gsd prov\n");
#endif
break;
case EGSD_S_C_PSC + EVAX_OFFSET:
{
/* Program section definition. */
name = _bfd_vms_save_counted_string (vms_rec + EGPS_S_B_NAMLNG);
section = bfd_make_section (abfd, name);
if (!section)
return -1;
old_flags = bfd_getl16 (vms_rec + EGPS_S_W_FLAGS);
section->size = bfd_getl32 (vms_rec + EGPS_S_L_ALLOC);
new_flags = vms_secflag_by_name (abfd, evax_section_flags, name,
section->size > 0);
if (old_flags & EGPS_S_V_REL)
new_flags |= SEC_RELOC;
if (!bfd_set_section_flags (abfd, section, new_flags))
return -1;
section->alignment_power = vms_rec[EGPS_S_B_ALIGN];
align_addr = (1 << section->alignment_power);
if ((base_addr % align_addr) != 0)
base_addr += (align_addr - (base_addr % align_addr));
section->vma = (bfd_vma)base_addr;
base_addr += section->size;
section->contents = bfd_zmalloc (section->size);
if (section->contents == NULL)
return -1;
section->filepos = (unsigned int)-1;
#if VMS_DEBUG
vms_debug (4, "EGSD P-section %d (%s, flags %04x=%s) ",
section->index, name, old_flags, flag2str(gpsflagdesc, old_flags));
vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n",
section->size, section->vma, section->contents);
#endif
}
break;
case EGSD_S_C_SYM + EVAX_OFFSET:
{
/* Global symbol specification (definition or reference). */
symbol = bfd_make_empty_symbol (abfd);
if (symbol == 0)
return -1;
old_flags = bfd_getl16 (vms_rec + EGSY_S_W_FLAGS);
new_flags = BSF_NO_FLAGS;
if (old_flags & EGSY_S_V_WEAK)
new_flags |= BSF_WEAK;
if (old_flags & EGSY_S_V_DEF)
{
/* Symbol definition. */
if (old_flags & EGSY_S_V_NORM)
new_flags |= BSF_FUNCTION;
symbol->name =
_bfd_vms_save_counted_string (vms_rec + ESDF_S_B_NAMLNG);
symbol->value = bfd_getl64 (vms_rec + ESDF_S_L_VALUE);
symbol->section =
(asection *)(unsigned long) bfd_getl32 (vms_rec + ESDF_S_L_PSINDX);
#if VMS_DEBUG
vms_debug (4, "EGSD sym def #%d (%s, %ld, %04x=%s)\n",
abfd->symcount, symbol->name, (long)symbol->section,
old_flags, flag2str (gsyflagdesc, old_flags));
#endif
}
else
{
/* Symbol reference. */
symbol->name =
_bfd_vms_save_counted_string (vms_rec + ESRF_S_B_NAMLNG);
#if VMS_DEBUG
vms_debug (4, "EGSD sym ref #%d (%s, %04x=%s)\n",
abfd->symcount, symbol->name, old_flags,
flag2str (gsyflagdesc, old_flags));
#endif
symbol->section = (asection *)(unsigned long)-1;
}
symbol->flags = new_flags;
/* Register symbol in VMS symbol table. */
entry = (vms_symbol_entry *) bfd_hash_lookup
(PRIV (vms_symbol_table), symbol->name, TRUE, FALSE);
if (entry == NULL)
{
bfd_set_error (bfd_error_no_memory);
return -1;
}
if (entry->symbol != NULL)
{
/* FIXME ?, DEC C generates this. */
#if VMS_DEBUG
vms_debug (4, "EGSD_S_C_SYM: duplicate \"%s\"\n", symbol->name);
#endif
}
else
{
entry->symbol = symbol;
PRIV (gsd_sym_count)++;
abfd->symcount++;
}
}
break;
case EGSD_S_C_SYMG + EVAX_OFFSET:
{
/* Universal symbol specification (definition). */
symbol = bfd_make_empty_symbol (abfd);
if (symbol == 0)
return -1;
old_flags = bfd_getl16 (vms_rec + EGST_S_W_FLAGS);
new_flags = BSF_NO_FLAGS;
if (old_flags & EGSY_S_V_WEAK)
new_flags |= BSF_WEAK;
if (old_flags & EGSY_S_V_DEF) /* symbol definition */
{
if (old_flags & EGSY_S_V_NORM)
new_flags |= BSF_FUNCTION;
symbol->name =
_bfd_vms_save_counted_string (vms_rec + EGST_S_B_NAMLNG);
/* For BSF_FUNCTION symbols, the entry point is in LP_1
and the descriptor in LP_2. For other symbols, the
unique value is in LP_2. */
symbol->value = bfd_getl64 (vms_rec + EGST_S_Q_LP_2);
/* Adding this offset is necessary in order for GDB to
read the DWARF-2 debug info from shared libraries. */
if (abfd->flags & DYNAMIC
&& strstr (symbol->name, "$DWARF2.DEBUG") != 0)
symbol->value += PRIV (symvva);
}
else /* symbol reference */
(*_bfd_error_handler) ("Invalid EGST reference");
symbol->flags = new_flags;
if (register_universal_symbol (abfd, symbol, old_flags) < 0)
return -1;
/* Make a second symbol for the entry point. */
if (symbol->flags & BSF_FUNCTION)
{
asymbol *en_sym;
char *name = bfd_alloc (abfd, strlen (symbol->name) + 5);
en_sym = bfd_make_empty_symbol (abfd);
if (en_sym == 0)
return -1;
strcpy (name, symbol->name);
strcat (name, "..en");
en_sym->name = name;
en_sym->value = bfd_getl64 (vms_rec + EGST_S_Q_LP_1);
if (register_universal_symbol (abfd, en_sym, old_flags) < 0)
return -1;
}
}
break;
case EGSD_S_C_IDC + EVAX_OFFSET:
break;
default:
(*_bfd_error_handler) (_("Unknown GSD/EGSD subtype %d"), gsd_type);
bfd_set_error (bfd_error_bad_value);
return -1;
}
PRIV (rec_size) -= gsd_size;
PRIV (vms_rec) += gsd_size;
}
if (abfd->symcount > 0)
abfd->flags |= HAS_SYMS;
return 0;
}
bfd_boolean
_bfd_elf_discard_section_eh_frame
(bfd *abfd, struct bfd_link_info *info, asection *sec,
bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
struct elf_reloc_cookie *cookie)
{
#define REQUIRE(COND) \
do \
if (!(COND)) \
goto free_no_table; \
while (0)
bfd_byte *ehbuf = NULL, *buf;
bfd_byte *last_fde;
struct eh_cie_fde *ent, *this_inf;
unsigned int hdr_length, hdr_id;
struct extended_cie
{
struct cie cie;
unsigned int offset;
unsigned int usage_count;
unsigned int entry;
} *ecies = NULL, *ecie;
unsigned int ecie_count = 0, ecie_alloced = 0;
struct cie *cie;
struct elf_link_hash_table *htab;
struct eh_frame_hdr_info *hdr_info;
struct eh_frame_sec_info *sec_info = NULL;
unsigned int offset;
unsigned int ptr_size;
unsigned int entry_alloced;
if (sec->size == 0)
{
/* This file does not contain .eh_frame information. */
return FALSE;
}
if (bfd_is_abs_section (sec->output_section))
{
/* At least one of the sections is being discarded from the
link, so we should just ignore them. */
return FALSE;
}
htab = elf_hash_table (info);
hdr_info = &htab->eh_info;
if (hdr_info->cies == NULL && !info->relocatable)
hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
/* Read the frame unwind information from abfd. */
REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
if (sec->size >= 4
&& bfd_get_32 (abfd, ehbuf) == 0
&& cookie->rel == cookie->relend)
{
/* Empty .eh_frame section. */
free (ehbuf);
return FALSE;
}
/* If .eh_frame section size doesn't fit into int, we cannot handle
it (it would need to use 64-bit .eh_frame format anyway). */
REQUIRE (sec->size == (unsigned int) sec->size);
ptr_size = (get_elf_backend_data (abfd)
->elf_backend_eh_frame_address_size (abfd, sec));
REQUIRE (ptr_size != 0);
buf = ehbuf;
sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
+ 99 * sizeof (struct eh_cie_fde));
REQUIRE (sec_info);
entry_alloced = 100;
#define ENSURE_NO_RELOCS(buf) \
REQUIRE (!(cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
< (bfd_size_type) ((buf) - ehbuf)) \
&& cookie->rel->r_info != 0))
#define SKIP_RELOCS(buf) \
while (cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
< (bfd_size_type) ((buf) - ehbuf))) \
cookie->rel++
#define GET_RELOC(buf) \
((cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
== (bfd_size_type) ((buf) - ehbuf))) \
? cookie->rel : NULL)
for (;;)
{
char *aug;
bfd_byte *start, *end, *insns, *insns_end;
bfd_size_type length;
unsigned int set_loc_count;
if (sec_info->count == entry_alloced)
{
sec_info = bfd_realloc (sec_info,
sizeof (struct eh_frame_sec_info)
+ ((entry_alloced + 99)
* sizeof (struct eh_cie_fde)));
REQUIRE (sec_info);
memset (&sec_info->entry[entry_alloced], 0,
100 * sizeof (struct eh_cie_fde));
entry_alloced += 100;
}
this_inf = sec_info->entry + sec_info->count;
last_fde = buf;
if ((bfd_size_type) (buf - ehbuf) == sec->size)
break;
/* Read the length of the entry. */
REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
hdr_length = bfd_get_32 (abfd, buf - 4);
/* 64-bit .eh_frame is not supported. */
REQUIRE (hdr_length != 0xffffffff);
/* The CIE/FDE must be fully contained in this input section. */
REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
end = buf + hdr_length;
this_inf->offset = last_fde - ehbuf;
this_inf->size = 4 + hdr_length;
if (hdr_length == 0)
{
/* A zero-length CIE should only be found at the end of
the section. */
REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
ENSURE_NO_RELOCS (buf);
sec_info->count++;
break;
}
REQUIRE (skip_bytes (&buf, end, 4));
hdr_id = bfd_get_32 (abfd, buf - 4);
if (hdr_id == 0)
{
unsigned int initial_insn_length;
/* CIE */
this_inf->cie = 1;
if (ecie_count == ecie_alloced)
{
ecies = bfd_realloc (ecies,
(ecie_alloced + 20) * sizeof (*ecies));
REQUIRE (ecies);
memset (&ecies[ecie_alloced], 0, 20 * sizeof (*ecies));
ecie_alloced += 20;
}
cie = &ecies[ecie_count].cie;
ecies[ecie_count].offset = this_inf->offset;
ecies[ecie_count++].entry = sec_info->count;
cie->length = hdr_length;
start = buf;
REQUIRE (read_byte (&buf, end, &cie->version));
/* Cannot handle unknown versions. */
REQUIRE (cie->version == 1 || cie->version == 3);
REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
strcpy (cie->augmentation, (char *) buf);
buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
ENSURE_NO_RELOCS (buf);
if (buf[0] == 'e' && buf[1] == 'h')
{
/* GCC < 3.0 .eh_frame CIE */
/* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
is private to each CIE, so we don't need it for anything.
Just skip it. */
REQUIRE (skip_bytes (&buf, end, ptr_size));
SKIP_RELOCS (buf);
}
REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
if (cie->version == 1)
{
REQUIRE (buf < end);
cie->ra_column = *buf++;
}
else
REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
ENSURE_NO_RELOCS (buf);
cie->lsda_encoding = DW_EH_PE_omit;
cie->fde_encoding = DW_EH_PE_omit;
cie->per_encoding = DW_EH_PE_omit;
aug = cie->augmentation;
if (aug[0] != 'e' || aug[1] != 'h')
{
if (*aug == 'z')
{
aug++;
REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
ENSURE_NO_RELOCS (buf);
}
while (*aug != '\0')
switch (*aug++)
{
case 'L':
REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
ENSURE_NO_RELOCS (buf);
REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
break;
case 'R':
REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
ENSURE_NO_RELOCS (buf);
REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
break;
case 'S':
break;
case 'P':
{
int per_width;
REQUIRE (read_byte (&buf, end, &cie->per_encoding));
per_width = get_DW_EH_PE_width (cie->per_encoding,
ptr_size);
REQUIRE (per_width);
if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned)
{
length = -(buf - ehbuf) & (per_width - 1);
REQUIRE (skip_bytes (&buf, end, length));
}
ENSURE_NO_RELOCS (buf);
/* Ensure we have a reloc here. */
if (GET_RELOC (buf) != NULL)
{
unsigned long r_symndx;
#ifdef BFD64
if (ptr_size == 8)
r_symndx = ELF64_R_SYM (cookie->rel->r_info);
else
#endif
r_symndx = ELF32_R_SYM (cookie->rel->r_info);
if (r_symndx >= cookie->locsymcount
|| ELF_ST_BIND (cookie->locsyms[r_symndx]
.st_info) != STB_LOCAL)
{
struct elf_link_hash_entry *h;
r_symndx -= cookie->extsymoff;
h = cookie->sym_hashes[r_symndx];
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *)
h->root.u.i.link;
cie->personality.h = h;
}
else
{
Elf_Internal_Sym *sym;
asection *sym_sec;
bfd_vma val;
sym = &cookie->locsyms[r_symndx];
sym_sec = (bfd_section_from_elf_index
(abfd, sym->st_shndx));
if (sym_sec != NULL)
{
if (sym_sec->kept_section != NULL)
sym_sec = sym_sec->kept_section;
if (sym_sec->output_section != NULL)
{
val = (sym->st_value
+ sym_sec->output_offset
+ sym_sec->output_section->vma);
cie->personality.val = val;
cie->local_personality = 1;
}
}
}
/* Cope with MIPS-style composite relocations. */
do
cookie->rel++;
while (GET_RELOC (buf) != NULL);
}
REQUIRE (skip_bytes (&buf, end, per_width));
REQUIRE (cie->local_personality || cie->personality.h);
}
break;
default:
/* Unrecognized augmentation. Better bail out. */
goto free_no_table;
}
}
/* For shared libraries, try to get rid of as many RELATIVE relocs
as possible. */
if (info->shared
&& (get_elf_backend_data (abfd)
->elf_backend_can_make_relative_eh_frame
(abfd, info, sec)))
{
if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
cie->make_relative = 1;
/* If the CIE doesn't already have an 'R' entry, it's fairly
easy to add one, provided that there's no aligned data
after the augmentation string. */
else if (cie->fde_encoding == DW_EH_PE_omit
&& (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
{
if (*cie->augmentation == 0)
this_inf->add_augmentation_size = 1;
this_inf->add_fde_encoding = 1;
cie->make_relative = 1;
}
}
if (info->shared
&& (get_elf_backend_data (abfd)
->elf_backend_can_make_lsda_relative_eh_frame
(abfd, info, sec))
&& (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
cie->make_lsda_relative = 1;
/* If FDE encoding was not specified, it defaults to
DW_EH_absptr. */
if (cie->fde_encoding == DW_EH_PE_omit)
cie->fde_encoding = DW_EH_PE_absptr;
initial_insn_length = end - buf;
if (initial_insn_length <= sizeof (cie->initial_instructions))
{
cie->initial_insn_length = initial_insn_length;
memcpy (cie->initial_instructions, buf, initial_insn_length);
}
insns = buf;
buf += initial_insn_length;
ENSURE_NO_RELOCS (buf);
}
else
{
/* Find the corresponding CIE. */
unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
if (cie_offset == ecie->offset)
break;
/* Ensure this FDE references one of the CIEs in this input
section. */
REQUIRE (ecie != ecies + ecie_count);
cie = &ecie->cie;
ENSURE_NO_RELOCS (buf);
REQUIRE (GET_RELOC (buf));
if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
/* This is a FDE against a discarded section. It should
be deleted. */
this_inf->removed = 1;
else
{
if (info->shared
&& (((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr
&& cie->make_relative == 0)
|| (cie->fde_encoding & 0xf0) == DW_EH_PE_aligned))
{
/* If a shared library uses absolute pointers
which we cannot turn into PC relative,
don't create the binary search table,
since it is affected by runtime relocations. */
hdr_info->table = FALSE;
(*info->callbacks->einfo)
(_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
" table being created.\n"), abfd, sec);
}
ecie->usage_count++;
hdr_info->fde_count++;
this_inf->cie_inf = (void *) (ecie - ecies);
}
/* Skip the initial location and address range. */
start = buf;
length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
REQUIRE (skip_bytes (&buf, end, 2 * length));
/* Skip the augmentation size, if present. */
if (cie->augmentation[0] == 'z')
REQUIRE (read_uleb128 (&buf, end, &length));
else
length = 0;
/* Of the supported augmentation characters above, only 'L'
adds augmentation data to the FDE. This code would need to
be adjusted if any future augmentations do the same thing. */
if (cie->lsda_encoding != DW_EH_PE_omit)
{
this_inf->lsda_offset = buf - start;
/* If there's no 'z' augmentation, we don't know where the
CFA insns begin. Assume no padding. */
if (cie->augmentation[0] != 'z')
length = end - buf;
}
/* Skip over the augmentation data. */
REQUIRE (skip_bytes (&buf, end, length));
insns = buf;
buf = last_fde + 4 + hdr_length;
SKIP_RELOCS (buf);
}
/* Try to interpret the CFA instructions and find the first
padding nop. Shrink this_inf's size so that it doesn't
include the padding. */
length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
set_loc_count = 0;
insns_end = skip_non_nops (insns, end, length, &set_loc_count);
/* If we don't understand the CFA instructions, we can't know
what needs to be adjusted there. */
if (insns_end == NULL
/* For the time being we don't support DW_CFA_set_loc in
CIE instructions. */
|| (set_loc_count && this_inf->cie))
goto free_no_table;
this_inf->size -= end - insns_end;
if (insns_end != end && this_inf->cie)
{
cie->initial_insn_length -= end - insns_end;
cie->length -= end - insns_end;
}
if (set_loc_count
&& ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
|| cie->make_relative))
{
unsigned int cnt;
bfd_byte *p;
this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
* sizeof (unsigned int));
REQUIRE (this_inf->set_loc);
this_inf->set_loc[0] = set_loc_count;
p = insns;
cnt = 0;
while (p < end)
{
if (*p == DW_CFA_set_loc)
this_inf->set_loc[++cnt] = p + 1 - start;
REQUIRE (skip_cfa_op (&p, end, length));
}
}
this_inf->fde_encoding = cie->fde_encoding;
this_inf->lsda_encoding = cie->lsda_encoding;
sec_info->count++;
}
elf_section_data (sec)->sec_info = sec_info;
sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
/* Look at all CIEs in this section and determine which can be
removed as unused, which can be merged with previous duplicate
CIEs and which need to be kept. */
for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
{
if (ecie->usage_count == 0)
{
sec_info->entry[ecie->entry].removed = 1;
continue;
}
ecie->cie.output_sec = sec->output_section;
ecie->cie.cie_inf = sec_info->entry + ecie->entry;
cie_compute_hash (&ecie->cie);
if (hdr_info->cies != NULL)
{
void **loc = htab_find_slot_with_hash (hdr_info->cies, &ecie->cie,
ecie->cie.hash, INSERT);
if (loc != NULL)
{
if (*loc != HTAB_EMPTY_ENTRY)
{
sec_info->entry[ecie->entry].removed = 1;
ecie->cie.cie_inf = ((struct cie *) *loc)->cie_inf;
continue;
}
*loc = malloc (sizeof (struct cie));
if (*loc == NULL)
*loc = HTAB_DELETED_ENTRY;
else
memcpy (*loc, &ecie->cie, sizeof (struct cie));
}
}
ecie->cie.cie_inf->make_relative = ecie->cie.make_relative;
ecie->cie.cie_inf->make_lsda_relative = ecie->cie.make_lsda_relative;
ecie->cie.cie_inf->per_encoding_relative
= (ecie->cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
}
/* Ok, now we can assign new offsets. */
offset = 0;
for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
if (!ent->removed)
{
if (!ent->cie)
{
ecie = ecies + (bfd_hostptr_t) ent->cie_inf;
ent->cie_inf = ecie->cie.cie_inf;
}
ent->new_offset = offset;
offset += size_of_output_cie_fde (ent, ptr_size);
}
/* Resize the sec as needed. */
sec->rawsize = sec->size;
sec->size = offset;
free (ehbuf);
if (ecies)
free (ecies);
return offset != sec->rawsize;
free_no_table:
(*info->callbacks->einfo)
(_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
abfd, sec);
if (ehbuf)
free (ehbuf);
if (sec_info)
free (sec_info);
if (ecies)
free (ecies);
hdr_info->table = FALSE;
return FALSE;
#undef REQUIRE
}
void
_bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
asection *sec, struct elf_reloc_cookie *cookie)
{
#define REQUIRE(COND) \
do \
if (!(COND)) \
goto free_no_table; \
while (0)
bfd_byte *ehbuf = NULL, *buf, *end;
bfd_byte *last_fde;
struct eh_cie_fde *this_inf;
unsigned int hdr_length, hdr_id;
unsigned int cie_count;
struct cie *cie, *local_cies = NULL;
struct elf_link_hash_table *htab;
struct eh_frame_hdr_info *hdr_info;
struct eh_frame_sec_info *sec_info = NULL;
unsigned int ptr_size;
unsigned int num_cies;
unsigned int num_entries;
elf_gc_mark_hook_fn gc_mark_hook;
htab = elf_hash_table (info);
hdr_info = &htab->eh_info;
if (hdr_info->parsed_eh_frames)
return;
if (sec->size == 0)
{
/* This file does not contain .eh_frame information. */
return;
}
if (bfd_is_abs_section (sec->output_section))
{
/* At least one of the sections is being discarded from the
link, so we should just ignore them. */
return;
}
/* Read the frame unwind information from abfd. */
REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
if (sec->size >= 4
&& bfd_get_32 (abfd, ehbuf) == 0
&& cookie->rel == cookie->relend)
{
/* Empty .eh_frame section. */
free (ehbuf);
return;
}
/* If .eh_frame section size doesn't fit into int, we cannot handle
it (it would need to use 64-bit .eh_frame format anyway). */
REQUIRE (sec->size == (unsigned int) sec->size);
ptr_size = (get_elf_backend_data (abfd)
->elf_backend_eh_frame_address_size (abfd, sec));
REQUIRE (ptr_size != 0);
/* Go through the section contents and work out how many FDEs and
CIEs there are. */
buf = ehbuf;
end = ehbuf + sec->size;
num_cies = 0;
num_entries = 0;
while (buf != end)
{
num_entries++;
/* Read the length of the entry. */
REQUIRE (skip_bytes (&buf, end, 4));
hdr_length = bfd_get_32 (abfd, buf - 4);
/* 64-bit .eh_frame is not supported. */
REQUIRE (hdr_length != 0xffffffff);
if (hdr_length == 0)
break;
REQUIRE (skip_bytes (&buf, end, 4));
hdr_id = bfd_get_32 (abfd, buf - 4);
if (hdr_id == 0)
num_cies++;
REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
}
sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
+ (num_entries - 1) * sizeof (struct eh_cie_fde));
REQUIRE (sec_info);
/* We need to have a "struct cie" for each CIE in this section. */
local_cies = bfd_zmalloc (num_cies * sizeof (*local_cies));
REQUIRE (local_cies);
#define ENSURE_NO_RELOCS(buf) \
REQUIRE (!(cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
< (bfd_size_type) ((buf) - ehbuf)) \
&& cookie->rel->r_info != 0))
#define SKIP_RELOCS(buf) \
while (cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
< (bfd_size_type) ((buf) - ehbuf))) \
cookie->rel++
#define GET_RELOC(buf) \
((cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
== (bfd_size_type) ((buf) - ehbuf))) \
? cookie->rel : NULL)
buf = ehbuf;
cie_count = 0;
gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
while ((bfd_size_type) (buf - ehbuf) != sec->size)
{
char *aug;
bfd_byte *start, *insns, *insns_end;
bfd_size_type length;
unsigned int set_loc_count;
this_inf = sec_info->entry + sec_info->count;
last_fde = buf;
/* Read the length of the entry. */
REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
hdr_length = bfd_get_32 (abfd, buf - 4);
/* The CIE/FDE must be fully contained in this input section. */
REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
end = buf + hdr_length;
this_inf->offset = last_fde - ehbuf;
this_inf->size = 4 + hdr_length;
this_inf->reloc_index = cookie->rel - cookie->rels;
if (hdr_length == 0)
{
/* A zero-length CIE should only be found at the end of
the section. */
REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
ENSURE_NO_RELOCS (buf);
sec_info->count++;
break;
}
REQUIRE (skip_bytes (&buf, end, 4));
hdr_id = bfd_get_32 (abfd, buf - 4);
if (hdr_id == 0)
{
unsigned int initial_insn_length;
/* CIE */
this_inf->cie = 1;
/* Point CIE to one of the section-local cie structures. */
cie = local_cies + cie_count++;
cie->cie_inf = this_inf;
cie->length = hdr_length;
cie->output_sec = sec->output_section;
start = buf;
REQUIRE (read_byte (&buf, end, &cie->version));
/* Cannot handle unknown versions. */
REQUIRE (cie->version == 1 || cie->version == 3);
REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
strcpy (cie->augmentation, (char *) buf);
buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
ENSURE_NO_RELOCS (buf);
if (buf[0] == 'e' && buf[1] == 'h')
{
/* GCC < 3.0 .eh_frame CIE */
/* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
is private to each CIE, so we don't need it for anything.
Just skip it. */
REQUIRE (skip_bytes (&buf, end, ptr_size));
SKIP_RELOCS (buf);
}
REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
if (cie->version == 1)
{
REQUIRE (buf < end);
cie->ra_column = *buf++;
}
else
REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
ENSURE_NO_RELOCS (buf);
cie->lsda_encoding = DW_EH_PE_omit;
cie->fde_encoding = DW_EH_PE_omit;
cie->per_encoding = DW_EH_PE_omit;
aug = cie->augmentation;
if (aug[0] != 'e' || aug[1] != 'h')
{
if (*aug == 'z')
{
aug++;
REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
ENSURE_NO_RELOCS (buf);
}
while (*aug != '\0')
switch (*aug++)
{
case 'L':
REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
ENSURE_NO_RELOCS (buf);
REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
break;
case 'R':
REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
ENSURE_NO_RELOCS (buf);
REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
break;
case 'S':
break;
case 'P':
{
int per_width;
REQUIRE (read_byte (&buf, end, &cie->per_encoding));
per_width = get_DW_EH_PE_width (cie->per_encoding,
ptr_size);
REQUIRE (per_width);
if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned)
{
length = -(buf - ehbuf) & (per_width - 1);
REQUIRE (skip_bytes (&buf, end, length));
}
ENSURE_NO_RELOCS (buf);
/* Ensure we have a reloc here. */
REQUIRE (GET_RELOC (buf));
cie->personality.reloc_index
= cookie->rel - cookie->rels;
/* Cope with MIPS-style composite relocations. */
do
cookie->rel++;
while (GET_RELOC (buf) != NULL);
REQUIRE (skip_bytes (&buf, end, per_width));
}
break;
default:
/* Unrecognized augmentation. Better bail out. */
goto free_no_table;
}
}
/* For shared libraries, try to get rid of as many RELATIVE relocs
as possible. */
if (info->shared
&& (get_elf_backend_data (abfd)
->elf_backend_can_make_relative_eh_frame
(abfd, info, sec)))
{
if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
this_inf->make_relative = 1;
/* If the CIE doesn't already have an 'R' entry, it's fairly
easy to add one, provided that there's no aligned data
after the augmentation string. */
else if (cie->fde_encoding == DW_EH_PE_omit
&& (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
{
if (*cie->augmentation == 0)
this_inf->add_augmentation_size = 1;
this_inf->u.cie.add_fde_encoding = 1;
this_inf->make_relative = 1;
}
}
if (info->shared
&& (get_elf_backend_data (abfd)
->elf_backend_can_make_lsda_relative_eh_frame
(abfd, info, sec))
&& (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
cie->can_make_lsda_relative = 1;
/* If FDE encoding was not specified, it defaults to
DW_EH_absptr. */
if (cie->fde_encoding == DW_EH_PE_omit)
cie->fde_encoding = DW_EH_PE_absptr;
initial_insn_length = end - buf;
if (initial_insn_length <= sizeof (cie->initial_instructions))
{
cie->initial_insn_length = initial_insn_length;
memcpy (cie->initial_instructions, buf, initial_insn_length);
}
insns = buf;
buf += initial_insn_length;
ENSURE_NO_RELOCS (buf);
if (hdr_info->merge_cies)
this_inf->u.cie.u.full_cie = cie;
this_inf->u.cie.per_encoding_relative
= (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
}
else
{
asection *rsec;
/* Find the corresponding CIE. */
unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
for (cie = local_cies; cie < local_cies + cie_count; cie++)
if (cie_offset == cie->cie_inf->offset)
break;
/* Ensure this FDE references one of the CIEs in this input
section. */
REQUIRE (cie != local_cies + cie_count);
this_inf->u.fde.cie_inf = cie->cie_inf;
this_inf->make_relative = cie->cie_inf->make_relative;
this_inf->add_augmentation_size
= cie->cie_inf->add_augmentation_size;
ENSURE_NO_RELOCS (buf);
REQUIRE (GET_RELOC (buf));
/* Chain together the FDEs for each section. */
rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
/* RSEC will be NULL if FDE was cleared out as it was belonging to
a discarded SHT_GROUP. */
if (rsec)
{
REQUIRE (rsec->owner == abfd);
this_inf->u.fde.next_for_section = elf_fde_list (rsec);
elf_fde_list (rsec) = this_inf;
}
/* Skip the initial location and address range. */
start = buf;
length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
REQUIRE (skip_bytes (&buf, end, 2 * length));
/* Skip the augmentation size, if present. */
if (cie->augmentation[0] == 'z')
REQUIRE (read_uleb128 (&buf, end, &length));
else
length = 0;
/* Of the supported augmentation characters above, only 'L'
adds augmentation data to the FDE. This code would need to
be adjusted if any future augmentations do the same thing. */
if (cie->lsda_encoding != DW_EH_PE_omit)
{
SKIP_RELOCS (buf);
if (cie->can_make_lsda_relative && GET_RELOC (buf))
cie->cie_inf->u.cie.make_lsda_relative = 1;
this_inf->lsda_offset = buf - start;
/* If there's no 'z' augmentation, we don't know where the
CFA insns begin. Assume no padding. */
if (cie->augmentation[0] != 'z')
length = end - buf;
}
/* Skip over the augmentation data. */
REQUIRE (skip_bytes (&buf, end, length));
insns = buf;
buf = last_fde + 4 + hdr_length;
/* For NULL RSEC (cleared FDE belonging to a discarded section)
the relocations are commonly cleared. We do not sanity check if
all these relocations are cleared as (1) relocations to
.gcc_except_table will remain uncleared (they will get dropped
with the drop of this unused FDE) and (2) BFD already safely drops
relocations of any type to .eh_frame by
elf_section_ignore_discarded_relocs.
TODO: The .gcc_except_table entries should be also filtered as
.eh_frame entries; or GCC could rather use COMDAT for them. */
SKIP_RELOCS (buf);
}
/* Try to interpret the CFA instructions and find the first
padding nop. Shrink this_inf's size so that it doesn't
include the padding. */
length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
set_loc_count = 0;
insns_end = skip_non_nops (insns, end, length, &set_loc_count);
/* If we don't understand the CFA instructions, we can't know
what needs to be adjusted there. */
if (insns_end == NULL
/* For the time being we don't support DW_CFA_set_loc in
CIE instructions. */
|| (set_loc_count && this_inf->cie))
goto free_no_table;
this_inf->size -= end - insns_end;
if (insns_end != end && this_inf->cie)
{
cie->initial_insn_length -= end - insns_end;
cie->length -= end - insns_end;
}
if (set_loc_count
&& ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
|| this_inf->make_relative))
{
unsigned int cnt;
bfd_byte *p;
this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
* sizeof (unsigned int));
REQUIRE (this_inf->set_loc);
this_inf->set_loc[0] = set_loc_count;
p = insns;
cnt = 0;
while (p < end)
{
if (*p == DW_CFA_set_loc)
this_inf->set_loc[++cnt] = p + 1 - start;
REQUIRE (skip_cfa_op (&p, end, length));
}
}
this_inf->removed = 1;
this_inf->fde_encoding = cie->fde_encoding;
this_inf->lsda_encoding = cie->lsda_encoding;
sec_info->count++;
}
BFD_ASSERT (sec_info->count == num_entries);
BFD_ASSERT (cie_count == num_cies);
elf_section_data (sec)->sec_info = sec_info;
sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
if (hdr_info->merge_cies)
{
sec_info->cies = local_cies;
local_cies = NULL;
}
goto success;
free_no_table:
(*info->callbacks->einfo)
(_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
abfd, sec);
hdr_info->table = FALSE;
if (sec_info)
free (sec_info);
success:
if (ehbuf)
free (ehbuf);
if (local_cies)
free (local_cies);
#undef REQUIRE
}
static const bfd_target *
cisco_core_file_validate (bfd *abfd, int crash_info_loc)
{
char buf[4];
unsigned int crashinfo_offset;
crashinfo_external crashinfo;
bfd_size_type nread;
unsigned int magic;
unsigned int version;
unsigned int rambase;
sec_ptr asect;
struct stat statbuf;
bfd_size_type amt;
flagword flags;
if (bfd_seek (abfd, (file_ptr) crash_info_loc, SEEK_SET) != 0)
return NULL;
nread = bfd_bread (buf, (bfd_size_type) 4, abfd);
if (nread != 4)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
crashinfo_offset = MASK_ADDR (bfd_get_32 (abfd, buf));
if (bfd_seek (abfd, (file_ptr) crashinfo_offset, SEEK_SET) != 0)
{
/* Most likely we failed because of a bogus (huge) offset */
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
nread = bfd_bread (&crashinfo, (bfd_size_type) sizeof (crashinfo), abfd);
if (nread != sizeof (crashinfo))
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
if (bfd_stat (abfd, &statbuf) < 0)
{
bfd_set_error (bfd_error_system_call);
return NULL;
}
magic = bfd_get_32 (abfd, crashinfo.magic);
if (magic != CRASH_MAGIC)
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
version = bfd_get_32 (abfd, crashinfo.version);
if (version == 0)
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
else if (version == 1)
{
/* V1 core dumps don't specify the dump base, assume 0 */
rambase = 0;
}
else
{
rambase = bfd_get_32 (abfd, crashinfo.rambase);
}
/* OK, we believe you. You're a core file. */
amt = sizeof (struct cisco_core_struct);
abfd->tdata.cisco_core_data = (struct cisco_core_struct *) bfd_zmalloc (amt);
if (abfd->tdata.cisco_core_data == NULL)
return NULL;
switch ((crashreason) bfd_get_32 (abfd, crashinfo.reason))
{
case CRASH_REASON_NOTCRASHED:
/* Crash file probably came from write core. */
abfd->tdata.cisco_core_data->sig = 0;
break;
case CRASH_REASON_CORRUPT:
/* The crash context area was corrupt -- proceed with caution.
We have no way of passing this information back to the caller. */
abfd->tdata.cisco_core_data->sig = 0;
break;
case CRASH_REASON_EXCEPTION:
/* Crash occured due to CPU exception. */
/* This is 68k-specific; for MIPS we'll need to interpret
cpu_vector differently based on the target configuration
(since CISCO core files don't seem to have the processor
encoded in them). */
switch (bfd_get_32 (abfd, crashinfo.cpu_vector))
{
/* bus error */
case 2 : abfd->tdata.cisco_core_data->sig = SIGBUS; break;
/* address error */
case 3 : abfd->tdata.cisco_core_data->sig = SIGBUS; break;
/* illegal instruction */
case 4 : abfd->tdata.cisco_core_data->sig = SIGILL; break;
/* zero divide */
case 5 : abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* chk instruction */
case 6 : abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* trapv instruction */
case 7 : abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* privilege violation */
case 8 : abfd->tdata.cisco_core_data->sig = SIGSEGV; break;
/* trace trap */
case 9 : abfd->tdata.cisco_core_data->sig = SIGTRAP; break;
/* line 1010 emulator */
case 10: abfd->tdata.cisco_core_data->sig = SIGILL; break;
/* line 1111 emulator */
case 11: abfd->tdata.cisco_core_data->sig = SIGILL; break;
/* Coprocessor protocol violation. Using a standard MMU or FPU
this cannot be triggered by software. Call it a SIGBUS. */
case 13: abfd->tdata.cisco_core_data->sig = SIGBUS; break;
/* interrupt */
case 31: abfd->tdata.cisco_core_data->sig = SIGINT; break;
/* breakpoint */
case 33: abfd->tdata.cisco_core_data->sig = SIGTRAP; break;
/* floating point err */
case 48: abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* floating point err */
case 49: abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* zero divide */
case 50: abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* underflow */
case 51: abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* operand error */
case 52: abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* overflow */
case 53: abfd->tdata.cisco_core_data->sig = SIGFPE; break;
/* NAN */
case 54: abfd->tdata.cisco_core_data->sig = SIGFPE; break;
default:
#ifndef SIGEMT
#define SIGEMT SIGTRAP
#endif
/* "software generated"*/
abfd->tdata.cisco_core_data->sig = SIGEMT;
}
break;
default:
/* Unknown crash reason. */
abfd->tdata.cisco_core_data->sig = 0;
break;
}
/* Create a ".data" section that maps the entire file, which is
essentially a dump of the target system's RAM. */
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
asect = bfd_make_section_anyway_with_flags (abfd, ".data", flags);
if (asect == NULL)
goto error_return;
/* The size of memory is the size of the core file itself. */
asect->size = statbuf.st_size;
asect->vma = rambase;
asect->filepos = 0;
/* Create a ".crash" section to allow access to the saved
crash information. */
flags = SEC_HAS_CONTENTS;
asect = bfd_make_section_anyway_with_flags (abfd, ".crash", flags);
if (asect == NULL)
goto error_return;
asect->vma = 0;
asect->filepos = crashinfo_offset;
asect->size = sizeof (crashinfo);
/* Create a ".reg" section to allow access to the saved
registers. */
asect = bfd_make_section_anyway_with_flags (abfd, ".reg", flags);
if (asect == NULL)
goto error_return;
asect->vma = 0;
asect->filepos = bfd_get_32 (abfd, crashinfo.registers) - rambase;
/* Since we don't know the exact size of the saved register info,
choose a register section size that is either the remaining part
of the file, or 1024, whichever is smaller. */
nread = statbuf.st_size - asect->filepos;
asect->size = (nread < 1024) ? nread : 1024;
return abfd->xvec;
/* Get here if we have already started filling out the BFD
and there is an error of some kind. */
error_return:
bfd_release (abfd, abfd->tdata.any);
abfd->tdata.any = NULL;
bfd_section_list_clear (abfd);
return NULL;
}
bfd_boolean
bfd_get_file_window (bfd *abfd,
file_ptr offset,
bfd_size_type size,
bfd_window *windowp,
bfd_boolean writable)
{
static size_t pagesize;
bfd_window_internal *i = windowp->i;
bfd_size_type size_to_alloc = size;
if (debug_windows)
fprintf (stderr, "bfd_get_file_window (%p, %6ld, %6ld, %p<%p,%lx,%p>, %d)",
abfd, (long) offset, (long) size,
windowp, windowp->data, (unsigned long) windowp->size,
windowp->i, writable);
/* Make sure we know the page size, so we can be friendly to mmap. */
if (pagesize == 0)
pagesize = getpagesize ();
if (pagesize == 0)
abort ();
if (i == NULL)
{
i = bfd_zmalloc (sizeof (bfd_window_internal));
if (i == NULL)
return FALSE;
i->data = NULL;
}
#ifdef HAVE_MMAP
if (ok_to_map
&& (i->data == NULL || i->mapped == 1)
&& (abfd->flags & BFD_IN_MEMORY) == 0)
{
file_ptr file_offset, offset2;
size_t real_size;
int fd;
/* Find the real file and the real offset into it. */
while (abfd->my_archive != NULL
&& !bfd_is_thin_archive (abfd->my_archive))
{
offset += abfd->origin;
abfd = abfd->my_archive;
}
/* Seek into the file, to ensure it is open if cacheable. */
if (abfd->iostream == NULL
&& (abfd->iovec == NULL
|| abfd->iovec->bseek (abfd, offset, SEEK_SET) != 0))
goto free_and_fail;
fd = fileno ((FILE *) abfd->iostream);
/* Compute offsets and size for mmap and for the user's data. */
offset2 = offset % pagesize;
if (offset2 < 0)
abort ();
file_offset = offset - offset2;
real_size = offset + size - file_offset;
real_size = real_size + pagesize - 1;
real_size -= real_size % pagesize;
/* If we're re-using a memory region, make sure it's big enough. */
if (i->data != NULL && i->size < size)
{
munmap (i->data, i->size);
i->data = NULL;
}
i->data = mmap (i->data, real_size,
writable ? PROT_WRITE | PROT_READ : PROT_READ,
(writable
? MAP_FILE | MAP_PRIVATE
: MAP_FILE | MAP_SHARED),
fd, file_offset);
if (i->data == (void *) -1)
{
/* An error happened. Report it, or try using malloc, or
something. */
bfd_set_error (bfd_error_system_call);
windowp->data = 0;
if (debug_windows)
fprintf (stderr, "\t\tmmap failed!\n");
goto free_and_fail;
}
if (debug_windows)
fprintf (stderr, "\n\tmapped %ld at %p, offset is %ld\n",
(long) real_size, i->data, (long) offset2);
i->size = real_size;
windowp->data = (bfd_byte *) i->data + offset2;
windowp->size = size;
i->mapped = 1;
i->refcount = 1;
windowp->i = i;
return TRUE;
}
else if (debug_windows)
{
if (ok_to_map)
fprintf (stderr, _("not mapping: data=%lx mapped=%d\n"),
(unsigned long) i->data, (int) i->mapped);
else
fprintf (stderr, _("not mapping: env var not set\n"));
}
#else
ok_to_map = 0;
#endif
#ifdef HAVE_MPROTECT
if (!writable)
{
size_to_alloc += pagesize - 1;
size_to_alloc -= size_to_alloc % pagesize;
}
#endif
if (debug_windows)
fprintf (stderr, "\n\t%s(%6ld)",
i->data ? "realloc" : " malloc", (long) size_to_alloc);
i->data = bfd_realloc_or_free (i->data, size_to_alloc);
if (debug_windows)
fprintf (stderr, "\t-> %p\n", i->data);
if (i->data == NULL)
{
if (size_to_alloc == 0)
{
windowp->i = i;
return TRUE;
}
goto free_and_fail;
}
i->refcount = 1;
if (bfd_seek (abfd, offset, SEEK_SET) != 0)
goto free_and_fail;
i->size = bfd_bread (i->data, size, abfd);
if (i->size != size)
goto free_and_fail;
i->mapped = 0;
#ifdef HAVE_MPROTECT
if (!writable)
{
if (debug_windows)
fprintf (stderr, "\tmprotect (%p, %ld, PROT_READ)\n", i->data,
(long) i->size);
mprotect (i->data, i->size, PROT_READ);
}
#endif
windowp->data = i->data;
windowp->size = i->size;
windowp->i = i;
return TRUE;
free_and_fail:
/* We have a bfd_window_internal, but an error occurred. Free it. */
free (i);
return FALSE;
}
bfd_boolean
_bfd_elf_discard_section_eh_frame
(bfd *abfd, struct bfd_link_info *info, asection *sec,
bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
struct elf_reloc_cookie *cookie)
{
bfd_byte *ehbuf = NULL, *buf;
bfd_byte *last_cie, *last_fde;
struct cie_header hdr;
struct cie cie;
struct elf_link_hash_table *htab;
struct eh_frame_hdr_info *hdr_info;
struct eh_frame_sec_info *sec_info = NULL;
unsigned int leb128_tmp;
unsigned int cie_usage_count, last_cie_ndx, i, offset;
unsigned int make_relative, make_lsda_relative;
bfd_size_type new_size;
unsigned int ptr_size;
if (sec->_raw_size == 0)
{
/* This file does not contain .eh_frame information. */
return FALSE;
}
if ((sec->output_section != NULL
&& bfd_is_abs_section (sec->output_section)))
{
/* At least one of the sections is being discarded from the
link, so we should just ignore them. */
return FALSE;
}
htab = elf_hash_table (info);
hdr_info = &htab->eh_info;
/* Read the frame unwind information from abfd. */
ehbuf = bfd_malloc (sec->_raw_size);
if (ehbuf == NULL)
goto free_no_table;
if (! bfd_get_section_contents (abfd, sec, ehbuf, 0, sec->_raw_size))
goto free_no_table;
if (sec->_raw_size >= 4
&& bfd_get_32 (abfd, ehbuf) == 0
&& cookie->rel == cookie->relend)
{
/* Empty .eh_frame section. */
free (ehbuf);
return FALSE;
}
/* If .eh_frame section size doesn't fit into int, we cannot handle
it (it would need to use 64-bit .eh_frame format anyway). */
if (sec->_raw_size != (unsigned int) sec->_raw_size)
goto free_no_table;
ptr_size = (elf_elfheader (abfd)->e_ident[EI_CLASS]
== ELFCLASS64) ? 8 : 4;
buf = ehbuf;
last_cie = NULL;
last_cie_ndx = 0;
memset (&cie, 0, sizeof (cie));
cie_usage_count = 0;
new_size = sec->_raw_size;
make_relative = hdr_info->last_cie.make_relative;
make_lsda_relative = hdr_info->last_cie.make_lsda_relative;
sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
+ 99 * sizeof (struct eh_cie_fde));
if (sec_info == NULL)
goto free_no_table;
sec_info->alloced = 100;
#define ENSURE_NO_RELOCS(buf) \
if (cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
< (bfd_size_type) ((buf) - ehbuf)) \
&& cookie->rel->r_info != 0) \
goto free_no_table
#define SKIP_RELOCS(buf) \
while (cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
< (bfd_size_type) ((buf) - ehbuf))) \
cookie->rel++
#define GET_RELOC(buf) \
((cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
== (bfd_size_type) ((buf) - ehbuf))) \
? cookie->rel : NULL)
for (;;)
{
unsigned char *aug;
if (sec_info->count == sec_info->alloced)
{
sec_info = bfd_realloc (sec_info,
sizeof (struct eh_frame_sec_info)
+ (sec_info->alloced + 99)
* sizeof (struct eh_cie_fde));
if (sec_info == NULL)
goto free_no_table;
memset (&sec_info->entry[sec_info->alloced], 0,
100 * sizeof (struct eh_cie_fde));
sec_info->alloced += 100;
}
last_fde = buf;
/* If we are at the end of the section, we still need to decide
on whether to output or discard last encountered CIE (if any). */
if ((bfd_size_type) (buf - ehbuf) == sec->_raw_size)
hdr.id = (unsigned int) -1;
else
{
if ((bfd_size_type) (buf + 4 - ehbuf) > sec->_raw_size)
/* No space for CIE/FDE header length. */
goto free_no_table;
hdr.length = bfd_get_32 (abfd, buf);
if (hdr.length == 0xffffffff)
/* 64-bit .eh_frame is not supported. */
goto free_no_table;
buf += 4;
if ((bfd_size_type) (buf - ehbuf) + hdr.length > sec->_raw_size)
/* CIE/FDE not contained fully in this .eh_frame input section. */
goto free_no_table;
sec_info->entry[sec_info->count].offset = last_fde - ehbuf;
sec_info->entry[sec_info->count].size = 4 + hdr.length;
if (hdr.length == 0)
{
/* CIE with length 0 must be only the last in the section. */
if ((bfd_size_type) (buf - ehbuf) < sec->_raw_size)
goto free_no_table;
ENSURE_NO_RELOCS (buf);
sec_info->count++;
/* Now just finish last encountered CIE processing and break
the loop. */
hdr.id = (unsigned int) -1;
}
else
{
hdr.id = bfd_get_32 (abfd, buf);
buf += 4;
if (hdr.id == (unsigned int) -1)
goto free_no_table;
}
}
if (hdr.id == 0 || hdr.id == (unsigned int) -1)
{
unsigned int initial_insn_length;
/* CIE */
if (last_cie != NULL)
{
/* Now check if this CIE is identical to the last CIE,
in which case we can remove it provided we adjust
all FDEs. Also, it can be removed if we have removed
all FDEs using it. */
if ((!info->relocatable
&& hdr_info->last_cie_sec
&& (sec->output_section
== hdr_info->last_cie_sec->output_section)
&& cie_compare (&cie, &hdr_info->last_cie) == 0)
|| cie_usage_count == 0)
{
new_size -= cie.hdr.length + 4;
sec_info->entry[last_cie_ndx].removed = 1;
sec_info->entry[last_cie_ndx].sec = hdr_info->last_cie_sec;
sec_info->entry[last_cie_ndx].new_offset
= hdr_info->last_cie_offset;
}
else
{
hdr_info->last_cie = cie;
hdr_info->last_cie_sec = sec;
hdr_info->last_cie_offset = last_cie - ehbuf;
sec_info->entry[last_cie_ndx].make_relative
= cie.make_relative;
sec_info->entry[last_cie_ndx].make_lsda_relative
= cie.make_lsda_relative;
sec_info->entry[last_cie_ndx].per_encoding_relative
= (cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
}
}
if (hdr.id == (unsigned int) -1)
break;
last_cie_ndx = sec_info->count;
sec_info->entry[sec_info->count].cie = 1;
cie_usage_count = 0;
memset (&cie, 0, sizeof (cie));
cie.hdr = hdr;
cie.version = *buf++;
/* Cannot handle unknown versions. */
if (cie.version != 1)
goto free_no_table;
if (strlen (buf) > sizeof (cie.augmentation) - 1)
goto free_no_table;
strcpy (cie.augmentation, buf);
buf = strchr (buf, '\0') + 1;
ENSURE_NO_RELOCS (buf);
if (buf[0] == 'e' && buf[1] == 'h')
{
/* GCC < 3.0 .eh_frame CIE */
/* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
is private to each CIE, so we don't need it for anything.
Just skip it. */
buf += ptr_size;
SKIP_RELOCS (buf);
}
read_uleb128 (cie.code_align, buf);
read_sleb128 (cie.data_align, buf);
/* Note - in DWARF2 the return address column is an unsigned byte.
In DWARF3 it is a ULEB128. We are following DWARF3. For most
ports this will not matter as the value will be less than 128.
For the others (eg FRV, SH, MMIX, IA64) they need a fixed GCC
which conforms to the DWARF3 standard. */
read_uleb128 (cie.ra_column, buf);
ENSURE_NO_RELOCS (buf);
cie.lsda_encoding = DW_EH_PE_omit;
cie.fde_encoding = DW_EH_PE_omit;
cie.per_encoding = DW_EH_PE_omit;
aug = cie.augmentation;
if (aug[0] != 'e' || aug[1] != 'h')
{
if (*aug == 'z')
{
aug++;
read_uleb128 (cie.augmentation_size, buf);
ENSURE_NO_RELOCS (buf);
}
while (*aug != '\0')
switch (*aug++)
{
case 'L':
cie.lsda_encoding = *buf++;
ENSURE_NO_RELOCS (buf);
if (get_DW_EH_PE_width (cie.lsda_encoding, ptr_size) == 0)
goto free_no_table;
break;
case 'R':
cie.fde_encoding = *buf++;
ENSURE_NO_RELOCS (buf);
if (get_DW_EH_PE_width (cie.fde_encoding, ptr_size) == 0)
goto free_no_table;
break;
case 'P':
{
int per_width;
cie.per_encoding = *buf++;
per_width = get_DW_EH_PE_width (cie.per_encoding,
ptr_size);
if (per_width == 0)
goto free_no_table;
if ((cie.per_encoding & 0xf0) == DW_EH_PE_aligned)
buf = (ehbuf
+ ((buf - ehbuf + per_width - 1)
& ~((bfd_size_type) per_width - 1)));
ENSURE_NO_RELOCS (buf);
/* Ensure we have a reloc here, against
a global symbol. */
if (GET_RELOC (buf) != NULL)
{
unsigned long r_symndx;
#ifdef BFD64
if (ptr_size == 8)
r_symndx = ELF64_R_SYM (cookie->rel->r_info);
else
#endif
r_symndx = ELF32_R_SYM (cookie->rel->r_info);
if (r_symndx >= cookie->locsymcount)
{
struct elf_link_hash_entry *h;
r_symndx -= cookie->extsymoff;
h = cookie->sym_hashes[r_symndx];
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *)
h->root.u.i.link;
cie.personality = h;
}
cookie->rel++;
}
buf += per_width;
}
break;
default:
/* Unrecognized augmentation. Better bail out. */
goto free_no_table;
}
}
/* For shared libraries, try to get rid of as many RELATIVE relocs
as possible. */
if (info->shared
&& (get_elf_backend_data (abfd)
->elf_backend_can_make_relative_eh_frame
(abfd, info, sec))
&& (cie.fde_encoding & 0xf0) == DW_EH_PE_absptr)
cie.make_relative = 1;
if (info->shared
&& (get_elf_backend_data (abfd)
->elf_backend_can_make_lsda_relative_eh_frame
(abfd, info, sec))
&& (cie.lsda_encoding & 0xf0) == DW_EH_PE_absptr)
cie.make_lsda_relative = 1;
/* If FDE encoding was not specified, it defaults to
DW_EH_absptr. */
if (cie.fde_encoding == DW_EH_PE_omit)
cie.fde_encoding = DW_EH_PE_absptr;
initial_insn_length = cie.hdr.length - (buf - last_fde - 4);
if (initial_insn_length <= 50)
{
cie.initial_insn_length = initial_insn_length;
memcpy (cie.initial_instructions, buf, initial_insn_length);
}
buf += initial_insn_length;
ENSURE_NO_RELOCS (buf);
last_cie = last_fde;
}
else
{
/* Ensure this FDE uses the last CIE encountered. */
if (last_cie == NULL
|| hdr.id != (unsigned int) (buf - 4 - last_cie))
goto free_no_table;
ENSURE_NO_RELOCS (buf);
if (GET_RELOC (buf) == NULL)
/* This should not happen. */
goto free_no_table;
if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
{
/* This is a FDE against a discarded section. It should
be deleted. */
new_size -= hdr.length + 4;
sec_info->entry[sec_info->count].removed = 1;
}
else
{
if (info->shared
&& (((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr
&& cie.make_relative == 0)
|| (cie.fde_encoding & 0xf0) == DW_EH_PE_aligned))
{
/* If a shared library uses absolute pointers
which we cannot turn into PC relative,
don't create the binary search table,
since it is affected by runtime relocations. */
hdr_info->table = FALSE;
}
cie_usage_count++;
hdr_info->fde_count++;
}
if (cie.lsda_encoding != DW_EH_PE_omit)
{
unsigned int dummy;
aug = buf;
buf += 2 * get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
if (cie.augmentation[0] == 'z')
read_uleb128 (dummy, buf);
/* If some new augmentation data is added before LSDA
in FDE augmentation area, this need to be adjusted. */
sec_info->entry[sec_info->count].lsda_offset = (buf - aug);
}
buf = last_fde + 4 + hdr.length;
SKIP_RELOCS (buf);
}
sec_info->entry[sec_info->count].fde_encoding = cie.fde_encoding;
sec_info->entry[sec_info->count].lsda_encoding = cie.lsda_encoding;
sec_info->count++;
}
elf_section_data (sec)->sec_info = sec_info;
sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
/* Ok, now we can assign new offsets. */
offset = 0;
last_cie_ndx = 0;
for (i = 0; i < sec_info->count; i++)
{
if (! sec_info->entry[i].removed)
{
sec_info->entry[i].new_offset = offset;
offset += sec_info->entry[i].size;
if (sec_info->entry[i].cie)
{
last_cie_ndx = i;
make_relative = sec_info->entry[i].make_relative;
make_lsda_relative = sec_info->entry[i].make_lsda_relative;
}
else
{
sec_info->entry[i].make_relative = make_relative;
sec_info->entry[i].make_lsda_relative = make_lsda_relative;
sec_info->entry[i].per_encoding_relative = 0;
}
}
else if (sec_info->entry[i].cie && sec_info->entry[i].sec == sec)
{
/* Need to adjust new_offset too. */
BFD_ASSERT (sec_info->entry[last_cie_ndx].offset
== sec_info->entry[i].new_offset);
sec_info->entry[i].new_offset
= sec_info->entry[last_cie_ndx].new_offset;
}
}
if (hdr_info->last_cie_sec == sec)
{
BFD_ASSERT (sec_info->entry[last_cie_ndx].offset
== hdr_info->last_cie_offset);
hdr_info->last_cie_offset = sec_info->entry[last_cie_ndx].new_offset;
}
/* FIXME: Currently it is not possible to shrink sections to zero size at
this point, so build a fake minimal CIE. */
if (new_size == 0)
new_size = 16;
/* Shrink the sec as needed. */
sec->_cooked_size = new_size;
if (sec->_cooked_size == 0)
sec->flags |= SEC_EXCLUDE;
free (ehbuf);
return new_size != sec->_raw_size;
free_no_table:
if (ehbuf)
free (ehbuf);
if (sec_info)
free (sec_info);
hdr_info->table = FALSE;
hdr_info->last_cie.hdr.length = 0;
return FALSE;
}
bfd_boolean
_bfd_elf_discard_section_eh_frame
(bfd *abfd, struct bfd_link_info *info, asection *sec,
bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
struct elf_reloc_cookie *cookie)
{
#define REQUIRE(COND) \
do \
if (!(COND)) \
goto free_no_table; \
while (0)
bfd_byte *ehbuf = NULL, *buf;
bfd_byte *last_cie, *last_fde;
struct eh_cie_fde *ent, *last_cie_inf, *this_inf;
struct cie_header hdr;
struct cie cie;
struct elf_link_hash_table *htab;
struct eh_frame_hdr_info *hdr_info;
struct eh_frame_sec_info *sec_info = NULL;
unsigned int cie_usage_count, offset;
unsigned int ptr_size;
if (sec->size == 0)
{
/* This file does not contain .eh_frame information. */
return FALSE;
}
if ((sec->output_section != NULL
&& bfd_is_abs_section (sec->output_section)))
{
/* At least one of the sections is being discarded from the
link, so we should just ignore them. */
return FALSE;
}
htab = elf_hash_table (info);
hdr_info = &htab->eh_info;
/* Read the frame unwind information from abfd. */
REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
if (sec->size >= 4
&& bfd_get_32 (abfd, ehbuf) == 0
&& cookie->rel == cookie->relend)
{
/* Empty .eh_frame section. */
free (ehbuf);
return FALSE;
}
/* If .eh_frame section size doesn't fit into int, we cannot handle
it (it would need to use 64-bit .eh_frame format anyway). */
REQUIRE (sec->size == (unsigned int) sec->size);
ptr_size = (get_elf_backend_data (abfd)
->elf_backend_eh_frame_address_size (abfd, sec));
REQUIRE (ptr_size != 0);
buf = ehbuf;
last_cie = NULL;
last_cie_inf = NULL;
memset (&cie, 0, sizeof (cie));
cie_usage_count = 0;
sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
+ 99 * sizeof (struct eh_cie_fde));
REQUIRE (sec_info);
sec_info->alloced = 100;
#define ENSURE_NO_RELOCS(buf) \
REQUIRE (!(cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
< (bfd_size_type) ((buf) - ehbuf)) \
&& cookie->rel->r_info != 0))
#define SKIP_RELOCS(buf) \
while (cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
< (bfd_size_type) ((buf) - ehbuf))) \
cookie->rel++
#define GET_RELOC(buf) \
((cookie->rel < cookie->relend \
&& (cookie->rel->r_offset \
== (bfd_size_type) ((buf) - ehbuf))) \
? cookie->rel : NULL)
for (;;)
{
char *aug;
bfd_byte *start, *end, *insns;
bfd_size_type length;
if (sec_info->count == sec_info->alloced)
{
struct eh_cie_fde *old_entry = sec_info->entry;
sec_info = bfd_realloc (sec_info,
sizeof (struct eh_frame_sec_info)
+ ((sec_info->alloced + 99)
* sizeof (struct eh_cie_fde)));
REQUIRE (sec_info);
memset (&sec_info->entry[sec_info->alloced], 0,
100 * sizeof (struct eh_cie_fde));
sec_info->alloced += 100;
/* Now fix any pointers into the array. */
if (last_cie_inf >= old_entry
&& last_cie_inf < old_entry + sec_info->count)
last_cie_inf = sec_info->entry + (last_cie_inf - old_entry);
}
this_inf = sec_info->entry + sec_info->count;
last_fde = buf;
/* If we are at the end of the section, we still need to decide
on whether to output or discard last encountered CIE (if any). */
if ((bfd_size_type) (buf - ehbuf) == sec->size)
{
hdr.length = 0;
hdr.id = (unsigned int) -1;
end = buf;
}
else
{
/* Read the length of the entry. */
REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
hdr.length = bfd_get_32 (abfd, buf - 4);
/* 64-bit .eh_frame is not supported. */
REQUIRE (hdr.length != 0xffffffff);
/* The CIE/FDE must be fully contained in this input section. */
REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr.length <= sec->size);
end = buf + hdr.length;
this_inf->offset = last_fde - ehbuf;
this_inf->size = 4 + hdr.length;
if (hdr.length == 0)
{
/* A zero-length CIE should only be found at the end of
the section. */
REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
ENSURE_NO_RELOCS (buf);
sec_info->count++;
/* Now just finish last encountered CIE processing and break
the loop. */
hdr.id = (unsigned int) -1;
}
else
{
REQUIRE (skip_bytes (&buf, end, 4));
hdr.id = bfd_get_32 (abfd, buf - 4);
REQUIRE (hdr.id != (unsigned int) -1);
}
}
if (hdr.id == 0 || hdr.id == (unsigned int) -1)
{
unsigned int initial_insn_length;
/* CIE */
if (last_cie != NULL)
{
/* Now check if this CIE is identical to the last CIE,
in which case we can remove it provided we adjust
all FDEs. Also, it can be removed if we have removed
all FDEs using it. */
if ((!info->relocatable
&& hdr_info->last_cie_sec
&& (sec->output_section
== hdr_info->last_cie_sec->output_section)
&& cie_compare (&cie, &hdr_info->last_cie) == 0)
|| cie_usage_count == 0)
last_cie_inf->removed = 1;
else
{
hdr_info->last_cie = cie;
hdr_info->last_cie_sec = sec;
last_cie_inf->make_relative = cie.make_relative;
last_cie_inf->make_lsda_relative = cie.make_lsda_relative;
last_cie_inf->per_encoding_relative
= (cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
}
}
if (hdr.id == (unsigned int) -1)
break;
last_cie_inf = this_inf;
this_inf->cie = 1;
cie_usage_count = 0;
memset (&cie, 0, sizeof (cie));
cie.hdr = hdr;
REQUIRE (read_byte (&buf, end, &cie.version));
/* Cannot handle unknown versions. */
REQUIRE (cie.version == 1 || cie.version == 3);
REQUIRE (strlen ((char *) buf) < sizeof (cie.augmentation));
strcpy (cie.augmentation, (char *) buf);
buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
ENSURE_NO_RELOCS (buf);
if (buf[0] == 'e' && buf[1] == 'h')
{
/* GCC < 3.0 .eh_frame CIE */
/* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
is private to each CIE, so we don't need it for anything.
Just skip it. */
REQUIRE (skip_bytes (&buf, end, ptr_size));
SKIP_RELOCS (buf);
}
REQUIRE (read_uleb128 (&buf, end, &cie.code_align));
REQUIRE (read_sleb128 (&buf, end, &cie.data_align));
if (cie.version == 1)
{
REQUIRE (buf < end);
cie.ra_column = *buf++;
}
else
REQUIRE (read_uleb128 (&buf, end, &cie.ra_column));
ENSURE_NO_RELOCS (buf);
cie.lsda_encoding = DW_EH_PE_omit;
cie.fde_encoding = DW_EH_PE_omit;
cie.per_encoding = DW_EH_PE_omit;
aug = cie.augmentation;
if (aug[0] != 'e' || aug[1] != 'h')
{
if (*aug == 'z')
{
aug++;
REQUIRE (read_uleb128 (&buf, end, &cie.augmentation_size));
ENSURE_NO_RELOCS (buf);
}
while (*aug != '\0')
switch (*aug++)
{
case 'L':
REQUIRE (read_byte (&buf, end, &cie.lsda_encoding));
ENSURE_NO_RELOCS (buf);
REQUIRE (get_DW_EH_PE_width (cie.lsda_encoding, ptr_size));
break;
case 'R':
REQUIRE (read_byte (&buf, end, &cie.fde_encoding));
ENSURE_NO_RELOCS (buf);
REQUIRE (get_DW_EH_PE_width (cie.fde_encoding, ptr_size));
break;
case 'P':
{
int per_width;
REQUIRE (read_byte (&buf, end, &cie.per_encoding));
per_width = get_DW_EH_PE_width (cie.per_encoding,
ptr_size);
REQUIRE (per_width);
if ((cie.per_encoding & 0xf0) == DW_EH_PE_aligned)
{
length = -(buf - ehbuf) & (per_width - 1);
REQUIRE (skip_bytes (&buf, end, length));
}
ENSURE_NO_RELOCS (buf);
/* Ensure we have a reloc here, against
a global symbol. */
if (GET_RELOC (buf) != NULL)
{
unsigned long r_symndx;
#ifdef BFD64
if (ptr_size == 8)
r_symndx = ELF64_R_SYM (cookie->rel->r_info);
else
#endif
r_symndx = ELF32_R_SYM (cookie->rel->r_info);
if (r_symndx >= cookie->locsymcount)
{
struct elf_link_hash_entry *h;
r_symndx -= cookie->extsymoff;
h = cookie->sym_hashes[r_symndx];
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *)
h->root.u.i.link;
cie.personality = h;
}
/* Cope with MIPS-style composite relocations. */
do
cookie->rel++;
while (GET_RELOC (buf) != NULL);
}
REQUIRE (skip_bytes (&buf, end, per_width));
}
break;
default:
/* Unrecognized augmentation. Better bail out. */
goto free_no_table;
}
}
/* For shared libraries, try to get rid of as many RELATIVE relocs
as possible. */
if (info->shared
&& (get_elf_backend_data (abfd)
->elf_backend_can_make_relative_eh_frame
(abfd, info, sec)))
{
if ((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr)
cie.make_relative = 1;
/* If the CIE doesn't already have an 'R' entry, it's fairly
easy to add one, provided that there's no aligned data
after the augmentation string. */
else if (cie.fde_encoding == DW_EH_PE_omit
&& (cie.per_encoding & 0xf0) != DW_EH_PE_aligned)
{
if (*cie.augmentation == 0)
this_inf->add_augmentation_size = 1;
this_inf->add_fde_encoding = 1;
cie.make_relative = 1;
}
}
if (info->shared
&& (get_elf_backend_data (abfd)
->elf_backend_can_make_lsda_relative_eh_frame
(abfd, info, sec))
&& (cie.lsda_encoding & 0xf0) == DW_EH_PE_absptr)
cie.make_lsda_relative = 1;
/* If FDE encoding was not specified, it defaults to
DW_EH_absptr. */
if (cie.fde_encoding == DW_EH_PE_omit)
cie.fde_encoding = DW_EH_PE_absptr;
initial_insn_length = end - buf;
if (initial_insn_length <= 50)
{
cie.initial_insn_length = initial_insn_length;
memcpy (cie.initial_instructions, buf, initial_insn_length);
}
insns = buf;
buf += initial_insn_length;
ENSURE_NO_RELOCS (buf);
last_cie = last_fde;
}
else
{
/* Ensure this FDE uses the last CIE encountered. */
REQUIRE (last_cie);
REQUIRE (hdr.id == (unsigned int) (buf - 4 - last_cie));
ENSURE_NO_RELOCS (buf);
REQUIRE (GET_RELOC (buf));
if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
/* This is a FDE against a discarded section. It should
be deleted. */
this_inf->removed = 1;
else
{
if (info->shared
&& (((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr
&& cie.make_relative == 0)
|| (cie.fde_encoding & 0xf0) == DW_EH_PE_aligned))
{
/* If a shared library uses absolute pointers
which we cannot turn into PC relative,
don't create the binary search table,
since it is affected by runtime relocations. */
hdr_info->table = FALSE;
}
cie_usage_count++;
hdr_info->fde_count++;
}
/* Skip the initial location and address range. */
start = buf;
length = get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
REQUIRE (skip_bytes (&buf, end, 2 * length));
/* Skip the augmentation size, if present. */
if (cie.augmentation[0] == 'z')
REQUIRE (read_uleb128 (&buf, end, &length));
else
length = 0;
/* Of the supported augmentation characters above, only 'L'
adds augmentation data to the FDE. This code would need to
be adjusted if any future augmentations do the same thing. */
if (cie.lsda_encoding != DW_EH_PE_omit)
{
this_inf->lsda_offset = buf - start;
/* If there's no 'z' augmentation, we don't know where the
CFA insns begin. Assume no padding. */
if (cie.augmentation[0] != 'z')
length = end - buf;
}
/* Skip over the augmentation data. */
REQUIRE (skip_bytes (&buf, end, length));
insns = buf;
buf = last_fde + 4 + hdr.length;
SKIP_RELOCS (buf);
}
/* Try to interpret the CFA instructions and find the first
padding nop. Shrink this_inf's size so that it doesn't
including the padding. */
length = get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
insns = skip_non_nops (insns, end, length);
if (insns != 0)
this_inf->size -= end - insns;
this_inf->fde_encoding = cie.fde_encoding;
this_inf->lsda_encoding = cie.lsda_encoding;
sec_info->count++;
}
elf_section_data (sec)->sec_info = sec_info;
sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
/* Ok, now we can assign new offsets. */
offset = 0;
last_cie_inf = hdr_info->last_cie_inf;
for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
if (!ent->removed)
{
if (ent->cie)
last_cie_inf = ent;
else
ent->cie_inf = last_cie_inf;
ent->new_offset = offset;
offset += size_of_output_cie_fde (ent, ptr_size);
}
hdr_info->last_cie_inf = last_cie_inf;
/* Resize the sec as needed. */
sec->rawsize = sec->size;
sec->size = offset;
if (sec->size == 0)
sec->flags |= SEC_EXCLUDE;
free (ehbuf);
return offset != sec->rawsize;
free_no_table:
if (ehbuf)
free (ehbuf);
if (sec_info)
free (sec_info);
hdr_info->table = FALSE;
hdr_info->last_cie.hdr.length = 0;
return FALSE;
#undef REQUIRE
}
