X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsomsolib.c;h=41e938e72ea3203e56a631660af84f6b64ff1ff7;hb=b1acf338d3974d99af32899092989edeee7fbef4;hp=8bb3e79e950943b673e0a5c6c71926bbc6716d89;hpb=9ca0e47c0078e485ad0d3a224014e677cf00d755;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/somsolib.c b/gdb/somsolib.c index 8bb3e79e95..41e938e72e 100644 --- a/gdb/somsolib.c +++ b/gdb/somsolib.c @@ -1,5 +1,7 @@ /* Handle HP SOM shared libraries for GDB, the GNU Debugger. - Copyright 1993, 1996, 1999, 2001 Free Software Foundation, Inc. + + Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, + 2003, 2004 Free Software Foundation, Inc. This file is part of GDB. @@ -37,8 +39,11 @@ #include "gdb-stabs.h" #include "gdb_stat.h" #include "gdbcmd.h" -#include "assert.h" #include "language.h" +#include "regcache.h" +#include "gdb_assert.h" +#include "exec.h" +#include "hppa-tdep.h" #include @@ -46,16 +51,20 @@ #define O_BINARY 0 #endif +#ifndef SHL_LOAD +#define SHL_LOAD 4 +#endif + +#ifndef SHL_UNLOAD +#define SHL_UNLOAD 8 +#endif + /* Uncomment this to turn on some debugging output. */ /* #define SOLIB_DEBUG */ -/* Defined in exec.c; used to prevent dangling pointer bug. - */ -extern struct target_ops exec_ops; - /* This lives in hppa-tdep.c. */ extern struct unwind_table_entry *find_unwind_entry (CORE_ADDR pc); @@ -71,9 +80,6 @@ extern struct unwind_table_entry *find_unwind_entry (CORE_ADDR pc); /* TODO: - * Most of this code should work for hp300 shared libraries. Does - anyone care enough to weed out any SOM-isms. - * Support for hpux8 dynamic linker. */ /* The basic structure which describes a dynamically loaded object. This @@ -159,11 +165,10 @@ 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 + is compared against the 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. - */ + the total size to exceed the threshold, then the new shlib's + symbols are not loaded. */ static LONGEST som_solib_total_st_size; /* When the threshold is reached for any shlib, we refuse to add @@ -190,7 +195,7 @@ addr_and_unwind_t; /* When adding fields, be sure to clear them in _initialize_som_solib. */ static struct { - boolean is_valid; + int is_valid; addr_and_unwind_t hook; addr_and_unwind_t hook_stub; addr_and_unwind_t load; @@ -219,7 +224,8 @@ som_solib_sizeof_symbol_table (char *filename) /* 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); @@ -282,7 +288,7 @@ static void som_solib_add_solib_objfile (struct so_list *so, char *name, int from_tty, CORE_ADDR text_addr) { - obj_private_data_t *obj_private; + struct hppa_objfile_private *obj_private; struct obj_section *s; so->objfile = symbol_file_add (name, from_tty, NULL, 0, OBJF_SHARED); @@ -311,17 +317,18 @@ som_solib_add_solib_objfile (struct so_list *so, char *name, int from_tty, */ 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; if (!bfd_check_format (so->abfd, bfd_object)) @@ -400,12 +407,27 @@ som_solib_load_symbols (struct so_list *so, char *name, int from_tty, } +/* FIXME: cagney/2003-02-01: This just isn't right. Given an address + within the target's address space, this converts the value into an + address within the host's (i.e., GDB's) address space. Given that + the host/target address spaces are separate, this can't be right. */ + +static void * +hpux_address_to_host_pointer_hack (CORE_ADDR addr) +{ + void *ptr; + + gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr)); + ADDRESS_TO_POINTER (builtin_type_void_data_ptr, &ptr, addr); + return ptr; +} + /* 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 -som_solib_add (char *arg_string, int from_tty, struct target_ops *target) +som_solib_add (char *arg_string, int from_tty, struct target_ops *target, int readsyms) { struct minimal_symbol *msymbol; struct so_list *so_list_tail; @@ -417,7 +439,8 @@ som_solib_add (char *arg_string, int from_tty, struct target_ops *target) int threshold_warning_given = 0; /* First validate our arguments. */ - if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL) + re_err = re_comp (arg_string ? arg_string : "."); + if (re_err != NULL) { error ("Invalid regexp: %s", re_err); } @@ -631,7 +654,7 @@ som_solib_add (char *arg_string, int from_tty, struct target_ops *target) } name = obsavestring (name, name_len - 1, - &symfile_objfile->symbol_obstack); + &symfile_objfile->objfile_obstack); status = target_read_memory (addr + 8, buf, 4); if (status != 0) @@ -713,7 +736,10 @@ som_solib_add (char *arg_string, int from_tty, struct target_ops *target) if (status != 0) goto err; - new_so->som_solib.next = (void *) extract_unsigned_integer (buf, 4); + /* FIXME: cagney/2003-02-01: I think som_solib.next should be a + CORE_ADDR. */ + new_so->som_solib.next = + hpux_address_to_host_pointer_hack (extract_unsigned_integer (buf, 4)); /* Note that we don't re-set "addr" to the next pointer * until after we've read the trailing data. @@ -775,12 +801,14 @@ som_solib_add (char *arg_string, int from_tty, struct target_ops *target) st_size = som_solib_sizeof_symbol_table (name); som_solib_st_size_threshold_exceeded = !from_tty && - ((st_size + som_solib_total_st_size) > (auto_solib_add * (LONGEST) 1000000)); + auto_solib_limit > 0 && + readsyms && + ((st_size + som_solib_total_st_size) > (auto_solib_limit * (LONGEST) (1024 * 1024))); if (som_solib_st_size_threshold_exceeded) { if (!threshold_warning_given) - warning ("Symbols for some libraries have not been loaded, because\ndoing so would exceed the size threshold specified by auto-solib-add.\nTo manually load symbols, use the 'sharedlibrary' command.\nTo raise the threshold, set auto-solib-add to a larger value and rerun\nthe program.\n"); + warning ("Symbols for some libraries have not been loaded, because\ndoing so would exceed the size threshold specified by auto-solib-limit.\nTo manually load symbols, use the 'sharedlibrary' command.\nTo raise the threshold, set auto-solib-limit to a larger value and rerun\nthe program.\n"); threshold_warning_given = 1; /* We'll still make note of this shlib, even if we don't @@ -865,18 +893,18 @@ som_solib_create_inferior_hook (void) return; have_endo = 0; - /* Slam the pid of the process into __d_pid; failing is only a warning! */ + /* Slam the pid of the process into __d_pid. + + We used to warn when this failed, but that warning is only useful + on very old HP systems (hpux9 and older). The warnings are an + annoyance to users of modern systems and foul up the testsuite as + well. As a result, the warnings have been disabled. */ msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile); if (msymbol == NULL) - { - warning ("Unable to find __d_pid symbol in object file."); - warning ("Suggest linking with /opt/langtools/lib/end.o."); - warning ("GDB will be unable to track shl_load/shl_unload calls"); - goto keep_going; - } + goto keep_going; anaddr = SYMBOL_VALUE_ADDRESS (msymbol); - store_unsigned_integer (buf, 4, inferior_pid); + store_unsigned_integer (buf, 4, PIDGET (inferior_ptid)); status = target_write_memory (anaddr, buf, 4); if (status != 0) { @@ -916,8 +944,8 @@ som_solib_create_inferior_hook (void) struct minimal_symbol *msymbol2; /* What a crock. */ - msymbol2 = lookup_minimal_symbol_solib_trampoline (SYMBOL_NAME (msymbol), - NULL, objfile); + msymbol2 = lookup_minimal_symbol_solib_trampoline (DEPRECATED_SYMBOL_NAME (msymbol), + objfile); /* Found a symbol with the right name. */ if (msymbol2) { @@ -1029,14 +1057,6 @@ keep_going: clear_symtab_users (); } - -static void -reset_inferior_pid (int saved_inferior_pid) -{ - inferior_pid = saved_inferior_pid; -} - - /* This operation removes the "hook" between GDB and the dynamic linker, which causes the dld to notify GDB of shared library events. @@ -1053,13 +1073,12 @@ som_solib_remove_inferior_hook (int pid) CORE_ADDR addr; struct minimal_symbol *msymbol; int status; - char dld_flags_buffer[TARGET_INT_BIT / TARGET_CHAR_BIT]; + char dld_flags_buffer[4]; unsigned int dld_flags_value; - int saved_inferior_pid = inferior_pid; - struct cleanup *old_cleanups = make_cleanup (reset_inferior_pid, saved_inferior_pid); + struct cleanup *old_cleanups = save_inferior_ptid (); /* Ensure that we're really operating on the specified process. */ - inferior_pid = pid; + inferior_ptid = pid_to_ptid (pid); /* We won't bother to remove the solib breakpoints from this process. @@ -1071,16 +1090,13 @@ som_solib_remove_inferior_hook (int pid) msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL); addr = SYMBOL_VALUE_ADDRESS (msymbol); - status = target_read_memory (addr, dld_flags_buffer, TARGET_INT_BIT / TARGET_CHAR_BIT); + status = target_read_memory (addr, dld_flags_buffer, 4); - dld_flags_value = extract_unsigned_integer (dld_flags_buffer, - sizeof (dld_flags_value)); + dld_flags_value = extract_unsigned_integer (dld_flags_buffer, 4); dld_flags_value &= ~DLD_FLAGS_HOOKVALID; - store_unsigned_integer (dld_flags_buffer, - sizeof (dld_flags_value), - dld_flags_value); - status = target_write_memory (addr, dld_flags_buffer, TARGET_INT_BIT / TARGET_CHAR_BIT); + store_unsigned_integer (dld_flags_buffer, 4, dld_flags_value); + status = target_write_memory (addr, dld_flags_buffer, 4); do_cleanups (old_cleanups); } @@ -1127,7 +1143,7 @@ som_solib_have_load_event (int pid) { CORE_ADDR event_kind; - event_kind = read_register (ARG0_REGNUM); + event_kind = read_register (HPPA_ARG0_REGNUM); return (event_kind == SHL_LOAD); } @@ -1136,7 +1152,7 @@ som_solib_have_unload_event (int pid) { CORE_ADDR event_kind; - event_kind = read_register (ARG0_REGNUM); + event_kind = read_register (HPPA_ARG0_REGNUM); return (event_kind == SHL_UNLOAD); } @@ -1150,7 +1166,7 @@ som_solib_library_pathname (int pid) static char dll_pathname[1024]; /* Read the descriptor of this newly-loaded library. */ - dll_handle_address = read_register (ARG1_REGNUM); + dll_handle_address = read_register (HPPA_ARG1_REGNUM); read_memory (dll_handle_address, (char *) &dll_descriptor, sizeof (dll_descriptor)); /* We can find a pointer to the dll's pathname within the descriptor. */ @@ -1214,7 +1230,6 @@ som_solib_desire_dynamic_linker_symbols (void) } dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_load", - NULL, objfile); if (dld_msymbol != NULL) { @@ -1254,7 +1269,6 @@ som_solib_desire_dynamic_linker_symbols (void) } dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_unload", - NULL, objfile); if (dld_msymbol != NULL) { @@ -1270,8 +1284,10 @@ som_solib_desire_dynamic_linker_symbols (void) } /* Did we find everything we were looking for? If so, stop. */ - if ((dld_cache.load.address != NULL) && (dld_cache.load_stub.address != NULL) - && (dld_cache.unload.address != NULL) && (dld_cache.unload_stub.address != NULL)) + if ((dld_cache.load.address != 0) + && (dld_cache.load_stub.address != 0) + && (dld_cache.unload.address != 0) + && (dld_cache.unload_stub.address != 0)) { dld_cache.is_valid = 1; break; @@ -1455,17 +1471,17 @@ som_sharedlibrary_info_command (char *ignore, int from_tty) if (so_list->objfile == NULL) printf_unfiltered (" (symbols not loaded)"); printf_unfiltered ("\n"); - printf_unfiltered (" %-12s", local_hex_string_custom (flags, "08l")); + printf_unfiltered (" %-12s", hex_string_custom (flags, 8)); printf_unfiltered ("%-12s", - local_hex_string_custom (so_list->som_solib.text_addr, "08l")); + hex_string_custom (so_list->som_solib.text_addr, 8)); printf_unfiltered ("%-12s", - local_hex_string_custom (so_list->som_solib.text_end, "08l")); + hex_string_custom (so_list->som_solib.text_end, 8)); printf_unfiltered ("%-12s", - local_hex_string_custom (so_list->som_solib.data_start, "08l")); + hex_string_custom (so_list->som_solib.data_start, 8)); printf_unfiltered ("%-12s", - local_hex_string_custom (so_list->som_solib.data_end, "08l")); + hex_string_custom (so_list->som_solib.data_end, 8)); printf_unfiltered ("%-12s\n", - local_hex_string_custom (so_list->som_solib.got_value, "08l")); + hex_string_custom (so_list->som_solib.got_value, 8)); so_list = so_list->next; } } @@ -1474,7 +1490,7 @@ static void som_solib_sharedlibrary_command (char *args, int from_tty) { dont_repeat (); - som_solib_add (args, from_tty, (struct target_ops *) 0); + som_solib_add (args, from_tty, (struct target_ops *) 0, 1); } @@ -1549,7 +1565,6 @@ som_solib_restart (void) } - void _initialize_som_solib (void) { @@ -1557,28 +1572,37 @@ _initialize_som_solib (void) "Load shared object library symbols for files matching REGEXP."); add_info ("sharedlibrary", som_sharedlibrary_info_command, "Status of loaded shared object libraries."); - add_show_from_set - (add_set_cmd ("auto-solib-add", class_support, var_zinteger, + + deprecated_add_show_from_set + (add_set_cmd ("auto-solib-add", class_support, var_boolean, (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'.", + "Set autoloading of shared library symbols.\n\ +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'.", &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 */ + deprecated_add_show_from_set + (add_set_cmd ("auto-solib-limit", class_support, var_zinteger, + (char *) &auto_solib_limit, + "Set threshold (in Mb) for autoloading shared library symbols.\n\ +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'.", + &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 */ som_solib_restart (); } @@ -1586,7 +1610,7 @@ Otherwise, symbols must be loaded manually, using `sharedlibrary'.", /* Get some HPUX-specific data from a shared lib. */ CORE_ADDR -so_lib_thread_start_addr (struct so_list *so) +som_solib_thread_start_addr (struct so_list *so) { return so->som_solib.tsd_start_addr; }