static void
darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
{
char *interp_name;
CORE_ADDR load_addr = 0;
bfd *dyld_bfd = NULL;
struct cleanup *cleanup;
/* This method doesn't work with an attached process. */
if (current_inferior ()->attach_flag)
return;
/* Find the program interpreter. */
interp_name = find_program_interpreter ();
if (!interp_name)
return;
cleanup = make_cleanup (null_cleanup, NULL);
/* Create a bfd for the interpreter. */
dyld_bfd = gdb_bfd_open (interp_name, gnutarget, -1);
if (dyld_bfd)
{
bfd *sub;
make_cleanup_bfd_unref (dyld_bfd);
sub = gdb_bfd_mach_o_fat_extract
(dyld_bfd, bfd_object, gdbarch_bfd_arch_info (target_gdbarch ()));
if (sub)
{
dyld_bfd = sub;
make_cleanup_bfd_unref (sub);
}
else
dyld_bfd = NULL;
}
if (!dyld_bfd)
{
do_cleanups (cleanup);
return;
}
/* We find the dynamic linker's base address by examining
the current pc (which should point at the entry point for the
dynamic linker) and subtracting the offset of the entry point. */
load_addr = (regcache_read_pc (get_current_regcache ())
- bfd_get_start_address (dyld_bfd));
/* Now try to set a breakpoint in the dynamic linker. */
info->all_image_addr =
lookup_symbol_from_bfd (dyld_bfd, "_dyld_all_image_infos");
do_cleanups (cleanup);
if (info->all_image_addr == 0)
return;
info->all_image_addr += load_addr;
}
gdb_bfd_ref_ptr
build_id_to_debug_bfd (size_t build_id_len, const bfd_byte *build_id)
{
char *link, *debugdir;
VEC (char_ptr) *debugdir_vec;
struct cleanup *back_to;
int ix;
gdb_bfd_ref_ptr abfd;
int alloc_len;
/* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
alloc_len = (strlen (debug_file_directory)
+ (sizeof "/.build-id/" - 1) + 1
+ 2 * build_id_len + (sizeof ".debug" - 1) + 1);
link = (char *) alloca (alloc_len);
/* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
cause "/.build-id/..." lookups. */
debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory);
back_to = make_cleanup_free_char_ptr_vec (debugdir_vec);
for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix)
{
size_t debugdir_len = strlen (debugdir);
const gdb_byte *data = build_id;
size_t size = build_id_len;
char *s;
char *filename = NULL;
struct cleanup *inner;
memcpy (link, debugdir, debugdir_len);
s = &link[debugdir_len];
s += sprintf (s, "/.build-id/");
if (size > 0)
{
size--;
s += sprintf (s, "%02x", (unsigned) *data++);
}
if (size > 0)
*s++ = '/';
while (size-- > 0)
s += sprintf (s, "%02x", (unsigned) *data++);
strcpy (s, ".debug");
if (separate_debug_file_debug)
printf_unfiltered (_(" Trying %s\n"), link);
/* lrealpath() is expensive even for the usually non-existent files. */
if (access (link, F_OK) == 0)
filename = lrealpath (link);
if (filename == NULL)
continue;
/* We expect to be silent on the non-existing files. */
inner = make_cleanup (xfree, filename);
abfd = gdb_bfd_open (filename, gnutarget, -1);
do_cleanups (inner);
if (abfd == NULL)
continue;
if (build_id_verify (abfd.get(), build_id_len, build_id))
break;
abfd.release ();
}
do_cleanups (back_to);
return abfd;
}
void
exec_file_attach (char *filename, int from_tty)
{
/* Remove any previous exec file. */
exec_close ();
/* Now open and digest the file the user requested, if any. */
if (!filename)
{
if (from_tty)
printf_unfiltered (_("No executable file now.\n"));
set_gdbarch_from_file (NULL);
}
else
{
struct cleanup *cleanups;
char *scratch_pathname, *canonical_pathname;
int scratch_chan;
struct target_section *sections = NULL, *sections_end = NULL;
char **matching;
scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
&scratch_pathname);
#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
if (scratch_chan < 0)
{
char *exename = alloca (strlen (filename) + 5);
strcat (strcpy (exename, filename), ".exe");
scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
&scratch_pathname);
}
#endif
if (scratch_chan < 0)
perror_with_name (filename);
cleanups = make_cleanup (xfree, scratch_pathname);
/* gdb_bfd_open (and its variants) prefers canonicalized pathname for
better BFD caching. */
canonical_pathname = gdb_realpath (scratch_pathname);
make_cleanup (xfree, canonical_pathname);
if (write_files)
exec_bfd = gdb_bfd_fopen (canonical_pathname, gnutarget,
FOPEN_RUB, scratch_chan);
else
exec_bfd = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
if (!exec_bfd)
{
error (_("\"%s\": could not open as an executable file: %s"),
scratch_pathname, bfd_errmsg (bfd_get_error ()));
}
gdb_assert (exec_filename == NULL);
exec_filename = gdb_realpath_keepfile (scratch_pathname);
if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
{
/* Make sure to close exec_bfd, or else "run" might try to use
it. */
exec_close ();
error (_("\"%s\": not in executable format: %s"),
scratch_pathname,
gdb_bfd_errmsg (bfd_get_error (), matching));
}
if (build_section_table (exec_bfd, §ions, §ions_end))
{
/* Make sure to close exec_bfd, or else "run" might try to use
it. */
exec_close ();
error (_("\"%s\": can't find the file sections: %s"),
scratch_pathname, bfd_errmsg (bfd_get_error ()));
}
exec_bfd_mtime = bfd_get_mtime (exec_bfd);
validate_files ();
set_gdbarch_from_file (exec_bfd);
/* Add the executable's sections to the current address spaces'
list of sections. This possibly pushes the exec_ops
target. */
add_target_sections (&exec_bfd, sections, sections_end);
xfree (sections);
/* Tell display code (if any) about the changed file name. */
if (deprecated_exec_file_display_hook)
(*deprecated_exec_file_display_hook) (filename);
do_cleanups (cleanups);
}
bfd_cache_close_all ();
observer_notify_executable_changed ();
}
void
exec_file_attach (const char *filename, int from_tty)
{
struct cleanup *cleanups;
/* First, acquire a reference to the current exec_bfd. We release
this at the end of the function; but acquiring it now lets the
BFD cache return it if this call refers to the same file. */
gdb_bfd_ref (exec_bfd);
cleanups = make_cleanup_bfd_unref (exec_bfd);
/* Remove any previous exec file. */
exec_close ();
/* Now open and digest the file the user requested, if any. */
if (!filename)
{
if (from_tty)
printf_unfiltered (_("No executable file now.\n"));
set_gdbarch_from_file (NULL);
}
else
{
int load_via_target = 0;
char *scratch_pathname, *canonical_pathname;
int scratch_chan;
struct target_section *sections = NULL, *sections_end = NULL;
char **matching;
if (is_target_filename (filename))
{
if (target_filesystem_is_local ())
filename += strlen (TARGET_SYSROOT_PREFIX);
else
load_via_target = 1;
}
if (load_via_target)
{
/* gdb_bfd_fopen does not support "target:" filenames. */
if (write_files)
warning (_("writing into executable files is "
"not supported for %s sysroots"),
TARGET_SYSROOT_PREFIX);
scratch_pathname = xstrdup (filename);
make_cleanup (xfree, scratch_pathname);
scratch_chan = -1;
canonical_pathname = scratch_pathname;
}
else
{
scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
filename, write_files ?
O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
&scratch_pathname);
#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
if (scratch_chan < 0)
{
char *exename = alloca (strlen (filename) + 5);
strcat (strcpy (exename, filename), ".exe");
scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
exename, write_files ?
O_RDWR | O_BINARY
: O_RDONLY | O_BINARY,
&scratch_pathname);
}
#endif
if (scratch_chan < 0)
perror_with_name (filename);
make_cleanup (xfree, scratch_pathname);
/* gdb_bfd_open (and its variants) prefers canonicalized
pathname for better BFD caching. */
canonical_pathname = gdb_realpath (scratch_pathname);
make_cleanup (xfree, canonical_pathname);
}
if (write_files && !load_via_target)
exec_bfd = gdb_bfd_fopen (canonical_pathname, gnutarget,
FOPEN_RUB, scratch_chan);
else
exec_bfd = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
if (!exec_bfd)
{
error (_("\"%s\": could not open as an executable file: %s"),
scratch_pathname, bfd_errmsg (bfd_get_error ()));
}
/* gdb_realpath_keepfile resolves symlinks on the local
filesystem and so cannot be used for "target:" files. */
gdb_assert (exec_filename == NULL);
if (load_via_target)
exec_filename = xstrdup (bfd_get_filename (exec_bfd));
else
exec_filename = gdb_realpath_keepfile (scratch_pathname);
if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
{
/* Make sure to close exec_bfd, or else "run" might try to use
it. */
exec_close ();
error (_("\"%s\": not in executable format: %s"),
scratch_pathname,
gdb_bfd_errmsg (bfd_get_error (), matching));
}
if (build_section_table (exec_bfd, §ions, §ions_end))
{
/* Make sure to close exec_bfd, or else "run" might try to use
it. */
exec_close ();
error (_("\"%s\": can't find the file sections: %s"),
scratch_pathname, bfd_errmsg (bfd_get_error ()));
}
exec_bfd_mtime = bfd_get_mtime (exec_bfd);
validate_files ();
set_gdbarch_from_file (exec_bfd);
/* Add the executable's sections to the current address spaces'
list of sections. This possibly pushes the exec_ops
target. */
add_target_sections (&exec_bfd, sections, sections_end);
xfree (sections);
/* Tell display code (if any) about the changed file name. */
if (deprecated_exec_file_display_hook)
(*deprecated_exec_file_display_hook) (filename);
}
do_cleanups (cleanups);
bfd_cache_close_all ();
observer_notify_executable_changed ();
}
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;
}
static struct vmap *
add_vmap (LdInfo *ldi)
{
bfd *abfd, *last;
char *mem, *filename;
struct objfile *obj;
struct vmap *vp;
int fd;
ARCH64_DECL (arch64);
/* This ldi structure was allocated using alloca() in
xcoff_relocate_symtab(). Now we need to have persistent object
and member names, so we should save them. */
filename = LDI_FILENAME (ldi, arch64);
mem = filename + strlen (filename) + 1;
mem = xstrdup (mem);
fd = LDI_FD (ldi, arch64);
abfd = gdb_bfd_open (filename, gnutarget, fd < 0 ? -1 : fd);
if (!abfd)
{
warning (_("Could not open `%s' as an executable file: %s"),
filename, bfd_errmsg (bfd_get_error ()));
return NULL;
}
/* Make sure we have an object file. */
if (bfd_check_format (abfd, bfd_object))
vp = map_vmap (abfd, 0);
else if (bfd_check_format (abfd, bfd_archive))
{
last = gdb_bfd_openr_next_archived_file (abfd, NULL);
while (last != NULL)
{
bfd *next;
if (strcmp (mem, last->filename) == 0)
break;
next = gdb_bfd_openr_next_archived_file (abfd, last);
gdb_bfd_unref (last);
last = next;
}
if (!last)
{
warning (_("\"%s\": member \"%s\" missing."), filename, mem);
gdb_bfd_unref (abfd);
return NULL;
}
if (!bfd_check_format (last, bfd_object))
{
warning (_("\"%s\": member \"%s\" not in executable format: %s."),
filename, mem, bfd_errmsg (bfd_get_error ()));
gdb_bfd_unref (last);
gdb_bfd_unref (abfd);
return NULL;
}
vp = map_vmap (last, abfd);
/* map_vmap acquired a reference to LAST, so we can release
ours. */
gdb_bfd_unref (last);
}
else
{
warning (_("\"%s\": not in executable format: %s."),
filename, bfd_errmsg (bfd_get_error ()));
gdb_bfd_unref (abfd);
return NULL;
}
obj = allocate_objfile (vp->bfd, 0);
vp->objfile = obj;
/* Always add symbols for the main objfile. */
if (vp == vmap || auto_solib_add)
vmap_add_symbols (vp);
/* Anything needing a reference to ABFD has already acquired it, so
release our local reference. */
gdb_bfd_unref (abfd);
return vp;
}
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_symfile_read_all_oso (std::vector<oso_el> *oso_vector_ptr,
struct objfile *main_objfile,
symfile_add_flags symfile_flags)
{
int ix;
oso_el *oso;
/* Sort oso by name so that files from libraries are gathered. */
std::sort (oso_vector_ptr->begin (), oso_vector_ptr->end (),
oso_el_compare_name);
for (ix = 0; ix < oso_vector_ptr->size (); ++ix)
{
int pfx_len;
oso = &(*oso_vector_ptr)[ix];
/* Check if this is a library name. */
pfx_len = get_archive_prefix_len (oso->name);
if (pfx_len > 0)
{
int last_ix;
oso_el *oso2;
int ix2;
std::string archive_name (oso->name, pfx_len);
/* Compute number of oso for this archive. */
for (last_ix = ix; last_ix < oso_vector_ptr->size (); last_ix++)
{
oso2 = &(*oso_vector_ptr)[last_ix];
if (strncmp (oso2->name, archive_name.c_str (), pfx_len) != 0)
break;
}
/* Open the archive and check the format. */
gdb_bfd_ref_ptr archive_bfd (gdb_bfd_open (archive_name.c_str (),
gnutarget, -1));
if (archive_bfd == NULL)
{
warning (_("Could not open OSO archive file \"%s\""),
archive_name.c_str ());
ix = last_ix;
continue;
}
if (!bfd_check_format (archive_bfd.get (), bfd_archive))
{
warning (_("OSO archive file \"%s\" not an archive."),
archive_name.c_str ());
ix = last_ix;
continue;
}
gdb_bfd_ref_ptr member_bfd
(gdb_bfd_openr_next_archived_file (archive_bfd.get (), NULL));
if (member_bfd == NULL)
{
warning (_("Could not read archive members out of "
"OSO archive \"%s\""), archive_name.c_str ());
ix = last_ix;
continue;
}
/* Load all oso in this library. */
while (member_bfd != NULL)
{
const char *member_name = member_bfd->filename;
int member_len = strlen (member_name);
/* If this member is referenced, add it as a symfile. */
for (ix2 = ix; ix2 < last_ix; ix2++)
{
oso2 = &(*oso_vector_ptr)[ix2];
if (oso2->name
&& strlen (oso2->name) == pfx_len + member_len + 2
&& !memcmp (member_name, oso2->name + pfx_len + 1,
member_len))
{
macho_add_oso_symfile (oso2, member_bfd,
bfd_get_filename (member_bfd),
main_objfile, symfile_flags);
oso2->name = NULL;
break;
}
}
member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd.get (),
member_bfd.get ());
}
for (ix2 = ix; ix2 < last_ix; ix2++)
{
oso_el *oso2 = &(*oso_vector_ptr)[ix2];
if (oso2->name != NULL)
warning (_("Could not find specified archive member "
"for OSO name \"%s\""), oso->name);
}
ix = last_ix;
}
else
{
gdb_bfd_ref_ptr abfd (gdb_bfd_open (oso->name, gnutarget, -1));
if (abfd == NULL)
warning (_("`%s': can't open to read symbols: %s."), oso->name,
bfd_errmsg (bfd_get_error ()));
else
macho_add_oso_symfile (oso, abfd, oso->name, main_objfile,
symfile_flags);
ix++;
}
}
}