X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fsomsolib.c;h=d623e4b76db9aceeb39462baa43d8fb1c79a6a5c;hb=9b3128c4d950f0f94a174e64842510f672aacbb1;hp=924fa5252c3e0969df90fb0654384be045e5bc64;hpb=ed288bb597072176e84fc8279707a3f2f475779b;p=binutils-gdb.git diff --git a/gdb/somsolib.c b/gdb/somsolib.c index 924fa5252c3..d623e4b76db 100644 --- a/gdb/somsolib.c +++ b/gdb/somsolib.c @@ -1,5 +1,6 @@ /* Handle HP SOM shared libraries for GDB, the GNU Debugger. - Copyright 1993, 1996, 1999 Free Software Foundation, Inc. + Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. This file is part of GDB. @@ -39,6 +40,7 @@ #include "gdbcmd.h" #include "assert.h" #include "language.h" +#include "regcache.h" #include @@ -57,7 +59,7 @@ extern struct target_ops exec_ops; /* This lives in hppa-tdep.c. */ -extern struct unwind_table_entry *find_unwind_entry PARAMS ((CORE_ADDR pc)); +extern struct unwind_table_entry *find_unwind_entry (CORE_ADDR pc); /* These ought to be defined in some public interface, but aren't. They define the meaning of the various bits in the distinguished __dld_flags @@ -159,11 +161,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 @@ -203,13 +204,12 @@ dld_cache; -static void som_sharedlibrary_info_command PARAMS ((char *, int)); +static void som_sharedlibrary_info_command (char *, int); -static void som_solib_sharedlibrary_command PARAMS ((char *, int)); +static void som_solib_sharedlibrary_command (char *, int); static LONGEST -som_solib_sizeof_symbol_table (filename) - char *filename; +som_solib_sizeof_symbol_table (char *filename) { bfd *abfd; int desc; @@ -231,7 +231,7 @@ som_solib_sizeof_symbol_table (filename) if (!abfd) { close (desc); - make_cleanup (free, filename); + make_cleanup (xfree, filename); error ("\"%s\": can't open to read symbols: %s.", filename, bfd_errmsg (bfd_get_error ())); } @@ -239,7 +239,7 @@ som_solib_sizeof_symbol_table (filename) if (!bfd_check_format (abfd, bfd_object)) /* Reads in section info */ { bfd_close (abfd); /* This also closes desc */ - make_cleanup (free, filename); + make_cleanup (xfree, filename); error ("\"%s\": can't read symbols: %s.", filename, bfd_errmsg (bfd_get_error ())); } @@ -257,7 +257,7 @@ som_solib_sizeof_symbol_table (filename) st_size += (LONGEST) bfd_section_size (abfd, sect); bfd_close (abfd); /* This also closes desc */ - free (filename); + xfree (filename); /* Unfortunately, just summing the sizes of various debug info sections isn't a very accurate measurement of how much heap @@ -280,17 +280,34 @@ som_solib_sizeof_symbol_table (filename) static void -som_solib_add_solib_objfile (so, name, from_tty, text_addr) - struct so_list *so; - char *name; - int from_tty; - CORE_ADDR text_addr; +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 obj_section *s; - so->objfile = symbol_file_add (name, from_tty, text_addr, 0, 0, 0, 0, 1); + so->objfile = symbol_file_add (name, from_tty, NULL, 0, OBJF_SHARED); so->abfd = so->objfile->obfd; + /* syms_from_objfile has bizarre section offset code, + so I do my own right here. */ + for (s = so->objfile->sections; s < so->objfile->sections_end; s++) + { + flagword aflag = bfd_get_section_flags(so->abfd, s->the_bfd_section); + if (aflag & SEC_CODE) + { + s->addr += so->som_solib.text_addr - so->som_solib.text_link_addr; + s->endaddr += so->som_solib.text_addr - so->som_solib.text_link_addr; + } + else if (aflag & SEC_DATA) + { + s->addr += so->som_solib.data_start; + s->endaddr += so->som_solib.data_start; + } + else + ; + } + /* Mark this as a shared library and save private data. */ so->objfile->flags |= OBJF_SHARED; @@ -317,12 +334,8 @@ som_solib_add_solib_objfile (so, name, from_tty, text_addr) static void -som_solib_load_symbols (so, name, from_tty, text_addr, target) - struct so_list *so; - char *name; - int from_tty; - CORE_ADDR text_addr; - struct target_ops *target; +som_solib_load_symbols (struct so_list *so, char *name, int from_tty, + CORE_ADDR text_addr, struct target_ops *target) { struct section_table *p; int status; @@ -351,13 +364,13 @@ som_solib_load_symbols (so, name, from_tty, text_addr, target) { if (p->the_bfd_section->flags & SEC_CODE) { - p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT); - p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT); + p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile)); + p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile)); } else if (p->the_bfd_section->flags & SEC_DATA) { - p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA); - p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA); + p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile)); + p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile)); } } @@ -375,49 +388,11 @@ som_solib_load_symbols (so, name, from_tty, text_addr, target) if (status != 0) { int old, new; - int update_coreops; - int update_execops; - - /* We must update the to_sections field in the core_ops structure - here, otherwise we dereference a potential dangling pointer - for each call to target_read/write_memory within this routine. */ - update_coreops = core_ops.to_sections == target->to_sections; - - /* Ditto exec_ops (this was a bug). - */ - update_execops = exec_ops.to_sections == target->to_sections; new = so->sections_end - so->sections; - /* Add sections from the shared library to the core target. */ - if (target->to_sections) - { - old = target->to_sections_end - target->to_sections; - target->to_sections = (struct section_table *) - xrealloc ((char *) target->to_sections, - ((sizeof (struct section_table)) * (old + new))); - } - else - { - old = 0; - target->to_sections = (struct section_table *) - xmalloc ((sizeof (struct section_table)) * new); - } - target->to_sections_end = (target->to_sections + old + new); - - /* Update the to_sections field in the core_ops structure - if needed, ditto exec_ops. */ - if (update_coreops) - { - core_ops.to_sections = target->to_sections; - core_ops.to_sections_end = target->to_sections_end; - } - - if (update_execops) - { - exec_ops.to_sections = target->to_sections; - exec_ops.to_sections_end = target->to_sections_end; - } - + + old = target_resize_to_sections (target, new); + /* Copy over the old data before it gets clobbered. */ memcpy ((char *) (target->to_sections + old), so->sections, @@ -427,14 +402,11 @@ som_solib_load_symbols (so, name, from_tty, text_addr, target) /* 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 (arg_string, from_tty, target) - 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; @@ -742,7 +714,8 @@ som_solib_add (arg_string, from_tty, target) if (status != 0) goto err; - new_so->som_solib.next = (void *) extract_unsigned_integer (buf, 4); + new_so->som_solib.next = + address_to_host_pointer (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. @@ -804,12 +777,14 @@ som_solib_add (arg_string, from_tty, 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 @@ -868,7 +843,7 @@ err: means running until the "_start" is called. */ void -som_solib_create_inferior_hook () +som_solib_create_inferior_hook (void) { struct minimal_symbol *msymbol; unsigned int dld_flags, status, have_endo; @@ -894,18 +869,18 @@ som_solib_create_inferior_hook () 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) { @@ -1052,21 +1027,12 @@ keep_going: struct so_list *temp; temp = so_list_head; - free (so_list_head); + xfree (so_list_head); so_list_head = temp->next; } clear_symtab_users (); } - -static void -reset_inferior_pid (saved_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. @@ -1078,19 +1044,17 @@ reset_inferior_pid (saved_inferior_pid) GDB may already have been notified of. */ void -som_solib_remove_inferior_hook (pid) - int pid; +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]; 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. @@ -1129,11 +1093,8 @@ som_solib_remove_inferior_hook (pid) som_solib_create_inferior_hook. */ void -som_solib_create_catch_load_hook (pid, tempflag, filename, cond_string) - int pid; - int tempflag; - char *filename; - char *cond_string; +som_solib_create_catch_load_hook (int pid, int tempflag, char *filename, + char *cond_string) { create_solib_load_event_breakpoint ("__d_trap", tempflag, filename, cond_string); } @@ -1150,18 +1111,14 @@ som_solib_create_catch_load_hook (pid, tempflag, filename, cond_string) som_solib_create_inferior_hook. */ void -som_solib_create_catch_unload_hook (pid, tempflag, filename, cond_string) - int pid; - int tempflag; - char *filename; - char *cond_string; +som_solib_create_catch_unload_hook (int pid, int tempflag, char *filename, + char *cond_string) { create_solib_unload_event_breakpoint ("__d_trap", tempflag, filename, cond_string); } int -som_solib_have_load_event (pid) - int pid; +som_solib_have_load_event (int pid) { CORE_ADDR event_kind; @@ -1170,8 +1127,7 @@ som_solib_have_load_event (pid) } int -som_solib_have_unload_event (pid) - int pid; +som_solib_have_unload_event (int pid) { CORE_ADDR event_kind; @@ -1180,8 +1136,7 @@ som_solib_have_unload_event (pid) } static char * -som_solib_library_pathname (pid) - int pid; +som_solib_library_pathname (int pid) { CORE_ADDR dll_handle_address; CORE_ADDR dll_pathname_address; @@ -1211,8 +1166,7 @@ som_solib_library_pathname (pid) } char * -som_solib_loaded_library_pathname (pid) - int pid; +som_solib_loaded_library_pathname (int pid) { if (!som_solib_have_load_event (pid)) error ("Must have a load event to use this query"); @@ -1221,8 +1175,7 @@ som_solib_loaded_library_pathname (pid) } char * -som_solib_unloaded_library_pathname (pid) - int pid; +som_solib_unloaded_library_pathname (int pid) { if (!som_solib_have_unload_event (pid)) error ("Must have an unload event to use this query"); @@ -1231,7 +1184,7 @@ som_solib_unloaded_library_pathname (pid) } static void -som_solib_desire_dynamic_linker_symbols () +som_solib_desire_dynamic_linker_symbols (void) { struct objfile *objfile; struct unwind_table_entry *u; @@ -1312,8 +1265,10 @@ som_solib_desire_dynamic_linker_symbols () } /* 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; @@ -1329,9 +1284,7 @@ som_solib_desire_dynamic_linker_symbols () } int -som_solib_in_dynamic_linker (pid, pc) - int pid; - CORE_ADDR pc; +som_solib_in_dynamic_linker (int pid, CORE_ADDR pc) { struct unwind_table_entry *u_pc; @@ -1378,8 +1331,7 @@ som_solib_in_dynamic_linker (pid, pc) ADDR isn't in any known shared library, return zero. */ CORE_ADDR -som_solib_get_got_by_pc (addr) - CORE_ADDR addr; +som_solib_get_got_by_pc (CORE_ADDR addr) { struct so_list *so_list = so_list_head; CORE_ADDR got_value = 0; @@ -1404,8 +1356,7 @@ som_solib_get_got_by_pc (addr) /* this function is used in hppa_fix_call_dummy in hppa-tdep.c */ CORE_ADDR -som_solib_get_solib_by_pc (addr) - CORE_ADDR addr; +som_solib_get_solib_by_pc (CORE_ADDR addr) { struct so_list *so_list = so_list_head; @@ -1426,9 +1377,8 @@ som_solib_get_solib_by_pc (addr) int -som_solib_section_offsets (objfile, offsets) - struct objfile *objfile; - struct section_offsets *offsets; +som_solib_section_offsets (struct objfile *objfile, + struct section_offsets *offsets) { struct so_list *so_list = so_list_head; @@ -1441,11 +1391,11 @@ som_solib_section_offsets (objfile, offsets) asection *private_section; /* The text offset is easy. */ - ANOFFSET (offsets, SECT_OFF_TEXT) + offsets->offsets[SECT_OFF_TEXT (objfile)] = (so_list->som_solib.text_addr - so_list->som_solib.text_link_addr); - ANOFFSET (offsets, SECT_OFF_RODATA) - = ANOFFSET (offsets, SECT_OFF_TEXT); + offsets->offsets[SECT_OFF_RODATA (objfile)] + = ANOFFSET (offsets, SECT_OFF_TEXT (objfile)); /* We should look at presumed_dp in the SOM header, but that's not easily available. This should be OK though. */ @@ -1454,14 +1404,14 @@ som_solib_section_offsets (objfile, offsets) if (!private_section) { warning ("Unable to find $PRIVATE$ in shared library!"); - ANOFFSET (offsets, SECT_OFF_DATA) = 0; - ANOFFSET (offsets, SECT_OFF_BSS) = 0; + offsets->offsets[SECT_OFF_DATA (objfile)] = 0; + offsets->offsets[SECT_OFF_BSS (objfile)] = 0; return 1; } - ANOFFSET (offsets, SECT_OFF_DATA) + offsets->offsets[SECT_OFF_DATA (objfile)] = (so_list->som_solib.data_start - private_section->vma); - ANOFFSET (offsets, SECT_OFF_BSS) - = ANOFFSET (offsets, SECT_OFF_DATA); + offsets->offsets[SECT_OFF_BSS (objfile)] + = ANOFFSET (offsets, SECT_OFF_DATA (objfile)); return 1; } so_list = so_list->next; @@ -1472,15 +1422,13 @@ som_solib_section_offsets (objfile, offsets) /* Dump information about all the currently loaded shared libraries. */ static void -som_sharedlibrary_info_command (ignore, from_tty) - char *ignore; - int from_tty; +som_sharedlibrary_info_command (char *ignore, int from_tty) { struct so_list *so_list = so_list_head; if (exec_bfd == NULL) { - printf_unfiltered ("no exec file.\n"); + printf_unfiltered ("No executable file.\n"); return; } @@ -1520,19 +1468,16 @@ som_sharedlibrary_info_command (ignore, from_tty) } static void -som_solib_sharedlibrary_command (args, from_tty) - char *args; - int from_tty; +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); } char * -som_solib_address (addr) - CORE_ADDR addr; +som_solib_address (CORE_ADDR addr) { struct so_list *so = so_list_head; @@ -1554,7 +1499,7 @@ som_solib_address (addr) void -som_solib_restart () +som_solib_restart (void) { struct so_list *sl = so_list_head; @@ -1568,7 +1513,7 @@ som_solib_restart () while (sl) { struct so_list *next_sl = sl->next; - free (sl); + xfree (sl); sl = next_sl; } so_list_head = NULL; @@ -1601,36 +1546,63 @@ som_solib_restart () } +/* LOCAL FUNCTION + + no_shared_libraries -- handle command to explicitly discard symbols + from shared libraries. + + DESCRIPTION + + Implements the command "nosharedlibrary", which discards symbols + that have been auto-loaded from shared libraries. Symbols from + shared libraries that were added by explicit request of the user + are not discarded. Also called from remote.c. */ + +void +no_shared_libraries (char *ignored, int from_tty) +{ + /* FIXME */ +} + void -_initialize_som_solib () +_initialize_som_solib (void) { add_com ("sharedlibrary", class_files, som_solib_sharedlibrary_command, "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, + (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 */ + 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 (); } @@ -1638,8 +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 (so) - struct so_list *so; +so_lib_thread_start_addr (struct so_list *so) { return so->som_solib.tsd_start_addr; }