/* Handle HP ELF shared libraries for GDB, the GNU Debugger.
- Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ Copyright 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
#include "gdb-stabs.h"
#include "gdb_stat.h"
#include "gdbcmd.h"
-#include "assert.h"
#include "language.h"
#include "regcache.h"
+#include "exec.h"
+#include "hppa-tdep.h"
#include <fcntl.h>
#define O_BINARY 0
#endif
-/* Defined in exec.c; used to prevent dangling pointer bug. */
-extern struct target_ops exec_ops;
-
static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
/* This lives in hppa-tdep.c. */
extern struct unwind_table_entry *find_unwind_entry (CORE_ADDR pc);
struct load_module_desc pa64_solib_desc;
struct section_table *sections;
struct section_table *sections_end;
- boolean loaded;
+ int loaded;
};
static struct so_list *so_list_head;
shared objects on the so_list_head list. (When we say size, here
we mean of the information before it is brought into memory and
potentially expanded by GDB.) When adding a new shlib, this value
- is compared against the threshold size, held by auto_solib_add
- (in megabytes). If adding symbols for the new shlib would cause
- the total size to exceed the threshold, then the new shlib's symbols
- are not loaded. */
+ is compared against a threshold size, held by auto_solib_limit (in
+ megabytes). If adding symbols for the new shlib would cause the
+ total size to exceed the threshold, then the new shlib's symbols
+ are not loaded. */
static LONGEST pa64_solib_total_st_size;
/* When the threshold is reached for any shlib, we refuse to add
symbols for subsequent shlibs, even if those shlibs' symbols would
- be small enough to fit under the threshold. (Although this may
+ be small enough to fit under the threshold. Although this may
result in one, early large shlib preventing the loading of later,
- smalller shlibs' symbols, it allows us to issue one informational
+ smaller shlibs' symbols, it allows us to issue one informational
message. The alternative, to issue a message for each shlib whose
symbols aren't loaded, could be a big annoyance where the threshold
- is exceeded due to a very large number of shlibs.) */
+ is exceeded due to a very large number of shlibs. */
static int pa64_solib_st_size_threshold_exceeded;
/* When adding fields, be sure to clear them in _initialize_pa64_solib. */
typedef struct
{
CORE_ADDR dld_flags_addr;
- long long dld_flags;
- sec_ptr dyninfo_sect;
- boolean have_read_dld_descriptor;
- boolean is_valid;
+ LONGEST dld_flags;
+ struct bfd_section *dyninfo_sect;
+ int have_read_dld_descriptor;
+ int is_valid;
CORE_ADDR load_map;
CORE_ADDR load_map_addr;
struct load_module_desc dld_desc;
static void *pa64_target_read_memory (void *, CORE_ADDR, size_t, int);
-static boolean read_dld_descriptor (struct target_ops *);
+static int read_dld_descriptor (struct target_ops *, int readsyms);
-static boolean read_dynamic_info (asection *, dld_cache_t *);
+static int read_dynamic_info (asection *, dld_cache_t *);
-static void add_to_solist (boolean, char *, struct load_module_desc *,
+static void add_to_solist (int, char *, int, struct load_module_desc *,
CORE_ADDR, struct target_ops *);
/* When examining the shared library for debugging information we have to
/* We believe that filename was handed to us by the dynamic linker, and
is therefore always an absolute path. */
- desc = openp (getenv ("PATH"), 1, filename, O_RDONLY | O_BINARY,
- 0, &absolute_name);
+ desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
+ O_RDONLY | O_BINARY, 0, &absolute_name);
if (desc < 0)
{
perror_with_name (filename);
{
close (desc);
make_cleanup (xfree, filename);
- error ("\"%s\": can't open to read symbols: %s.", filename,
+ error (_("\"%s\": can't open to read symbols: %s."), filename,
bfd_errmsg (bfd_get_error ()));
}
{
bfd_close (abfd);
make_cleanup (xfree, filename);
- error ("\"%s\": can't read symbols: %s.", filename,
+ error (_("\"%s\": can't read symbols: %s."), filename,
bfd_errmsg (bfd_get_error ()));
}
{
bfd *tmp_bfd;
asection *sec;
- obj_private_data_t *obj_private;
- struct section_addr_info section_addrs;
+ struct hppa_objfile_private *obj_private;
+ struct section_addr_info *section_addrs;
+ struct cleanup *my_cleanups;
- memset (§ion_addrs, 0, sizeof (section_addrs));
/* We need the BFD so that we can look at its sections. We open up the
file temporarily, then close it when we are done. */
tmp_bfd = bfd_openr (name, gnutarget);
if (!bfd_check_format (tmp_bfd, bfd_object))
{
bfd_close (tmp_bfd);
- error ("\"%s\" is not an object file: %s", name,
+ error (_("\"%s\" is not an object file: %s"), name,
bfd_errmsg (bfd_get_error ()));
}
/* Now find the true lowest section in the shared library. */
sec = NULL;
- bfd_map_over_sections (tmp_bfd, find_lowest_section, (PTR) &sec);
+ bfd_map_over_sections (tmp_bfd, find_lowest_section, &sec);
if (sec)
{
text_addr += sec->filepos;
}
+ section_addrs = alloc_section_addr_info (bfd_count_sections (tmp_bfd));
+ my_cleanups = make_cleanup (xfree, section_addrs);
+
/* We are done with the temporary bfd. Get rid of it and make sure
nobody else can us it. */
bfd_close (tmp_bfd);
tmp_bfd = NULL;
/* Now let the generic code load up symbols for this library. */
- section_addrs.other[0].addr = text_addr;
- section_addrs.other[0].name = ".text";
- so->objfile = symbol_file_add (name, from_tty, §ion_addrs, 0, OBJF_SHARED);
+ section_addrs->other[0].addr = text_addr;
+ section_addrs->other[0].name = ".text";
+ so->objfile = symbol_file_add (name, from_tty, section_addrs, 0, OBJF_SHARED);
so->abfd = so->objfile->obfd;
/* Mark this as a shared library and save private data. */
so->objfile->flags |= OBJF_SHARED;
- if (so->objfile->obj_private == NULL)
+ obj_private = (struct hppa_objfile_private *)
+ objfile_data (so->objfile, hppa_objfile_priv_data);
+ if (obj_private == NULL)
{
- obj_private = (obj_private_data_t *)
- obstack_alloc (&so->objfile->psymbol_obstack,
- sizeof (obj_private_data_t));
+ obj_private = (struct hppa_objfile_private *)
+ obstack_alloc (&so->objfile->objfile_obstack,
+ sizeof (struct hppa_objfile_private));
+ set_objfile_data (so->objfile, hppa_objfile_priv_data, obj_private);
obj_private->unwind_info = NULL;
obj_private->so_info = NULL;
- so->objfile->obj_private = (PTR) obj_private;
}
- obj_private = (obj_private_data_t *) so->objfile->obj_private;
obj_private->so_info = so;
obj_private->dp = so->pa64_solib_desc.linkage_ptr;
+ do_cleanups (my_cleanups);
}
/* Load debugging information for a shared library. TARGET may be
&so->sections,
&so->sections_end))
{
- error ("Unable to build section table for shared library\n.");
+ error (_("Unable to build section table for shared library\n."));
return;
}
/* Add symbols from shared libraries into the symtab list, unless the
- size threshold (specified by auto_solib_add, in megabytes) would
+ size threshold specified by auto_solib_limit (in megabytes) would
be exceeded. */
void
-pa64_solib_add (char *arg_string, int from_tty, struct target_ops *target)
+pa64_solib_add (char *arg_string, int from_tty, struct target_ops *target, int readsyms)
{
struct minimal_symbol *msymbol;
CORE_ADDR addr;
/* First validate our arguments. */
if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
{
- error ("Invalid regexp: %s", re_err);
+ error (_("Invalid regexp: %s"), re_err);
}
/* If we're debugging a core file, or have attached to a running
We need to first determine if we're dealing with a dynamically
linked executable. If not, then return without an error or warning.
- We also need to examine __dld_flags to determine if the shared library
- list is valid and to determine if the libraries have been privately
- mapped. */
+ We also need to examine __dld_flags to determine if the shared
+ library list is valid and to determine if the libraries have been
+ privately mapped. */
if (symfile_objfile == NULL)
return;
/* Read in the load map pointer if we have not done so already. */
if (! dld_cache.have_read_dld_descriptor)
- if (! read_dld_descriptor (target))
+ if (! read_dld_descriptor (target, readsyms))
return;
/* If the libraries were not mapped private, warn the user. */
if ((dld_cache.dld_flags & DT_HP_DEBUG_PRIVATE) == 0)
- warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
+ warning (_("\
+The shared libraries were not privately mapped; setting a\n\
+breakpoint in a shared library will not work until you rerun the program."));
/* For each shaerd library, add it to the shared library list. */
for (dll_index = 1; ; dll_index++)
0, dld_cache.load_map);
if (!dll_path)
- error ("pa64_solib_add, unable to read shared library path.");
+ error (_("pa64_solib_add, unable to read shared library path."));
- add_to_solist (from_tty, dll_path, &dll_desc, 0, target);
+ add_to_solist (from_tty, dll_path, readsyms, &dll_desc, 0, target);
}
}
DT_HP_DEBUG_PRIVATE to indicate that shared libraries should be
mapped private.
- DT_HP_DEBUG_CALLBACK to indicate that we want the dynamic linker to
- call the breakpoint routine for significant events. */
+ DT_HP_DEBUG_CALLBACK to indicate that we want the dynamic linker
+ to call the breakpoint routine for significant events. */
void
pa64_solib_create_inferior_hook (void)
/* Read in the .dynamic section. */
if (! read_dynamic_info (shlib_info, &dld_cache))
- error ("Unable to read the .dynamic section.");
+ error (_("Unable to read the .dynamic section."));
/* Turn on the flags we care about. */
dld_cache.dld_flags |= DT_HP_DEBUG_PRIVATE;
(char *) &dld_cache.dld_flags,
sizeof (dld_cache.dld_flags));
if (status != 0)
- error ("Unable to modify dynamic linker flags.");
+ error (_("Unable to modify dynamic linker flags."));
/* Now we have to create a shared library breakpoint in the dynamic
linker. This can be somewhat tricky since the symbol is inside
/* Make sure the dynamic linker's really a useful object. */
if (!bfd_check_format (tmp_bfd, bfd_object))
{
- warning ("Unable to grok dynamic linker %s as an object file", buf);
+ warning (_("Unable to grok dynamic linker %s as an object file"), buf);
bfd_close (tmp_bfd);
goto get_out;
}
shared library events. To resume notifications, GDB must call
pa64_solib_create_inferior_hook.
- This operation does not remove any knowledge of shared libraries which
- GDB may already have been notified of. */
+ This operation does not remove any knowledge of shared libraries
+ of which GDB may already have been notified. */
void
pa64_solib_remove_inferior_hook (int pid)
{
CORE_ADDR event_kind;
- event_kind = read_register (ARG0_REGNUM);
+ event_kind = read_register (HPPA_ARG0_REGNUM);
return (event_kind == DLD_CB_LOAD);
}
{
CORE_ADDR event_kind;
- event_kind = read_register (ARG0_REGNUM);
+ event_kind = read_register (HPPA_ARG0_REGNUM);
return (event_kind == DLD_CB_UNLOAD);
}
pa64_solib_loaded_library_pathname (int pid)
{
static char dll_path[MAXPATHLEN];
- CORE_ADDR dll_path_addr = read_register (ARG3_REGNUM);
+ CORE_ADDR dll_path_addr = read_register (HPPA_ARG3_REGNUM);
read_memory_string (dll_path_addr, dll_path, MAXPATHLEN);
return dll_path;
}
pa64_solib_unloaded_library_pathname (int pid)
{
static char dll_path[MAXPATHLEN];
- CORE_ADDR dll_path_addr = read_register (ARG3_REGNUM);
+ CORE_ADDR dll_path_addr = read_register (HPPA_ARG3_REGNUM);
read_memory_string (dll_path_addr, dll_path, MAXPATHLEN);
return dll_path;
}
return 0;
if (!dld_cache.have_read_dld_descriptor)
- if (!read_dld_descriptor (¤t_target))
+ if (!read_dld_descriptor (¤t_target, auto_solib_add))
return 0;
return (pc >= dld_cache.dld_desc.text_base
if (so_list->loaded == 0)
printf_unfiltered (" (shared library unloaded)");
printf_unfiltered (" %-18s",
- local_hex_string_custom (so_list->pa64_solib_desc.linkage_ptr,
- "016l"));
+ hex_string_custom (so_list->pa64_solib_desc.linkage_ptr, 16));
printf_unfiltered ("\n");
printf_unfiltered ("%-18s",
- local_hex_string_custom (so_list->pa64_solib_desc.text_base,
- "016l"));
+ hex_string_custom (so_list->pa64_solib_desc.text_base, 16));
printf_unfiltered (" %-18s",
- local_hex_string_custom ((so_list->pa64_solib_desc.text_base
- + so_list->pa64_solib_desc.text_size),
- "016l"));
+ hex_string_custom ((so_list->pa64_solib_desc.text_base
+ + so_list->pa64_solib_desc.text_size), 16));
printf_unfiltered (" %-18s",
- local_hex_string_custom (so_list->pa64_solib_desc.data_base,
- "016l"));
+ hex_string_custom (so_list->pa64_solib_desc.data_base, 16));
printf_unfiltered (" %-18s\n",
- local_hex_string_custom ((so_list->pa64_solib_desc.data_base
- + so_list->pa64_solib_desc.data_size),
- "016l"));
+ hex_string_custom ((so_list->pa64_solib_desc.data_base
+ + so_list->pa64_solib_desc.data_size), 16));
so_list = so_list->next;
}
}
pa64_solib_sharedlibrary_command (char *args, int from_tty)
{
dont_repeat ();
- pa64_solib_add (args, from_tty, (struct target_ops *) 0);
+ pa64_solib_add (args, from_tty, (struct target_ops *) 0, 1);
}
/* Return the name of the shared library containing ADDR or NULL if ADDR
_initialize_pa64_solib (void)
{
add_com ("sharedlibrary", class_files, pa64_solib_sharedlibrary_command,
- "Load shared object library symbols for files matching REGEXP.");
+ _("Load shared object library symbols for files matching REGEXP."));
add_info ("sharedlibrary", pa64_sharedlibrary_info_command,
- "Status of loaded shared object libraries.");
- add_show_from_set
- (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
- (char *) &auto_solib_add,
- "Set autoloading size threshold (in megabytes) of shared library symbols.\n\
-If nonzero, symbols from all shared object libraries will be loaded\n\
-automatically when the inferior begins execution or when the dynamic linker\n\
-informs gdb that a new library has been loaded, until the symbol table\n\
-of the program and libraries exceeds this threshold.\n\
-Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
- &setlist),
- &showlist);
-
- /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how much
- data space a process can use. We ought to be reading MAXDSIZ and
- setting auto_solib_add to some large fraction of that value. If
- not that, we maybe ought to be setting it smaller than the default
- for MAXDSIZ (that being 64Mb, I believe). However, [1] this threshold
- is only crudely approximated rather than actually measured, and [2]
- 50 Mbytes is too small for debugging gdb itself. Thus, the arbitrary
- 100 figure.
- */
- auto_solib_add = 100; /* Megabytes */
+ _("Status of loaded shared object libraries."));
+
+ add_setshow_boolean_cmd ("auto-solib-add", class_support,
+ &auto_solib_add, _("\
+Set autoloading of shared library symbols."), _("\
+Show autoloading of shared library symbols."), _("\
+If \"on\", symbols from all shared object libraries will be loaded\n\
+automatically when the inferior begins execution, when the dynamic linker\n\
+informs gdb that a new library has been loaded, or when attaching to the\n\
+inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'."),
+ NULL,
+ NULL, /* FIXME: i18n: */
+ &setlist, &showlist);
+
+ add_setshow_zinteger_cmd ("auto-solib-limit", class_support,
+ &auto_solib_limit, _("\
+Set threshold (in Mb) for autoloading shared library symbols."), _("\
+Show threshold (in Mb) for autoloading shared library symbols."), _("\
+When shared library autoloading is enabled, new libraries will be loaded\n\
+only until the total size of shared library symbols exceeds this\n\
+threshold in megabytes. Is ignored when using `sharedlibrary'."),
+ NULL,
+ NULL, /* FIXME: i18n: */
+ &setlist, &showlist);
+
+ /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how
+ much data space a process can use. We ought to be reading
+ MAXDSIZ and setting auto_solib_limit to some large fraction of
+ that value. If not that, we maybe ought to be setting it smaller
+ than the default for MAXDSIZ (that being 64Mb, I believe).
+ However, [1] this threshold is only crudely approximated rather
+ than actually measured, and [2] 50 Mbytes is too small for
+ debugging gdb itself. Thus, the arbitrary 100 figure. */
+ auto_solib_limit = 100; /* Megabytes */
pa64_solib_restart ();
}
/* Get some HPUX-specific data from a shared lib. */
CORE_ADDR
-so_lib_thread_start_addr (struct so_list *so)
+pa64_solib_thread_start_addr (struct so_list *so)
{
return so->pa64_solib_desc.tls_start_addr;
}
descriptor. If the library is archive bound, then return zero, else
return nonzero. */
-static boolean
-read_dld_descriptor (struct target_ops *target)
+static int
+read_dld_descriptor (struct target_ops *target, int readsyms)
{
char *dll_path;
asection *dyninfo_sect;
if (!dld_cache.is_valid)
{
if (symfile_objfile == NULL)
- error ("No object file symbols.");
+ error (_("No object file symbols."));
dyninfo_sect = bfd_get_section_by_name (symfile_objfile->obfd,
".dynamic");
}
if (!read_dynamic_info (dyninfo_sect, &dld_cache))
- error ("Unable to read in .dynamic section information.");
+ error (_("Unable to read in .dynamic section information."));
}
/* Read the load map pointer. */
sizeof(dld_cache.load_map))
!= 0)
{
- error ("Error while reading in load map pointer.");
+ error (_("Error while reading in load map pointer."));
}
/* Read in the dld load module descriptor */
dld_cache.load_map)
== 0)
{
- error ("Error trying to get information about dynamic linker.");
+ error (_("Error trying to get information about dynamic linker."));
}
/* Indicate that we have loaded the dld descriptor. */
pa64_target_read_memory,
0,
dld_cache.load_map);
- add_to_solist(0, dll_path, &dld_cache.dld_desc, 0, target);
+ add_to_solist(0, dll_path, readsyms, &dld_cache.dld_desc, 0, target);
return 1;
}
which is stored in dld_cache. The routine elf_locate_base in solib.c
was used as a model for this. */
-static boolean
+static int
read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p)
{
char *buf;
sizeof(dld_cache_p->dld_flags))
!= 0)
{
- error ("Error while reading in .dynamic section of the program.");
+ error (_("Error while reading in .dynamic section of the program."));
}
}
else if (dyn_tag == DT_HP_LOAD_MAP)
sizeof(dld_cache_p->load_map_addr))
!= 0)
{
- error ("Error while reading in .dynamic section of the program.");
+ error (_("Error while reading in .dynamic section of the program."));
}
}
else
be read from the inferior process at the address load_module_desc_addr. */
static void
-add_to_solist (boolean from_tty, char *dll_path,
+add_to_solist (int from_tty, char *dll_path, int readsyms,
struct load_module_desc *load_module_desc_p,
CORE_ADDR load_module_desc_addr, struct target_ops *target)
{
sizeof(struct load_module_desc))
!= 0)
{
- error ("Error while reading in dynamic library %s", dll_path);
+ error (_("Error while reading in dynamic library %s"), dll_path);
}
}
new_so->pa64_solib_desc_addr = load_module_desc_addr;
new_so->loaded = 1;
new_so->name = obsavestring (dll_path, strlen(dll_path),
- &symfile_objfile->symbol_obstack);
+ &symfile_objfile->objfile_obstack);
/* If we are not going to load the library, tell the user if we
haven't already and return. */
st_size = pa64_solib_sizeof_symbol_table (dll_path);
pa64_solib_st_size_threshhold_exceeded =
!from_tty
+ && readsyms
&& ( (st_size + pa64_solib_total_st_size)
- > (auto_solib_add * (LONGEST)1000000));
+ > (auto_solib_limit * (LONGEST) (1024 * 1024)));
if (pa64_solib_st_size_threshhold_exceeded)
{
pa64_solib_add_solib_objfile (new_so, dll_path, from_tty, 1);
if (storage_needed > 0)
{
symbol_table = (asymbol **) xmalloc (storage_needed);
- back_to = make_cleanup (xfree, (PTR) symbol_table);
+ back_to = make_cleanup (xfree, symbol_table);
number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
for (i = 0; i < number_of_symbols; i++)
{
sym = *symbol_table++;
- if (STREQ (sym->name, symname))
+ if (strcmp (sym->name, symname) == 0)
{
/* Bfd symbols are section relative. */
symaddr = sym->value + sym->section->vma;