1 /* Handle HP ELF shared libraries for GDB, the GNU Debugger.
2 Copyright 1999 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 HP in their infinite stupidity choose not to use standard ELF dynamic
22 linker interfaces. They also choose not to make their ELF dymamic
23 linker interfaces compatible with the SOM dynamic linker. The
24 net result is we can not use either of the existing somsolib.c or
25 solib.c. What a crock.
27 Even more disgusting. This file depends on functions provided only
28 in certain PA64 libraries. Thus this file is supposed to only be
29 used native. When will HP ever learn that they need to provide the
30 same functionality in all their libraries! */
43 #include "breakpoint.h"
47 #include "gdb-stabs.h"
59 /* Defined in exec.c; used to prevent dangling pointer bug. */
60 extern struct target_ops exec_ops;
62 static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
63 /* This lives in hppa-tdep.c. */
64 extern struct unwind_table_entry *find_unwind_entry (CORE_ADDR pc);
66 /* These ought to be defined in some public interface, but aren't. They
67 identify dynamic linker events. */
69 #define DLD_CB_UNLOAD 0
71 /* A structure to keep track of all the known shared objects. */
77 struct objfile *objfile;
78 CORE_ADDR pa64_solib_desc_addr;
79 struct load_module_desc pa64_solib_desc;
80 struct section_table *sections;
81 struct section_table *sections_end;
85 static struct so_list *so_list_head;
87 /* This is the cumulative size in bytes of the symbol tables of all
88 shared objects on the so_list_head list. (When we say size, here
89 we mean of the information before it is brought into memory and
90 potentially expanded by GDB.) When adding a new shlib, this value
91 is compared against the threshold size, held by auto_solib_add
92 (in megabytes). If adding symbols for the new shlib would cause
93 the total size to exceed the threshold, then the new shlib's symbols
95 static LONGEST pa64_solib_total_st_size;
97 /* When the threshold is reached for any shlib, we refuse to add
98 symbols for subsequent shlibs, even if those shlibs' symbols would
99 be small enough to fit under the threshold. (Although this may
100 result in one, early large shlib preventing the loading of later,
101 smalller shlibs' symbols, it allows us to issue one informational
102 message. The alternative, to issue a message for each shlib whose
103 symbols aren't loaded, could be a big annoyance where the threshold
104 is exceeded due to a very large number of shlibs.) */
105 static int pa64_solib_st_size_threshold_exceeded;
107 /* When adding fields, be sure to clear them in _initialize_pa64_solib. */
110 CORE_ADDR dld_flags_addr;
112 sec_ptr dyninfo_sect;
113 boolean have_read_dld_descriptor;
116 CORE_ADDR load_map_addr;
117 struct load_module_desc dld_desc;
121 static dld_cache_t dld_cache;
123 static void pa64_sharedlibrary_info_command (char *, int);
125 static void pa64_solib_sharedlibrary_command (char *, int);
127 static void *pa64_target_read_memory (void *, CORE_ADDR, size_t, int);
129 static boolean read_dld_descriptor (struct target_ops *);
131 static boolean read_dynamic_info (asection *, dld_cache_t *);
133 static void add_to_solist (boolean, char *, struct load_module_desc *,
134 CORE_ADDR, struct target_ops *);
136 /* When examining the shared library for debugging information we have to
137 look for HP debug symbols, stabs and dwarf2 debug symbols. */
138 static char *pa64_debug_section_names[] = {
139 ".debug_header", ".debug_gntt", ".debug_lntt", ".debug_slt", ".debug_vt",
140 ".stabs", ".stabstr", ".debug_info", ".debug_abbrev", ".debug_aranges",
141 ".debug_macinfo", ".debug_line", ".debug_loc", ".debug_pubnames",
145 /* Return a ballbark figure for the amount of memory GDB will need to
146 allocate to read in the debug symbols from FILENAME. */
148 pa64_solib_sizeof_symbol_table (filename)
155 LONGEST st_size = (LONGEST) 0;
158 /* We believe that filename was handed to us by the dynamic linker, and
159 is therefore always an absolute path. */
160 desc = openp (getenv ("PATH"), 1, filename, O_RDONLY | O_BINARY,
164 perror_with_name (filename);
166 filename = absolute_name;
168 abfd = bfd_fdopenr (filename, gnutarget, desc);
172 make_cleanup (free, filename);
173 error ("\"%s\": can't open to read symbols: %s.", filename,
174 bfd_errmsg (bfd_get_error ()));
177 if (!bfd_check_format (abfd, bfd_object))
180 make_cleanup (free, filename);
181 error ("\"%s\": can't read symbols: %s.", filename,
182 bfd_errmsg (bfd_get_error ()));
185 /* Sum the sizes of the various sections that compose debug info. */
186 for (i = 0; pa64_debug_section_names[i] != NULL; i++)
190 sect = bfd_get_section_by_name (abfd, pa64_debug_section_names[i]);
192 st_size += (LONGEST)bfd_section_size (abfd, sect);
198 /* Unfortunately, just summing the sizes of various debug info
199 sections isn't a very accurate measurement of how much heap
200 space the debugger will need to hold them. It also doesn't
201 account for space needed by linker (aka "minimal") symbols.
203 Anecdotal evidence suggests that just summing the sizes of
204 debug-info-related sections understates the heap space needed
205 to represent it internally by about an order of magnitude.
207 Since it's not exactly brain surgery we're doing here, rather
208 than attempt to more accurately measure the size of a shlib's
209 symbol table in GDB's heap, we'll just apply a 10x fudge-
210 factor to the debug info sections' size-sum. No, this doesn't
211 account for minimal symbols in non-debuggable shlibs. But it
212 all roughly washes out in the end. */
213 return st_size * (LONGEST) 10;
216 /* Add a shared library to the objfile list and load its symbols into
217 GDB's symbol table. */
219 pa64_solib_add_solib_objfile (so, name, from_tty, text_addr)
227 obj_private_data_t *obj_private;
228 struct section_addr_info section_addrs;
230 memset (§ion_addrs, 0, sizeof (section_addrs));
231 /* We need the BFD so that we can look at its sections. We open up the
232 file temporarily, then close it when we are done. */
233 tmp_bfd = bfd_openr (name, gnutarget);
236 perror_with_name (name);
240 if (!bfd_check_format (tmp_bfd, bfd_object))
243 error ("\"%s\" is not an object file: %s", name,
244 bfd_errmsg (bfd_get_error ()));
248 /* Undo some braindamage from symfile.c.
250 First, symfile.c will subtract the VMA of the first .text section
251 in the shared library that it finds. Undo that. */
252 sec = bfd_get_section_by_name (tmp_bfd, ".text");
253 text_addr += bfd_section_vma (tmp_bfd, sec);
255 /* Now find the true lowest section in the shared library. */
257 bfd_map_over_sections (tmp_bfd, find_lowest_section, (PTR) &sec);
261 /* Subtract out the VMA of the lowest section. */
262 text_addr -= bfd_section_vma (tmp_bfd, sec);
264 /* ??? Add back in the filepos of that lowest section. */
265 text_addr += sec->filepos;
268 /* We are done with the temporary bfd. Get rid of it and make sure
269 nobody else can us it. */
273 /* Now let the generic code load up symbols for this library. */
274 section_addrs.other[0].addr = text_addr;
275 section_addrs.other[0].name = ".text";
276 so->objfile = symbol_file_add (name, from_tty, §ion_addrs, 0, OBJF_SHARED);
277 so->abfd = so->objfile->obfd;
279 /* Mark this as a shared library and save private data. */
280 so->objfile->flags |= OBJF_SHARED;
282 if (so->objfile->obj_private == NULL)
284 obj_private = (obj_private_data_t *)
285 obstack_alloc (&so->objfile->psymbol_obstack,
286 sizeof (obj_private_data_t));
287 obj_private->unwind_info = NULL;
288 obj_private->so_info = NULL;
289 so->objfile->obj_private = (PTR) obj_private;
292 obj_private = (obj_private_data_t *) so->objfile->obj_private;
293 obj_private->so_info = so;
294 obj_private->dp = so->pa64_solib_desc.linkage_ptr;
297 /* Load debugging information for a shared library. TARGET may be
298 NULL if we are not attaching to a process or reading a core file. */
301 pa64_solib_load_symbols (so, name, from_tty, text_addr, target)
306 struct target_ops *target;
308 struct section_table *p;
312 CORE_ADDR presumed_data_start;
315 text_addr = so->pa64_solib_desc.text_base;
317 pa64_solib_add_solib_objfile (so, name, from_tty, text_addr);
319 /* Now we need to build a section table for this library since
320 we might be debugging a core file from a dynamically linked
321 executable in which the libraries were not privately mapped. */
322 if (build_section_table (so->abfd,
326 error ("Unable to build section table for shared library\n.");
330 ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile))
331 = so->pa64_solib_desc.text_base;
332 ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile))
333 = so->pa64_solib_desc.data_base;
335 /* Relocate all the sections based on where they got loaded. */
336 for (p = so->sections; p < so->sections_end; p++)
338 if (p->the_bfd_section->flags & SEC_CODE)
340 p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile));
341 p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile));
343 else if (p->the_bfd_section->flags & SEC_DATA)
345 p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile));
346 p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile));
350 /* Now see if we need to map in the text and data for this shared
351 library (for example debugging a core file which does not use
352 private shared libraries.).
354 Carefully peek at the first text address in the library. If the
355 read succeeds, then the libraries were privately mapped and were
356 included in the core dump file.
358 If the peek failed, then the libraries were not privately mapped
359 and are not in the core file, we'll have to read them in ourselves. */
360 status = target_read_memory (text_addr, buf, 4);
365 new = so->sections_end - so->sections;
367 old = target_resize_to_sections (target, new);
369 /* Copy over the old data before it gets clobbered. */
370 memcpy ((char *) (target->to_sections + old),
372 ((sizeof (struct section_table)) * new));
377 /* Add symbols from shared libraries into the symtab list, unless the
378 size threshold (specified by auto_solib_add, in megabytes) would
382 pa64_solib_add (arg_string, from_tty, target)
385 struct target_ops *target;
387 struct minimal_symbol *msymbol;
389 asection *shlib_info;
391 unsigned int dld_flags;
392 char buf[4], *re_err;
393 int threshold_warning_given = 0;
395 struct load_module_desc dll_desc;
398 /* First validate our arguments. */
399 if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
401 error ("Invalid regexp: %s", re_err);
404 /* If we're debugging a core file, or have attached to a running
405 process, then pa64_solib_create_inferior_hook will not have been
408 We need to first determine if we're dealing with a dynamically
409 linked executable. If not, then return without an error or warning.
411 We also need to examine __dld_flags to determine if the shared library
412 list is valid and to determine if the libraries have been privately
414 if (symfile_objfile == NULL)
417 /* First see if the objfile was dynamically linked. */
418 shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic");
422 /* It's got a .dynamic section, make sure it's not empty. */
423 if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
426 /* Read in the load map pointer if we have not done so already. */
427 if (! dld_cache.have_read_dld_descriptor)
428 if (! read_dld_descriptor (target))
431 /* If the libraries were not mapped private, warn the user. */
432 if ((dld_cache.dld_flags & DT_HP_DEBUG_PRIVATE) == 0)
433 warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
435 /* For each shaerd library, add it to the shared library list. */
436 for (dll_index = 1; ; dll_index++)
438 /* Read in the load module descriptor. */
439 if (dlgetmodinfo (dll_index, &dll_desc, sizeof (dll_desc),
440 pa64_target_read_memory, 0, dld_cache.load_map)
444 /* Get the name of the shared library. */
445 dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
446 pa64_target_read_memory,
447 0, dld_cache.load_map);
450 error ("pa64_solib_add, unable to read shared library path.");
452 add_to_solist (from_tty, dll_path, &dll_desc, 0, target);
457 /* This hook gets called just before the first instruction in the
458 inferior process is executed.
460 This is our opportunity to set magic flags in the inferior so
461 that GDB can be notified when a shared library is mapped in and
462 to tell the dynamic linker that a private copy of the library is
463 needed (so GDB can set breakpoints in the library).
465 We need to set two flag bits in this routine.
467 DT_HP_DEBUG_PRIVATE to indicate that shared libraries should be
470 DT_HP_DEBUG_CALLBACK to indicate that we want the dynamic linker to
471 call the breakpoint routine for significant events. */
474 pa64_solib_create_inferior_hook ()
476 struct minimal_symbol *msymbol;
477 unsigned int dld_flags, status;
478 asection *shlib_info, *interp_sect;
480 struct objfile *objfile;
483 /* First, remove all the solib event breakpoints. Their addresses
484 may have changed since the last time we ran the program. */
485 remove_solib_event_breakpoints ();
487 if (symfile_objfile == NULL)
490 /* First see if the objfile was dynamically linked. */
491 shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic");
495 /* It's got a .dynamic section, make sure it's not empty. */
496 if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
499 /* Read in the .dynamic section. */
500 if (! read_dynamic_info (shlib_info, &dld_cache))
501 error ("Unable to read the .dynamic section.");
503 /* Turn on the flags we care about. */
504 dld_cache.dld_flags |= DT_HP_DEBUG_PRIVATE;
505 dld_cache.dld_flags |= DT_HP_DEBUG_CALLBACK;
506 status = target_write_memory (dld_cache.dld_flags_addr,
507 (char *) &dld_cache.dld_flags,
508 sizeof (dld_cache.dld_flags));
510 error ("Unable to modify dynamic linker flags.");
512 /* Now we have to create a shared library breakpoint in the dynamic
513 linker. This can be somewhat tricky since the symbol is inside
514 the dynamic linker (for which we do not have symbols or a base
515 load address! Luckily I wrote this code for solib.c years ago. */
516 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
519 unsigned int interp_sect_size;
523 CORE_ADDR sym_addr = 0;
525 /* Read the contents of the .interp section into a local buffer;
526 the contents specify the dynamic linker this program uses. */
527 interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
528 buf = alloca (interp_sect_size);
529 bfd_get_section_contents (exec_bfd, interp_sect,
530 buf, 0, interp_sect_size);
532 /* Now we need to figure out where the dynamic linker was
533 loaded so that we can load its symbols and place a breakpoint
534 in the dynamic linker itself.
536 This address is stored on the stack. However, I've been unable
537 to find any magic formula to find it for Solaris (appears to
538 be trivial on GNU/Linux). Therefore, we have to try an alternate
539 mechanism to find the dynamic linker's base address. */
540 tmp_bfd = bfd_openr (buf, gnutarget);
544 /* Make sure the dynamic linker's really a useful object. */
545 if (!bfd_check_format (tmp_bfd, bfd_object))
547 warning ("Unable to grok dynamic linker %s as an object file", buf);
552 /* We find the dynamic linker's base address by examining the
553 current pc (which point at the entry point for the dynamic
554 linker) and subtracting the offset of the entry point.
556 Also note the breakpoint is the second instruction in the
558 load_addr = read_pc () - tmp_bfd->start_address;
559 sym_addr = bfd_lookup_symbol (tmp_bfd, "__dld_break");
560 sym_addr = load_addr + sym_addr + 4;
562 /* Create the shared library breakpoint. */
565 = create_solib_event_breakpoint (sym_addr);
567 /* The breakpoint is actually hard-coded into the dynamic linker,
568 so we don't need to actually insert a breakpoint instruction
569 there. In fact, the dynamic linker's code is immutable, even to
570 ttrace, so we shouldn't even try to do that. For cases like
571 this, we have "permanent" breakpoints. */
572 make_breakpoint_permanent (b);
575 /* We're done with the temporary bfd. */
580 /* Wipe out all knowledge of old shared libraries since their
581 mapping can change from one exec to another! */
584 struct so_list *temp;
588 so_list_head = temp->next;
590 clear_symtab_users ();
593 /* This operation removes the "hook" between GDB and the dynamic linker,
594 which causes the dld to notify GDB of shared library events.
596 After this operation completes, the dld will no longer notify GDB of
597 shared library events. To resume notifications, GDB must call
598 pa64_solib_create_inferior_hook.
600 This operation does not remove any knowledge of shared libraries which
601 GDB may already have been notified of. */
604 pa64_solib_remove_inferior_hook (pid)
607 /* Turn off the DT_HP_DEBUG_CALLBACK bit in the dynamic linker flags. */
608 dld_cache.dld_flags &= ~DT_HP_DEBUG_CALLBACK;
609 target_write_memory (dld_cache.dld_flags_addr,
610 (char *)&dld_cache.dld_flags,
611 sizeof (dld_cache.dld_flags));
614 /* This function creates a breakpoint on the dynamic linker hook, which
615 is called when e.g., a shl_load or shl_unload call is made. This
616 breakpoint will only trigger when a shl_load call is made.
618 If filename is NULL, then loads of any dll will be caught. Else,
619 only loads of the file whose pathname is the string contained by
620 filename will be caught.
622 Undefined behaviour is guaranteed if this function is called before
623 pa64_solib_create_inferior_hook. */
626 pa64_solib_create_catch_load_hook (pid, tempflag, filename, cond_string)
632 create_solib_load_event_breakpoint ("", tempflag, filename, cond_string);
635 /* This function creates a breakpoint on the dynamic linker hook, which
636 is called when e.g., a shl_load or shl_unload call is made. This
637 breakpoint will only trigger when a shl_unload call is made.
639 If filename is NULL, then unloads of any dll will be caught. Else,
640 only unloads of the file whose pathname is the string contained by
641 filename will be caught.
643 Undefined behaviour is guaranteed if this function is called before
644 pa64_solib_create_inferior_hook. */
647 pa64_solib_create_catch_unload_hook (pid, tempflag, filename, cond_string)
653 create_solib_unload_event_breakpoint ("", tempflag, filename, cond_string);
656 /* Return nonzero if the dynamic linker has reproted that a library
660 pa64_solib_have_load_event (pid)
663 CORE_ADDR event_kind;
665 event_kind = read_register (ARG0_REGNUM);
666 return (event_kind == DLD_CB_LOAD);
669 /* Return nonzero if the dynamic linker has reproted that a library
670 has been unloaded. */
672 pa64_solib_have_unload_event (pid)
675 CORE_ADDR event_kind;
677 event_kind = read_register (ARG0_REGNUM);
678 return (event_kind == DLD_CB_UNLOAD);
681 /* Return a pointer to a string indicating the pathname of the most
682 recently loaded library.
684 The caller is reposible for copying the string before the inferior is
688 pa64_solib_loaded_library_pathname (pid)
691 static char dll_path[MAXPATHLEN];
692 CORE_ADDR dll_path_addr = read_register (ARG3_REGNUM);
693 read_memory_string (dll_path_addr, dll_path, MAXPATHLEN);
697 /* Return a pointer to a string indicating the pathname of the most
698 recently unloaded library.
700 The caller is reposible for copying the string before the inferior is
704 pa64_solib_unloaded_library_pathname (pid)
707 static char dll_path[MAXPATHLEN];
708 CORE_ADDR dll_path_addr = read_register (ARG3_REGNUM);
709 read_memory_string (dll_path_addr, dll_path, MAXPATHLEN);
713 /* Return nonzero if PC is an address inside the dynamic linker. */
716 pa64_solib_in_dynamic_linker (pid, pc)
720 asection *shlib_info;
722 if (symfile_objfile == NULL)
725 if (!dld_cache.have_read_dld_descriptor)
726 if (!read_dld_descriptor (¤t_target))
729 return (pc >= dld_cache.dld_desc.text_base
730 && pc < dld_cache.dld_desc.text_base + dld_cache.dld_desc.text_size);
734 /* Return the GOT value for the shared library in which ADDR belongs. If
735 ADDR isn't in any known shared library, return zero. */
738 pa64_solib_get_got_by_pc (addr)
741 struct so_list *so_list = so_list_head;
742 CORE_ADDR got_value = 0;
746 if (so_list->pa64_solib_desc.text_base <= addr
747 && ((so_list->pa64_solib_desc.text_base
748 + so_list->pa64_solib_desc.text_size)
751 got_value = so_list->pa64_solib_desc.linkage_ptr;
754 so_list = so_list->next;
759 /* Return the address of the handle of the shared library in which ADDR
760 belongs. If ADDR isn't in any known shared library, return zero.
762 This function is used in hppa_fix_call_dummy in hppa-tdep.c. */
765 pa64_solib_get_solib_by_pc (addr)
768 struct so_list *so_list = so_list_head;
769 CORE_ADDR retval = 0;
773 if (so_list->pa64_solib_desc.text_base <= addr
774 && ((so_list->pa64_solib_desc.text_base
775 + so_list->pa64_solib_desc.text_size)
778 retval = so_list->pa64_solib_desc_addr;
781 so_list = so_list->next;
786 /* Dump information about all the currently loaded shared libraries. */
789 pa64_sharedlibrary_info_command (ignore, from_tty)
793 struct so_list *so_list = so_list_head;
795 if (exec_bfd == NULL)
797 printf_unfiltered ("No executable file.\n");
803 printf_unfiltered ("No shared libraries loaded at this time.\n");
807 printf_unfiltered ("Shared Object Libraries\n");
808 printf_unfiltered (" %-19s%-19s%-19s%-19s\n",
809 " text start", " text end",
810 " data start", " data end");
815 printf_unfiltered ("%s", so_list->name);
816 if (so_list->objfile == NULL)
817 printf_unfiltered (" (symbols not loaded)");
818 if (so_list->loaded == 0)
819 printf_unfiltered (" (shared library unloaded)");
820 printf_unfiltered (" %-18s",
821 local_hex_string_custom (so_list->pa64_solib_desc.linkage_ptr,
823 printf_unfiltered ("\n");
824 printf_unfiltered ("%-18s",
825 local_hex_string_custom (so_list->pa64_solib_desc.text_base,
827 printf_unfiltered (" %-18s",
828 local_hex_string_custom ((so_list->pa64_solib_desc.text_base
829 + so_list->pa64_solib_desc.text_size),
831 printf_unfiltered (" %-18s",
832 local_hex_string_custom (so_list->pa64_solib_desc.data_base,
834 printf_unfiltered (" %-18s\n",
835 local_hex_string_custom ((so_list->pa64_solib_desc.data_base
836 + so_list->pa64_solib_desc.data_size),
838 so_list = so_list->next;
842 /* Load up one or more shared libraries as directed by the user. */
845 pa64_solib_sharedlibrary_command (args, from_tty)
850 pa64_solib_add (args, from_tty, (struct target_ops *) 0);
853 /* Return the name of the shared library containing ADDR or NULL if ADDR
854 is not contained in any known shared library. */
857 pa64_solib_address (addr)
860 struct so_list *so = so_list_head;
864 /* Is this address within this shlib's text range? If so,
865 return the shlib's name. */
866 if (addr >= so->pa64_solib_desc.text_base
867 && addr < (so->pa64_solib_desc.text_base
868 | so->pa64_solib_desc.text_size))
871 /* Nope, keep looking... */
875 /* No, we couldn't prove that the address is within a shlib. */
879 /* We are killing the inferior and restarting the program. */
882 pa64_solib_restart ()
884 struct so_list *sl = so_list_head;
886 /* Before the shlib info vanishes, use it to disable any breakpoints
887 that may still be active in those shlibs. */
888 disable_breakpoints_in_shlibs (0);
890 /* Discard all the shlib descriptors. */
893 struct so_list *next_sl = sl->next;
899 pa64_solib_total_st_size = (LONGEST) 0;
900 pa64_solib_st_size_threshold_exceeded = 0;
902 dld_cache.is_valid = 0;
903 dld_cache.have_read_dld_descriptor = 0;
904 dld_cache.dld_flags_addr = 0;
905 dld_cache.load_map = 0;
906 dld_cache.load_map_addr = 0;
907 dld_cache.dld_desc.data_base = 0;
908 dld_cache.dld_flags = 0;
909 dld_cache.dyninfo_sect = 0;
913 _initialize_pa64_solib ()
915 add_com ("sharedlibrary", class_files, pa64_solib_sharedlibrary_command,
916 "Load shared object library symbols for files matching REGEXP.");
917 add_info ("sharedlibrary", pa64_sharedlibrary_info_command,
918 "Status of loaded shared object libraries.");
920 (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
921 (char *) &auto_solib_add,
922 "Set autoloading size threshold (in megabytes) of shared library symbols.\n\
923 If nonzero, symbols from all shared object libraries will be loaded\n\
924 automatically when the inferior begins execution or when the dynamic linker\n\
925 informs gdb that a new library has been loaded, until the symbol table\n\
926 of the program and libraries exceeds this threshold.\n\
927 Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
931 /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how much
932 data space a process can use. We ought to be reading MAXDSIZ and
933 setting auto_solib_add to some large fraction of that value. If
934 not that, we maybe ought to be setting it smaller than the default
935 for MAXDSIZ (that being 64Mb, I believe). However, [1] this threshold
936 is only crudely approximated rather than actually measured, and [2]
937 50 Mbytes is too small for debugging gdb itself. Thus, the arbitrary
940 auto_solib_add = 100; /* Megabytes */
942 pa64_solib_restart ();
945 /* Get some HPUX-specific data from a shared lib. */
947 so_lib_thread_start_addr (so)
950 return so->pa64_solib_desc.tls_start_addr;
953 /* Read the dynamic linker's internal shared library descriptor.
955 This must happen after dld starts running, so we can't do it in
956 read_dynamic_info. Record the fact that we have loaded the
957 descriptor. If the library is archive bound, then return zero, else
961 read_dld_descriptor (target)
962 struct target_ops *target;
965 asection *dyninfo_sect;
967 /* If necessary call read_dynamic_info to extract the contents of the
968 .dynamic section from the shared library. */
969 if (!dld_cache.is_valid)
971 if (symfile_objfile == NULL)
972 error ("No object file symbols.");
974 dyninfo_sect = bfd_get_section_by_name (symfile_objfile->obfd,
981 if (!read_dynamic_info (dyninfo_sect, &dld_cache))
982 error ("Unable to read in .dynamic section information.");
985 /* Read the load map pointer. */
986 if (target_read_memory (dld_cache.load_map_addr,
987 (char*) &dld_cache.load_map,
988 sizeof(dld_cache.load_map))
991 error ("Error while reading in load map pointer.");
994 /* Read in the dld load module descriptor */
995 if (dlgetmodinfo (-1,
997 sizeof(dld_cache.dld_desc),
998 pa64_target_read_memory,
1003 error ("Error trying to get information about dynamic linker.");
1006 /* Indicate that we have loaded the dld descriptor. */
1007 dld_cache.have_read_dld_descriptor = 1;
1009 /* Add dld.sl to the list of known shared libraries so that we can
1012 ?!? This may not be correct. Consider of dld.sl contains symbols
1013 which are also referenced/defined by the user program or some user
1014 shared library. We need to make absolutely sure that we do not
1015 pollute the namespace from GDB's point of view. */
1016 dll_path = dlgetname (&dld_cache.dld_desc,
1017 sizeof(dld_cache.dld_desc),
1018 pa64_target_read_memory,
1020 dld_cache.load_map);
1021 add_to_solist(0, dll_path, &dld_cache.dld_desc, 0, target);
1026 /* Read the .dynamic section and extract the information of interest,
1027 which is stored in dld_cache. The routine elf_locate_base in solib.c
1028 was used as a model for this. */
1031 read_dynamic_info (dyninfo_sect, dld_cache_p)
1032 asection *dyninfo_sect;
1033 dld_cache_t *dld_cache_p;
1037 CORE_ADDR dyninfo_addr;
1038 int dyninfo_sect_size;
1039 CORE_ADDR entry_addr;
1041 /* Read in .dynamic section, silently ignore errors. */
1042 dyninfo_addr = bfd_section_vma (symfile_objfile->obfd, dyninfo_sect);
1043 dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
1044 buf = alloca (dyninfo_sect_size);
1045 if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
1048 /* Scan the .dynamic section and record the items of interest.
1049 In particular, DT_HP_DLD_FLAGS */
1050 for (bufend = buf + dyninfo_sect_size, entry_addr = dyninfo_addr;
1052 buf += sizeof (Elf64_Dyn), entry_addr += sizeof (Elf64_Dyn))
1054 Elf64_Dyn *x_dynp = (Elf64_Dyn*)buf;
1055 Elf64_Sxword dyn_tag;
1057 char pbuf[TARGET_PTR_BIT / HOST_CHAR_BIT];
1059 dyn_tag = bfd_h_get_64 (symfile_objfile->obfd,
1060 (bfd_byte*) &x_dynp->d_tag);
1062 /* We can't use a switch here because dyn_tag is 64 bits and HP's
1063 lame comiler does not handle 64bit items in switch statements. */
1064 if (dyn_tag == DT_NULL)
1066 else if (dyn_tag == DT_HP_DLD_FLAGS)
1068 /* Set dld_flags_addr and dld_flags in *dld_cache_p */
1069 dld_cache_p->dld_flags_addr = entry_addr + offsetof(Elf64_Dyn, d_un);
1070 if (target_read_memory (dld_cache_p->dld_flags_addr,
1071 (char*) &dld_cache_p->dld_flags,
1072 sizeof(dld_cache_p->dld_flags))
1075 error ("Error while reading in .dynamic section of the program.");
1078 else if (dyn_tag == DT_HP_LOAD_MAP)
1080 /* Dld will place the address of the load map at load_map_addr
1081 after it starts running. */
1082 if (target_read_memory (entry_addr + offsetof(Elf64_Dyn,
1084 (char*) &dld_cache_p->load_map_addr,
1085 sizeof(dld_cache_p->load_map_addr))
1088 error ("Error while reading in .dynamic section of the program.");
1093 /* tag is not of interest */
1097 /* Record other information and set is_valid to 1. */
1098 dld_cache_p->dyninfo_sect = dyninfo_sect;
1100 /* Verify that we read in required info. These fields are re-set to zero
1101 in pa64_solib_restart. */
1103 if (dld_cache_p->dld_flags_addr != 0 && dld_cache_p->load_map_addr != 0)
1104 dld_cache_p->is_valid = 1;
1111 /* Wrapper for target_read_memory to make dlgetmodinfo happy. */
1114 pa64_target_read_memory (buffer, ptr, bufsiz, ident)
1120 if (target_read_memory (ptr, buffer, bufsiz) != 0)
1125 /* Called from handle_dynlink_load_event and pa64_solib_add to add
1126 a shared library to so_list_head list and possibly to read in the
1127 debug information for the library.
1129 If load_module_desc_p is NULL, then the load module descriptor must
1130 be read from the inferior process at the address load_module_desc_addr. */
1133 add_to_solist (from_tty, dll_path, load_module_desc_p,
1134 load_module_desc_addr, target)
1137 struct load_module_desc *load_module_desc_p;
1138 CORE_ADDR load_module_desc_addr;
1139 struct target_ops *target;
1141 struct so_list *new_so, *so_list_tail;
1142 int pa64_solib_st_size_threshhold_exceeded;
1145 if (symfile_objfile == NULL)
1148 so_list_tail = so_list_head;
1149 /* Find the end of the list of shared objects. */
1150 while (so_list_tail && so_list_tail->next)
1152 if (strcmp (so_list_tail->name, dll_path) == 0)
1154 so_list_tail = so_list_tail->next;
1157 if (so_list_tail && strcmp (so_list_tail->name, dll_path) == 0)
1160 /* Add the shared library to the so_list_head list */
1161 new_so = (struct so_list *) xmalloc (sizeof (struct so_list));
1162 memset ((char *)new_so, 0, sizeof (struct so_list));
1163 if (so_list_head == NULL)
1165 so_list_head = new_so;
1166 so_list_tail = new_so;
1170 so_list_tail->next = new_so;
1171 so_list_tail = new_so;
1174 /* Initialize the new_so */
1175 if (load_module_desc_p)
1177 new_so->pa64_solib_desc = *load_module_desc_p;
1181 if (target_read_memory (load_module_desc_addr,
1182 (char*) &new_so->pa64_solib_desc,
1183 sizeof(struct load_module_desc))
1186 error ("Error while reading in dynamic library %s", dll_path);
1190 new_so->pa64_solib_desc_addr = load_module_desc_addr;
1192 new_so->name = obsavestring (dll_path, strlen(dll_path),
1193 &symfile_objfile->symbol_obstack);
1195 /* If we are not going to load the library, tell the user if we
1196 haven't already and return. */
1198 st_size = pa64_solib_sizeof_symbol_table (dll_path);
1199 pa64_solib_st_size_threshhold_exceeded =
1201 && ( (st_size + pa64_solib_total_st_size)
1202 > (auto_solib_add * (LONGEST)1000000));
1203 if (pa64_solib_st_size_threshhold_exceeded)
1205 pa64_solib_add_solib_objfile (new_so, dll_path, from_tty, 1);
1209 /* Now read in debug info. */
1210 pa64_solib_total_st_size += st_size;
1212 /* This fills in new_so->objfile, among others. */
1213 pa64_solib_load_symbols (new_so,
1224 bfd_lookup_symbol -- lookup the value for a specific symbol
1228 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
1232 An expensive way to lookup the value of a single symbol for
1233 bfd's that are only temporary anyway. This is used by the
1234 shared library support to find the address of the debugger
1235 interface structures in the shared library.
1237 Note that 0 is specifically allowed as an error return (no
1242 bfd_lookup_symbol (abfd, symname)
1246 unsigned int storage_needed;
1248 asymbol **symbol_table;
1249 unsigned int number_of_symbols;
1251 struct cleanup *back_to;
1252 CORE_ADDR symaddr = 0;
1254 storage_needed = bfd_get_symtab_upper_bound (abfd);
1256 if (storage_needed > 0)
1258 symbol_table = (asymbol **) xmalloc (storage_needed);
1259 back_to = make_cleanup (free, (PTR) symbol_table);
1260 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
1262 for (i = 0; i < number_of_symbols; i++)
1264 sym = *symbol_table++;
1265 if (STREQ (sym->name, symname))
1267 /* Bfd symbols are section relative. */
1268 symaddr = sym->value + sym->section->vma;
1272 do_cleanups (back_to);