1 /* Handle HP SOM shared libraries for GDB, the GNU Debugger.
2 Copyright 1993, 1996 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, Boston, MA 02111-1307, USA.
20 Written by the Center for Software Science at the Univerity of Utah
21 and by Cygnus Support. */
32 #include "breakpoint.h"
36 #include "gdb-stabs.h"
42 * Most of this code should work for hp300 shared libraries. Does
43 anyone care enough to weed out any SOM-isms.
45 * Support for hpux8 dynamic linker. */
47 /* The basic structure which describes a dynamically loaded object. This
48 data structure is private to the dynamic linker and isn't found in
49 any HPUX include file. */
51 struct som_solib_mapped_entry
53 /* The name of the library. */
56 /* Version of this structure (it is expected to change again in hpux10). */
57 unsigned char struct_version
;
59 /* Binding mode for this library. */
60 unsigned char bind_mode
;
62 /* Version of this library. */
63 short library_version
;
65 /* Start of text address, link-time text location, end of text address. */
67 CORE_ADDR text_link_addr
;
70 /* Start of data, start of bss and end of data. */
75 /* Value of linkage pointer (%r19). */
79 struct som_solib_mapped_entry
*next
;
81 /* There are other fields, but I don't have information as to what is
85 /* A structure to keep track of all the known shared objects. */
88 struct som_solib_mapped_entry som_solib
;
89 struct objfile
*objfile
;
91 struct section_table
*sections
;
92 struct section_table
*sections_end
;
96 static struct so_list
*so_list_head
;
98 static void som_sharedlibrary_info_command
PARAMS ((char *, int));
100 static void som_solib_sharedlibrary_command
PARAMS ((char *, int));
102 /* Add symbols from shared libraries into the symtab list. */
105 som_solib_add (arg_string
, from_tty
, target
)
108 struct target_ops
*target
;
110 struct minimal_symbol
*msymbol
;
111 struct so_list
*so_list_tail
;
113 asection
*shlib_info
;
115 unsigned int dld_flags
;
116 char buf
[4], *re_err
;
118 /* First validate our arguments. */
119 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
121 error ("Invalid regexp: %s", re_err
);
124 /* If we're debugging a core file, or have attached to a running
125 process, then som_solib_create_inferior_hook will not have been
128 We need to first determine if we're dealing with a dynamically
129 linked executable. If not, then return without an error or warning.
131 We also need to examine __dld_flags to determine if the shared library
132 list is valid and to determine if the libraries have been privately
134 if (symfile_objfile
== NULL
)
137 /* First see if the objfile was dynamically linked. */
138 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
142 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
143 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
146 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
149 error ("Unable to find __dld_flags symbol in object file.\n");
153 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
154 /* Read the current contents. */
155 status
= target_read_memory (addr
, buf
, 4);
158 error ("Unable to read __dld_flags\n");
161 dld_flags
= extract_unsigned_integer (buf
, 4);
163 /* __dld_list may not be valid. If it's not valid tell the user. */
164 if ((dld_flags
& 4) == 0)
166 error ("__dld_list is not valid according to __dld_flags.\n");
170 /* If the libraries were not mapped private, warn the user. */
171 if ((dld_flags
& 1) == 0)
172 warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
174 msymbol
= lookup_minimal_symbol ("__dld_list", NULL
, NULL
);
177 /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
178 but the data is still available if you know where to look. */
179 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
182 error ("Unable to find dynamic library list.\n");
185 addr
= SYMBOL_VALUE_ADDRESS (msymbol
) - 8;
188 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
190 status
= target_read_memory (addr
, buf
, 4);
193 error ("Unable to find dynamic library list.\n");
197 addr
= extract_unsigned_integer (buf
, 4);
199 /* If addr is zero, then we're using an old dynamic loader which
200 doesn't maintain __dld_list. We'll have to use a completely
201 different approach to get shared library information. */
205 /* Using the information in __dld_list is the preferred method
206 to get at shared library information. It doesn't depend on
207 any functions in /usr/lib/end.o and has a chance of working
208 with hpux10 when it is released. */
209 status
= target_read_memory (addr
, buf
, 4);
212 error ("Unable to find dynamic library list.\n");
216 /* addr now holds the address of the first entry in the dynamic
218 addr
= extract_unsigned_integer (buf
, 4);
220 /* Now that we have a pointer to the dynamic library list, walk
221 through it and add the symbols for each library. */
223 so_list_tail
= so_list_head
;
224 /* Find the end of the list of shared objects. */
225 while (so_list_tail
&& so_list_tail
->next
)
226 so_list_tail
= so_list_tail
->next
;
230 CORE_ADDR name_addr
, text_addr
;
231 unsigned int name_len
;
233 struct so_list
*new_so
;
234 struct so_list
*so_list
= so_list_head
;
235 struct section_table
*p
;
241 /* Get a pointer to the name of this library. */
242 status
= target_read_memory (addr
, buf
, 4);
246 name_addr
= extract_unsigned_integer (buf
, 4);
250 target_read_memory (name_addr
+ name_len
, buf
, 1);
258 name
= alloca (name_len
);
259 status
= target_read_memory (name_addr
, name
, name_len
);
263 /* See if we've already loaded something with this name. */
266 if (!strcmp (so_list
->som_solib
.name
, name
))
268 so_list
= so_list
->next
;
271 /* See if the file exists. If not, give a warning, but don't
273 status
= stat (name
, &statbuf
);
276 warning ("Can't find file %s referenced in dld_list.", name
);
278 status
= target_read_memory (addr
+ 36, buf
, 4);
282 addr
= (CORE_ADDR
) extract_unsigned_integer (buf
, 4);
286 /* If we've already loaded this one or it's the main program, skip it. */
287 if (so_list
|| !strcmp (name
, symfile_objfile
->name
))
289 status
= target_read_memory (addr
+ 36, buf
, 4);
293 addr
= (CORE_ADDR
) extract_unsigned_integer (buf
, 4);
297 name
= obsavestring (name
, name_len
- 1,
298 &symfile_objfile
->symbol_obstack
);
300 status
= target_read_memory (addr
+ 8, buf
, 4);
304 text_addr
= extract_unsigned_integer (buf
, 4);
307 new_so
= (struct so_list
*) xmalloc (sizeof (struct so_list
));
308 memset ((char *)new_so
, 0, sizeof (struct so_list
));
309 if (so_list_head
== NULL
)
311 so_list_head
= new_so
;
312 so_list_tail
= new_so
;
316 so_list_tail
->next
= new_so
;
317 so_list_tail
= new_so
;
320 /* Fill in all the entries in GDB's shared library list. */
321 new_so
->som_solib
.name
= name
;
322 status
= target_read_memory (addr
+ 4, buf
, 4);
326 new_so
->som_solib
.struct_version
= extract_unsigned_integer (buf
+ 3, 1);
327 new_so
->som_solib
.bind_mode
= extract_unsigned_integer (buf
+ 2, 1);
328 new_so
->som_solib
.library_version
= extract_unsigned_integer (buf
, 2);
329 new_so
->som_solib
.text_addr
= text_addr
;
331 status
= target_read_memory (addr
+ 12, buf
, 4);
335 new_so
->som_solib
.text_link_addr
= extract_unsigned_integer (buf
, 4);
337 status
= target_read_memory (addr
+ 16, buf
, 4);
341 new_so
->som_solib
.text_end
= extract_unsigned_integer (buf
, 4);
343 status
= target_read_memory (addr
+ 20, buf
, 4);
347 new_so
->som_solib
.data_start
= extract_unsigned_integer (buf
, 4);
349 status
= target_read_memory (addr
+ 24, buf
, 4);
353 new_so
->som_solib
.bss_start
= extract_unsigned_integer (buf
, 4);
355 status
= target_read_memory (addr
+ 28, buf
, 4);
359 new_so
->som_solib
.data_end
= extract_unsigned_integer (buf
, 4);
361 status
= target_read_memory (addr
+ 32, buf
, 4);
365 new_so
->som_solib
.got_value
= extract_unsigned_integer (buf
, 4);
367 status
= target_read_memory (addr
+ 36, buf
, 4);
371 new_so
->som_solib
.next
= (void *)extract_unsigned_integer (buf
, 4);
372 addr
= (CORE_ADDR
)new_so
->som_solib
.next
;
374 new_so
->objfile
= symbol_file_add (name
, from_tty
, text_addr
, 0, 0, 0);
375 new_so
->abfd
= new_so
->objfile
->obfd
;
377 if (!bfd_check_format (new_so
->abfd
, bfd_object
))
379 error ("\"%s\": not in executable format: %s.",
380 name
, bfd_errmsg (bfd_get_error ()));
383 /* Now we need to build a section table for this library since
384 we might be debugging a core file from a dynamically linked
385 executable in which the libraries were not privately mapped. */
386 if (build_section_table (new_so
->abfd
,
388 &new_so
->sections_end
))
390 error ("Unable to build section table for shared library\n.");
394 /* Relocate all the sections based on where they got loaded. */
395 for (p
= new_so
->sections
; p
< new_so
->sections_end
; p
++)
397 if (p
->the_bfd_section
->flags
& SEC_CODE
)
399 p
->addr
+= text_addr
- new_so
->som_solib
.text_link_addr
;
400 p
->endaddr
+= text_addr
- new_so
->som_solib
.text_link_addr
;
402 else if (p
->the_bfd_section
->flags
& SEC_DATA
)
404 p
->addr
+= new_so
->som_solib
.data_start
;
405 p
->endaddr
+= new_so
->som_solib
.data_start
;
409 /* Now see if we need to map in the text and data for this shared
410 library (for example debugging a core file which does not use
411 private shared libraries.).
413 Carefully peek at the first text address in the library. If the
414 read succeeds, then the libraries were privately mapped and were
415 included in the core dump file.
417 If the peek failed, then the libraries were not privately mapped
418 and are not in the core file, we'll have to read them in ourselves. */
419 status
= target_read_memory (text_addr
, buf
, 4);
425 /* We must update the to_sections field in the core_ops structure
426 here, otherwise we dereference a potential dangling pointer
427 for each call to target_read/write_memory within this routine. */
428 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
430 new = new_so
->sections_end
- new_so
->sections
;
431 /* Add sections from the shared library to the core target. */
432 if (target
->to_sections
)
434 old
= target
->to_sections_end
- target
->to_sections
;
435 target
->to_sections
= (struct section_table
*)
436 xrealloc ((char *)target
->to_sections
,
437 ((sizeof (struct section_table
)) * (old
+ new)));
442 target
->to_sections
= (struct section_table
*)
443 xmalloc ((sizeof (struct section_table
)) * new);
445 target
->to_sections_end
= (target
->to_sections
+ old
+ new);
447 /* Update the to_sections field in the core_ops structure
451 core_ops
.to_sections
= target
->to_sections
;
452 core_ops
.to_sections_end
= target
->to_sections_end
;
455 /* Copy over the old data before it gets clobbered. */
456 memcpy ((char *)(target
->to_sections
+ old
),
458 ((sizeof (struct section_table
)) * new));
462 /* Getting new symbols may change our opinion about what is
464 reinit_frame_cache ();
468 error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
472 error ("Error while reading dynamic library list.\n");
477 /* This hook gets called just before the first instruction in the
478 inferior process is executed.
480 This is our opportunity to set magic flags in the inferior so
481 that GDB can be notified when a shared library is mapped in and
482 to tell the dynamic linker that a private copy of the library is
483 needed (so GDB can set breakpoints in the library).
485 __dld_flags is the location of the magic flags; as of this implementation
486 there are 3 flags of interest:
488 bit 0 when set indicates that private copies of the libraries are needed
489 bit 1 when set indicates that the callback hook routine is valid
490 bit 2 when set indicates that the dynamic linker should maintain the
491 __dld_list structure when loading/unloading libraries.
493 Note that shared libraries are not mapped in at this time, so we have
494 run the inferior until the libraries are mapped in. Typically this
495 means running until the "_start" is called. */
498 som_solib_create_inferior_hook()
500 struct minimal_symbol
*msymbol
;
501 unsigned int dld_flags
, status
, have_endo
;
502 asection
*shlib_info
;
504 struct objfile
*objfile
;
507 /* First, remove all the solib event breakpoints. Their addresses
508 may have changed since the last time we ran the program. */
509 remove_solib_event_breakpoints ();
511 if (symfile_objfile
== NULL
)
514 /* First see if the objfile was dynamically linked. */
515 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
519 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
520 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
524 /* If __d_pid is present, then put the inferior's pid into __d_pid. hpux9
525 requires __d_pid to be set. hpux10 doesn't require __d_pid to be set
526 and the symbol may not be available. */
527 msymbol
= lookup_minimal_symbol ("__d_pid", NULL
, symfile_objfile
);
530 warning ("Unable to find __d_pid symbol in object file.");
534 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
535 store_unsigned_integer (buf
, 4, inferior_pid
);
536 status
= target_write_memory (anaddr
, buf
, 4);
539 warning ("Unable to write __d_pid");
544 /* If __d_trap_fptr exists, then load whatever's at that address
545 and put it into __dld_hook. */
546 msymbol
= lookup_minimal_symbol ("__d_trap_fptr", NULL
, symfile_objfile
);
549 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
550 status
= target_read_memory (anaddr
, buf
, 4);
551 anaddr
= extract_unsigned_integer (buf
, 4);
553 /* If it's a plabel, then get the address of the real function.
554 Egad. This is just the opposite of how hpux9 and _DLD_HOOK
558 status
= target_read_memory (anaddr
& ~0x2, buf
, 4);
559 anaddr
= extract_unsigned_integer (buf
, 4);
564 /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
565 This will force the dynamic linker to call __d_trap when significant
567 msymbol
= lookup_minimal_symbol ("_DLD_HOOK", NULL
, symfile_objfile
);
570 warning ("Unable to find _DLD_HOOK symbol in object file.");
571 warning ("Suggest linking with /usr/lib/end.o.");
572 warning ("GDB will be unable to track shl_load/shl_unload calls");
575 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
577 /* Grrr, this might not be an export symbol! We have to find the
579 ALL_OBJFILES (objfile
)
581 extern struct unwind_table_entry
*find_unwind_entry
PARAMS ((CORE_ADDR pc
));
585 = lookup_minimal_symbol_solib_trampoline (SYMBOL_NAME (msymbol
),
587 /* Found a symbol with the right name. */
590 struct unwind_table_entry
*u
;
591 /* It must be a shared library trampoline. */
592 if (SYMBOL_TYPE (msymbol
) != mst_solib_trampoline
)
595 /* It must also be an export stub. */
596 u
= find_unwind_entry (SYMBOL_VALUE (msymbol
));
597 if (!u
|| u
->stub_type
!= EXPORT
)
600 /* OK. Looks like the correct import stub. */
601 anaddr
= SYMBOL_VALUE (msymbol
);
606 store_unsigned_integer (buf
, 4, anaddr
);
608 msymbol
= lookup_minimal_symbol ("__dld_hook", NULL
, symfile_objfile
);
611 warning ("Unable to find __dld_hook symbol in object file.");
612 warning ("Suggest linking with /usr/lib/end.o.");
613 warning ("GDB will be unable to track shl_load/shl_unload calls");
616 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
617 status
= target_write_memory (anaddr
, buf
, 4);
619 /* Now set a shlib_event breakpoint at __d_trap so we can track
620 significant shared library events. */
621 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
624 warning ("Unable to find __dld_d_trap symbol in object file.");
625 warning ("Suggest linking with /usr/lib/end.o.");
626 warning ("GDB will be unable to track shl_load/shl_unload calls");
629 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
631 /* We have all the support usually found in end.o, so we can track
632 shl_load and shl_unload calls. */
637 /* Get the address of __dld_flags, if no such symbol exists, then we can
638 not debug the shared code. */
639 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
642 error ("Unable to find __dld_flags symbol in object file.\n");
647 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
648 /* Read the current contents. */
649 status
= target_read_memory (anaddr
, buf
, 4);
652 error ("Unable to read __dld_flags\n");
655 dld_flags
= extract_unsigned_integer (buf
, 4);
657 /* Turn on the flags we care about. */
658 dld_flags
|= (0x5 | (have_endo
<< 1));
659 store_unsigned_integer (buf
, 4, dld_flags
);
660 status
= target_write_memory (anaddr
, buf
, 4);
663 error ("Unable to write __dld_flags\n");
667 /* Now find the address of _start and set a breakpoint there.
668 We still need this code for two reasons:
670 * Not all sites have /usr/lib/end.o, so it's not always
671 possible to track the dynamic linker's events.
673 * At this time no events are triggered for shared libraries
674 loaded at startup time (what a crock). */
676 msymbol
= lookup_minimal_symbol ("_start", NULL
, symfile_objfile
);
679 error ("Unable to find _start symbol in object file.\n");
683 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
685 /* Make the breakpoint at "_start" a shared library event breakpoint. */
686 create_solib_event_breakpoint (anaddr
);
688 /* Wipe out all knowledge of old shared libraries since their
689 mapping can change from one exec to another! */
692 struct so_list
*temp
;
694 free_objfile (so_list_head
->objfile
);
697 so_list_head
= temp
->next
;
699 clear_symtab_users ();
702 /* Return the GOT value for the shared library in which ADDR belongs. If
703 ADDR isn't in any known shared library, return zero. */
706 som_solib_get_got_by_pc (addr
)
709 struct so_list
*so_list
= so_list_head
;
710 CORE_ADDR got_value
= 0;
714 if (so_list
->som_solib
.text_addr
<= addr
715 && so_list
->som_solib
.text_end
> addr
)
717 got_value
= so_list
->som_solib
.got_value
;
720 so_list
= so_list
->next
;
726 som_solib_section_offsets (objfile
, offsets
)
727 struct objfile
*objfile
;
728 struct section_offsets
*offsets
;
730 struct so_list
*so_list
= so_list_head
;
734 /* Oh what a pain! We need the offsets before so_list->objfile
735 is valid. The BFDs will never match. Make a best guess. */
736 if (strstr (objfile
->name
, so_list
->som_solib
.name
))
738 asection
*private_section
;
740 /* The text offset is easy. */
741 ANOFFSET (offsets
, SECT_OFF_TEXT
)
742 = (so_list
->som_solib
.text_addr
743 - so_list
->som_solib
.text_link_addr
);
744 ANOFFSET (offsets
, SECT_OFF_RODATA
)
745 = ANOFFSET (offsets
, SECT_OFF_TEXT
);
747 /* We should look at presumed_dp in the SOM header, but
748 that's not easily available. This should be OK though. */
749 private_section
= bfd_get_section_by_name (objfile
->obfd
,
751 if (!private_section
)
753 warning ("Unable to find $PRIVATE$ in shared library!");
754 ANOFFSET (offsets
, SECT_OFF_DATA
) = 0;
755 ANOFFSET (offsets
, SECT_OFF_BSS
) = 0;
758 ANOFFSET (offsets
, SECT_OFF_DATA
)
759 = (so_list
->som_solib
.data_start
- private_section
->vma
);
760 ANOFFSET (offsets
, SECT_OFF_BSS
)
761 = ANOFFSET (offsets
, SECT_OFF_DATA
);
764 so_list
= so_list
->next
;
769 /* Dump information about all the currently loaded shared libraries. */
772 som_sharedlibrary_info_command (ignore
, from_tty
)
776 struct so_list
*so_list
= so_list_head
;
778 if (exec_bfd
== NULL
)
780 printf_unfiltered ("no exec file.\n");
786 printf_unfiltered ("No shared libraries loaded at this time.\n");
790 printf_unfiltered ("Shared Object Libraries\n");
791 printf_unfiltered (" %-12s%-12s%-12s%-12s%-12s%-12s\n",
792 " flags", " tstart", " tend", " dstart", " dend", " dlt");
797 flags
= so_list
->som_solib
.struct_version
<< 24;
798 flags
|= so_list
->som_solib
.bind_mode
<< 16;
799 flags
|= so_list
->som_solib
.library_version
;
800 printf_unfiltered ("%s\n", so_list
->som_solib
.name
);
801 printf_unfiltered (" %-12s", local_hex_string_custom (flags
, "08l"));
802 printf_unfiltered ("%-12s",
803 local_hex_string_custom (so_list
->som_solib
.text_addr
, "08l"));
804 printf_unfiltered ("%-12s",
805 local_hex_string_custom (so_list
->som_solib
.text_end
, "08l"));
806 printf_unfiltered ("%-12s",
807 local_hex_string_custom (so_list
->som_solib
.data_start
, "08l"));
808 printf_unfiltered ("%-12s",
809 local_hex_string_custom (so_list
->som_solib
.data_end
, "08l"));
810 printf_unfiltered ("%-12s\n",
811 local_hex_string_custom (so_list
->som_solib
.got_value
, "08l"));
812 so_list
= so_list
->next
;
817 som_solib_sharedlibrary_command (args
, from_tty
)
822 som_solib_add (args
, from_tty
, (struct target_ops
*) 0);
826 _initialize_som_solib ()
828 add_com ("sharedlibrary", class_files
, som_solib_sharedlibrary_command
,
829 "Load shared object library symbols for files matching REGEXP.");
830 add_info ("sharedlibrary", som_sharedlibrary_info_command
,
831 "Status of loaded shared object libraries.");
833 (add_set_cmd ("auto-solib-add", class_support
, var_zinteger
,
834 (char *) &auto_solib_add
,
835 "Set autoloading of shared library symbols at startup.\n\
836 If nonzero, symbols from all shared object libraries will be loaded\n\
837 automatically when the inferior begins execution or when the dynamic linker\n\
838 informs gdb that a new library has been loaded. Otherwise, symbols\n\
839 must be loaded manually, using `sharedlibrary'.",