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"
48 /* Uncomment this to turn on some debugging output.
51 /* #define SOLIB_DEBUG
54 /* Defined in exec.c; used to prevent dangling pointer bug.
56 extern struct target_ops exec_ops;
58 /* This lives in hppa-tdep.c. */
59 extern struct unwind_table_entry *find_unwind_entry PARAMS ((CORE_ADDR pc));
61 /* These ought to be defined in some public interface, but aren't. They
62 define the meaning of the various bits in the distinguished __dld_flags
63 variable that is declared in every debuggable a.out on HP-UX, and that
64 is shared between the debugger and the dynamic linker.
66 #define DLD_FLAGS_MAPPRIVATE 0x1
67 #define DLD_FLAGS_HOOKVALID 0x2
68 #define DLD_FLAGS_LISTVALID 0x4
69 #define DLD_FLAGS_BOR_ENABLE 0x8
73 * Most of this code should work for hp300 shared libraries. Does
74 anyone care enough to weed out any SOM-isms.
76 * Support for hpux8 dynamic linker. */
78 /* The basic structure which describes a dynamically loaded object. This
79 data structure is private to the dynamic linker and isn't found in
80 any HPUX include file. */
82 struct som_solib_mapped_entry
84 /* The name of the library. */
87 /* Version of this structure (it is expected to change again in hpux10). */
88 unsigned char struct_version;
90 /* Binding mode for this library. */
91 unsigned char bind_mode;
93 /* Version of this library. */
94 short library_version;
96 /* Start of text address,
97 * link-time text location (length of text area),
98 * end of text address. */
100 CORE_ADDR text_link_addr;
103 /* Start of data, start of bss and end of data. */
104 CORE_ADDR data_start;
108 /* Value of linkage pointer (%r19). */
112 struct som_solib_mapped_entry *next;
114 /* There are other fields, but I don't have information as to what is
115 contained in them. */
117 /* For versions from HPUX-10.30 and up */
119 /* Address in target of offset from thread-local register of
120 * start of this thread's data. I.e., the first thread-local
121 * variable in this shared library starts at *(tsd_start_addr)
122 * from that area pointed to by cr27 (mpsfu_hi).
124 * We do the indirection as soon as we read it, so from then
125 * on it's the offset itself.
127 CORE_ADDR tsd_start_addr;
129 /* Following this are longwords holding:
131 * ?, ?, ?, ptr to -1, ptr to-1, ptr to lib name (leaf name),
132 * ptr to __data_start, ptr to __data_end
138 /* A structure to keep track of all the known shared objects. */
141 struct som_solib_mapped_entry som_solib;
142 struct objfile *objfile;
144 struct section_table *sections;
145 struct section_table *sections_end;
146 /* elz: added this field to store the address in target space (in the
147 library) of the library descriptor (handle) which we read into
148 som_solib_mapped_entry structure*/
149 CORE_ADDR solib_addr;
150 struct so_list *next;
154 static struct so_list *so_list_head;
157 /* This is the cumulative size in bytes of the symbol tables of all
158 shared objects on the so_list_head list. (When we say size, here
159 we mean of the information before it is brought into memory and
160 potentially expanded by GDB.) When adding a new shlib, this value
161 is compared against the threshold size, held by auto_solib_add
162 (in megabytes). If adding symbols for the new shlib would cause
163 the total size to exceed the threshold, then the new shlib's symbols
166 static LONGEST som_solib_total_st_size;
168 /* When the threshold is reached for any shlib, we refuse to add
169 symbols for subsequent shlibs, even if those shlibs' symbols would
170 be small enough to fit under the threshold. (Although this may
171 result in one, early large shlib preventing the loading of later,
172 smalller shlibs' symbols, it allows us to issue one informational
173 message. The alternative, to issue a message for each shlib whose
174 symbols aren't loaded, could be a big annoyance where the threshold
175 is exceeded due to a very large number of shlibs.)
177 static int som_solib_st_size_threshold_exceeded;
179 /* These addresses should be filled in by som_solib_create_inferior_hook.
180 They are also used elsewhere in this module.
184 struct unwind_table_entry * unwind;
187 /* When adding fields, be sure to clear them in _initialize_som_solib. */
190 addr_and_unwind_t hook;
191 addr_and_unwind_t hook_stub;
192 addr_and_unwind_t load;
193 addr_and_unwind_t load_stub;
194 addr_and_unwind_t unload;
195 addr_and_unwind_t unload2;
196 addr_and_unwind_t unload_stub;
201 static void som_sharedlibrary_info_command PARAMS ((char *, int));
203 static void som_solib_sharedlibrary_command PARAMS ((char *, int));
206 som_solib_sizeof_symbol_table (filename)
211 char * absolute_name;
212 LONGEST st_size = (LONGEST) 0;
215 /* We believe that filename was handed to us by the dynamic linker, and
216 is therefore always an absolute path.
218 desc = openp (getenv ("PATH"), 1, filename, O_RDONLY | O_BINARY, 0, &absolute_name);
221 perror_with_name (filename);
223 filename = absolute_name;
225 abfd = bfd_fdopenr (filename, gnutarget, desc);
229 make_cleanup (free, filename);
230 error ("\"%s\": can't open to read symbols: %s.", filename,
231 bfd_errmsg (bfd_get_error ()));
234 if (!bfd_check_format (abfd, bfd_object)) /* Reads in section info */
236 bfd_close (abfd); /* This also closes desc */
237 make_cleanup (free, filename);
238 error ("\"%s\": can't read symbols: %s.", filename,
239 bfd_errmsg (bfd_get_error ()));
242 /* Sum the sizes of the various sections that compose debug info. */
244 /* This contains non-DOC information. */
245 sect = bfd_get_section_by_name (abfd, "$DEBUG$");
247 st_size += (LONGEST) bfd_section_size (abfd, sect);
249 /* This contains DOC information. */
250 sect = bfd_get_section_by_name (abfd, "$PINFO$");
252 st_size += (LONGEST) bfd_section_size (abfd, sect);
254 bfd_close (abfd); /* This also closes desc */
257 /* Unfortunately, just summing the sizes of various debug info
258 sections isn't a very accurate measurement of how much heap
259 space the debugger will need to hold them. It also doesn't
260 account for space needed by linker (aka "minimal") symbols.
262 Anecdotal evidence suggests that just summing the sizes of
263 debug-info-related sections understates the heap space needed
264 to represent it internally by about an order of magnitude.
266 Since it's not exactly brain surgery we're doing here, rather
267 than attempt to more accurately measure the size of a shlib's
268 symbol table in GDB's heap, we'll just apply a 10x fudge-
269 factor to the debug info sections' size-sum. No, this doesn't
270 account for minimal symbols in non-debuggable shlibs. But it
271 all roughly washes out in the end.
273 return st_size * (LONGEST) 10;
278 som_solib_add_solib_objfile (so, name, from_tty, text_addr)
284 obj_private_data_t *obj_private;
286 so->objfile = symbol_file_add (name, from_tty, text_addr, 0, 0, 0, 0, 1);
287 so->abfd = so->objfile->obfd;
289 /* Mark this as a shared library and save private data.
291 so->objfile->flags |= OBJF_SHARED;
293 if( so->objfile->obj_private == NULL )
295 obj_private = (obj_private_data_t *)
296 obstack_alloc( &so->objfile->psymbol_obstack,
297 sizeof( obj_private_data_t ));
298 obj_private->unwind_info = NULL;
299 obj_private->so_info = NULL;
300 so->objfile->obj_private = (PTR) obj_private;
303 obj_private = (obj_private_data_t *) so->objfile->obj_private;
304 obj_private->so_info = so;
306 if (!bfd_check_format (so->abfd, bfd_object))
308 error ("\"%s\": not in executable format: %s.",
309 name, bfd_errmsg (bfd_get_error ()));
315 som_solib_load_symbols (so, name, from_tty, text_addr, target)
320 struct target_ops * target;
322 struct section_table * p;
325 CORE_ADDR presumed_data_start;
328 printf( "--Adding symbols for shared library \"%s\"\n", name );
331 som_solib_add_solib_objfile (so, name, from_tty, text_addr);
333 /* Now we need to build a section table for this library since
334 we might be debugging a core file from a dynamically linked
335 executable in which the libraries were not privately mapped. */
336 if (build_section_table (so->abfd,
340 error ("Unable to build section table for shared library\n.");
344 /* Relocate all the sections based on where they got loaded. */
345 for (p = so->sections; p < so->sections_end; p++)
347 if (p->the_bfd_section->flags & SEC_CODE)
349 p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT);
350 p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT);
352 else if (p->the_bfd_section->flags & SEC_DATA)
354 p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA);
355 p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA);
359 /* Now see if we need to map in the text and data for this shared
360 library (for example debugging a core file which does not use
361 private shared libraries.).
363 Carefully peek at the first text address in the library. If the
364 read succeeds, then the libraries were privately mapped and were
365 included in the core dump file.
367 If the peek failed, then the libraries were not privately mapped
368 and are not in the core file, we'll have to read them in ourselves. */
369 status = target_read_memory (text_addr, buf, 4);
376 /* We must update the to_sections field in the core_ops structure
377 here, otherwise we dereference a potential dangling pointer
378 for each call to target_read/write_memory within this routine. */
379 update_coreops = core_ops.to_sections == target->to_sections;
381 /* Ditto exec_ops (this was a bug).
383 update_execops = exec_ops.to_sections == target->to_sections;
385 new = so->sections_end - so->sections;
386 /* Add sections from the shared library to the core target. */
387 if (target->to_sections)
389 old = target->to_sections_end - target->to_sections;
390 target->to_sections = (struct section_table *)
391 xrealloc ((char *)target->to_sections,
392 ((sizeof (struct section_table)) * (old + new)));
397 target->to_sections = (struct section_table *)
398 xmalloc ((sizeof (struct section_table)) * new);
400 target->to_sections_end = (target->to_sections + old + new);
402 /* Update the to_sections field in the core_ops structure
403 if needed, ditto exec_ops. */
406 core_ops.to_sections = target->to_sections;
407 core_ops.to_sections_end = target->to_sections_end;
412 exec_ops.to_sections = target->to_sections;
413 exec_ops.to_sections_end = target->to_sections_end;
416 /* Copy over the old data before it gets clobbered. */
417 memcpy ((char *)(target->to_sections + old),
419 ((sizeof (struct section_table)) * new));
424 /* Add symbols from shared libraries into the symtab list, unless the
425 size threshold (specified by auto_solib_add, in megabytes) would
429 som_solib_add (arg_string, from_tty, target)
432 struct target_ops *target;
434 struct minimal_symbol *msymbol;
435 struct so_list *so_list_tail;
437 asection *shlib_info;
439 unsigned int dld_flags;
440 char buf[4], *re_err;
441 int threshold_warning_given = 0;
443 /* First validate our arguments. */
444 if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
446 error ("Invalid regexp: %s", re_err);
449 /* If we're debugging a core file, or have attached to a running
450 process, then som_solib_create_inferior_hook will not have been
453 We need to first determine if we're dealing with a dynamically
454 linked executable. If not, then return without an error or warning.
456 We also need to examine __dld_flags to determine if the shared library
457 list is valid and to determine if the libraries have been privately
459 if (symfile_objfile == NULL)
462 /* First see if the objfile was dynamically linked. */
463 shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
467 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
468 if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
471 msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
474 error ("Unable to find __dld_flags symbol in object file.\n");
478 addr = SYMBOL_VALUE_ADDRESS (msymbol);
479 /* Read the current contents. */
480 status = target_read_memory (addr, buf, 4);
483 error ("Unable to read __dld_flags\n");
486 dld_flags = extract_unsigned_integer (buf, 4);
488 /* __dld_list may not be valid. If not, then we punt, warning the user if
489 we were called as a result of the add-symfile command.
491 if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)
494 error ("__dld_list is not valid according to __dld_flags.\n");
498 /* If the libraries were not mapped private, warn the user. */
499 if ((dld_flags & DLD_FLAGS_MAPPRIVATE) == 0)
500 warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
502 msymbol = lookup_minimal_symbol ("__dld_list", NULL, NULL);
505 /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
506 but the data is still available if you know where to look. */
507 msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
510 error ("Unable to find dynamic library list.\n");
513 addr = SYMBOL_VALUE_ADDRESS (msymbol) - 8;
516 addr = SYMBOL_VALUE_ADDRESS (msymbol);
518 status = target_read_memory (addr, buf, 4);
521 error ("Unable to find dynamic library list.\n");
525 addr = extract_unsigned_integer (buf, 4);
527 /* If addr is zero, then we're using an old dynamic loader which
528 doesn't maintain __dld_list. We'll have to use a completely
529 different approach to get shared library information. */
533 /* Using the information in __dld_list is the preferred method
534 to get at shared library information. It doesn't depend on
535 any functions in /opt/langtools/lib/end.o and has a chance of working
536 with hpux10 when it is released. */
537 status = target_read_memory (addr, buf, 4);
540 error ("Unable to find dynamic library list.\n");
544 /* addr now holds the address of the first entry in the dynamic
546 addr = extract_unsigned_integer (buf, 4);
548 /* Now that we have a pointer to the dynamic library list, walk
549 through it and add the symbols for each library. */
551 so_list_tail = so_list_head;
552 /* Find the end of the list of shared objects. */
553 while (so_list_tail && so_list_tail->next)
554 so_list_tail = so_list_tail->next;
557 printf( "--About to read shared library list data\n" );
560 /* "addr" will always point to the base of the
561 * current data entry describing the current
566 CORE_ADDR name_addr, text_addr;
567 unsigned int name_len;
569 struct so_list *new_so;
570 struct so_list *so_list = so_list_head;
578 /* Get a pointer to the name of this library. */
579 status = target_read_memory (addr, buf, 4);
583 name_addr = extract_unsigned_integer (buf, 4);
587 target_read_memory (name_addr + name_len, buf, 1);
595 name = alloca (name_len);
596 status = target_read_memory (name_addr, name, name_len);
600 /* See if we've already loaded something with this name. */
603 if (!strcmp (so_list->som_solib.name, name))
605 so_list = so_list->next;
608 /* See if the file exists. If not, give a warning, but don't
610 status = stat (name, &statbuf);
613 warning ("Can't find file %s referenced in dld_list.", name);
615 status = target_read_memory (addr + 36, buf, 4);
619 addr = (CORE_ADDR) extract_unsigned_integer (buf, 4);
623 /* If we've already loaded this one or it's the main program, skip it. */
624 is_main_program = (strcmp (name, symfile_objfile->name) == 0);
625 if (so_list || is_main_program)
627 /* This is the "next" pointer in the strcuture.
629 status = target_read_memory (addr + 36, buf, 4);
633 addr = (CORE_ADDR) extract_unsigned_integer (buf, 4);
635 /* Record the main program's symbol table size. */
636 if (is_main_program && !so_list)
638 st_size = som_solib_sizeof_symbol_table (name);
639 som_solib_total_st_size += st_size;
642 /* Was this a shlib that we noted but didn't load the symbols for?
643 If so, were we invoked this time from the command-line, via
644 a 'sharedlibrary' or 'add-symbol-file' command? If yes to
645 both, we'd better load the symbols this time.
647 if (from_tty && so_list && !is_main_program && (so_list->objfile == NULL))
648 som_solib_load_symbols (so_list,
651 so_list->som_solib.text_addr,
657 name = obsavestring (name, name_len - 1,
658 &symfile_objfile->symbol_obstack);
660 status = target_read_memory (addr + 8, buf, 4);
664 text_addr = extract_unsigned_integer (buf, 4);
666 new_so = (struct so_list *) xmalloc (sizeof (struct so_list));
667 memset ((char *)new_so, 0, sizeof (struct so_list));
668 if (so_list_head == NULL)
670 so_list_head = new_so;
671 so_list_tail = new_so;
675 so_list_tail->next = new_so;
676 so_list_tail = new_so;
679 /* Fill in all the entries in GDB's shared library list.
682 new_so->solib_addr = addr;
683 new_so->som_solib.name = name;
684 status = target_read_memory (addr + 4, buf, 4);
688 new_so->som_solib.struct_version = extract_unsigned_integer (buf + 3, 1);
689 new_so->som_solib.bind_mode = extract_unsigned_integer (buf + 2, 1);
690 /* Following is "high water mark", highest version number
691 * seen, rather than plain version number.
693 new_so->som_solib.library_version = extract_unsigned_integer (buf, 2);
694 new_so->som_solib.text_addr = text_addr;
696 /* Q: What about longword at "addr + 8"?
697 * A: It's read above, out of order, into "text_addr".
700 status = target_read_memory (addr + 12, buf, 4);
704 new_so->som_solib.text_link_addr = extract_unsigned_integer (buf, 4);
706 status = target_read_memory (addr + 16, buf, 4);
710 new_so->som_solib.text_end = extract_unsigned_integer (buf, 4);
712 status = target_read_memory (addr + 20, buf, 4);
716 new_so->som_solib.data_start = extract_unsigned_integer (buf, 4);
718 status = target_read_memory (addr + 24, buf, 4);
722 new_so->som_solib.bss_start = extract_unsigned_integer (buf, 4);
724 status = target_read_memory (addr + 28, buf, 4);
728 new_so->som_solib.data_end = extract_unsigned_integer (buf, 4);
730 status = target_read_memory (addr + 32, buf, 4);
734 new_so->som_solib.got_value = extract_unsigned_integer (buf, 4);
736 status = target_read_memory (addr + 36, buf, 4);
740 new_so->som_solib.next = (void *)extract_unsigned_integer (buf, 4);
742 /* Note that we don't re-set "addr" to the next pointer
743 * until after we've read the trailing data.
746 status = target_read_memory (addr + 40, buf, 4);
747 new_so->som_solib.tsd_start_addr = extract_unsigned_integer (buf, 4);
751 /* Now indirect via that value!
753 status = target_read_memory (new_so->som_solib.tsd_start_addr, buf, 4);
754 new_so->som_solib.tsd_start_addr = extract_unsigned_integer (buf, 4);
758 printf( "\n+ library \"%s\" is described at 0x%x\n", name, addr );
759 printf( " 'version' is %d\n", new_so->som_solib.struct_version );
760 printf( " 'bind_mode' is %d\n", new_so->som_solib.bind_mode );
761 printf( " 'library_version' is %d\n", new_so->som_solib.library_version );
762 printf( " 'text_addr' is 0x%x\n", new_so->som_solib.text_addr );
763 printf( " 'text_link_addr' is 0x%x\n", new_so->som_solib.text_link_addr );
764 printf( " 'text_end' is 0x%x\n", new_so->som_solib.text_end );
765 printf( " 'data_start' is 0x%x\n", new_so->som_solib.data_start );
766 printf( " 'bss_start' is 0x%x\n", new_so->som_solib.bss_start );
767 printf( " 'data_end' is 0x%x\n", new_so->som_solib.data_end );
768 printf( " 'got_value' is %x\n", new_so->som_solib.got_value );
769 printf( " 'next' is 0x%x\n", new_so->som_solib.next );
770 printf( " 'tsd_start_addr' is 0x%x\n", new_so->som_solib.tsd_start_addr );
773 /* Go on to the next shared library descriptor.
775 addr = (CORE_ADDR)new_so->som_solib.next;
779 /* At this point, we have essentially hooked the shlib into the
780 "info share" command. However, we haven't yet loaded its
781 symbol table. We must now decide whether we ought to, i.e.,
782 whether doing so would exceed the symbol table size threshold.
784 If the threshold has just now been exceeded, then we'll issue
785 a warning message (which explains how to load symbols manually,
786 if the user so desires).
788 If the threshold has just now or previously been exceeded,
789 we'll just add the shlib to the list of object files, but won't
790 actually load its symbols. (This is more useful than it might
791 sound, for it allows us to e.g., still load and use the shlibs'
792 unwind information for stack tracebacks.)
795 /* Note that we DON'T want to preclude the user from using the
796 add-symbol-file command! Thus, we only worry about the threshold
797 when we're invoked for other reasons.
799 st_size = som_solib_sizeof_symbol_table (name);
800 som_solib_st_size_threshold_exceeded =
802 ((st_size + som_solib_total_st_size) > (auto_solib_add * (LONGEST)1000000));
804 if (som_solib_st_size_threshold_exceeded)
806 if (! threshold_warning_given)
807 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");
808 threshold_warning_given = 1;
810 /* We'll still make note of this shlib, even if we don't
811 read its symbols. This allows us to use its unwind
812 information well enough to know how to e.g., correctly
813 do a traceback from a PC within the shlib, even if we
814 can't symbolize those PCs...
816 som_solib_add_solib_objfile (new_so, name, from_tty, text_addr);
820 som_solib_total_st_size += st_size;
822 /* This fills in new_so->objfile, among others. */
823 som_solib_load_symbols (new_so, name, from_tty, text_addr, target);
827 printf( "--Done reading shared library data\n" );
830 /* Getting new symbols may change our opinion about what is
832 reinit_frame_cache ();
836 error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
840 error ("Error while reading dynamic library list.\n");
845 /* This hook gets called just before the first instruction in the
846 inferior process is executed.
848 This is our opportunity to set magic flags in the inferior so
849 that GDB can be notified when a shared library is mapped in and
850 to tell the dynamic linker that a private copy of the library is
851 needed (so GDB can set breakpoints in the library).
853 __dld_flags is the location of the magic flags; as of this implementation
854 there are 3 flags of interest:
856 bit 0 when set indicates that private copies of the libraries are needed
857 bit 1 when set indicates that the callback hook routine is valid
858 bit 2 when set indicates that the dynamic linker should maintain the
859 __dld_list structure when loading/unloading libraries.
861 Note that shared libraries are not mapped in at this time, so we have
862 run the inferior until the libraries are mapped in. Typically this
863 means running until the "_start" is called. */
866 som_solib_create_inferior_hook()
868 struct minimal_symbol *msymbol;
869 unsigned int dld_flags, status, have_endo;
870 asection *shlib_info;
872 struct objfile *objfile;
875 /* First, remove all the solib event breakpoints. Their addresses
876 may have changed since the last time we ran the program. */
877 remove_solib_event_breakpoints ();
879 if (symfile_objfile == NULL)
882 /* First see if the objfile was dynamically linked. */
883 shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
887 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
888 if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
892 /* Slam the pid of the process into __d_pid; failing is only a warning! */
893 msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
896 warning ("Unable to find __d_pid symbol in object file.");
897 warning ("Suggest linking with /opt/langtools/lib/end.o.");
898 warning ("GDB will be unable to track shl_load/shl_unload calls");
902 anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
903 store_unsigned_integer (buf, 4, inferior_pid);
904 status = target_write_memory (anaddr, buf, 4);
907 warning ("Unable to write __d_pid");
908 warning ("Suggest linking with /opt/langtools/lib/end.o.");
909 warning ("GDB will be unable to track shl_load/shl_unload calls");
913 /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
914 This will force the dynamic linker to call __d_trap when significant
917 Note that the above is the pre-HP-UX 9.0 behaviour. At 9.0 and above,
918 the dld provides an export stub named "__d_trap" as well as the
919 function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
920 We'll look first for the old flavor and then the new.
922 msymbol = lookup_minimal_symbol ("_DLD_HOOK", NULL, symfile_objfile);
924 msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
927 warning ("Unable to find _DLD_HOOK symbol in object file.");
928 warning ("Suggest linking with /opt/langtools/lib/end.o.");
929 warning ("GDB will be unable to track shl_load/shl_unload calls");
932 anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
933 dld_cache.hook.address = anaddr;
935 /* Grrr, this might not be an export symbol! We have to find the
937 ALL_OBJFILES (objfile)
939 struct unwind_table_entry *u;
940 struct minimal_symbol *msymbol2;
943 msymbol2 = lookup_minimal_symbol_solib_trampoline (SYMBOL_NAME (msymbol),
945 /* Found a symbol with the right name. */
948 struct unwind_table_entry *u;
949 /* It must be a shared library trampoline. */
950 if (SYMBOL_TYPE (msymbol2) != mst_solib_trampoline)
953 /* It must also be an export stub. */
954 u = find_unwind_entry (SYMBOL_VALUE (msymbol2));
955 if (!u || u->stub_unwind.stub_type != EXPORT)
958 /* OK. Looks like the correct import stub. */
959 anaddr = SYMBOL_VALUE (msymbol2);
960 dld_cache.hook_stub.address = anaddr;
963 store_unsigned_integer (buf, 4, anaddr);
965 msymbol = lookup_minimal_symbol ("__dld_hook", NULL, symfile_objfile);
968 warning ("Unable to find __dld_hook symbol in object file.");
969 warning ("Suggest linking with /opt/langtools/lib/end.o.");
970 warning ("GDB will be unable to track shl_load/shl_unload calls");
973 anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
974 status = target_write_memory (anaddr, buf, 4);
976 /* Now set a shlib_event breakpoint at __d_trap so we can track
977 significant shared library events. */
978 msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
981 warning ("Unable to find __dld_d_trap symbol in object file.");
982 warning ("Suggest linking with /opt/langtools/lib/end.o.");
983 warning ("GDB will be unable to track shl_load/shl_unload calls");
986 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
988 /* We have all the support usually found in end.o, so we can track
989 shl_load and shl_unload calls. */
994 /* Get the address of __dld_flags, if no such symbol exists, then we can
995 not debug the shared code. */
996 msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
999 error ("Unable to find __dld_flags symbol in object file.\n");
1002 anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
1004 /* Read the current contents. */
1005 status = target_read_memory (anaddr, buf, 4);
1008 error ("Unable to read __dld_flags\n");
1010 dld_flags = extract_unsigned_integer (buf, 4);
1012 /* Turn on the flags we care about. */
1013 dld_flags |= DLD_FLAGS_MAPPRIVATE;
1015 dld_flags |= DLD_FLAGS_HOOKVALID;
1016 store_unsigned_integer (buf, 4, dld_flags);
1017 status = target_write_memory (anaddr, buf, 4);
1020 error ("Unable to write __dld_flags\n");
1023 /* Now find the address of _start and set a breakpoint there.
1024 We still need this code for two reasons:
1026 * Not all sites have /opt/langtools/lib/end.o, so it's not always
1027 possible to track the dynamic linker's events.
1029 * At this time no events are triggered for shared libraries
1030 loaded at startup time (what a crock). */
1032 msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
1033 if (msymbol == NULL)
1035 error ("Unable to find _start symbol in object file.\n");
1038 anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
1040 /* Make the breakpoint at "_start" a shared library event breakpoint. */
1041 create_solib_event_breakpoint (anaddr);
1043 /* Wipe out all knowledge of old shared libraries since their
1044 mapping can change from one exec to another! */
1045 while (so_list_head)
1047 struct so_list *temp;
1049 temp = so_list_head;
1050 free (so_list_head);
1051 so_list_head = temp->next;
1053 clear_symtab_users ();
1058 reset_inferior_pid (saved_inferior_pid)
1059 int saved_inferior_pid;
1061 inferior_pid = saved_inferior_pid;
1065 /* This operation removes the "hook" between GDB and the dynamic linker,
1066 which causes the dld to notify GDB of shared library events.
1068 After this operation completes, the dld will no longer notify GDB of
1069 shared library events. To resume notifications, GDB must call
1070 som_solib_create_inferior_hook.
1072 This operation does not remove any knowledge of shared libraries which
1073 GDB may already have been notified of.
1076 som_solib_remove_inferior_hook (pid)
1080 struct minimal_symbol * msymbol;
1082 char dld_flags_buffer [TARGET_INT_BIT/TARGET_CHAR_BIT];
1083 unsigned int dld_flags_value;
1084 int saved_inferior_pid = inferior_pid;
1085 struct cleanup * old_cleanups = make_cleanup (reset_inferior_pid, saved_inferior_pid);
1087 /* Ensure that we're really operating on the specified process. */
1090 /* We won't bother to remove the solib breakpoints from this process.
1092 In fact, on PA64 the breakpoint is hard-coded into the dld callback,
1093 and thus we're not supposed to remove it.
1095 Rather, we'll merely clear the dld_flags bit that enables callbacks.
1097 msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
1099 addr = SYMBOL_VALUE_ADDRESS (msymbol);
1100 status = target_read_memory (addr, dld_flags_buffer, TARGET_INT_BIT/TARGET_CHAR_BIT);
1102 dld_flags_value = extract_unsigned_integer (dld_flags_buffer,
1103 sizeof (dld_flags_value));
1105 dld_flags_value &= ~DLD_FLAGS_HOOKVALID;
1106 store_unsigned_integer (dld_flags_buffer,
1107 sizeof (dld_flags_value),
1109 status = target_write_memory (addr, dld_flags_buffer, TARGET_INT_BIT/TARGET_CHAR_BIT);
1111 do_cleanups (old_cleanups);
1115 /* This function creates a breakpoint on the dynamic linker hook, which
1116 is called when e.g., a shl_load or shl_unload call is made. This
1117 breakpoint will only trigger when a shl_load call is made.
1119 If filename is NULL, then loads of any dll will be caught. Else,
1120 only loads of the file whose pathname is the string contained by
1121 filename will be caught.
1123 Undefined behaviour is guaranteed if this function is called before
1124 som_solib_create_inferior_hook.
1127 som_solib_create_catch_load_hook (pid, tempflag, filename, cond_string)
1133 create_solib_load_event_breakpoint ("__d_trap", tempflag, filename, cond_string);
1136 /* This function creates a breakpoint on the dynamic linker hook, which
1137 is called when e.g., a shl_load or shl_unload call is made. This
1138 breakpoint will only trigger when a shl_unload call is made.
1140 If filename is NULL, then unloads of any dll will be caught. Else,
1141 only unloads of the file whose pathname is the string contained by
1142 filename will be caught.
1144 Undefined behaviour is guaranteed if this function is called before
1145 som_solib_create_inferior_hook.
1148 som_solib_create_catch_unload_hook (pid, tempflag, filename, cond_string)
1154 create_solib_unload_event_breakpoint ("__d_trap", tempflag, filename, cond_string);
1158 som_solib_have_load_event (pid)
1161 CORE_ADDR event_kind;
1163 event_kind = read_register (ARG0_REGNUM);
1164 return (event_kind == SHL_LOAD);
1168 som_solib_have_unload_event (pid)
1171 CORE_ADDR event_kind;
1173 event_kind = read_register (ARG0_REGNUM);
1174 return (event_kind == SHL_UNLOAD);
1178 som_solib_library_pathname (pid)
1181 CORE_ADDR dll_handle_address;
1182 CORE_ADDR dll_pathname_address;
1183 struct som_solib_mapped_entry dll_descriptor;
1185 static char dll_pathname [1024];
1187 /* Read the descriptor of this newly-loaded library. */
1188 dll_handle_address = read_register (ARG1_REGNUM);
1189 read_memory (dll_handle_address, (char *) &dll_descriptor, sizeof (dll_descriptor));
1191 /* We can find a pointer to the dll's pathname within the descriptor. */
1192 dll_pathname_address = (CORE_ADDR) dll_descriptor.name;
1194 /* Read the pathname, one byte at a time. */
1199 read_memory (dll_pathname_address++, (char *) &b, 1);
1205 return dll_pathname;
1209 som_solib_loaded_library_pathname (pid)
1212 if (! som_solib_have_load_event (pid))
1213 error ("Must have a load event to use this query");
1215 return som_solib_library_pathname (pid);
1219 som_solib_unloaded_library_pathname (pid)
1222 if (! som_solib_have_unload_event (pid))
1223 error ("Must have an unload event to use this query");
1225 return som_solib_library_pathname (pid);
1229 som_solib_desire_dynamic_linker_symbols ()
1231 struct objfile *objfile;
1232 struct unwind_table_entry *u;
1233 struct minimal_symbol * dld_msymbol;
1235 /* Do we already know the value of these symbols? If so, then
1236 we've no work to do.
1238 (If you add clauses to this test, be sure to likewise update the
1239 test within the loop.)
1241 if (dld_cache.is_valid)
1244 ALL_OBJFILES (objfile)
1246 dld_msymbol = lookup_minimal_symbol ("shl_load", NULL, objfile);
1247 if (dld_msymbol != NULL)
1249 dld_cache.load.address = SYMBOL_VALUE (dld_msymbol);
1250 dld_cache.load.unwind = find_unwind_entry (dld_cache.load.address);
1253 dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_load",
1256 if (dld_msymbol != NULL)
1258 if (SYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
1260 u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
1261 if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
1263 dld_cache.load_stub.address = SYMBOL_VALUE (dld_msymbol);
1264 dld_cache.load_stub.unwind = u;
1269 dld_msymbol = lookup_minimal_symbol ("shl_unload", NULL, objfile);
1270 if (dld_msymbol != NULL)
1272 dld_cache.unload.address = SYMBOL_VALUE (dld_msymbol);
1273 dld_cache.unload.unwind = find_unwind_entry (dld_cache.unload.address);
1275 /* ??rehrauer: I'm not sure exactly what this is, but it appears
1276 that on some HPUX 10.x versions, there's two unwind regions to
1277 cover the body of "shl_unload", the second being 4 bytes past
1278 the end of the first. This is a large hack to handle that
1279 case, but since I don't seem to have any legitimate way to
1280 look for this thing via the symbol table...
1282 if (dld_cache.unload.unwind != NULL)
1284 u = find_unwind_entry (dld_cache.unload.unwind->region_end + 4);
1287 dld_cache.unload2.address = u->region_start;
1288 dld_cache.unload2.unwind = u;
1293 dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_unload",
1296 if (dld_msymbol != NULL)
1298 if (SYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
1300 u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
1301 if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
1303 dld_cache.unload_stub.address = SYMBOL_VALUE (dld_msymbol);
1304 dld_cache.unload_stub.unwind = u;
1309 /* Did we find everything we were looking for? If so, stop. */
1310 if ((dld_cache.load.address != NULL) && (dld_cache.load_stub.address != NULL)
1311 && (dld_cache.unload.address != NULL) && (dld_cache.unload_stub.address != NULL))
1313 dld_cache.is_valid = 1;
1318 dld_cache.hook.unwind = find_unwind_entry (dld_cache.hook.address);
1319 dld_cache.hook_stub.unwind = find_unwind_entry (dld_cache.hook_stub.address);
1321 /* We're prepared not to find some of these symbols, which is why
1322 this function is a "desire" operation, and not a "require".
1327 som_solib_in_dynamic_linker (pid, pc)
1331 struct unwind_table_entry * u_pc;
1333 /* Are we in the dld itself?
1335 ??rehrauer: Large hack -- We'll assume that any address in a
1336 shared text region is the dld's text. This would obviously
1337 fall down if the user attached to a process, whose shlibs
1338 weren't mapped to a (writeable) private region. However, in
1339 that case the debugger probably isn't able to set the fundamental
1340 breakpoint in the dld callback anyways, so this hack should be
1343 if ((pc & (CORE_ADDR) 0xc0000000) == (CORE_ADDR) 0xc0000000)
1346 /* Cache the address of some symbols that are part of the dynamic
1347 linker, if not already known.
1349 som_solib_desire_dynamic_linker_symbols ();
1351 /* Are we in the dld callback? Or its export stub? */
1352 u_pc = find_unwind_entry (pc);
1356 if ((u_pc == dld_cache.hook.unwind) || (u_pc == dld_cache.hook_stub.unwind))
1359 /* Or the interface of the dld (i.e., "shl_load" or friends)? */
1360 if ((u_pc == dld_cache.load.unwind)
1361 || (u_pc == dld_cache.unload.unwind)
1362 || (u_pc == dld_cache.unload2.unwind)
1363 || (u_pc == dld_cache.load_stub.unwind)
1364 || (u_pc == dld_cache.unload_stub.unwind))
1367 /* Apparently this address isn't part of the dld's text. */
1372 /* Return the GOT value for the shared library in which ADDR belongs. If
1373 ADDR isn't in any known shared library, return zero. */
1376 som_solib_get_got_by_pc (addr)
1379 struct so_list *so_list = so_list_head;
1380 CORE_ADDR got_value = 0;
1384 if (so_list->som_solib.text_addr <= addr
1385 && so_list->som_solib.text_end > addr)
1387 got_value = so_list->som_solib.got_value;
1390 so_list = so_list->next;
1396 Return the address of the handle of the shared library
1397 in which ADDR belongs. If
1398 ADDR isn't in any known shared library, return zero. */
1399 /* this function is used in hppa_fix_call_dummy in hppa-tdep.c*/
1402 som_solib_get_solib_by_pc (addr)
1405 struct so_list *so_list = so_list_head;
1409 if (so_list->som_solib.text_addr <= addr
1410 && so_list->som_solib.text_end > addr)
1414 so_list = so_list->next;
1417 return so_list->solib_addr;
1424 som_solib_section_offsets (objfile, offsets)
1425 struct objfile *objfile;
1426 struct section_offsets *offsets;
1428 struct so_list *so_list = so_list_head;
1432 /* Oh what a pain! We need the offsets before so_list->objfile
1433 is valid. The BFDs will never match. Make a best guess. */
1434 if (strstr (objfile->name, so_list->som_solib.name))
1436 asection *private_section;
1438 /* The text offset is easy. */
1439 ANOFFSET (offsets, SECT_OFF_TEXT)
1440 = (so_list->som_solib.text_addr
1441 - so_list->som_solib.text_link_addr);
1442 ANOFFSET (offsets, SECT_OFF_RODATA)
1443 = ANOFFSET (offsets, SECT_OFF_TEXT);
1445 /* We should look at presumed_dp in the SOM header, but
1446 that's not easily available. This should be OK though. */
1447 private_section = bfd_get_section_by_name (objfile->obfd,
1449 if (!private_section)
1451 warning ("Unable to find $PRIVATE$ in shared library!");
1452 ANOFFSET (offsets, SECT_OFF_DATA) = 0;
1453 ANOFFSET (offsets, SECT_OFF_BSS) = 0;
1456 ANOFFSET (offsets, SECT_OFF_DATA)
1457 = (so_list->som_solib.data_start - private_section->vma);
1458 ANOFFSET (offsets, SECT_OFF_BSS)
1459 = ANOFFSET (offsets, SECT_OFF_DATA);
1462 so_list = so_list->next;
1467 /* Dump information about all the currently loaded shared libraries. */
1470 som_sharedlibrary_info_command (ignore, from_tty)
1474 struct so_list *so_list = so_list_head;
1476 if (exec_bfd == NULL)
1478 printf_unfiltered ("no exec file.\n");
1482 if (so_list == NULL)
1484 printf_unfiltered ("No shared libraries loaded at this time.\n");
1488 printf_unfiltered ("Shared Object Libraries\n");
1489 printf_unfiltered (" %-12s%-12s%-12s%-12s%-12s%-12s\n",
1490 " flags", " tstart", " tend", " dstart", " dend", " dlt");
1495 flags = so_list->som_solib.struct_version << 24;
1496 flags |= so_list->som_solib.bind_mode << 16;
1497 flags |= so_list->som_solib.library_version;
1498 printf_unfiltered ("%s", so_list->som_solib.name);
1499 if (so_list->objfile == NULL)
1500 printf_unfiltered (" (symbols not loaded)");
1501 printf_unfiltered ("\n");
1502 printf_unfiltered (" %-12s", local_hex_string_custom (flags, "08l"));
1503 printf_unfiltered ("%-12s",
1504 local_hex_string_custom (so_list->som_solib.text_addr, "08l"));
1505 printf_unfiltered ("%-12s",
1506 local_hex_string_custom (so_list->som_solib.text_end, "08l"));
1507 printf_unfiltered ("%-12s",
1508 local_hex_string_custom (so_list->som_solib.data_start, "08l"));
1509 printf_unfiltered ("%-12s",
1510 local_hex_string_custom (so_list->som_solib.data_end, "08l"));
1511 printf_unfiltered ("%-12s\n",
1512 local_hex_string_custom (so_list->som_solib.got_value, "08l"));
1513 so_list = so_list->next;
1518 som_solib_sharedlibrary_command (args, from_tty)
1523 som_solib_add (args, from_tty, (struct target_ops *) 0);
1529 som_solib_address (addr)
1532 struct so_list * so = so_list_head;
1536 /* Is this address within this shlib's text range? If so,
1537 return the shlib's name.
1539 if ((addr >= so->som_solib.text_addr) && (addr <= so->som_solib.text_end))
1540 return so->som_solib.name;
1542 /* Nope, keep looking... */
1546 /* No, we couldn't prove that the address is within a shlib. */
1552 som_solib_restart ()
1554 struct so_list * sl = so_list_head;
1556 /* Before the shlib info vanishes, use it to disable any breakpoints
1557 that may still be active in those shlibs.
1559 disable_breakpoints_in_shlibs (0);
1561 /* Discard all the shlib descriptors.
1565 struct so_list * next_sl = sl->next;
1569 so_list_head = NULL;
1571 som_solib_total_st_size = (LONGEST) 0;
1572 som_solib_st_size_threshold_exceeded = 0;
1574 dld_cache.is_valid = 0;
1576 dld_cache.hook.address = 0;
1577 dld_cache.hook.unwind = NULL;
1579 dld_cache.hook_stub.address = 0;
1580 dld_cache.hook_stub.unwind = NULL;
1582 dld_cache.load.address = 0;
1583 dld_cache.load.unwind = NULL;
1585 dld_cache.load_stub.address = 0;
1586 dld_cache.load_stub.unwind = NULL;
1588 dld_cache.unload.address = 0;
1589 dld_cache.unload.unwind = NULL;
1591 dld_cache.unload2.address = 0;
1592 dld_cache.unload2.unwind = NULL;
1594 dld_cache.unload_stub.address = 0;
1595 dld_cache.unload_stub.unwind = NULL;
1601 _initialize_som_solib ()
1603 add_com ("sharedlibrary", class_files, som_solib_sharedlibrary_command,
1604 "Load shared object library symbols for files matching REGEXP.");
1605 add_info ("sharedlibrary", som_sharedlibrary_info_command,
1606 "Status of loaded shared object libraries.");
1608 (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
1609 (char *) &auto_solib_add,
1610 "Set autoloading size threshold (in megabytes) of shared library symbols.\n\
1611 If nonzero, symbols from all shared object libraries will be loaded\n\
1612 automatically when the inferior begins execution or when the dynamic linker\n\
1613 informs gdb that a new library has been loaded, until the symbol table\n\
1614 of the program and libraries exceeds this threshold.\n\
1615 Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
1619 /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how much
1620 data space a process can use. We ought to be reading MAXDSIZ and
1621 setting auto_solib_add to some large fraction of that value. If
1622 not that, we maybe ought to be setting it smaller than the default
1623 for MAXDSIZ (that being 64Mb, I believe). However, [1] this threshold
1624 is only crudely approximated rather than actually measured, and [2]
1625 50 Mbytes is too small for debugging gdb itself. Thus, the arbitrary
1628 auto_solib_add = 100; /* Megabytes */
1630 som_solib_restart ();
1633 /* Get some HPUX-specific data from a shared lib.
1636 so_lib_thread_start_addr( so )
1639 return so->som_solib.tsd_start_addr;