1 /* Handle HP ELF shared libraries for GDB, the GNU Debugger.
3 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 HP in their infinite stupidity choose not to use standard ELF dynamic
23 linker interfaces. They also choose not to make their ELF dymamic
24 linker interfaces compatible with the SOM dynamic linker. The
25 net result is we can not use either of the existing somsolib.c or
26 solib.c. What a crock.
28 Even more disgusting. This file depends on functions provided only
29 in certain PA64 libraries. Thus this file is supposed to only be
30 used native. When will HP ever learn that they need to provide the
31 same functionality in all their libraries! */
44 #include "breakpoint.h"
48 #include "gdb-stabs.h"
60 /* Defined in exec.c; used to prevent dangling pointer bug. */
61 extern struct target_ops exec_ops
;
63 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *);
64 /* This lives in hppa-tdep.c. */
65 extern struct unwind_table_entry
*find_unwind_entry (CORE_ADDR pc
);
67 /* These ought to be defined in some public interface, but aren't. They
68 identify dynamic linker events. */
70 #define DLD_CB_UNLOAD 0
72 /* A structure to keep track of all the known shared objects. */
78 struct objfile
*objfile
;
79 CORE_ADDR pa64_solib_desc_addr
;
80 struct load_module_desc pa64_solib_desc
;
81 struct section_table
*sections
;
82 struct section_table
*sections_end
;
86 static struct so_list
*so_list_head
;
88 /* This is the cumulative size in bytes of the symbol tables of all
89 shared objects on the so_list_head list. (When we say size, here
90 we mean of the information before it is brought into memory and
91 potentially expanded by GDB.) When adding a new shlib, this value
92 is compared against a threshold size, held by auto_solib_limit (in
93 megabytes). If adding symbols for the new shlib would cause the
94 total size to exceed the threshold, then the new shlib's symbols
96 static LONGEST pa64_solib_total_st_size
;
98 /* When the threshold is reached for any shlib, we refuse to add
99 symbols for subsequent shlibs, even if those shlibs' symbols would
100 be small enough to fit under the threshold. Although this may
101 result in one, early large shlib preventing the loading of later,
102 smaller shlibs' symbols, it allows us to issue one informational
103 message. The alternative, to issue a message for each shlib whose
104 symbols aren't loaded, could be a big annoyance where the threshold
105 is exceeded due to a very large number of shlibs. */
106 static int pa64_solib_st_size_threshold_exceeded
;
108 /* When adding fields, be sure to clear them in _initialize_pa64_solib. */
111 CORE_ADDR dld_flags_addr
;
113 sec_ptr dyninfo_sect
;
114 int have_read_dld_descriptor
;
117 CORE_ADDR load_map_addr
;
118 struct load_module_desc dld_desc
;
122 static dld_cache_t dld_cache
;
124 static void pa64_sharedlibrary_info_command (char *, int);
126 static void pa64_solib_sharedlibrary_command (char *, int);
128 static void *pa64_target_read_memory (void *, CORE_ADDR
, size_t, int);
130 static int read_dld_descriptor (struct target_ops
*, int readsyms
);
132 static int read_dynamic_info (asection
*, dld_cache_t
*);
134 static void add_to_solist (int, char *, int, struct load_module_desc
*,
135 CORE_ADDR
, struct target_ops
*);
137 /* When examining the shared library for debugging information we have to
138 look for HP debug symbols, stabs and dwarf2 debug symbols. */
139 static char *pa64_debug_section_names
[] = {
140 ".debug_header", ".debug_gntt", ".debug_lntt", ".debug_slt", ".debug_vt",
141 ".stabs", ".stabstr", ".debug_info", ".debug_abbrev", ".debug_aranges",
142 ".debug_macinfo", ".debug_line", ".debug_loc", ".debug_pubnames",
146 /* Return a ballbark figure for the amount of memory GDB will need to
147 allocate to read in the debug symbols from FILENAME. */
149 pa64_solib_sizeof_symbol_table (char *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 (xfree
, 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 (xfree
, 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 (struct so_list
*so
, char *name
, int from_tty
,
224 obj_private_data_t
*obj_private
;
225 struct section_addr_info
*section_addrs
;
226 struct cleanup
*my_cleanups
;
228 /* We need the BFD so that we can look at its sections. We open up the
229 file temporarily, then close it when we are done. */
230 tmp_bfd
= bfd_openr (name
, gnutarget
);
233 perror_with_name (name
);
237 if (!bfd_check_format (tmp_bfd
, bfd_object
))
240 error ("\"%s\" is not an object file: %s", name
,
241 bfd_errmsg (bfd_get_error ()));
245 /* Undo some braindamage from symfile.c.
247 First, symfile.c will subtract the VMA of the first .text section
248 in the shared library that it finds. Undo that. */
249 sec
= bfd_get_section_by_name (tmp_bfd
, ".text");
250 text_addr
+= bfd_section_vma (tmp_bfd
, sec
);
252 /* Now find the true lowest section in the shared library. */
254 bfd_map_over_sections (tmp_bfd
, find_lowest_section
, &sec
);
258 /* Subtract out the VMA of the lowest section. */
259 text_addr
-= bfd_section_vma (tmp_bfd
, sec
);
261 /* ??? Add back in the filepos of that lowest section. */
262 text_addr
+= sec
->filepos
;
265 section_addrs
= alloc_section_addr_info (bfd_count_sections (tmp_bfd
));
266 my_cleanups
= make_cleanup (xfree
, section_addrs
);
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
, section_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
= 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
;
295 do_cleanups (my_cleanups
);
298 /* Load debugging information for a shared library. TARGET may be
299 NULL if we are not attaching to a process or reading a core file. */
302 pa64_solib_load_symbols (struct so_list
*so
, char *name
, int from_tty
,
303 CORE_ADDR text_addr
, struct target_ops
*target
)
305 struct section_table
*p
;
309 CORE_ADDR presumed_data_start
;
312 text_addr
= so
->pa64_solib_desc
.text_base
;
314 pa64_solib_add_solib_objfile (so
, name
, from_tty
, text_addr
);
316 /* Now we need to build a section table for this library since
317 we might be debugging a core file from a dynamically linked
318 executable in which the libraries were not privately mapped. */
319 if (build_section_table (so
->abfd
,
323 error ("Unable to build section table for shared library\n.");
327 (so
->objfile
->section_offsets
)->offsets
[SECT_OFF_TEXT (so
->objfile
)]
328 = so
->pa64_solib_desc
.text_base
;
329 (so
->objfile
->section_offsets
)->offsets
[SECT_OFF_DATA (so
->objfile
)]
330 = so
->pa64_solib_desc
.data_base
;
332 /* Relocate all the sections based on where they got loaded. */
333 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
335 if (p
->the_bfd_section
->flags
& SEC_CODE
)
337 p
->addr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_TEXT (so
->objfile
));
338 p
->endaddr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_TEXT (so
->objfile
));
340 else if (p
->the_bfd_section
->flags
& SEC_DATA
)
342 p
->addr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_DATA (so
->objfile
));
343 p
->endaddr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_DATA (so
->objfile
));
347 /* Now see if we need to map in the text and data for this shared
348 library (for example debugging a core file which does not use
349 private shared libraries.).
351 Carefully peek at the first text address in the library. If the
352 read succeeds, then the libraries were privately mapped and were
353 included in the core dump file.
355 If the peek failed, then the libraries were not privately mapped
356 and are not in the core file, we'll have to read them in ourselves. */
357 status
= target_read_memory (text_addr
, buf
, 4);
362 new = so
->sections_end
- so
->sections
;
364 old
= target_resize_to_sections (target
, new);
366 /* Copy over the old data before it gets clobbered. */
367 memcpy ((char *) (target
->to_sections
+ old
),
369 ((sizeof (struct section_table
)) * new));
374 /* Add symbols from shared libraries into the symtab list, unless the
375 size threshold specified by auto_solib_limit (in megabytes) would
379 pa64_solib_add (char *arg_string
, int from_tty
, struct target_ops
*target
, int readsyms
)
381 struct minimal_symbol
*msymbol
;
383 asection
*shlib_info
;
385 unsigned int dld_flags
;
386 char buf
[4], *re_err
;
387 int threshold_warning_given
= 0;
389 struct load_module_desc dll_desc
;
392 /* First validate our arguments. */
393 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
395 error ("Invalid regexp: %s", re_err
);
398 /* If we're debugging a core file, or have attached to a running
399 process, then pa64_solib_create_inferior_hook will not have been
402 We need to first determine if we're dealing with a dynamically
403 linked executable. If not, then return without an error or warning.
405 We also need to examine __dld_flags to determine if the shared library
406 list is valid and to determine if the libraries have been privately
408 if (symfile_objfile
== NULL
)
411 /* First see if the objfile was dynamically linked. */
412 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, ".dynamic");
416 /* It's got a .dynamic section, make sure it's not empty. */
417 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
420 /* Read in the load map pointer if we have not done so already. */
421 if (! dld_cache
.have_read_dld_descriptor
)
422 if (! read_dld_descriptor (target
, readsyms
))
425 /* If the libraries were not mapped private, warn the user. */
426 if ((dld_cache
.dld_flags
& DT_HP_DEBUG_PRIVATE
) == 0)
427 warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
429 /* For each shaerd library, add it to the shared library list. */
430 for (dll_index
= 1; ; dll_index
++)
432 /* Read in the load module descriptor. */
433 if (dlgetmodinfo (dll_index
, &dll_desc
, sizeof (dll_desc
),
434 pa64_target_read_memory
, 0, dld_cache
.load_map
)
438 /* Get the name of the shared library. */
439 dll_path
= (char *)dlgetname (&dll_desc
, sizeof (dll_desc
),
440 pa64_target_read_memory
,
441 0, dld_cache
.load_map
);
444 error ("pa64_solib_add, unable to read shared library path.");
446 add_to_solist (from_tty
, dll_path
, readsyms
, &dll_desc
, 0, target
);
451 /* This hook gets called just before the first instruction in the
452 inferior process is executed.
454 This is our opportunity to set magic flags in the inferior so
455 that GDB can be notified when a shared library is mapped in and
456 to tell the dynamic linker that a private copy of the library is
457 needed (so GDB can set breakpoints in the library).
459 We need to set two flag bits in this routine.
461 DT_HP_DEBUG_PRIVATE to indicate that shared libraries should be
464 DT_HP_DEBUG_CALLBACK to indicate that we want the dynamic linker to
465 call the breakpoint routine for significant events. */
468 pa64_solib_create_inferior_hook (void)
470 struct minimal_symbol
*msymbol
;
471 unsigned int dld_flags
, status
;
472 asection
*shlib_info
, *interp_sect
;
474 struct objfile
*objfile
;
477 /* First, remove all the solib event breakpoints. Their addresses
478 may have changed since the last time we ran the program. */
479 remove_solib_event_breakpoints ();
481 if (symfile_objfile
== NULL
)
484 /* First see if the objfile was dynamically linked. */
485 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, ".dynamic");
489 /* It's got a .dynamic section, make sure it's not empty. */
490 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
493 /* Read in the .dynamic section. */
494 if (! read_dynamic_info (shlib_info
, &dld_cache
))
495 error ("Unable to read the .dynamic section.");
497 /* Turn on the flags we care about. */
498 dld_cache
.dld_flags
|= DT_HP_DEBUG_PRIVATE
;
499 dld_cache
.dld_flags
|= DT_HP_DEBUG_CALLBACK
;
500 status
= target_write_memory (dld_cache
.dld_flags_addr
,
501 (char *) &dld_cache
.dld_flags
,
502 sizeof (dld_cache
.dld_flags
));
504 error ("Unable to modify dynamic linker flags.");
506 /* Now we have to create a shared library breakpoint in the dynamic
507 linker. This can be somewhat tricky since the symbol is inside
508 the dynamic linker (for which we do not have symbols or a base
509 load address! Luckily I wrote this code for solib.c years ago. */
510 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
513 unsigned int interp_sect_size
;
517 CORE_ADDR sym_addr
= 0;
519 /* Read the contents of the .interp section into a local buffer;
520 the contents specify the dynamic linker this program uses. */
521 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
522 buf
= alloca (interp_sect_size
);
523 bfd_get_section_contents (exec_bfd
, interp_sect
,
524 buf
, 0, interp_sect_size
);
526 /* Now we need to figure out where the dynamic linker was
527 loaded so that we can load its symbols and place a breakpoint
528 in the dynamic linker itself.
530 This address is stored on the stack. However, I've been unable
531 to find any magic formula to find it for Solaris (appears to
532 be trivial on GNU/Linux). Therefore, we have to try an alternate
533 mechanism to find the dynamic linker's base address. */
534 tmp_bfd
= bfd_openr (buf
, gnutarget
);
538 /* Make sure the dynamic linker's really a useful object. */
539 if (!bfd_check_format (tmp_bfd
, bfd_object
))
541 warning ("Unable to grok dynamic linker %s as an object file", buf
);
546 /* We find the dynamic linker's base address by examining the
547 current pc (which point at the entry point for the dynamic
548 linker) and subtracting the offset of the entry point.
550 Also note the breakpoint is the second instruction in the
552 load_addr
= read_pc () - tmp_bfd
->start_address
;
553 sym_addr
= bfd_lookup_symbol (tmp_bfd
, "__dld_break");
554 sym_addr
= load_addr
+ sym_addr
+ 4;
556 /* Create the shared library breakpoint. */
559 = create_solib_event_breakpoint (sym_addr
);
561 /* The breakpoint is actually hard-coded into the dynamic linker,
562 so we don't need to actually insert a breakpoint instruction
563 there. In fact, the dynamic linker's code is immutable, even to
564 ttrace, so we shouldn't even try to do that. For cases like
565 this, we have "permanent" breakpoints. */
566 make_breakpoint_permanent (b
);
569 /* We're done with the temporary bfd. */
574 /* Wipe out all knowledge of old shared libraries since their
575 mapping can change from one exec to another! */
578 struct so_list
*temp
;
581 xfree (so_list_head
);
582 so_list_head
= temp
->next
;
584 clear_symtab_users ();
587 /* This operation removes the "hook" between GDB and the dynamic linker,
588 which causes the dld to notify GDB of shared library events.
590 After this operation completes, the dld will no longer notify GDB of
591 shared library events. To resume notifications, GDB must call
592 pa64_solib_create_inferior_hook.
594 This operation does not remove any knowledge of shared libraries which
595 GDB may already have been notified of. */
598 pa64_solib_remove_inferior_hook (int pid
)
600 /* Turn off the DT_HP_DEBUG_CALLBACK bit in the dynamic linker flags. */
601 dld_cache
.dld_flags
&= ~DT_HP_DEBUG_CALLBACK
;
602 target_write_memory (dld_cache
.dld_flags_addr
,
603 (char *)&dld_cache
.dld_flags
,
604 sizeof (dld_cache
.dld_flags
));
607 /* This function creates a breakpoint on the dynamic linker hook, which
608 is called when e.g., a shl_load or shl_unload call is made. This
609 breakpoint will only trigger when a shl_load call is made.
611 If filename is NULL, then loads of any dll will be caught. Else,
612 only loads of the file whose pathname is the string contained by
613 filename will be caught.
615 Undefined behaviour is guaranteed if this function is called before
616 pa64_solib_create_inferior_hook. */
619 pa64_solib_create_catch_load_hook (int pid
, int tempflag
, char *filename
,
622 create_solib_load_event_breakpoint ("", tempflag
, filename
, cond_string
);
625 /* This function creates a breakpoint on the dynamic linker hook, which
626 is called when e.g., a shl_load or shl_unload call is made. This
627 breakpoint will only trigger when a shl_unload call is made.
629 If filename is NULL, then unloads of any dll will be caught. Else,
630 only unloads of the file whose pathname is the string contained by
631 filename will be caught.
633 Undefined behaviour is guaranteed if this function is called before
634 pa64_solib_create_inferior_hook. */
637 pa64_solib_create_catch_unload_hook (int pid
, int tempflag
, char *filename
,
640 create_solib_unload_event_breakpoint ("", tempflag
, filename
, cond_string
);
643 /* Return nonzero if the dynamic linker has reproted that a library
647 pa64_solib_have_load_event (int pid
)
649 CORE_ADDR event_kind
;
651 event_kind
= read_register (ARG0_REGNUM
);
652 return (event_kind
== DLD_CB_LOAD
);
655 /* Return nonzero if the dynamic linker has reproted that a library
656 has been unloaded. */
658 pa64_solib_have_unload_event (int pid
)
660 CORE_ADDR event_kind
;
662 event_kind
= read_register (ARG0_REGNUM
);
663 return (event_kind
== DLD_CB_UNLOAD
);
666 /* Return a pointer to a string indicating the pathname of the most
667 recently loaded library.
669 The caller is reposible for copying the string before the inferior is
673 pa64_solib_loaded_library_pathname (int pid
)
675 static char dll_path
[MAXPATHLEN
];
676 CORE_ADDR dll_path_addr
= read_register (ARG3_REGNUM
);
677 read_memory_string (dll_path_addr
, dll_path
, MAXPATHLEN
);
681 /* Return a pointer to a string indicating the pathname of the most
682 recently unloaded library.
684 The caller is reposible for copying the string before the inferior is
688 pa64_solib_unloaded_library_pathname (int pid
)
690 static char dll_path
[MAXPATHLEN
];
691 CORE_ADDR dll_path_addr
= read_register (ARG3_REGNUM
);
692 read_memory_string (dll_path_addr
, dll_path
, MAXPATHLEN
);
696 /* Return nonzero if PC is an address inside the dynamic linker. */
699 pa64_solib_in_dynamic_linker (int pid
, CORE_ADDR pc
)
701 asection
*shlib_info
;
703 if (symfile_objfile
== NULL
)
706 if (!dld_cache
.have_read_dld_descriptor
)
707 if (!read_dld_descriptor (¤t_target
, auto_solib_add
))
710 return (pc
>= dld_cache
.dld_desc
.text_base
711 && pc
< dld_cache
.dld_desc
.text_base
+ dld_cache
.dld_desc
.text_size
);
715 /* Return the GOT value for the shared library in which ADDR belongs. If
716 ADDR isn't in any known shared library, return zero. */
719 pa64_solib_get_got_by_pc (CORE_ADDR addr
)
721 struct so_list
*so_list
= so_list_head
;
722 CORE_ADDR got_value
= 0;
726 if (so_list
->pa64_solib_desc
.text_base
<= addr
727 && ((so_list
->pa64_solib_desc
.text_base
728 + so_list
->pa64_solib_desc
.text_size
)
731 got_value
= so_list
->pa64_solib_desc
.linkage_ptr
;
734 so_list
= so_list
->next
;
739 /* Return the address of the handle of the shared library in which ADDR
740 belongs. If ADDR isn't in any known shared library, return zero.
742 This function is used in hppa_fix_call_dummy in hppa-tdep.c. */
745 pa64_solib_get_solib_by_pc (CORE_ADDR addr
)
747 struct so_list
*so_list
= so_list_head
;
748 CORE_ADDR retval
= 0;
752 if (so_list
->pa64_solib_desc
.text_base
<= addr
753 && ((so_list
->pa64_solib_desc
.text_base
754 + so_list
->pa64_solib_desc
.text_size
)
757 retval
= so_list
->pa64_solib_desc_addr
;
760 so_list
= so_list
->next
;
765 /* Dump information about all the currently loaded shared libraries. */
768 pa64_sharedlibrary_info_command (char *ignore
, int from_tty
)
770 struct so_list
*so_list
= so_list_head
;
772 if (exec_bfd
== NULL
)
774 printf_unfiltered ("No executable file.\n");
780 printf_unfiltered ("No shared libraries loaded at this time.\n");
784 printf_unfiltered ("Shared Object Libraries\n");
785 printf_unfiltered (" %-19s%-19s%-19s%-19s\n",
786 " text start", " text end",
787 " data start", " data end");
792 printf_unfiltered ("%s", so_list
->name
);
793 if (so_list
->objfile
== NULL
)
794 printf_unfiltered (" (symbols not loaded)");
795 if (so_list
->loaded
== 0)
796 printf_unfiltered (" (shared library unloaded)");
797 printf_unfiltered (" %-18s",
798 local_hex_string_custom (so_list
->pa64_solib_desc
.linkage_ptr
,
800 printf_unfiltered ("\n");
801 printf_unfiltered ("%-18s",
802 local_hex_string_custom (so_list
->pa64_solib_desc
.text_base
,
804 printf_unfiltered (" %-18s",
805 local_hex_string_custom ((so_list
->pa64_solib_desc
.text_base
806 + so_list
->pa64_solib_desc
.text_size
),
808 printf_unfiltered (" %-18s",
809 local_hex_string_custom (so_list
->pa64_solib_desc
.data_base
,
811 printf_unfiltered (" %-18s\n",
812 local_hex_string_custom ((so_list
->pa64_solib_desc
.data_base
813 + so_list
->pa64_solib_desc
.data_size
),
815 so_list
= so_list
->next
;
819 /* Load up one or more shared libraries as directed by the user. */
822 pa64_solib_sharedlibrary_command (char *args
, int from_tty
)
825 pa64_solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
828 /* Return the name of the shared library containing ADDR or NULL if ADDR
829 is not contained in any known shared library. */
832 pa64_solib_address (CORE_ADDR addr
)
834 struct so_list
*so
= so_list_head
;
838 /* Is this address within this shlib's text range? If so,
839 return the shlib's name. */
840 if (addr
>= so
->pa64_solib_desc
.text_base
841 && addr
< (so
->pa64_solib_desc
.text_base
842 | so
->pa64_solib_desc
.text_size
))
845 /* Nope, keep looking... */
849 /* No, we couldn't prove that the address is within a shlib. */
853 /* We are killing the inferior and restarting the program. */
856 pa64_solib_restart (void)
858 struct so_list
*sl
= so_list_head
;
860 /* Before the shlib info vanishes, use it to disable any breakpoints
861 that may still be active in those shlibs. */
862 disable_breakpoints_in_shlibs (0);
864 /* Discard all the shlib descriptors. */
867 struct so_list
*next_sl
= sl
->next
;
873 pa64_solib_total_st_size
= (LONGEST
) 0;
874 pa64_solib_st_size_threshold_exceeded
= 0;
876 dld_cache
.is_valid
= 0;
877 dld_cache
.have_read_dld_descriptor
= 0;
878 dld_cache
.dld_flags_addr
= 0;
879 dld_cache
.load_map
= 0;
880 dld_cache
.load_map_addr
= 0;
881 dld_cache
.dld_desc
.data_base
= 0;
882 dld_cache
.dld_flags
= 0;
883 dld_cache
.dyninfo_sect
= 0;
887 _initialize_pa64_solib (void)
889 add_com ("sharedlibrary", class_files
, pa64_solib_sharedlibrary_command
,
890 "Load shared object library symbols for files matching REGEXP.");
891 add_info ("sharedlibrary", pa64_sharedlibrary_info_command
,
892 "Status of loaded shared object libraries.");
895 (add_set_cmd ("auto-solib-add", class_support
, var_boolean
,
896 (char *) &auto_solib_add
,
897 "Set autoloading of shared library symbols.\n\
898 If \"on\", symbols from all shared object libraries will be loaded\n\
899 automatically when the inferior begins execution, when the dynamic linker\n\
900 informs gdb that a new library has been loaded, or when attaching to the\n\
901 inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
906 (add_set_cmd ("auto-solib-limit", class_support
, var_zinteger
,
907 (char *) &auto_solib_limit
,
908 "Set threshold (in Mb) for autoloading shared library symbols.\n\
909 When shared library autoloading is enabled, new libraries will be loaded\n\
910 only until the total size of shared library symbols exceeds this\n\
911 threshold in megabytes. Is ignored when using `sharedlibrary'.",
915 /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how
916 much data space a process can use. We ought to be reading
917 MAXDSIZ and setting auto_solib_limit to some large fraction of
918 that value. If not that, we maybe ought to be setting it smaller
919 than the default for MAXDSIZ (that being 64Mb, I believe).
920 However, [1] this threshold is only crudely approximated rather
921 than actually measured, and [2] 50 Mbytes is too small for
922 debugging gdb itself. Thus, the arbitrary 100 figure. */
923 auto_solib_limit
= 100; /* Megabytes */
925 pa64_solib_restart ();
928 /* Get some HPUX-specific data from a shared lib. */
930 so_lib_thread_start_addr (struct so_list
*so
)
932 return so
->pa64_solib_desc
.tls_start_addr
;
935 /* Read the dynamic linker's internal shared library descriptor.
937 This must happen after dld starts running, so we can't do it in
938 read_dynamic_info. Record the fact that we have loaded the
939 descriptor. If the library is archive bound, then return zero, else
943 read_dld_descriptor (struct target_ops
*target
, int readsyms
)
946 asection
*dyninfo_sect
;
948 /* If necessary call read_dynamic_info to extract the contents of the
949 .dynamic section from the shared library. */
950 if (!dld_cache
.is_valid
)
952 if (symfile_objfile
== NULL
)
953 error ("No object file symbols.");
955 dyninfo_sect
= bfd_get_section_by_name (symfile_objfile
->obfd
,
962 if (!read_dynamic_info (dyninfo_sect
, &dld_cache
))
963 error ("Unable to read in .dynamic section information.");
966 /* Read the load map pointer. */
967 if (target_read_memory (dld_cache
.load_map_addr
,
968 (char*) &dld_cache
.load_map
,
969 sizeof(dld_cache
.load_map
))
972 error ("Error while reading in load map pointer.");
975 /* Read in the dld load module descriptor */
976 if (dlgetmodinfo (-1,
978 sizeof(dld_cache
.dld_desc
),
979 pa64_target_read_memory
,
984 error ("Error trying to get information about dynamic linker.");
987 /* Indicate that we have loaded the dld descriptor. */
988 dld_cache
.have_read_dld_descriptor
= 1;
990 /* Add dld.sl to the list of known shared libraries so that we can
993 ?!? This may not be correct. Consider of dld.sl contains symbols
994 which are also referenced/defined by the user program or some user
995 shared library. We need to make absolutely sure that we do not
996 pollute the namespace from GDB's point of view. */
997 dll_path
= dlgetname (&dld_cache
.dld_desc
,
998 sizeof(dld_cache
.dld_desc
),
999 pa64_target_read_memory
,
1001 dld_cache
.load_map
);
1002 add_to_solist(0, dll_path
, readsyms
, &dld_cache
.dld_desc
, 0, target
);
1007 /* Read the .dynamic section and extract the information of interest,
1008 which is stored in dld_cache. The routine elf_locate_base in solib.c
1009 was used as a model for this. */
1012 read_dynamic_info (asection
*dyninfo_sect
, dld_cache_t
*dld_cache_p
)
1016 CORE_ADDR dyninfo_addr
;
1017 int dyninfo_sect_size
;
1018 CORE_ADDR entry_addr
;
1020 /* Read in .dynamic section, silently ignore errors. */
1021 dyninfo_addr
= bfd_section_vma (symfile_objfile
->obfd
, dyninfo_sect
);
1022 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
1023 buf
= alloca (dyninfo_sect_size
);
1024 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
1027 /* Scan the .dynamic section and record the items of interest.
1028 In particular, DT_HP_DLD_FLAGS */
1029 for (bufend
= buf
+ dyninfo_sect_size
, entry_addr
= dyninfo_addr
;
1031 buf
+= sizeof (Elf64_Dyn
), entry_addr
+= sizeof (Elf64_Dyn
))
1033 Elf64_Dyn
*x_dynp
= (Elf64_Dyn
*)buf
;
1034 Elf64_Sxword dyn_tag
;
1038 pbuf
= alloca (TARGET_PTR_BIT
/ HOST_CHAR_BIT
);
1039 dyn_tag
= bfd_h_get_64 (symfile_objfile
->obfd
,
1040 (bfd_byte
*) &x_dynp
->d_tag
);
1042 /* We can't use a switch here because dyn_tag is 64 bits and HP's
1043 lame comiler does not handle 64bit items in switch statements. */
1044 if (dyn_tag
== DT_NULL
)
1046 else if (dyn_tag
== DT_HP_DLD_FLAGS
)
1048 /* Set dld_flags_addr and dld_flags in *dld_cache_p */
1049 dld_cache_p
->dld_flags_addr
= entry_addr
+ offsetof(Elf64_Dyn
, d_un
);
1050 if (target_read_memory (dld_cache_p
->dld_flags_addr
,
1051 (char*) &dld_cache_p
->dld_flags
,
1052 sizeof(dld_cache_p
->dld_flags
))
1055 error ("Error while reading in .dynamic section of the program.");
1058 else if (dyn_tag
== DT_HP_LOAD_MAP
)
1060 /* Dld will place the address of the load map at load_map_addr
1061 after it starts running. */
1062 if (target_read_memory (entry_addr
+ offsetof(Elf64_Dyn
,
1064 (char*) &dld_cache_p
->load_map_addr
,
1065 sizeof(dld_cache_p
->load_map_addr
))
1068 error ("Error while reading in .dynamic section of the program.");
1073 /* tag is not of interest */
1077 /* Record other information and set is_valid to 1. */
1078 dld_cache_p
->dyninfo_sect
= dyninfo_sect
;
1080 /* Verify that we read in required info. These fields are re-set to zero
1081 in pa64_solib_restart. */
1083 if (dld_cache_p
->dld_flags_addr
!= 0 && dld_cache_p
->load_map_addr
!= 0)
1084 dld_cache_p
->is_valid
= 1;
1091 /* Wrapper for target_read_memory to make dlgetmodinfo happy. */
1094 pa64_target_read_memory (void *buffer
, CORE_ADDR ptr
, size_t bufsiz
, int ident
)
1096 if (target_read_memory (ptr
, buffer
, bufsiz
) != 0)
1101 /* Called from handle_dynlink_load_event and pa64_solib_add to add
1102 a shared library to so_list_head list and possibly to read in the
1103 debug information for the library.
1105 If load_module_desc_p is NULL, then the load module descriptor must
1106 be read from the inferior process at the address load_module_desc_addr. */
1109 add_to_solist (int from_tty
, char *dll_path
, int readsyms
,
1110 struct load_module_desc
*load_module_desc_p
,
1111 CORE_ADDR load_module_desc_addr
, struct target_ops
*target
)
1113 struct so_list
*new_so
, *so_list_tail
;
1114 int pa64_solib_st_size_threshhold_exceeded
;
1117 if (symfile_objfile
== NULL
)
1120 so_list_tail
= so_list_head
;
1121 /* Find the end of the list of shared objects. */
1122 while (so_list_tail
&& so_list_tail
->next
)
1124 if (strcmp (so_list_tail
->name
, dll_path
) == 0)
1126 so_list_tail
= so_list_tail
->next
;
1129 if (so_list_tail
&& strcmp (so_list_tail
->name
, dll_path
) == 0)
1132 /* Add the shared library to the so_list_head list */
1133 new_so
= (struct so_list
*) xmalloc (sizeof (struct so_list
));
1134 memset ((char *)new_so
, 0, sizeof (struct so_list
));
1135 if (so_list_head
== NULL
)
1137 so_list_head
= new_so
;
1138 so_list_tail
= new_so
;
1142 so_list_tail
->next
= new_so
;
1143 so_list_tail
= new_so
;
1146 /* Initialize the new_so */
1147 if (load_module_desc_p
)
1149 new_so
->pa64_solib_desc
= *load_module_desc_p
;
1153 if (target_read_memory (load_module_desc_addr
,
1154 (char*) &new_so
->pa64_solib_desc
,
1155 sizeof(struct load_module_desc
))
1158 error ("Error while reading in dynamic library %s", dll_path
);
1162 new_so
->pa64_solib_desc_addr
= load_module_desc_addr
;
1164 new_so
->name
= obsavestring (dll_path
, strlen(dll_path
),
1165 &symfile_objfile
->symbol_obstack
);
1167 /* If we are not going to load the library, tell the user if we
1168 haven't already and return. */
1170 st_size
= pa64_solib_sizeof_symbol_table (dll_path
);
1171 pa64_solib_st_size_threshhold_exceeded
=
1174 && ( (st_size
+ pa64_solib_total_st_size
)
1175 > (auto_solib_limit
* (LONGEST
) (1024 * 1024)));
1176 if (pa64_solib_st_size_threshhold_exceeded
)
1178 pa64_solib_add_solib_objfile (new_so
, dll_path
, from_tty
, 1);
1182 /* Now read in debug info. */
1183 pa64_solib_total_st_size
+= st_size
;
1185 /* This fills in new_so->objfile, among others. */
1186 pa64_solib_load_symbols (new_so
,
1198 bfd_lookup_symbol -- lookup the value for a specific symbol
1202 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
1206 An expensive way to lookup the value of a single symbol for
1207 bfd's that are only temporary anyway. This is used by the
1208 shared library support to find the address of the debugger
1209 interface structures in the shared library.
1211 Note that 0 is specifically allowed as an error return (no
1216 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
1218 unsigned int storage_needed
;
1220 asymbol
**symbol_table
;
1221 unsigned int number_of_symbols
;
1223 struct cleanup
*back_to
;
1224 CORE_ADDR symaddr
= 0;
1226 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1228 if (storage_needed
> 0)
1230 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1231 back_to
= make_cleanup (xfree
, symbol_table
);
1232 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
1234 for (i
= 0; i
< number_of_symbols
; i
++)
1236 sym
= *symbol_table
++;
1237 if (strcmp (sym
->name
, symname
) == 0)
1239 /* Bfd symbols are section relative. */
1240 symaddr
= sym
->value
+ sym
->section
->vma
;
1244 do_cleanups (back_to
);