/* Read inferior memory at ADDR to find the header of a loaded object file
and read its in-core symbols out of inferior memory. TEMPL is a bfd
representing the target's format. NAME is the name to use for this
symbol file in messages; it can be NULL or a malloc-allocated string
which will be attached to the BFD. */
static struct objfile *
symbol_file_add_from_memory (struct bfd *templ, CORE_ADDR addr, char *name,
int from_tty)
{
struct objfile *objf;
struct bfd *nbfd;
struct bfd_section *sec;
bfd_vma loadbase;
struct section_addr_info *sai;
unsigned int i;
struct cleanup *cleanup;
if (bfd_get_flavour (templ) != bfd_target_elf_flavour)
error (_("add-symbol-file-from-memory not supported for this target"));
nbfd = bfd_elf_bfd_from_remote_memory (templ, addr, &loadbase,
target_read_memory_bfd);
if (nbfd == NULL)
error (_("Failed to read a valid object file image from memory."));
gdb_bfd_ref (nbfd);
if (name == NULL)
nbfd->filename = "shared object read from target memory";
else
{
nbfd->filename = name;
gdb_bfd_stash_filename (nbfd);
xfree (name);
}
cleanup = make_cleanup_bfd_unref (nbfd);
if (!bfd_check_format (nbfd, bfd_object))
error (_("Got object file from memory but can't read symbols: %s."),
bfd_errmsg (bfd_get_error ()));
sai = alloc_section_addr_info (bfd_count_sections (nbfd));
make_cleanup (xfree, sai);
i = 0;
for (sec = nbfd->sections; sec != NULL; sec = sec->next)
if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
{
sai->other[i].addr = bfd_get_section_vma (nbfd, sec) + loadbase;
sai->other[i].name = (char *) bfd_get_section_name (nbfd, sec);
sai->other[i].sectindex = sec->index;
++i;
}
sai->num_sections = i;
objf = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd),
from_tty ? SYMFILE_VERBOSE : 0,
sai, OBJF_SHARED, NULL);
/* This might change our ideas about frames already looked at. */
reinit_frame_cache ();
do_cleanups (cleanup);
return objf;
}
/* Read inferior memory at ADDR to find the header of a loaded object file
and read its in-core symbols out of inferior memory. TEMPL is a bfd
representing the target's format. NAME is the name to use for this
symbol file in messages; it can be NULL or a malloc-allocated string
which will be attached to the BFD. */
static struct objfile *
symbol_file_add_from_memory (struct bfd *templ, CORE_ADDR addr, char *name,
int from_tty)
{
struct objfile *objf;
struct bfd *nbfd;
struct bfd_section *sec;
bfd_vma loadbase;
struct section_addr_info *sai;
unsigned int i;
if (bfd_get_flavour (templ) != bfd_target_elf_flavour)
error (_("add-symbol-file-from-memory not supported for this target"));
nbfd = bfd_elf_bfd_from_remote_memory (templ, addr, &loadbase,
target_read_memory);
if (nbfd == NULL)
error (_("Failed to read a valid object file image from memory."));
if (name == NULL)
nbfd->filename = xstrdup ("shared object read from target memory");
else
nbfd->filename = name;
if (!bfd_check_format (nbfd, bfd_object))
{
/* FIXME: should be checking for errors from bfd_close (for one thing,
on error it does not free all the storage associated with the
bfd). */
bfd_close (nbfd);
error (_("Got object file from memory but can't read symbols: %s."),
bfd_errmsg (bfd_get_error ()));
}
sai = alloc_section_addr_info (bfd_count_sections (nbfd));
make_cleanup (xfree, sai);
i = 0;
for (sec = nbfd->sections; sec != NULL; sec = sec->next)
if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
{
sai->other[i].addr = bfd_get_section_vma (nbfd, sec) + loadbase;
sai->other[i].name = (char *) bfd_get_section_name (nbfd, sec);
sai->other[i].sectindex = sec->index;
++i;
}
objf = symbol_file_add_from_bfd (nbfd, from_tty ? SYMFILE_VERBOSE : 0,
sai, OBJF_SHARED);
/* This might change our ideas about frames already looked at. */
reinit_frame_cache ();
return objf;
}
/* Read inferior memory at ADDR to find the header of a loaded object file
and read its in-core symbols out of inferior memory. SIZE, if
non-zero, is the known size of the object. TEMPL is a bfd
representing the target's format. NAME is the name to use for this
symbol file in messages; it can be NULL or a malloc-allocated string
which will be attached to the BFD. */
static struct objfile *
symbol_file_add_from_memory (struct bfd *templ, CORE_ADDR addr,
size_t size, char *name, int from_tty)
{
struct objfile *objf;
struct bfd *nbfd;
struct bfd_section *sec;
bfd_vma loadbase;
symfile_add_flags add_flags = 0;
if (bfd_get_flavour (templ) != bfd_target_elf_flavour)
error (_("add-symbol-file-from-memory not supported for this target"));
nbfd = bfd_elf_bfd_from_remote_memory (templ, addr, size, &loadbase,
target_read_memory_bfd);
if (nbfd == NULL)
error (_("Failed to read a valid object file image from memory."));
/* Manage the new reference for the duration of this function. */
gdb_bfd_ref_ptr nbfd_holder = gdb_bfd_ref_ptr::new_reference (nbfd);
xfree (bfd_get_filename (nbfd));
if (name == NULL)
nbfd->filename = xstrdup ("shared object read from target memory");
else
nbfd->filename = name;
if (!bfd_check_format (nbfd, bfd_object))
error (_("Got object file from memory but can't read symbols: %s."),
bfd_errmsg (bfd_get_error ()));
section_addr_info sai;
for (sec = nbfd->sections; sec != NULL; sec = sec->next)
if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
sai.emplace_back (bfd_get_section_vma (nbfd, sec) + loadbase,
bfd_get_section_name (nbfd, sec),
sec->index);
if (from_tty)
add_flags |= SYMFILE_VERBOSE;
objf = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd),
add_flags, &sai, OBJF_SHARED, NULL);
add_target_sections_of_objfile (objf);
/* This might change our ideas about frames already looked at. */
reinit_frame_cache ();
return objf;
}
struct compile_module *
compile_object_load (const char *object_file, const char *source_file,
enum compile_i_scope_types scope, void *scope_data)
{
struct cleanup *cleanups, *cleanups_free_objfile;
bfd *abfd;
struct setup_sections_data setup_sections_data;
CORE_ADDR addr, regs_addr, out_value_addr = 0;
struct symbol *func_sym;
struct type *func_type;
struct bound_minimal_symbol bmsym;
long storage_needed;
asymbol **symbol_table, **symp;
long number_of_symbols, missing_symbols;
struct type *dptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
unsigned dptr_type_len = TYPE_LENGTH (dptr_type);
struct compile_module *retval;
struct type *regs_type, *out_value_type = NULL;
char *filename, **matching;
struct objfile *objfile;
int expect_parameters;
struct type *expect_return_type;
struct munmap_list *munmap_list_head = NULL;
filename = tilde_expand (object_file);
cleanups = make_cleanup (xfree, filename);
abfd = gdb_bfd_open (filename, gnutarget, -1);
if (abfd == NULL)
error (_("\"%s\": could not open as compiled module: %s"),
filename, bfd_errmsg (bfd_get_error ()));
make_cleanup_bfd_unref (abfd);
if (!bfd_check_format_matches (abfd, bfd_object, &matching))
error (_("\"%s\": not in loadable format: %s"),
filename, gdb_bfd_errmsg (bfd_get_error (), matching));
if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) != 0)
error (_("\"%s\": not in object format."), filename);
setup_sections_data.last_size = 0;
setup_sections_data.last_section_first = abfd->sections;
setup_sections_data.last_prot = -1;
setup_sections_data.last_max_alignment = 1;
setup_sections_data.munmap_list_headp = &munmap_list_head;
make_cleanup (munmap_listp_free_cleanup, &munmap_list_head);
bfd_map_over_sections (abfd, setup_sections, &setup_sections_data);
setup_sections (abfd, NULL, &setup_sections_data);
storage_needed = bfd_get_symtab_upper_bound (abfd);
if (storage_needed < 0)
error (_("Cannot read symbols of compiled module \"%s\": %s"),
filename, bfd_errmsg (bfd_get_error ()));
/* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
"Reading symbols from ..." message for automatically generated file. */
objfile = symbol_file_add_from_bfd (abfd, filename, 0, NULL, 0, NULL);
cleanups_free_objfile = make_cleanup_free_objfile (objfile);
func_sym = lookup_global_symbol_from_objfile (objfile,
GCC_FE_WRAPPER_FUNCTION,
VAR_DOMAIN).symbol;
if (func_sym == NULL)
error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
func_type = SYMBOL_TYPE (func_sym);
if (TYPE_CODE (func_type) != TYPE_CODE_FUNC)
error (_("Invalid type code %d of function \"%s\" in compiled "
"module \"%s\"."),
TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION,
objfile_name (objfile));
switch (scope)
{
case COMPILE_I_SIMPLE_SCOPE:
expect_parameters = 1;
expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
break;
case COMPILE_I_RAW_SCOPE:
expect_parameters = 0;
expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
break;
case COMPILE_I_PRINT_ADDRESS_SCOPE:
case COMPILE_I_PRINT_VALUE_SCOPE:
expect_parameters = 2;
expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
break;
default:
internal_error (__FILE__, __LINE__, _("invalid scope %d"), scope);
}
if (TYPE_NFIELDS (func_type) != expect_parameters)
error (_("Invalid %d parameters of function \"%s\" in compiled "
"module \"%s\"."),
TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION,
objfile_name (objfile));
if (!types_deeply_equal (expect_return_type, TYPE_TARGET_TYPE (func_type)))
error (_("Invalid return type of function \"%s\" in compiled "
"module \"%s\"."),
GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
/* The memory may be later needed
by bfd_generic_get_relocated_section_contents
called from default_symfile_relocate. */
symbol_table = obstack_alloc (&objfile->objfile_obstack, storage_needed);
number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
if (number_of_symbols < 0)
error (_("Cannot parse symbols of compiled module \"%s\": %s"),
filename, bfd_errmsg (bfd_get_error ()));
missing_symbols = 0;
for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++)
{
asymbol *sym = *symp;
if (sym->flags != 0)
continue;
sym->flags = BSF_GLOBAL;
sym->section = bfd_abs_section_ptr;
if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0)
{
if (compile_debug)
fprintf_unfiltered (gdb_stdlog,
"ELF symbol \"%s\" relocated to zero\n",
sym->name);
/* It seems to be a GCC bug, with -mcmodel=large there should be no
need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
sym->value = 0;
continue;
}
bmsym = lookup_minimal_symbol (sym->name, NULL, NULL);
switch (bmsym.minsym == NULL
? mst_unknown : MSYMBOL_TYPE (bmsym.minsym))
{
case mst_text:
sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym);
if (compile_debug)
fprintf_unfiltered (gdb_stdlog,
"ELF mst_text symbol \"%s\" relocated to %s\n",
sym->name,
paddress (target_gdbarch (), sym->value));
break;
case mst_text_gnu_ifunc:
sym->value = gnu_ifunc_resolve_addr (target_gdbarch (),
BMSYMBOL_VALUE_ADDRESS (bmsym));
if (compile_debug)
fprintf_unfiltered (gdb_stdlog,
"ELF mst_text_gnu_ifunc symbol \"%s\" "
"relocated to %s\n",
sym->name,
paddress (target_gdbarch (), sym->value));
break;
default:
warning (_("Could not find symbol \"%s\" "
"for compiled module \"%s\"."),
sym->name, filename);
missing_symbols++;
}
}
if (missing_symbols)
error (_("%ld symbols were missing, cannot continue."), missing_symbols);
bfd_map_over_sections (abfd, copy_sections, symbol_table);
regs_type = get_regs_type (func_sym, objfile);
if (regs_type == NULL)
regs_addr = 0;
else
{
/* Use read-only non-executable memory protection. */
regs_addr = gdbarch_infcall_mmap (target_gdbarch (),
TYPE_LENGTH (regs_type),
GDB_MMAP_PROT_READ);
gdb_assert (regs_addr != 0);
munmap_list_add (&munmap_list_head, regs_addr, TYPE_LENGTH (regs_type));
if (compile_debug)
fprintf_unfiltered (gdb_stdlog,
"allocated %s bytes at %s for registers\n",
paddress (target_gdbarch (),
TYPE_LENGTH (regs_type)),
paddress (target_gdbarch (), regs_addr));
store_regs (regs_type, regs_addr);
}
if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE
|| scope == COMPILE_I_PRINT_VALUE_SCOPE)
{
out_value_type = get_out_value_type (func_sym, objfile, scope);
if (out_value_type == NULL)
{
do_cleanups (cleanups);
return NULL;
}
check_typedef (out_value_type);
out_value_addr = gdbarch_infcall_mmap (target_gdbarch (),
TYPE_LENGTH (out_value_type),
(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE));
gdb_assert (out_value_addr != 0);
munmap_list_add (&munmap_list_head, out_value_addr,
TYPE_LENGTH (out_value_type));
if (compile_debug)
fprintf_unfiltered (gdb_stdlog,
"allocated %s bytes at %s for printed value\n",
paddress (target_gdbarch (),
TYPE_LENGTH (out_value_type)),
paddress (target_gdbarch (), out_value_addr));
}
discard_cleanups (cleanups_free_objfile);
retval = xmalloc (sizeof (*retval));
retval->objfile = objfile;
retval->source_file = xstrdup (source_file);
retval->func_sym = func_sym;
retval->regs_addr = regs_addr;
retval->scope = scope;
retval->scope_data = scope_data;
retval->out_value_type = out_value_type;
retval->out_value_addr = out_value_addr;
/* CLEANUPS will free MUNMAP_LIST_HEAD. */
retval->munmap_list_head = munmap_list_head;
munmap_list_head = NULL;
do_cleanups (cleanups);
return retval;
}
struct compile_module *
compile_object_load (const char *object_file, const char *source_file)
{
struct cleanup *cleanups, *cleanups_free_objfile;
bfd *abfd;
struct setup_sections_data setup_sections_data;
CORE_ADDR addr, func_addr, regs_addr;
struct bound_minimal_symbol bmsym;
long storage_needed;
asymbol **symbol_table, **symp;
long number_of_symbols, missing_symbols;
struct type *dptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
unsigned dptr_type_len = TYPE_LENGTH (dptr_type);
struct compile_module *retval;
struct type *regs_type;
char *filename, **matching;
struct objfile *objfile;
filename = tilde_expand (object_file);
cleanups = make_cleanup (xfree, filename);
abfd = gdb_bfd_open (filename, gnutarget, -1);
if (abfd == NULL)
error (_("\"%s\": could not open as compiled module: %s"),
filename, bfd_errmsg (bfd_get_error ()));
make_cleanup_bfd_unref (abfd);
if (!bfd_check_format_matches (abfd, bfd_object, &matching))
error (_("\"%s\": not in loadable format: %s"),
filename, gdb_bfd_errmsg (bfd_get_error (), matching));
if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) != 0)
error (_("\"%s\": not in object format."), filename);
setup_sections_data.last_size = 0;
setup_sections_data.last_section_first = abfd->sections;
setup_sections_data.last_prot = -1;
setup_sections_data.last_max_alignment = 1;
bfd_map_over_sections (abfd, setup_sections, &setup_sections_data);
setup_sections (abfd, NULL, &setup_sections_data);
storage_needed = bfd_get_symtab_upper_bound (abfd);
if (storage_needed < 0)
error (_("Cannot read symbols of compiled module \"%s\": %s"),
filename, bfd_errmsg (bfd_get_error ()));
/* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
"Reading symbols from ..." message for automatically generated file. */
objfile = symbol_file_add_from_bfd (abfd, filename, 0, NULL, 0, NULL);
cleanups_free_objfile = make_cleanup_free_objfile (objfile);
bmsym = lookup_minimal_symbol_text (GCC_FE_WRAPPER_FUNCTION, objfile);
if (bmsym.minsym == NULL || MSYMBOL_TYPE (bmsym.minsym) == mst_file_text)
error (_("Could not find symbol \"%s\" of compiled module \"%s\"."),
GCC_FE_WRAPPER_FUNCTION, filename);
func_addr = BMSYMBOL_VALUE_ADDRESS (bmsym);
/* The memory may be later needed
by bfd_generic_get_relocated_section_contents
called from default_symfile_relocate. */
symbol_table = obstack_alloc (&objfile->objfile_obstack, storage_needed);
number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
if (number_of_symbols < 0)
error (_("Cannot parse symbols of compiled module \"%s\": %s"),
filename, bfd_errmsg (bfd_get_error ()));
missing_symbols = 0;
for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++)
{
asymbol *sym = *symp;
if (sym->flags != 0)
continue;
if (compile_debug)
fprintf_unfiltered (gdb_stdout,
"lookup undefined ELF symbol \"%s\"\n",
sym->name);
sym->flags = BSF_GLOBAL;
sym->section = bfd_abs_section_ptr;
if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0)
{
sym->value = 0;
continue;
}
bmsym = lookup_minimal_symbol (sym->name, NULL, NULL);
switch (bmsym.minsym == NULL
? mst_unknown : MSYMBOL_TYPE (bmsym.minsym))
{
case mst_text:
sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym);
break;
default:
warning (_("Could not find symbol \"%s\" "
"for compiled module \"%s\"."),
sym->name, filename);
missing_symbols++;
}
}
if (missing_symbols)
error (_("%ld symbols were missing, cannot continue."), missing_symbols);
bfd_map_over_sections (abfd, copy_sections, symbol_table);
regs_type = get_regs_type (objfile);
if (regs_type == NULL)
regs_addr = 0;
else
{
/* Use read-only non-executable memory protection. */
regs_addr = gdbarch_infcall_mmap (target_gdbarch (),
TYPE_LENGTH (regs_type),
GDB_MMAP_PROT_READ);
gdb_assert (regs_addr != 0);
store_regs (regs_type, regs_addr);
}
discard_cleanups (cleanups_free_objfile);
do_cleanups (cleanups);
retval = xmalloc (sizeof (*retval));
retval->objfile = objfile;
retval->source_file = xstrdup (source_file);
retval->func_addr = func_addr;
retval->regs_addr = regs_addr;
return retval;
}
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);
}
