1 /* Handle HP SOM shared libraries for GDB, the GNU Debugger.
3 Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
4 2003 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Written by the Center for Software Science at the Univerity of Utah
24 and by Cygnus Support. */
35 #include "breakpoint.h"
39 #include "gdb-stabs.h"
44 #include "gdb_assert.h"
52 /* Uncomment this to turn on some debugging output.
55 /* #define SOLIB_DEBUG
58 /* Defined in exec.c; used to prevent dangling pointer bug.
60 extern struct target_ops exec_ops
;
62 /* This lives in hppa-tdep.c. */
63 extern struct unwind_table_entry
*find_unwind_entry (CORE_ADDR pc
);
65 /* These ought to be defined in some public interface, but aren't. They
66 define the meaning of the various bits in the distinguished __dld_flags
67 variable that is declared in every debuggable a.out on HP-UX, and that
68 is shared between the debugger and the dynamic linker.
70 #define DLD_FLAGS_MAPPRIVATE 0x1
71 #define DLD_FLAGS_HOOKVALID 0x2
72 #define DLD_FLAGS_LISTVALID 0x4
73 #define DLD_FLAGS_BOR_ENABLE 0x8
77 * Support for hpux8 dynamic linker. */
79 /* The basic structure which describes a dynamically loaded object. This
80 data structure is private to the dynamic linker and isn't found in
81 any HPUX include file. */
83 struct som_solib_mapped_entry
85 /* The name of the library. */
88 /* Version of this structure (it is expected to change again in hpux10). */
89 unsigned char struct_version
;
91 /* Binding mode for this library. */
92 unsigned char bind_mode
;
94 /* Version of this library. */
95 short library_version
;
97 /* Start of text address,
98 * link-time text location (length of text area),
99 * end of text address. */
101 CORE_ADDR text_link_addr
;
104 /* Start of data, start of bss and end of data. */
105 CORE_ADDR data_start
;
109 /* Value of linkage pointer (%r19). */
113 struct som_solib_mapped_entry
*next
;
115 /* There are other fields, but I don't have information as to what is
116 contained in them. */
118 /* For versions from HPUX-10.30 and up */
120 /* Address in target of offset from thread-local register of
121 * start of this thread's data. I.e., the first thread-local
122 * variable in this shared library starts at *(tsd_start_addr)
123 * from that area pointed to by cr27 (mpsfu_hi).
125 * We do the indirection as soon as we read it, so from then
126 * on it's the offset itself.
128 CORE_ADDR tsd_start_addr
;
130 /* Following this are longwords holding:
132 * ?, ?, ?, ptr to -1, ptr to-1, ptr to lib name (leaf name),
133 * ptr to __data_start, ptr to __data_end
139 /* A structure to keep track of all the known shared objects. */
142 struct som_solib_mapped_entry som_solib
;
143 struct objfile
*objfile
;
145 struct section_table
*sections
;
146 struct section_table
*sections_end
;
147 /* elz: added this field to store the address in target space (in the
148 library) of the library descriptor (handle) which we read into
149 som_solib_mapped_entry structure */
150 CORE_ADDR solib_addr
;
151 struct so_list
*next
;
155 static struct so_list
*so_list_head
;
158 /* This is the cumulative size in bytes of the symbol tables of all
159 shared objects on the so_list_head list. (When we say size, here
160 we mean of the information before it is brought into memory and
161 potentially expanded by GDB.) When adding a new shlib, this value
162 is compared against the threshold size, held by auto_solib_limit
163 (in megabytes). If adding symbols for the new shlib would cause
164 the total size to exceed the threshold, then the new shlib's
165 symbols are not loaded. */
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.
185 struct unwind_table_entry
*unwind
;
189 /* When adding fields, be sure to clear them in _initialize_som_solib. */
193 addr_and_unwind_t hook
;
194 addr_and_unwind_t hook_stub
;
195 addr_and_unwind_t load
;
196 addr_and_unwind_t load_stub
;
197 addr_and_unwind_t unload
;
198 addr_and_unwind_t unload2
;
199 addr_and_unwind_t unload_stub
;
205 static void som_sharedlibrary_info_command (char *, int);
207 static void som_solib_sharedlibrary_command (char *, int);
210 som_solib_sizeof_symbol_table (char *filename
)
215 LONGEST st_size
= (LONGEST
) 0;
218 /* We believe that filename was handed to us by the dynamic linker, and
219 is therefore always an absolute path.
221 desc
= openp (getenv ("PATH"), 1, filename
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
224 perror_with_name (filename
);
226 filename
= absolute_name
;
228 abfd
= bfd_fdopenr (filename
, gnutarget
, desc
);
232 make_cleanup (xfree
, filename
);
233 error ("\"%s\": can't open to read symbols: %s.", filename
,
234 bfd_errmsg (bfd_get_error ()));
237 if (!bfd_check_format (abfd
, bfd_object
)) /* Reads in section info */
239 bfd_close (abfd
); /* This also closes desc */
240 make_cleanup (xfree
, filename
);
241 error ("\"%s\": can't read symbols: %s.", filename
,
242 bfd_errmsg (bfd_get_error ()));
245 /* Sum the sizes of the various sections that compose debug info. */
247 /* This contains non-DOC information. */
248 sect
= bfd_get_section_by_name (abfd
, "$DEBUG$");
250 st_size
+= (LONGEST
) bfd_section_size (abfd
, sect
);
252 /* This contains DOC information. */
253 sect
= bfd_get_section_by_name (abfd
, "$PINFO$");
255 st_size
+= (LONGEST
) bfd_section_size (abfd
, sect
);
257 bfd_close (abfd
); /* This also closes desc */
260 /* Unfortunately, just summing the sizes of various debug info
261 sections isn't a very accurate measurement of how much heap
262 space the debugger will need to hold them. It also doesn't
263 account for space needed by linker (aka "minimal") symbols.
265 Anecdotal evidence suggests that just summing the sizes of
266 debug-info-related sections understates the heap space needed
267 to represent it internally by about an order of magnitude.
269 Since it's not exactly brain surgery we're doing here, rather
270 than attempt to more accurately measure the size of a shlib's
271 symbol table in GDB's heap, we'll just apply a 10x fudge-
272 factor to the debug info sections' size-sum. No, this doesn't
273 account for minimal symbols in non-debuggable shlibs. But it
274 all roughly washes out in the end.
276 return st_size
* (LONGEST
) 10;
281 som_solib_add_solib_objfile (struct so_list
*so
, char *name
, int from_tty
,
284 obj_private_data_t
*obj_private
;
285 struct obj_section
*s
;
287 so
->objfile
= symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
288 so
->abfd
= so
->objfile
->obfd
;
290 /* syms_from_objfile has bizarre section offset code,
291 so I do my own right here. */
292 for (s
= so
->objfile
->sections
; s
< so
->objfile
->sections_end
; s
++)
294 flagword aflag
= bfd_get_section_flags(so
->abfd
, s
->the_bfd_section
);
295 if (aflag
& SEC_CODE
)
297 s
->addr
+= so
->som_solib
.text_addr
- so
->som_solib
.text_link_addr
;
298 s
->endaddr
+= so
->som_solib
.text_addr
- so
->som_solib
.text_link_addr
;
300 else if (aflag
& SEC_DATA
)
302 s
->addr
+= so
->som_solib
.data_start
;
303 s
->endaddr
+= so
->som_solib
.data_start
;
309 /* Mark this as a shared library and save private data.
311 so
->objfile
->flags
|= OBJF_SHARED
;
313 if (so
->objfile
->obj_private
== NULL
)
315 obj_private
= (obj_private_data_t
*)
316 obstack_alloc (&so
->objfile
->psymbol_obstack
,
317 sizeof (obj_private_data_t
));
318 obj_private
->unwind_info
= NULL
;
319 obj_private
->so_info
= NULL
;
320 so
->objfile
->obj_private
= obj_private
;
323 obj_private
= (obj_private_data_t
*) so
->objfile
->obj_private
;
324 obj_private
->so_info
= so
;
326 if (!bfd_check_format (so
->abfd
, bfd_object
))
328 error ("\"%s\": not in executable format: %s.",
329 name
, bfd_errmsg (bfd_get_error ()));
335 som_solib_load_symbols (struct so_list
*so
, char *name
, int from_tty
,
336 CORE_ADDR text_addr
, struct target_ops
*target
)
338 struct section_table
*p
;
341 CORE_ADDR presumed_data_start
;
344 printf ("--Adding symbols for shared library \"%s\"\n", name
);
347 som_solib_add_solib_objfile (so
, name
, from_tty
, text_addr
);
349 /* Now we need to build a section table for this library since
350 we might be debugging a core file from a dynamically linked
351 executable in which the libraries were not privately mapped. */
352 if (build_section_table (so
->abfd
,
356 error ("Unable to build section table for shared library\n.");
360 /* Relocate all the sections based on where they got loaded. */
361 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
363 if (p
->the_bfd_section
->flags
& SEC_CODE
)
365 p
->addr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_TEXT (so
->objfile
));
366 p
->endaddr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_TEXT (so
->objfile
));
368 else if (p
->the_bfd_section
->flags
& SEC_DATA
)
370 p
->addr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_DATA (so
->objfile
));
371 p
->endaddr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_DATA (so
->objfile
));
375 /* Now see if we need to map in the text and data for this shared
376 library (for example debugging a core file which does not use
377 private shared libraries.).
379 Carefully peek at the first text address in the library. If the
380 read succeeds, then the libraries were privately mapped and were
381 included in the core dump file.
383 If the peek failed, then the libraries were not privately mapped
384 and are not in the core file, we'll have to read them in ourselves. */
385 status
= target_read_memory (text_addr
, buf
, 4);
390 new = so
->sections_end
- so
->sections
;
392 old
= target_resize_to_sections (target
, new);
394 /* Copy over the old data before it gets clobbered. */
395 memcpy ((char *) (target
->to_sections
+ old
),
397 ((sizeof (struct section_table
)) * new));
402 /* FIXME: cagney/2003-02-01: This just isn't right. Given an address
403 within the target's address space, this converts the value into an
404 address within the host's (i.e., GDB's) address space. Given that
405 the host/target address spaces are separate, this can't be right. */
408 hpux_address_to_host_pointer_hack (CORE_ADDR addr
)
412 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
413 ADDRESS_TO_POINTER (builtin_type_void_data_ptr
, &ptr
, addr
);
417 /* Add symbols from shared libraries into the symtab list, unless the
418 size threshold specified by auto_solib_limit (in megabytes) would
422 som_solib_add (char *arg_string
, int from_tty
, struct target_ops
*target
, int readsyms
)
424 struct minimal_symbol
*msymbol
;
425 struct so_list
*so_list_tail
;
427 asection
*shlib_info
;
429 unsigned int dld_flags
;
430 char buf
[4], *re_err
;
431 int threshold_warning_given
= 0;
433 /* First validate our arguments. */
434 re_err
= re_comp (arg_string
? arg_string
: ".");
437 error ("Invalid regexp: %s", re_err
);
440 /* If we're debugging a core file, or have attached to a running
441 process, then som_solib_create_inferior_hook will not have been
444 We need to first determine if we're dealing with a dynamically
445 linked executable. If not, then return without an error or warning.
447 We also need to examine __dld_flags to determine if the shared library
448 list is valid and to determine if the libraries have been privately
450 if (symfile_objfile
== NULL
)
453 /* First see if the objfile was dynamically linked. */
454 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
458 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
459 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
462 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
465 error ("Unable to find __dld_flags symbol in object file.\n");
469 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
470 /* Read the current contents. */
471 status
= target_read_memory (addr
, buf
, 4);
474 error ("Unable to read __dld_flags\n");
477 dld_flags
= extract_unsigned_integer (buf
, 4);
479 /* __dld_list may not be valid. If not, then we punt, warning the user if
480 we were called as a result of the add-symfile command.
482 if ((dld_flags
& DLD_FLAGS_LISTVALID
) == 0)
485 error ("__dld_list is not valid according to __dld_flags.\n");
489 /* If the libraries were not mapped private, warn the user. */
490 if ((dld_flags
& DLD_FLAGS_MAPPRIVATE
) == 0)
491 warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
493 msymbol
= lookup_minimal_symbol ("__dld_list", NULL
, NULL
);
496 /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
497 but the data is still available if you know where to look. */
498 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
501 error ("Unable to find dynamic library list.\n");
504 addr
= SYMBOL_VALUE_ADDRESS (msymbol
) - 8;
507 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
509 status
= target_read_memory (addr
, buf
, 4);
512 error ("Unable to find dynamic library list.\n");
516 addr
= extract_unsigned_integer (buf
, 4);
518 /* If addr is zero, then we're using an old dynamic loader which
519 doesn't maintain __dld_list. We'll have to use a completely
520 different approach to get shared library information. */
524 /* Using the information in __dld_list is the preferred method
525 to get at shared library information. It doesn't depend on
526 any functions in /opt/langtools/lib/end.o and has a chance of working
527 with hpux10 when it is released. */
528 status
= target_read_memory (addr
, buf
, 4);
531 error ("Unable to find dynamic library list.\n");
535 /* addr now holds the address of the first entry in the dynamic
537 addr
= extract_unsigned_integer (buf
, 4);
539 /* Now that we have a pointer to the dynamic library list, walk
540 through it and add the symbols for each library. */
542 so_list_tail
= so_list_head
;
543 /* Find the end of the list of shared objects. */
544 while (so_list_tail
&& so_list_tail
->next
)
545 so_list_tail
= so_list_tail
->next
;
548 printf ("--About to read shared library list data\n");
551 /* "addr" will always point to the base of the
552 * current data entry describing the current
557 CORE_ADDR name_addr
, text_addr
;
558 unsigned int name_len
;
560 struct so_list
*new_so
;
561 struct so_list
*so_list
= so_list_head
;
569 /* Get a pointer to the name of this library. */
570 status
= target_read_memory (addr
, buf
, 4);
574 name_addr
= extract_unsigned_integer (buf
, 4);
578 target_read_memory (name_addr
+ name_len
, buf
, 1);
586 name
= alloca (name_len
);
587 status
= target_read_memory (name_addr
, name
, name_len
);
591 /* See if we've already loaded something with this name. */
594 if (!strcmp (so_list
->som_solib
.name
, name
))
596 so_list
= so_list
->next
;
599 /* See if the file exists. If not, give a warning, but don't
601 status
= stat (name
, &statbuf
);
604 warning ("Can't find file %s referenced in dld_list.", name
);
606 status
= target_read_memory (addr
+ 36, buf
, 4);
610 addr
= (CORE_ADDR
) extract_unsigned_integer (buf
, 4);
614 /* If we've already loaded this one or it's the main program, skip it. */
615 is_main_program
= (strcmp (name
, symfile_objfile
->name
) == 0);
616 if (so_list
|| is_main_program
)
618 /* This is the "next" pointer in the strcuture.
620 status
= target_read_memory (addr
+ 36, buf
, 4);
624 addr
= (CORE_ADDR
) extract_unsigned_integer (buf
, 4);
626 /* Record the main program's symbol table size. */
627 if (is_main_program
&& !so_list
)
629 st_size
= som_solib_sizeof_symbol_table (name
);
630 som_solib_total_st_size
+= st_size
;
633 /* Was this a shlib that we noted but didn't load the symbols for?
634 If so, were we invoked this time from the command-line, via
635 a 'sharedlibrary' or 'add-symbol-file' command? If yes to
636 both, we'd better load the symbols this time.
638 if (from_tty
&& so_list
&& !is_main_program
&& (so_list
->objfile
== NULL
))
639 som_solib_load_symbols (so_list
,
642 so_list
->som_solib
.text_addr
,
648 name
= obsavestring (name
, name_len
- 1,
649 &symfile_objfile
->symbol_obstack
);
651 status
= target_read_memory (addr
+ 8, buf
, 4);
655 text_addr
= extract_unsigned_integer (buf
, 4);
657 new_so
= (struct so_list
*) xmalloc (sizeof (struct so_list
));
658 memset ((char *) new_so
, 0, sizeof (struct so_list
));
659 if (so_list_head
== NULL
)
661 so_list_head
= new_so
;
662 so_list_tail
= new_so
;
666 so_list_tail
->next
= new_so
;
667 so_list_tail
= new_so
;
670 /* Fill in all the entries in GDB's shared library list.
673 new_so
->solib_addr
= addr
;
674 new_so
->som_solib
.name
= name
;
675 status
= target_read_memory (addr
+ 4, buf
, 4);
679 new_so
->som_solib
.struct_version
= extract_unsigned_integer (buf
+ 3, 1);
680 new_so
->som_solib
.bind_mode
= extract_unsigned_integer (buf
+ 2, 1);
681 /* Following is "high water mark", highest version number
682 * seen, rather than plain version number.
684 new_so
->som_solib
.library_version
= extract_unsigned_integer (buf
, 2);
685 new_so
->som_solib
.text_addr
= text_addr
;
687 /* Q: What about longword at "addr + 8"?
688 * A: It's read above, out of order, into "text_addr".
691 status
= target_read_memory (addr
+ 12, buf
, 4);
695 new_so
->som_solib
.text_link_addr
= extract_unsigned_integer (buf
, 4);
697 status
= target_read_memory (addr
+ 16, buf
, 4);
701 new_so
->som_solib
.text_end
= extract_unsigned_integer (buf
, 4);
703 status
= target_read_memory (addr
+ 20, buf
, 4);
707 new_so
->som_solib
.data_start
= extract_unsigned_integer (buf
, 4);
709 status
= target_read_memory (addr
+ 24, buf
, 4);
713 new_so
->som_solib
.bss_start
= extract_unsigned_integer (buf
, 4);
715 status
= target_read_memory (addr
+ 28, buf
, 4);
719 new_so
->som_solib
.data_end
= extract_unsigned_integer (buf
, 4);
721 status
= target_read_memory (addr
+ 32, buf
, 4);
725 new_so
->som_solib
.got_value
= extract_unsigned_integer (buf
, 4);
727 status
= target_read_memory (addr
+ 36, buf
, 4);
731 /* FIXME: cagney/2003-02-01: I think som_solib.next should be a
733 new_so
->som_solib
.next
=
734 hpux_address_to_host_pointer_hack (extract_unsigned_integer (buf
, 4));
736 /* Note that we don't re-set "addr" to the next pointer
737 * until after we've read the trailing data.
740 status
= target_read_memory (addr
+ 40, buf
, 4);
741 new_so
->som_solib
.tsd_start_addr
= extract_unsigned_integer (buf
, 4);
745 /* Now indirect via that value!
747 status
= target_read_memory (new_so
->som_solib
.tsd_start_addr
, buf
, 4);
748 new_so
->som_solib
.tsd_start_addr
= extract_unsigned_integer (buf
, 4);
752 printf ("\n+ library \"%s\" is described at 0x%x\n", name
, addr
);
753 printf (" 'version' is %d\n", new_so
->som_solib
.struct_version
);
754 printf (" 'bind_mode' is %d\n", new_so
->som_solib
.bind_mode
);
755 printf (" 'library_version' is %d\n", new_so
->som_solib
.library_version
);
756 printf (" 'text_addr' is 0x%x\n", new_so
->som_solib
.text_addr
);
757 printf (" 'text_link_addr' is 0x%x\n", new_so
->som_solib
.text_link_addr
);
758 printf (" 'text_end' is 0x%x\n", new_so
->som_solib
.text_end
);
759 printf (" 'data_start' is 0x%x\n", new_so
->som_solib
.data_start
);
760 printf (" 'bss_start' is 0x%x\n", new_so
->som_solib
.bss_start
);
761 printf (" 'data_end' is 0x%x\n", new_so
->som_solib
.data_end
);
762 printf (" 'got_value' is %x\n", new_so
->som_solib
.got_value
);
763 printf (" 'next' is 0x%x\n", new_so
->som_solib
.next
);
764 printf (" 'tsd_start_addr' is 0x%x\n", new_so
->som_solib
.tsd_start_addr
);
767 /* Go on to the next shared library descriptor.
769 addr
= (CORE_ADDR
) new_so
->som_solib
.next
;
773 /* At this point, we have essentially hooked the shlib into the
774 "info share" command. However, we haven't yet loaded its
775 symbol table. We must now decide whether we ought to, i.e.,
776 whether doing so would exceed the symbol table size threshold.
778 If the threshold has just now been exceeded, then we'll issue
779 a warning message (which explains how to load symbols manually,
780 if the user so desires).
782 If the threshold has just now or previously been exceeded,
783 we'll just add the shlib to the list of object files, but won't
784 actually load its symbols. (This is more useful than it might
785 sound, for it allows us to e.g., still load and use the shlibs'
786 unwind information for stack tracebacks.)
789 /* Note that we DON'T want to preclude the user from using the
790 add-symbol-file command! Thus, we only worry about the threshold
791 when we're invoked for other reasons.
793 st_size
= som_solib_sizeof_symbol_table (name
);
794 som_solib_st_size_threshold_exceeded
=
796 auto_solib_limit
> 0 &&
798 ((st_size
+ som_solib_total_st_size
) > (auto_solib_limit
* (LONGEST
) (1024 * 1024)));
800 if (som_solib_st_size_threshold_exceeded
)
802 if (!threshold_warning_given
)
803 warning ("Symbols for some libraries have not been loaded, because\ndoing so would exceed the size threshold specified by auto-solib-limit.\nTo manually load symbols, use the 'sharedlibrary' command.\nTo raise the threshold, set auto-solib-limit to a larger value and rerun\nthe program.\n");
804 threshold_warning_given
= 1;
806 /* We'll still make note of this shlib, even if we don't
807 read its symbols. This allows us to use its unwind
808 information well enough to know how to e.g., correctly
809 do a traceback from a PC within the shlib, even if we
810 can't symbolize those PCs...
812 som_solib_add_solib_objfile (new_so
, name
, from_tty
, text_addr
);
816 som_solib_total_st_size
+= st_size
;
818 /* This fills in new_so->objfile, among others. */
819 som_solib_load_symbols (new_so
, name
, from_tty
, text_addr
, target
);
823 printf ("--Done reading shared library data\n");
826 /* Getting new symbols may change our opinion about what is
828 reinit_frame_cache ();
832 error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
836 error ("Error while reading dynamic library list.\n");
841 /* This hook gets called just before the first instruction in the
842 inferior process is executed.
844 This is our opportunity to set magic flags in the inferior so
845 that GDB can be notified when a shared library is mapped in and
846 to tell the dynamic linker that a private copy of the library is
847 needed (so GDB can set breakpoints in the library).
849 __dld_flags is the location of the magic flags; as of this implementation
850 there are 3 flags of interest:
852 bit 0 when set indicates that private copies of the libraries are needed
853 bit 1 when set indicates that the callback hook routine is valid
854 bit 2 when set indicates that the dynamic linker should maintain the
855 __dld_list structure when loading/unloading libraries.
857 Note that shared libraries are not mapped in at this time, so we have
858 run the inferior until the libraries are mapped in. Typically this
859 means running until the "_start" is called. */
862 som_solib_create_inferior_hook (void)
864 struct minimal_symbol
*msymbol
;
865 unsigned int dld_flags
, status
, have_endo
;
866 asection
*shlib_info
;
868 struct objfile
*objfile
;
871 /* First, remove all the solib event breakpoints. Their addresses
872 may have changed since the last time we ran the program. */
873 remove_solib_event_breakpoints ();
875 if (symfile_objfile
== NULL
)
878 /* First see if the objfile was dynamically linked. */
879 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
883 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
884 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
888 /* Slam the pid of the process into __d_pid.
890 We used to warn when this failed, but that warning is only useful
891 on very old HP systems (hpux9 and older). The warnings are an
892 annoyance to users of modern systems and foul up the testsuite as
893 well. As a result, the warnings have been disabled. */
894 msymbol
= lookup_minimal_symbol ("__d_pid", NULL
, symfile_objfile
);
898 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
899 store_unsigned_integer (buf
, 4, PIDGET (inferior_ptid
));
900 status
= target_write_memory (anaddr
, buf
, 4);
903 warning ("Unable to write __d_pid");
904 warning ("Suggest linking with /opt/langtools/lib/end.o.");
905 warning ("GDB will be unable to track shl_load/shl_unload calls");
909 /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
910 This will force the dynamic linker to call __d_trap when significant
913 Note that the above is the pre-HP-UX 9.0 behaviour. At 9.0 and above,
914 the dld provides an export stub named "__d_trap" as well as the
915 function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
916 We'll look first for the old flavor and then the new.
918 msymbol
= lookup_minimal_symbol ("_DLD_HOOK", NULL
, symfile_objfile
);
920 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
923 warning ("Unable to find _DLD_HOOK symbol in object file.");
924 warning ("Suggest linking with /opt/langtools/lib/end.o.");
925 warning ("GDB will be unable to track shl_load/shl_unload calls");
928 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
929 dld_cache
.hook
.address
= anaddr
;
931 /* Grrr, this might not be an export symbol! We have to find the
933 ALL_OBJFILES (objfile
)
935 struct unwind_table_entry
*u
;
936 struct minimal_symbol
*msymbol2
;
939 msymbol2
= lookup_minimal_symbol_solib_trampoline (DEPRECATED_SYMBOL_NAME (msymbol
),
941 /* Found a symbol with the right name. */
944 struct unwind_table_entry
*u
;
945 /* It must be a shared library trampoline. */
946 if (SYMBOL_TYPE (msymbol2
) != mst_solib_trampoline
)
949 /* It must also be an export stub. */
950 u
= find_unwind_entry (SYMBOL_VALUE (msymbol2
));
951 if (!u
|| u
->stub_unwind
.stub_type
!= EXPORT
)
954 /* OK. Looks like the correct import stub. */
955 anaddr
= SYMBOL_VALUE (msymbol2
);
956 dld_cache
.hook_stub
.address
= anaddr
;
959 store_unsigned_integer (buf
, 4, anaddr
);
961 msymbol
= lookup_minimal_symbol ("__dld_hook", NULL
, symfile_objfile
);
964 warning ("Unable to find __dld_hook symbol in object file.");
965 warning ("Suggest linking with /opt/langtools/lib/end.o.");
966 warning ("GDB will be unable to track shl_load/shl_unload calls");
969 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
970 status
= target_write_memory (anaddr
, buf
, 4);
972 /* Now set a shlib_event breakpoint at __d_trap so we can track
973 significant shared library events. */
974 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
977 warning ("Unable to find __dld_d_trap symbol in object file.");
978 warning ("Suggest linking with /opt/langtools/lib/end.o.");
979 warning ("GDB will be unable to track shl_load/shl_unload calls");
982 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
984 /* We have all the support usually found in end.o, so we can track
985 shl_load and shl_unload calls. */
990 /* Get the address of __dld_flags, if no such symbol exists, then we can
991 not debug the shared code. */
992 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
995 error ("Unable to find __dld_flags symbol in object file.\n");
998 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1000 /* Read the current contents. */
1001 status
= target_read_memory (anaddr
, buf
, 4);
1004 error ("Unable to read __dld_flags\n");
1006 dld_flags
= extract_unsigned_integer (buf
, 4);
1008 /* Turn on the flags we care about. */
1009 dld_flags
|= DLD_FLAGS_MAPPRIVATE
;
1011 dld_flags
|= DLD_FLAGS_HOOKVALID
;
1012 store_unsigned_integer (buf
, 4, dld_flags
);
1013 status
= target_write_memory (anaddr
, buf
, 4);
1016 error ("Unable to write __dld_flags\n");
1019 /* Now find the address of _start and set a breakpoint there.
1020 We still need this code for two reasons:
1022 * Not all sites have /opt/langtools/lib/end.o, so it's not always
1023 possible to track the dynamic linker's events.
1025 * At this time no events are triggered for shared libraries
1026 loaded at startup time (what a crock). */
1028 msymbol
= lookup_minimal_symbol ("_start", NULL
, symfile_objfile
);
1029 if (msymbol
== NULL
)
1031 error ("Unable to find _start symbol in object file.\n");
1034 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1036 /* Make the breakpoint at "_start" a shared library event breakpoint. */
1037 create_solib_event_breakpoint (anaddr
);
1039 /* Wipe out all knowledge of old shared libraries since their
1040 mapping can change from one exec to another! */
1041 while (so_list_head
)
1043 struct so_list
*temp
;
1045 temp
= so_list_head
;
1046 xfree (so_list_head
);
1047 so_list_head
= temp
->next
;
1049 clear_symtab_users ();
1052 /* This operation removes the "hook" between GDB and the dynamic linker,
1053 which causes the dld to notify GDB of shared library events.
1055 After this operation completes, the dld will no longer notify GDB of
1056 shared library events. To resume notifications, GDB must call
1057 som_solib_create_inferior_hook.
1059 This operation does not remove any knowledge of shared libraries which
1060 GDB may already have been notified of.
1063 som_solib_remove_inferior_hook (int pid
)
1066 struct minimal_symbol
*msymbol
;
1068 char dld_flags_buffer
[TARGET_INT_BIT
/ TARGET_CHAR_BIT
];
1069 unsigned int dld_flags_value
;
1070 struct cleanup
*old_cleanups
= save_inferior_ptid ();
1072 /* Ensure that we're really operating on the specified process. */
1073 inferior_ptid
= pid_to_ptid (pid
);
1075 /* We won't bother to remove the solib breakpoints from this process.
1077 In fact, on PA64 the breakpoint is hard-coded into the dld callback,
1078 and thus we're not supposed to remove it.
1080 Rather, we'll merely clear the dld_flags bit that enables callbacks.
1082 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
1084 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1085 status
= target_read_memory (addr
, dld_flags_buffer
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
);
1087 dld_flags_value
= extract_unsigned_integer (dld_flags_buffer
,
1088 sizeof (dld_flags_value
));
1090 dld_flags_value
&= ~DLD_FLAGS_HOOKVALID
;
1091 store_unsigned_integer (dld_flags_buffer
,
1092 sizeof (dld_flags_value
),
1094 status
= target_write_memory (addr
, dld_flags_buffer
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
);
1096 do_cleanups (old_cleanups
);
1100 /* This function creates a breakpoint on the dynamic linker hook, which
1101 is called when e.g., a shl_load or shl_unload call is made. This
1102 breakpoint will only trigger when a shl_load call is made.
1104 If filename is NULL, then loads of any dll will be caught. Else,
1105 only loads of the file whose pathname is the string contained by
1106 filename will be caught.
1108 Undefined behaviour is guaranteed if this function is called before
1109 som_solib_create_inferior_hook.
1112 som_solib_create_catch_load_hook (int pid
, int tempflag
, char *filename
,
1115 create_solib_load_event_breakpoint ("__d_trap", tempflag
, filename
, cond_string
);
1118 /* This function creates a breakpoint on the dynamic linker hook, which
1119 is called when e.g., a shl_load or shl_unload call is made. This
1120 breakpoint will only trigger when a shl_unload call is made.
1122 If filename is NULL, then unloads of any dll will be caught. Else,
1123 only unloads of the file whose pathname is the string contained by
1124 filename will be caught.
1126 Undefined behaviour is guaranteed if this function is called before
1127 som_solib_create_inferior_hook.
1130 som_solib_create_catch_unload_hook (int pid
, int tempflag
, char *filename
,
1133 create_solib_unload_event_breakpoint ("__d_trap", tempflag
, filename
, cond_string
);
1137 som_solib_have_load_event (int pid
)
1139 CORE_ADDR event_kind
;
1141 event_kind
= read_register (ARG0_REGNUM
);
1142 return (event_kind
== SHL_LOAD
);
1146 som_solib_have_unload_event (int pid
)
1148 CORE_ADDR event_kind
;
1150 event_kind
= read_register (ARG0_REGNUM
);
1151 return (event_kind
== SHL_UNLOAD
);
1155 som_solib_library_pathname (int pid
)
1157 CORE_ADDR dll_handle_address
;
1158 CORE_ADDR dll_pathname_address
;
1159 struct som_solib_mapped_entry dll_descriptor
;
1161 static char dll_pathname
[1024];
1163 /* Read the descriptor of this newly-loaded library. */
1164 dll_handle_address
= read_register (ARG1_REGNUM
);
1165 read_memory (dll_handle_address
, (char *) &dll_descriptor
, sizeof (dll_descriptor
));
1167 /* We can find a pointer to the dll's pathname within the descriptor. */
1168 dll_pathname_address
= (CORE_ADDR
) dll_descriptor
.name
;
1170 /* Read the pathname, one byte at a time. */
1175 read_memory (dll_pathname_address
++, (char *) &b
, 1);
1181 return dll_pathname
;
1185 som_solib_loaded_library_pathname (int pid
)
1187 if (!som_solib_have_load_event (pid
))
1188 error ("Must have a load event to use this query");
1190 return som_solib_library_pathname (pid
);
1194 som_solib_unloaded_library_pathname (int pid
)
1196 if (!som_solib_have_unload_event (pid
))
1197 error ("Must have an unload event to use this query");
1199 return som_solib_library_pathname (pid
);
1203 som_solib_desire_dynamic_linker_symbols (void)
1205 struct objfile
*objfile
;
1206 struct unwind_table_entry
*u
;
1207 struct minimal_symbol
*dld_msymbol
;
1209 /* Do we already know the value of these symbols? If so, then
1210 we've no work to do.
1212 (If you add clauses to this test, be sure to likewise update the
1213 test within the loop.)
1215 if (dld_cache
.is_valid
)
1218 ALL_OBJFILES (objfile
)
1220 dld_msymbol
= lookup_minimal_symbol ("shl_load", NULL
, objfile
);
1221 if (dld_msymbol
!= NULL
)
1223 dld_cache
.load
.address
= SYMBOL_VALUE (dld_msymbol
);
1224 dld_cache
.load
.unwind
= find_unwind_entry (dld_cache
.load
.address
);
1227 dld_msymbol
= lookup_minimal_symbol_solib_trampoline ("shl_load",
1229 if (dld_msymbol
!= NULL
)
1231 if (SYMBOL_TYPE (dld_msymbol
) == mst_solib_trampoline
)
1233 u
= find_unwind_entry (SYMBOL_VALUE (dld_msymbol
));
1234 if ((u
!= NULL
) && (u
->stub_unwind
.stub_type
== EXPORT
))
1236 dld_cache
.load_stub
.address
= SYMBOL_VALUE (dld_msymbol
);
1237 dld_cache
.load_stub
.unwind
= u
;
1242 dld_msymbol
= lookup_minimal_symbol ("shl_unload", NULL
, objfile
);
1243 if (dld_msymbol
!= NULL
)
1245 dld_cache
.unload
.address
= SYMBOL_VALUE (dld_msymbol
);
1246 dld_cache
.unload
.unwind
= find_unwind_entry (dld_cache
.unload
.address
);
1248 /* ??rehrauer: I'm not sure exactly what this is, but it appears
1249 that on some HPUX 10.x versions, there's two unwind regions to
1250 cover the body of "shl_unload", the second being 4 bytes past
1251 the end of the first. This is a large hack to handle that
1252 case, but since I don't seem to have any legitimate way to
1253 look for this thing via the symbol table...
1255 if (dld_cache
.unload
.unwind
!= NULL
)
1257 u
= find_unwind_entry (dld_cache
.unload
.unwind
->region_end
+ 4);
1260 dld_cache
.unload2
.address
= u
->region_start
;
1261 dld_cache
.unload2
.unwind
= u
;
1266 dld_msymbol
= lookup_minimal_symbol_solib_trampoline ("shl_unload",
1268 if (dld_msymbol
!= NULL
)
1270 if (SYMBOL_TYPE (dld_msymbol
) == mst_solib_trampoline
)
1272 u
= find_unwind_entry (SYMBOL_VALUE (dld_msymbol
));
1273 if ((u
!= NULL
) && (u
->stub_unwind
.stub_type
== EXPORT
))
1275 dld_cache
.unload_stub
.address
= SYMBOL_VALUE (dld_msymbol
);
1276 dld_cache
.unload_stub
.unwind
= u
;
1281 /* Did we find everything we were looking for? If so, stop. */
1282 if ((dld_cache
.load
.address
!= 0)
1283 && (dld_cache
.load_stub
.address
!= 0)
1284 && (dld_cache
.unload
.address
!= 0)
1285 && (dld_cache
.unload_stub
.address
!= 0))
1287 dld_cache
.is_valid
= 1;
1292 dld_cache
.hook
.unwind
= find_unwind_entry (dld_cache
.hook
.address
);
1293 dld_cache
.hook_stub
.unwind
= find_unwind_entry (dld_cache
.hook_stub
.address
);
1295 /* We're prepared not to find some of these symbols, which is why
1296 this function is a "desire" operation, and not a "require".
1301 som_solib_in_dynamic_linker (int pid
, CORE_ADDR pc
)
1303 struct unwind_table_entry
*u_pc
;
1305 /* Are we in the dld itself?
1307 ??rehrauer: Large hack -- We'll assume that any address in a
1308 shared text region is the dld's text. This would obviously
1309 fall down if the user attached to a process, whose shlibs
1310 weren't mapped to a (writeable) private region. However, in
1311 that case the debugger probably isn't able to set the fundamental
1312 breakpoint in the dld callback anyways, so this hack should be
1315 if ((pc
& (CORE_ADDR
) 0xc0000000) == (CORE_ADDR
) 0xc0000000)
1318 /* Cache the address of some symbols that are part of the dynamic
1319 linker, if not already known.
1321 som_solib_desire_dynamic_linker_symbols ();
1323 /* Are we in the dld callback? Or its export stub? */
1324 u_pc
= find_unwind_entry (pc
);
1328 if ((u_pc
== dld_cache
.hook
.unwind
) || (u_pc
== dld_cache
.hook_stub
.unwind
))
1331 /* Or the interface of the dld (i.e., "shl_load" or friends)? */
1332 if ((u_pc
== dld_cache
.load
.unwind
)
1333 || (u_pc
== dld_cache
.unload
.unwind
)
1334 || (u_pc
== dld_cache
.unload2
.unwind
)
1335 || (u_pc
== dld_cache
.load_stub
.unwind
)
1336 || (u_pc
== dld_cache
.unload_stub
.unwind
))
1339 /* Apparently this address isn't part of the dld's text. */
1344 /* Return the GOT value for the shared library in which ADDR belongs. If
1345 ADDR isn't in any known shared library, return zero. */
1348 som_solib_get_got_by_pc (CORE_ADDR addr
)
1350 struct so_list
*so_list
= so_list_head
;
1351 CORE_ADDR got_value
= 0;
1355 if (so_list
->som_solib
.text_addr
<= addr
1356 && so_list
->som_solib
.text_end
> addr
)
1358 got_value
= so_list
->som_solib
.got_value
;
1361 so_list
= so_list
->next
;
1367 Return the address of the handle of the shared library
1368 in which ADDR belongs. If
1369 ADDR isn't in any known shared library, return zero. */
1370 /* this function is used in hppa_fix_call_dummy in hppa-tdep.c */
1373 som_solib_get_solib_by_pc (CORE_ADDR addr
)
1375 struct so_list
*so_list
= so_list_head
;
1379 if (so_list
->som_solib
.text_addr
<= addr
1380 && so_list
->som_solib
.text_end
> addr
)
1384 so_list
= so_list
->next
;
1387 return so_list
->solib_addr
;
1394 som_solib_section_offsets (struct objfile
*objfile
,
1395 struct section_offsets
*offsets
)
1397 struct so_list
*so_list
= so_list_head
;
1401 /* Oh what a pain! We need the offsets before so_list->objfile
1402 is valid. The BFDs will never match. Make a best guess. */
1403 if (strstr (objfile
->name
, so_list
->som_solib
.name
))
1405 asection
*private_section
;
1407 /* The text offset is easy. */
1408 offsets
->offsets
[SECT_OFF_TEXT (objfile
)]
1409 = (so_list
->som_solib
.text_addr
1410 - so_list
->som_solib
.text_link_addr
);
1411 offsets
->offsets
[SECT_OFF_RODATA (objfile
)]
1412 = ANOFFSET (offsets
, SECT_OFF_TEXT (objfile
));
1414 /* We should look at presumed_dp in the SOM header, but
1415 that's not easily available. This should be OK though. */
1416 private_section
= bfd_get_section_by_name (objfile
->obfd
,
1418 if (!private_section
)
1420 warning ("Unable to find $PRIVATE$ in shared library!");
1421 offsets
->offsets
[SECT_OFF_DATA (objfile
)] = 0;
1422 offsets
->offsets
[SECT_OFF_BSS (objfile
)] = 0;
1425 offsets
->offsets
[SECT_OFF_DATA (objfile
)]
1426 = (so_list
->som_solib
.data_start
- private_section
->vma
);
1427 offsets
->offsets
[SECT_OFF_BSS (objfile
)]
1428 = ANOFFSET (offsets
, SECT_OFF_DATA (objfile
));
1431 so_list
= so_list
->next
;
1436 /* Dump information about all the currently loaded shared libraries. */
1439 som_sharedlibrary_info_command (char *ignore
, int from_tty
)
1441 struct so_list
*so_list
= so_list_head
;
1443 if (exec_bfd
== NULL
)
1445 printf_unfiltered ("No executable file.\n");
1449 if (so_list
== NULL
)
1451 printf_unfiltered ("No shared libraries loaded at this time.\n");
1455 printf_unfiltered ("Shared Object Libraries\n");
1456 printf_unfiltered (" %-12s%-12s%-12s%-12s%-12s%-12s\n",
1457 " flags", " tstart", " tend", " dstart", " dend", " dlt");
1462 flags
= so_list
->som_solib
.struct_version
<< 24;
1463 flags
|= so_list
->som_solib
.bind_mode
<< 16;
1464 flags
|= so_list
->som_solib
.library_version
;
1465 printf_unfiltered ("%s", so_list
->som_solib
.name
);
1466 if (so_list
->objfile
== NULL
)
1467 printf_unfiltered (" (symbols not loaded)");
1468 printf_unfiltered ("\n");
1469 printf_unfiltered (" %-12s", local_hex_string_custom (flags
, "08l"));
1470 printf_unfiltered ("%-12s",
1471 local_hex_string_custom (so_list
->som_solib
.text_addr
, "08l"));
1472 printf_unfiltered ("%-12s",
1473 local_hex_string_custom (so_list
->som_solib
.text_end
, "08l"));
1474 printf_unfiltered ("%-12s",
1475 local_hex_string_custom (so_list
->som_solib
.data_start
, "08l"));
1476 printf_unfiltered ("%-12s",
1477 local_hex_string_custom (so_list
->som_solib
.data_end
, "08l"));
1478 printf_unfiltered ("%-12s\n",
1479 local_hex_string_custom (so_list
->som_solib
.got_value
, "08l"));
1480 so_list
= so_list
->next
;
1485 som_solib_sharedlibrary_command (char *args
, int from_tty
)
1488 som_solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1494 som_solib_address (CORE_ADDR addr
)
1496 struct so_list
*so
= so_list_head
;
1500 /* Is this address within this shlib's text range? If so,
1501 return the shlib's name.
1503 if ((addr
>= so
->som_solib
.text_addr
) && (addr
<= so
->som_solib
.text_end
))
1504 return so
->som_solib
.name
;
1506 /* Nope, keep looking... */
1510 /* No, we couldn't prove that the address is within a shlib. */
1516 som_solib_restart (void)
1518 struct so_list
*sl
= so_list_head
;
1520 /* Before the shlib info vanishes, use it to disable any breakpoints
1521 that may still be active in those shlibs.
1523 disable_breakpoints_in_shlibs (0);
1525 /* Discard all the shlib descriptors.
1529 struct so_list
*next_sl
= sl
->next
;
1533 so_list_head
= NULL
;
1535 som_solib_total_st_size
= (LONGEST
) 0;
1536 som_solib_st_size_threshold_exceeded
= 0;
1538 dld_cache
.is_valid
= 0;
1540 dld_cache
.hook
.address
= 0;
1541 dld_cache
.hook
.unwind
= NULL
;
1543 dld_cache
.hook_stub
.address
= 0;
1544 dld_cache
.hook_stub
.unwind
= NULL
;
1546 dld_cache
.load
.address
= 0;
1547 dld_cache
.load
.unwind
= NULL
;
1549 dld_cache
.load_stub
.address
= 0;
1550 dld_cache
.load_stub
.unwind
= NULL
;
1552 dld_cache
.unload
.address
= 0;
1553 dld_cache
.unload
.unwind
= NULL
;
1555 dld_cache
.unload2
.address
= 0;
1556 dld_cache
.unload2
.unwind
= NULL
;
1558 dld_cache
.unload_stub
.address
= 0;
1559 dld_cache
.unload_stub
.unwind
= NULL
;
1565 no_shared_libraries -- handle command to explicitly discard symbols
1566 from shared libraries.
1570 Implements the command "nosharedlibrary", which discards symbols
1571 that have been auto-loaded from shared libraries. Symbols from
1572 shared libraries that were added by explicit request of the user
1573 are not discarded. Also called from remote.c. */
1576 no_shared_libraries (char *ignored
, int from_tty
)
1583 _initialize_som_solib (void)
1585 add_com ("sharedlibrary", class_files
, som_solib_sharedlibrary_command
,
1586 "Load shared object library symbols for files matching REGEXP.");
1587 add_info ("sharedlibrary", som_sharedlibrary_info_command
,
1588 "Status of loaded shared object libraries.");
1591 (add_set_cmd ("auto-solib-add", class_support
, var_boolean
,
1592 (char *) &auto_solib_add
,
1593 "Set autoloading of shared library symbols.\n\
1594 If \"on\", symbols from all shared object libraries will be loaded\n\
1595 automatically when the inferior begins execution, when the dynamic linker\n\
1596 informs gdb that a new library has been loaded, or when attaching to the\n\
1597 inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
1602 (add_set_cmd ("auto-solib-limit", class_support
, var_zinteger
,
1603 (char *) &auto_solib_limit
,
1604 "Set threshold (in Mb) for autoloading shared library symbols.\n\
1605 When shared library autoloading is enabled, new libraries will be loaded\n\
1606 only until the total size of shared library symbols exceeds this\n\
1607 threshold in megabytes. Is ignored when using `sharedlibrary'.",
1611 /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how
1612 much data space a process can use. We ought to be reading
1613 MAXDSIZ and setting auto_solib_limit to some large fraction of
1614 that value. If not that, we maybe ought to be setting it smaller
1615 than the default for MAXDSIZ (that being 64Mb, I believe).
1616 However, [1] this threshold is only crudely approximated rather
1617 than actually measured, and [2] 50 Mbytes is too small for
1618 debugging gdb itself. Thus, the arbitrary 100 figure. */
1619 auto_solib_limit
= 100; /* Megabytes */
1621 som_solib_restart ();
1624 /* Get some HPUX-specific data from a shared lib.
1627 so_lib_thread_start_addr (struct so_list
*so
)
1629 return so
->som_solib
.tsd_start_addr
;