void
_bfd_delete_bfd (bfd *abfd)
{
bfd_hash_table_free (&abfd->section_htab);
objalloc_free ((struct objalloc *) abfd->memory);
free (abfd);
}
void
_bfd_elf_strtab_free (struct elf_strtab_hash *tab)
{
bfd_hash_table_free (&tab->table);
free (tab->array);
free (tab);
}
bfd_boolean
_bfd_write_stab_strings (bfd *output_bfd, struct stab_info *sinfo)
{
if (bfd_is_abs_section (sinfo->stabstr->output_section))
/* The section was discarded from the link. */
return TRUE;
BFD_ASSERT ((sinfo->stabstr->output_offset
+ _bfd_stringtab_size (sinfo->strings))
<= sinfo->stabstr->output_section->size);
if (bfd_seek (output_bfd,
(file_ptr) (sinfo->stabstr->output_section->filepos
+ sinfo->stabstr->output_offset),
SEEK_SET) != 0)
return FALSE;
if (! _bfd_stringtab_emit (output_bfd, sinfo->strings))
return FALSE;
/* We no longer need the stabs information. */
_bfd_stringtab_free (sinfo->strings);
bfd_hash_table_free (&sinfo->includes);
return TRUE;
}
void
m68hc11_elf_bfd_link_hash_table_free (struct bfd_link_hash_table *hash)
{
struct m68hc11_elf_link_hash_table *ret
= (struct m68hc11_elf_link_hash_table *) hash;
bfd_hash_table_free (ret->stub_hash_table);
free (ret->stub_hash_table);
_bfd_generic_link_hash_table_free (hash);
}
static void
m68hc11_elf_bfd_link_hash_table_free (bfd *obfd)
{
struct m68hc11_elf_link_hash_table *ret
= (struct m68hc11_elf_link_hash_table *) obfd->link.hash;
bfd_hash_table_free (ret->stub_hash_table);
free (ret->stub_hash_table);
_bfd_elf_link_hash_table_free (obfd);
}
static void
_bfd_delete_bfd (bfd *abfd)
{
if (abfd->memory)
{
bfd_hash_table_free (&abfd->section_htab);
objalloc_free ((struct objalloc *) abfd->memory);
}
free (abfd->arelt_data);
free (abfd);
}
bfd_boolean
_bfd_free_cached_info (bfd *abfd)
{
if (abfd->memory)
{
bfd_hash_table_free (&abfd->section_htab);
objalloc_free ((struct objalloc *) abfd->memory);
abfd->sections = NULL;
abfd->section_last = NULL;
abfd->outsymbols = NULL;
abfd->tdata.any = NULL;
abfd->usrdata = NULL;
abfd->memory = NULL;
}
return TRUE;
}
static void
bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
{
bfd_hash_table_free (&abfd->section_htab);
abfd->tdata.any = preserve->tdata;
abfd->arch_info = preserve->arch_info;
abfd->flags = preserve->flags;
abfd->section_htab = preserve->section_htab;
abfd->sections = preserve->sections;
abfd->section_last = preserve->section_last;
abfd->section_count = preserve->section_count;
/* bfd_release frees all memory more recently bfd_alloc'd than
its arg, as well as its arg. */
bfd_release (abfd, preserve->marker);
preserve->marker = NULL;
}
static bfd_boolean
vms_initialize (bfd * abfd)
{
int i;
bfd_size_type amt;
bfd_set_start_address(abfd, (bfd_vma)-1);
amt = sizeof(struct vms_private_data_struct);
abfd->tdata.any = bfd_alloc(abfd, amt);
if (abfd->tdata.any == NULL) {
return FALSE;
}
#ifdef __ALPHA
PRIV(is_vax) = FALSE;
#else
PRIV(is_vax) = TRUE;
#endif /* __ALPHA */
PRIV(vms_buf) = NULL;
PRIV(buf_size) = 0;
PRIV(rec_length) = 0;
PRIV(file_format) = FF_UNKNOWN;
PRIV(fixup_done) = FALSE;
PRIV(sections) = NULL;
amt = (sizeof(struct stack_struct) * STACKSIZE);
PRIV(stack) = (struct stack_struct *)bfd_alloc(abfd, amt);
if (PRIV(stack) == NULL) {
goto error_ret1;
}
PRIV(stackptr) = 0;
amt = sizeof(struct bfd_hash_table);
PRIV(vms_symbol_table) = (struct bfd_hash_table *)bfd_alloc(abfd, amt);
if (PRIV (vms_symbol_table) == NULL)
goto error_ret1;
if (!bfd_hash_table_init (PRIV (vms_symbol_table), _bfd_vms_hash_newfunc))
goto error_ret1;
amt = sizeof(struct location_struct) * LOCATION_SAVE_SIZE;
PRIV(location_stack) = (struct location_struct *)bfd_alloc(abfd, amt);
if (PRIV(location_stack) == NULL) {
goto error_ret2;
}
for ((i = 0); (i < VMS_SECTION_COUNT); i++) {
PRIV(vms_section_table)[i] = NULL;
}
amt = MAX_OUTREC_SIZE;
PRIV(output_buf) = (unsigned char *)bfd_alloc(abfd, amt);
if (PRIV(output_buf) == NULL) {
goto error_ret2;
}
PRIV (push_level) = 0;
PRIV (pushed_size) = 0;
PRIV (length_pos) = 2;
PRIV (output_size) = 0;
PRIV (output_alignment) = 1;
return TRUE;
error_ret2:
bfd_hash_table_free (PRIV (vms_symbol_table));
error_ret1:
bfd_release (abfd, abfd->tdata.any);
abfd->tdata.any = NULL;
return FALSE;
}
static void
macho_add_oso_symfile (oso_el *oso, const gdb_bfd_ref_ptr &abfd,
const char *name,
struct objfile *main_objfile,
symfile_add_flags symfile_flags)
{
int storage;
int i;
asymbol **symbol_table;
asymbol **symp;
struct bfd_hash_table table;
int nbr_sections;
/* Per section flag to mark which section have been rebased. */
unsigned char *sections_rebased;
if (mach_o_debug_level > 0)
printf_unfiltered
(_("Loading debugging symbols from oso: %s\n"), oso->name);
if (!bfd_check_format (abfd.get (), bfd_object))
{
warning (_("`%s': can't read symbols: %s."), oso->name,
bfd_errmsg (bfd_get_error ()));
return;
}
if (abfd->my_archive == NULL && oso->mtime != bfd_get_mtime (abfd.get ()))
{
warning (_("`%s': file time stamp mismatch."), oso->name);
return;
}
if (!bfd_hash_table_init_n (&table, macho_sym_hash_newfunc,
sizeof (struct macho_sym_hash_entry),
oso->nbr_syms))
{
warning (_("`%s': can't create hash table"), oso->name);
return;
}
bfd_set_cacheable (abfd.get (), 1);
/* Read symbols table. */
storage = bfd_get_symtab_upper_bound (abfd.get ());
symbol_table = (asymbol **) xmalloc (storage);
bfd_canonicalize_symtab (abfd.get (), symbol_table);
/* Init section flags. */
nbr_sections = bfd_count_sections (abfd.get ());
sections_rebased = (unsigned char *) alloca (nbr_sections);
for (i = 0; i < nbr_sections; i++)
sections_rebased[i] = 0;
/* Put symbols for the OSO file in the hash table. */
for (symp = oso->oso_sym; symp != oso->end_sym; symp++)
{
const asymbol *sym = *symp;
bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
switch (mach_o_sym->n_type)
{
case N_ENSYM:
case N_BNSYM:
case N_GSYM:
sym = NULL;
break;
case N_FUN:
if (sym->name == NULL || sym->name[0] == 0)
sym = NULL;
break;
case N_STSYM:
break;
default:
sym = NULL;
break;
}
if (sym != NULL)
{
struct macho_sym_hash_entry *ent;
ent = (struct macho_sym_hash_entry *)
bfd_hash_lookup (&table, sym->name, TRUE, FALSE);
if (ent->sym != NULL)
complaint (_("Duplicated symbol %s in symbol table"), sym->name);
else
{
if (mach_o_debug_level > 4)
{
struct gdbarch *arch = get_objfile_arch (main_objfile);
printf_unfiltered
(_("Adding symbol %s (addr: %s)\n"),
sym->name, paddress (arch, sym->value));
}
ent->sym = sym;
}
}
}
/* Relocate symbols of the OSO. */
for (i = 0; symbol_table[i]; i++)
{
asymbol *sym = symbol_table[i];
bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
if (mach_o_sym->n_type & BFD_MACH_O_N_STAB)
continue;
if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF
&& sym->value != 0)
{
/* For common symbol use the min symtab and modify the OSO
symbol table. */
CORE_ADDR res;
res = macho_resolve_oso_sym_with_minsym (main_objfile, sym);
if (res != 0)
{
sym->section = bfd_com_section_ptr;
sym->value = res;
}
}
else if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
{
/* Normal symbol. */
asection *sec = sym->section;
bfd_mach_o_section *msec;
unsigned int sec_type;
/* Skip buggy ones. */
if (sec == NULL || sections_rebased[sec->index] != 0)
continue;
/* Only consider regular, non-debugging sections. */
msec = bfd_mach_o_get_mach_o_section (sec);
sec_type = msec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
if ((sec_type == BFD_MACH_O_S_REGULAR
|| sec_type == BFD_MACH_O_S_ZEROFILL)
&& (msec->flags & BFD_MACH_O_S_ATTR_DEBUG) == 0)
{
CORE_ADDR addr = 0;
if ((mach_o_sym->n_type & BFD_MACH_O_N_EXT) != 0)
{
/* Use the min symtab for global symbols. */
addr = macho_resolve_oso_sym_with_minsym (main_objfile, sym);
}
else
{
struct macho_sym_hash_entry *ent;
ent = (struct macho_sym_hash_entry *)
bfd_hash_lookup (&table, sym->name, FALSE, FALSE);
if (ent != NULL)
addr = bfd_asymbol_value (ent->sym);
}
/* Adjust the section. */
if (addr != 0)
{
CORE_ADDR res = addr - sym->value;
if (mach_o_debug_level > 3)
{
struct gdbarch *arch = get_objfile_arch (main_objfile);
printf_unfiltered
(_("resolve sect %s with %s (set to %s)\n"),
sec->name, sym->name,
paddress (arch, res));
}
bfd_set_section_vma (abfd.get (), sec, res);
sections_rebased[sec->index] = 1;
}
}
else
{
/* Mark the section as never rebased. */
sections_rebased[sec->index] = 2;
}
}
}
bfd_hash_table_free (&table);
/* We need to clear SYMFILE_MAINLINE to avoid interractive question
from symfile.c:symbol_file_add_with_addrs_or_offsets. */
symbol_file_add_from_bfd
(abfd.get (), name, symfile_flags & ~(SYMFILE_MAINLINE | SYMFILE_VERBOSE),
NULL,
main_objfile->flags & (OBJF_REORDERED | OBJF_SHARED
| OBJF_READNOW | OBJF_USERLOADED),
main_objfile);
}
