1 /* Handle HP SOM shared libraries for GDB, the GNU Debugger.
3 Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004 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"
46 #include "hppa-tdep.h"
62 /* Uncomment this to turn on some debugging output.
65 /* #define SOLIB_DEBUG
68 /* This lives in hppa-tdep.c. */
69 extern struct unwind_table_entry
*find_unwind_entry (CORE_ADDR pc
);
71 /* These ought to be defined in some public interface, but aren't. They
72 define the meaning of the various bits in the distinguished __dld_flags
73 variable that is declared in every debuggable a.out on HP-UX, and that
74 is shared between the debugger and the dynamic linker.
76 #define DLD_FLAGS_MAPPRIVATE 0x1
77 #define DLD_FLAGS_HOOKVALID 0x2
78 #define DLD_FLAGS_LISTVALID 0x4
79 #define DLD_FLAGS_BOR_ENABLE 0x8
83 * Support for hpux8 dynamic linker. */
85 /* The basic structure which describes a dynamically loaded object. This
86 data structure is private to the dynamic linker and isn't found in
87 any HPUX include file. */
89 struct som_solib_mapped_entry
91 /* The name of the library. */
94 /* Version of this structure (it is expected to change again in hpux10). */
95 unsigned char struct_version
;
97 /* Binding mode for this library. */
98 unsigned char bind_mode
;
100 /* Version of this library. */
101 short library_version
;
103 /* Start of text address,
104 * link-time text location (length of text area),
105 * end of text address. */
107 CORE_ADDR text_link_addr
;
110 /* Start of data, start of bss and end of data. */
111 CORE_ADDR data_start
;
115 /* Value of linkage pointer (%r19). */
119 struct som_solib_mapped_entry
*next
;
121 /* There are other fields, but I don't have information as to what is
122 contained in them. */
124 /* For versions from HPUX-10.30 and up */
126 /* Address in target of offset from thread-local register of
127 * start of this thread's data. I.e., the first thread-local
128 * variable in this shared library starts at *(tsd_start_addr)
129 * from that area pointed to by cr27 (mpsfu_hi).
131 * We do the indirection as soon as we read it, so from then
132 * on it's the offset itself.
134 CORE_ADDR tsd_start_addr
;
136 /* Following this are longwords holding:
138 * ?, ?, ?, ptr to -1, ptr to-1, ptr to lib name (leaf name),
139 * ptr to __data_start, ptr to __data_end
145 /* A structure to keep track of all the known shared objects. */
148 struct som_solib_mapped_entry som_solib
;
149 struct objfile
*objfile
;
151 struct section_table
*sections
;
152 struct section_table
*sections_end
;
153 /* elz: added this field to store the address in target space (in the
154 library) of the library descriptor (handle) which we read into
155 som_solib_mapped_entry structure */
156 CORE_ADDR solib_addr
;
157 struct so_list
*next
;
161 static struct so_list
*so_list_head
;
164 /* This is the cumulative size in bytes of the symbol tables of all
165 shared objects on the so_list_head list. (When we say size, here
166 we mean of the information before it is brought into memory and
167 potentially expanded by GDB.) When adding a new shlib, this value
168 is compared against the threshold size, held by auto_solib_limit
169 (in megabytes). If adding symbols for the new shlib would cause
170 the total size to exceed the threshold, then the new shlib's
171 symbols are not loaded. */
172 static LONGEST som_solib_total_st_size
;
174 /* When the threshold is reached for any shlib, we refuse to add
175 symbols for subsequent shlibs, even if those shlibs' symbols would
176 be small enough to fit under the threshold. (Although this may
177 result in one, early large shlib preventing the loading of later,
178 smalller shlibs' symbols, it allows us to issue one informational
179 message. The alternative, to issue a message for each shlib whose
180 symbols aren't loaded, could be a big annoyance where the threshold
181 is exceeded due to a very large number of shlibs.)
183 static int som_solib_st_size_threshold_exceeded
;
185 /* These addresses should be filled in by som_solib_create_inferior_hook.
186 They are also used elsewhere in this module.
191 struct unwind_table_entry
*unwind
;
195 /* When adding fields, be sure to clear them in _initialize_som_solib. */
199 addr_and_unwind_t hook
;
200 addr_and_unwind_t hook_stub
;
201 addr_and_unwind_t load
;
202 addr_and_unwind_t load_stub
;
203 addr_and_unwind_t unload
;
204 addr_and_unwind_t unload2
;
205 addr_and_unwind_t unload_stub
;
211 static void som_sharedlibrary_info_command (char *, int);
213 static void som_solib_sharedlibrary_command (char *, int);
216 som_solib_sizeof_symbol_table (char *filename
)
221 LONGEST st_size
= (LONGEST
) 0;
224 /* We believe that filename was handed to us by the dynamic linker, and
225 is therefore always an absolute path.
227 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, filename
,
228 O_RDONLY
| O_BINARY
, 0, &absolute_name
);
231 perror_with_name (filename
);
233 filename
= absolute_name
;
235 abfd
= bfd_fdopenr (filename
, gnutarget
, desc
);
239 make_cleanup (xfree
, filename
);
240 error ("\"%s\": can't open to read symbols: %s.", filename
,
241 bfd_errmsg (bfd_get_error ()));
244 if (!bfd_check_format (abfd
, bfd_object
)) /* Reads in section info */
246 bfd_close (abfd
); /* This also closes desc */
247 make_cleanup (xfree
, filename
);
248 error ("\"%s\": can't read symbols: %s.", filename
,
249 bfd_errmsg (bfd_get_error ()));
252 /* Sum the sizes of the various sections that compose debug info. */
254 /* This contains non-DOC information. */
255 sect
= bfd_get_section_by_name (abfd
, "$DEBUG$");
257 st_size
+= (LONGEST
) bfd_section_size (abfd
, sect
);
259 /* This contains DOC information. */
260 sect
= bfd_get_section_by_name (abfd
, "$PINFO$");
262 st_size
+= (LONGEST
) bfd_section_size (abfd
, sect
);
264 bfd_close (abfd
); /* This also closes desc */
267 /* Unfortunately, just summing the sizes of various debug info
268 sections isn't a very accurate measurement of how much heap
269 space the debugger will need to hold them. It also doesn't
270 account for space needed by linker (aka "minimal") symbols.
272 Anecdotal evidence suggests that just summing the sizes of
273 debug-info-related sections understates the heap space needed
274 to represent it internally by about an order of magnitude.
276 Since it's not exactly brain surgery we're doing here, rather
277 than attempt to more accurately measure the size of a shlib's
278 symbol table in GDB's heap, we'll just apply a 10x fudge-
279 factor to the debug info sections' size-sum. No, this doesn't
280 account for minimal symbols in non-debuggable shlibs. But it
281 all roughly washes out in the end.
283 return st_size
* (LONGEST
) 10;
288 som_solib_add_solib_objfile (struct so_list
*so
, char *name
, int from_tty
,
291 struct hppa_objfile_private
*obj_private
;
292 struct obj_section
*s
;
294 so
->objfile
= symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
295 so
->abfd
= so
->objfile
->obfd
;
297 /* syms_from_objfile has bizarre section offset code,
298 so I do my own right here. */
299 for (s
= so
->objfile
->sections
; s
< so
->objfile
->sections_end
; s
++)
301 flagword aflag
= bfd_get_section_flags(so
->abfd
, s
->the_bfd_section
);
302 if (aflag
& SEC_CODE
)
304 s
->addr
+= so
->som_solib
.text_addr
- so
->som_solib
.text_link_addr
;
305 s
->endaddr
+= so
->som_solib
.text_addr
- so
->som_solib
.text_link_addr
;
307 else if (aflag
& SEC_DATA
)
309 s
->addr
+= so
->som_solib
.data_start
;
310 s
->endaddr
+= so
->som_solib
.data_start
;
316 /* Mark this as a shared library and save private data.
318 so
->objfile
->flags
|= OBJF_SHARED
;
320 obj_private
= (struct hppa_objfile_private
*)
321 objfile_data (so
->objfile
, hppa_objfile_priv_data
);
322 if (obj_private
== NULL
)
324 obj_private
= (struct hppa_objfile_private
*)
325 obstack_alloc (&so
->objfile
->objfile_obstack
,
326 sizeof (struct hppa_objfile_private
));
327 set_objfile_data (so
->objfile
, hppa_objfile_priv_data
, obj_private
);
328 obj_private
->unwind_info
= NULL
;
329 obj_private
->so_info
= NULL
;
332 obj_private
->so_info
= so
;
334 if (!bfd_check_format (so
->abfd
, bfd_object
))
336 error ("\"%s\": not in executable format: %s.",
337 name
, bfd_errmsg (bfd_get_error ()));
343 som_solib_load_symbols (struct so_list
*so
, char *name
, int from_tty
,
344 CORE_ADDR text_addr
, struct target_ops
*target
)
346 struct section_table
*p
;
349 CORE_ADDR presumed_data_start
;
352 printf ("--Adding symbols for shared library \"%s\"\n", name
);
355 som_solib_add_solib_objfile (so
, name
, from_tty
, text_addr
);
357 /* Now we need to build a section table for this library since
358 we might be debugging a core file from a dynamically linked
359 executable in which the libraries were not privately mapped. */
360 if (build_section_table (so
->abfd
,
364 error ("Unable to build section table for shared library\n.");
368 /* Relocate all the sections based on where they got loaded. */
369 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
371 if (p
->the_bfd_section
->flags
& SEC_CODE
)
373 p
->addr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_TEXT (so
->objfile
));
374 p
->endaddr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_TEXT (so
->objfile
));
376 else if (p
->the_bfd_section
->flags
& SEC_DATA
)
378 p
->addr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_DATA (so
->objfile
));
379 p
->endaddr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_DATA (so
->objfile
));
383 /* Now see if we need to map in the text and data for this shared
384 library (for example debugging a core file which does not use
385 private shared libraries.).
387 Carefully peek at the first text address in the library. If the
388 read succeeds, then the libraries were privately mapped and were
389 included in the core dump file.
391 If the peek failed, then the libraries were not privately mapped
392 and are not in the core file, we'll have to read them in ourselves. */
393 status
= target_read_memory (text_addr
, buf
, 4);
398 new = so
->sections_end
- so
->sections
;
400 old
= target_resize_to_sections (target
, new);
402 /* Copy over the old data before it gets clobbered. */
403 memcpy ((char *) (target
->to_sections
+ old
),
405 ((sizeof (struct section_table
)) * new));
410 /* FIXME: cagney/2003-02-01: This just isn't right. Given an address
411 within the target's address space, this converts the value into an
412 address within the host's (i.e., GDB's) address space. Given that
413 the host/target address spaces are separate, this can't be right. */
416 hpux_address_to_host_pointer_hack (CORE_ADDR addr
)
420 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
421 ADDRESS_TO_POINTER (builtin_type_void_data_ptr
, &ptr
, addr
);
425 /* Add symbols from shared libraries into the symtab list, unless the
426 size threshold specified by auto_solib_limit (in megabytes) would
430 som_solib_add (char *arg_string
, int from_tty
, struct target_ops
*target
, int readsyms
)
432 struct minimal_symbol
*msymbol
;
433 struct so_list
*so_list_tail
;
435 asection
*shlib_info
;
437 unsigned int dld_flags
;
438 char buf
[4], *re_err
;
439 int threshold_warning_given
= 0;
441 /* First validate our arguments. */
442 re_err
= re_comp (arg_string
? arg_string
: ".");
445 error ("Invalid regexp: %s", re_err
);
448 /* If we're debugging a core file, or have attached to a running
449 process, then som_solib_create_inferior_hook will not have been
452 We need to first determine if we're dealing with a dynamically
453 linked executable. If not, then return without an error or warning.
455 We also need to examine __dld_flags to determine if the shared library
456 list is valid and to determine if the libraries have been privately
458 if (symfile_objfile
== NULL
)
461 /* First see if the objfile was dynamically linked. */
462 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
466 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
467 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
470 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
473 error ("Unable to find __dld_flags symbol in object file.\n");
477 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
478 /* Read the current contents. */
479 status
= target_read_memory (addr
, buf
, 4);
482 error ("Unable to read __dld_flags\n");
485 dld_flags
= extract_unsigned_integer (buf
, 4);
487 /* __dld_list may not be valid. If not, then we punt, warning the user if
488 we were called as a result of the add-symfile command.
490 if ((dld_flags
& DLD_FLAGS_LISTVALID
) == 0)
493 error ("__dld_list is not valid according to __dld_flags.\n");
497 /* If the libraries were not mapped private, warn the user. */
498 if ((dld_flags
& DLD_FLAGS_MAPPRIVATE
) == 0)
499 warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
501 msymbol
= lookup_minimal_symbol ("__dld_list", NULL
, NULL
);
504 /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
505 but the data is still available if you know where to look. */
506 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
509 error ("Unable to find dynamic library list.\n");
512 addr
= SYMBOL_VALUE_ADDRESS (msymbol
) - 8;
515 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
517 status
= target_read_memory (addr
, buf
, 4);
520 error ("Unable to find dynamic library list.\n");
524 addr
= extract_unsigned_integer (buf
, 4);
526 /* If addr is zero, then we're using an old dynamic loader which
527 doesn't maintain __dld_list. We'll have to use a completely
528 different approach to get shared library information. */
532 /* Using the information in __dld_list is the preferred method
533 to get at shared library information. It doesn't depend on
534 any functions in /opt/langtools/lib/end.o and has a chance of working
535 with hpux10 when it is released. */
536 status
= target_read_memory (addr
, buf
, 4);
539 error ("Unable to find dynamic library list.\n");
543 /* addr now holds the address of the first entry in the dynamic
545 addr
= extract_unsigned_integer (buf
, 4);
547 /* Now that we have a pointer to the dynamic library list, walk
548 through it and add the symbols for each library. */
550 so_list_tail
= so_list_head
;
551 /* Find the end of the list of shared objects. */
552 while (so_list_tail
&& so_list_tail
->next
)
553 so_list_tail
= so_list_tail
->next
;
556 printf ("--About to read shared library list data\n");
559 /* "addr" will always point to the base of the
560 * current data entry describing the current
565 CORE_ADDR name_addr
, text_addr
;
566 unsigned int name_len
;
568 struct so_list
*new_so
;
569 struct so_list
*so_list
= so_list_head
;
577 /* Get a pointer to the name of this library. */
578 status
= target_read_memory (addr
, buf
, 4);
582 name_addr
= extract_unsigned_integer (buf
, 4);
586 target_read_memory (name_addr
+ name_len
, buf
, 1);
594 name
= alloca (name_len
);
595 status
= target_read_memory (name_addr
, name
, name_len
);
599 /* See if we've already loaded something with this name. */
602 if (!strcmp (so_list
->som_solib
.name
, name
))
604 so_list
= so_list
->next
;
607 /* See if the file exists. If not, give a warning, but don't
609 status
= stat (name
, &statbuf
);
612 warning ("Can't find file %s referenced in dld_list.", name
);
614 status
= target_read_memory (addr
+ 36, buf
, 4);
618 addr
= (CORE_ADDR
) extract_unsigned_integer (buf
, 4);
622 /* If we've already loaded this one or it's the main program, skip it. */
623 is_main_program
= (strcmp (name
, symfile_objfile
->name
) == 0);
624 if (so_list
|| is_main_program
)
626 /* This is the "next" pointer in the strcuture.
628 status
= target_read_memory (addr
+ 36, buf
, 4);
632 addr
= (CORE_ADDR
) extract_unsigned_integer (buf
, 4);
634 /* Record the main program's symbol table size. */
635 if (is_main_program
&& !so_list
)
637 st_size
= som_solib_sizeof_symbol_table (name
);
638 som_solib_total_st_size
+= st_size
;
641 /* Was this a shlib that we noted but didn't load the symbols for?
642 If so, were we invoked this time from the command-line, via
643 a 'sharedlibrary' or 'add-symbol-file' command? If yes to
644 both, we'd better load the symbols this time.
646 if (from_tty
&& so_list
&& !is_main_program
&& (so_list
->objfile
== NULL
))
647 som_solib_load_symbols (so_list
,
650 so_list
->som_solib
.text_addr
,
656 name
= obsavestring (name
, name_len
- 1,
657 &symfile_objfile
->objfile_obstack
);
659 status
= target_read_memory (addr
+ 8, buf
, 4);
663 text_addr
= extract_unsigned_integer (buf
, 4);
665 new_so
= (struct so_list
*) xmalloc (sizeof (struct so_list
));
666 memset ((char *) new_so
, 0, sizeof (struct so_list
));
667 if (so_list_head
== NULL
)
669 so_list_head
= new_so
;
670 so_list_tail
= new_so
;
674 so_list_tail
->next
= new_so
;
675 so_list_tail
= new_so
;
678 /* Fill in all the entries in GDB's shared library list.
681 new_so
->solib_addr
= addr
;
682 new_so
->som_solib
.name
= name
;
683 status
= target_read_memory (addr
+ 4, buf
, 4);
687 new_so
->som_solib
.struct_version
= extract_unsigned_integer (buf
+ 3, 1);
688 new_so
->som_solib
.bind_mode
= extract_unsigned_integer (buf
+ 2, 1);
689 /* Following is "high water mark", highest version number
690 * seen, rather than plain version number.
692 new_so
->som_solib
.library_version
= extract_unsigned_integer (buf
, 2);
693 new_so
->som_solib
.text_addr
= text_addr
;
695 /* Q: What about longword at "addr + 8"?
696 * A: It's read above, out of order, into "text_addr".
699 status
= target_read_memory (addr
+ 12, buf
, 4);
703 new_so
->som_solib
.text_link_addr
= extract_unsigned_integer (buf
, 4);
705 status
= target_read_memory (addr
+ 16, buf
, 4);
709 new_so
->som_solib
.text_end
= extract_unsigned_integer (buf
, 4);
711 status
= target_read_memory (addr
+ 20, buf
, 4);
715 new_so
->som_solib
.data_start
= extract_unsigned_integer (buf
, 4);
717 status
= target_read_memory (addr
+ 24, buf
, 4);
721 new_so
->som_solib
.bss_start
= extract_unsigned_integer (buf
, 4);
723 status
= target_read_memory (addr
+ 28, buf
, 4);
727 new_so
->som_solib
.data_end
= extract_unsigned_integer (buf
, 4);
729 status
= target_read_memory (addr
+ 32, buf
, 4);
733 new_so
->som_solib
.got_value
= extract_unsigned_integer (buf
, 4);
735 status
= target_read_memory (addr
+ 36, buf
, 4);
739 /* FIXME: cagney/2003-02-01: I think som_solib.next should be a
741 new_so
->som_solib
.next
=
742 hpux_address_to_host_pointer_hack (extract_unsigned_integer (buf
, 4));
744 /* Note that we don't re-set "addr" to the next pointer
745 * until after we've read the trailing data.
748 status
= target_read_memory (addr
+ 40, buf
, 4);
749 new_so
->som_solib
.tsd_start_addr
= extract_unsigned_integer (buf
, 4);
753 /* Now indirect via that value!
755 status
= target_read_memory (new_so
->som_solib
.tsd_start_addr
, buf
, 4);
756 new_so
->som_solib
.tsd_start_addr
= extract_unsigned_integer (buf
, 4);
760 printf ("\n+ library \"%s\" is described at 0x%x\n", name
, addr
);
761 printf (" 'version' is %d\n", new_so
->som_solib
.struct_version
);
762 printf (" 'bind_mode' is %d\n", new_so
->som_solib
.bind_mode
);
763 printf (" 'library_version' is %d\n", new_so
->som_solib
.library_version
);
764 printf (" 'text_addr' is 0x%x\n", new_so
->som_solib
.text_addr
);
765 printf (" 'text_link_addr' is 0x%x\n", new_so
->som_solib
.text_link_addr
);
766 printf (" 'text_end' is 0x%x\n", new_so
->som_solib
.text_end
);
767 printf (" 'data_start' is 0x%x\n", new_so
->som_solib
.data_start
);
768 printf (" 'bss_start' is 0x%x\n", new_so
->som_solib
.bss_start
);
769 printf (" 'data_end' is 0x%x\n", new_so
->som_solib
.data_end
);
770 printf (" 'got_value' is %x\n", new_so
->som_solib
.got_value
);
771 printf (" 'next' is 0x%x\n", new_so
->som_solib
.next
);
772 printf (" 'tsd_start_addr' is 0x%x\n", new_so
->som_solib
.tsd_start_addr
);
775 /* Go on to the next shared library descriptor.
777 addr
= (CORE_ADDR
) new_so
->som_solib
.next
;
781 /* At this point, we have essentially hooked the shlib into the
782 "info share" command. However, we haven't yet loaded its
783 symbol table. We must now decide whether we ought to, i.e.,
784 whether doing so would exceed the symbol table size threshold.
786 If the threshold has just now been exceeded, then we'll issue
787 a warning message (which explains how to load symbols manually,
788 if the user so desires).
790 If the threshold has just now or previously been exceeded,
791 we'll just add the shlib to the list of object files, but won't
792 actually load its symbols. (This is more useful than it might
793 sound, for it allows us to e.g., still load and use the shlibs'
794 unwind information for stack tracebacks.)
797 /* Note that we DON'T want to preclude the user from using the
798 add-symbol-file command! Thus, we only worry about the threshold
799 when we're invoked for other reasons.
801 st_size
= som_solib_sizeof_symbol_table (name
);
802 som_solib_st_size_threshold_exceeded
=
804 auto_solib_limit
> 0 &&
806 ((st_size
+ som_solib_total_st_size
) > (auto_solib_limit
* (LONGEST
) (1024 * 1024)));
808 if (som_solib_st_size_threshold_exceeded
)
810 if (!threshold_warning_given
)
811 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");
812 threshold_warning_given
= 1;
814 /* We'll still make note of this shlib, even if we don't
815 read its symbols. This allows us to use its unwind
816 information well enough to know how to e.g., correctly
817 do a traceback from a PC within the shlib, even if we
818 can't symbolize those PCs...
820 som_solib_add_solib_objfile (new_so
, name
, from_tty
, text_addr
);
824 som_solib_total_st_size
+= st_size
;
826 /* This fills in new_so->objfile, among others. */
827 som_solib_load_symbols (new_so
, name
, from_tty
, text_addr
, target
);
831 printf ("--Done reading shared library data\n");
834 /* Getting new symbols may change our opinion about what is
836 reinit_frame_cache ();
840 error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
844 error ("Error while reading dynamic library list.\n");
849 /* This hook gets called just before the first instruction in the
850 inferior process is executed.
852 This is our opportunity to set magic flags in the inferior so
853 that GDB can be notified when a shared library is mapped in and
854 to tell the dynamic linker that a private copy of the library is
855 needed (so GDB can set breakpoints in the library).
857 __dld_flags is the location of the magic flags; as of this implementation
858 there are 3 flags of interest:
860 bit 0 when set indicates that private copies of the libraries are needed
861 bit 1 when set indicates that the callback hook routine is valid
862 bit 2 when set indicates that the dynamic linker should maintain the
863 __dld_list structure when loading/unloading libraries.
865 Note that shared libraries are not mapped in at this time, so we have
866 run the inferior until the libraries are mapped in. Typically this
867 means running until the "_start" is called. */
870 som_solib_create_inferior_hook (void)
872 struct minimal_symbol
*msymbol
;
873 unsigned int dld_flags
, status
, have_endo
;
874 asection
*shlib_info
;
876 struct objfile
*objfile
;
879 /* First, remove all the solib event breakpoints. Their addresses
880 may have changed since the last time we ran the program. */
881 remove_solib_event_breakpoints ();
883 if (symfile_objfile
== NULL
)
886 /* First see if the objfile was dynamically linked. */
887 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
891 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
892 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
896 /* Slam the pid of the process into __d_pid.
898 We used to warn when this failed, but that warning is only useful
899 on very old HP systems (hpux9 and older). The warnings are an
900 annoyance to users of modern systems and foul up the testsuite as
901 well. As a result, the warnings have been disabled. */
902 msymbol
= lookup_minimal_symbol ("__d_pid", NULL
, symfile_objfile
);
906 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
907 store_unsigned_integer (buf
, 4, PIDGET (inferior_ptid
));
908 status
= target_write_memory (anaddr
, buf
, 4);
911 warning ("Unable to write __d_pid");
912 warning ("Suggest linking with /opt/langtools/lib/end.o.");
913 warning ("GDB will be unable to track shl_load/shl_unload calls");
917 /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
918 This will force the dynamic linker to call __d_trap when significant
921 Note that the above is the pre-HP-UX 9.0 behaviour. At 9.0 and above,
922 the dld provides an export stub named "__d_trap" as well as the
923 function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
924 We'll look first for the old flavor and then the new.
926 msymbol
= lookup_minimal_symbol ("_DLD_HOOK", NULL
, symfile_objfile
);
928 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
931 warning ("Unable to find _DLD_HOOK symbol in object file.");
932 warning ("Suggest linking with /opt/langtools/lib/end.o.");
933 warning ("GDB will be unable to track shl_load/shl_unload calls");
936 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
937 dld_cache
.hook
.address
= anaddr
;
939 /* Grrr, this might not be an export symbol! We have to find the
941 ALL_OBJFILES (objfile
)
943 struct unwind_table_entry
*u
;
944 struct minimal_symbol
*msymbol2
;
947 msymbol2
= lookup_minimal_symbol_solib_trampoline (DEPRECATED_SYMBOL_NAME (msymbol
),
949 /* Found a symbol with the right name. */
952 struct unwind_table_entry
*u
;
953 /* It must be a shared library trampoline. */
954 if (SYMBOL_TYPE (msymbol2
) != mst_solib_trampoline
)
957 /* It must also be an export stub. */
958 u
= find_unwind_entry (SYMBOL_VALUE (msymbol2
));
959 if (!u
|| u
->stub_unwind
.stub_type
!= EXPORT
)
962 /* OK. Looks like the correct import stub. */
963 anaddr
= SYMBOL_VALUE (msymbol2
);
964 dld_cache
.hook_stub
.address
= anaddr
;
967 store_unsigned_integer (buf
, 4, anaddr
);
969 msymbol
= lookup_minimal_symbol ("__dld_hook", NULL
, symfile_objfile
);
972 warning ("Unable to find __dld_hook symbol in object file.");
973 warning ("Suggest linking with /opt/langtools/lib/end.o.");
974 warning ("GDB will be unable to track shl_load/shl_unload calls");
977 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
978 status
= target_write_memory (anaddr
, buf
, 4);
980 /* Now set a shlib_event breakpoint at __d_trap so we can track
981 significant shared library events. */
982 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
985 warning ("Unable to find __dld_d_trap symbol in object file.");
986 warning ("Suggest linking with /opt/langtools/lib/end.o.");
987 warning ("GDB will be unable to track shl_load/shl_unload calls");
990 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
992 /* We have all the support usually found in end.o, so we can track
993 shl_load and shl_unload calls. */
998 /* Get the address of __dld_flags, if no such symbol exists, then we can
999 not debug the shared code. */
1000 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
1001 if (msymbol
== NULL
)
1003 error ("Unable to find __dld_flags symbol in object file.\n");
1006 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1008 /* Read the current contents. */
1009 status
= target_read_memory (anaddr
, buf
, 4);
1012 error ("Unable to read __dld_flags\n");
1014 dld_flags
= extract_unsigned_integer (buf
, 4);
1016 /* Turn on the flags we care about. */
1017 dld_flags
|= DLD_FLAGS_MAPPRIVATE
;
1019 dld_flags
|= DLD_FLAGS_HOOKVALID
;
1020 store_unsigned_integer (buf
, 4, dld_flags
);
1021 status
= target_write_memory (anaddr
, buf
, 4);
1024 error ("Unable to write __dld_flags\n");
1027 /* Now find the address of _start and set a breakpoint there.
1028 We still need this code for two reasons:
1030 * Not all sites have /opt/langtools/lib/end.o, so it's not always
1031 possible to track the dynamic linker's events.
1033 * At this time no events are triggered for shared libraries
1034 loaded at startup time (what a crock). */
1036 msymbol
= lookup_minimal_symbol ("_start", NULL
, symfile_objfile
);
1037 if (msymbol
== NULL
)
1039 error ("Unable to find _start symbol in object file.\n");
1042 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1044 /* Make the breakpoint at "_start" a shared library event breakpoint. */
1045 create_solib_event_breakpoint (anaddr
);
1047 /* Wipe out all knowledge of old shared libraries since their
1048 mapping can change from one exec to another! */
1049 while (so_list_head
)
1051 struct so_list
*temp
;
1053 temp
= so_list_head
;
1054 xfree (so_list_head
);
1055 so_list_head
= temp
->next
;
1057 clear_symtab_users ();
1060 /* This operation removes the "hook" between GDB and the dynamic linker,
1061 which causes the dld to notify GDB of shared library events.
1063 After this operation completes, the dld will no longer notify GDB of
1064 shared library events. To resume notifications, GDB must call
1065 som_solib_create_inferior_hook.
1067 This operation does not remove any knowledge of shared libraries which
1068 GDB may already have been notified of.
1071 som_solib_remove_inferior_hook (int pid
)
1074 struct minimal_symbol
*msymbol
;
1076 char dld_flags_buffer
[4];
1077 unsigned int dld_flags_value
;
1078 struct cleanup
*old_cleanups
= save_inferior_ptid ();
1080 /* Ensure that we're really operating on the specified process. */
1081 inferior_ptid
= pid_to_ptid (pid
);
1083 /* We won't bother to remove the solib breakpoints from this process.
1085 In fact, on PA64 the breakpoint is hard-coded into the dld callback,
1086 and thus we're not supposed to remove it.
1088 Rather, we'll merely clear the dld_flags bit that enables callbacks.
1090 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
1092 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1093 status
= target_read_memory (addr
, dld_flags_buffer
, 4);
1095 dld_flags_value
= extract_unsigned_integer (dld_flags_buffer
, 4);
1097 dld_flags_value
&= ~DLD_FLAGS_HOOKVALID
;
1098 store_unsigned_integer (dld_flags_buffer
, 4, dld_flags_value
);
1099 status
= target_write_memory (addr
, dld_flags_buffer
, 4);
1101 do_cleanups (old_cleanups
);
1105 /* This function creates a breakpoint on the dynamic linker hook, which
1106 is called when e.g., a shl_load or shl_unload call is made. This
1107 breakpoint will only trigger when a shl_load call is made.
1109 If filename is NULL, then loads of any dll will be caught. Else,
1110 only loads of the file whose pathname is the string contained by
1111 filename will be caught.
1113 Undefined behaviour is guaranteed if this function is called before
1114 som_solib_create_inferior_hook.
1117 som_solib_create_catch_load_hook (int pid
, int tempflag
, char *filename
,
1120 create_solib_load_event_breakpoint ("__d_trap", tempflag
, filename
, cond_string
);
1123 /* This function creates a breakpoint on the dynamic linker hook, which
1124 is called when e.g., a shl_load or shl_unload call is made. This
1125 breakpoint will only trigger when a shl_unload call is made.
1127 If filename is NULL, then unloads of any dll will be caught. Else,
1128 only unloads of the file whose pathname is the string contained by
1129 filename will be caught.
1131 Undefined behaviour is guaranteed if this function is called before
1132 som_solib_create_inferior_hook.
1135 som_solib_create_catch_unload_hook (int pid
, int tempflag
, char *filename
,
1138 create_solib_unload_event_breakpoint ("__d_trap", tempflag
, filename
, cond_string
);
1142 som_solib_have_load_event (int pid
)
1144 CORE_ADDR event_kind
;
1146 event_kind
= read_register (HPPA_ARG0_REGNUM
);
1147 return (event_kind
== SHL_LOAD
);
1151 som_solib_have_unload_event (int pid
)
1153 CORE_ADDR event_kind
;
1155 event_kind
= read_register (HPPA_ARG0_REGNUM
);
1156 return (event_kind
== SHL_UNLOAD
);
1160 som_solib_library_pathname (int pid
)
1162 CORE_ADDR dll_handle_address
;
1163 CORE_ADDR dll_pathname_address
;
1164 struct som_solib_mapped_entry dll_descriptor
;
1166 static char dll_pathname
[1024];
1168 /* Read the descriptor of this newly-loaded library. */
1169 dll_handle_address
= read_register (HPPA_ARG1_REGNUM
);
1170 read_memory (dll_handle_address
, (char *) &dll_descriptor
, sizeof (dll_descriptor
));
1172 /* We can find a pointer to the dll's pathname within the descriptor. */
1173 dll_pathname_address
= (CORE_ADDR
) dll_descriptor
.name
;
1175 /* Read the pathname, one byte at a time. */
1180 read_memory (dll_pathname_address
++, (char *) &b
, 1);
1186 return dll_pathname
;
1190 som_solib_loaded_library_pathname (int pid
)
1192 if (!som_solib_have_load_event (pid
))
1193 error ("Must have a load event to use this query");
1195 return som_solib_library_pathname (pid
);
1199 som_solib_unloaded_library_pathname (int pid
)
1201 if (!som_solib_have_unload_event (pid
))
1202 error ("Must have an unload event to use this query");
1204 return som_solib_library_pathname (pid
);
1208 som_solib_desire_dynamic_linker_symbols (void)
1210 struct objfile
*objfile
;
1211 struct unwind_table_entry
*u
;
1212 struct minimal_symbol
*dld_msymbol
;
1214 /* Do we already know the value of these symbols? If so, then
1215 we've no work to do.
1217 (If you add clauses to this test, be sure to likewise update the
1218 test within the loop.)
1220 if (dld_cache
.is_valid
)
1223 ALL_OBJFILES (objfile
)
1225 dld_msymbol
= lookup_minimal_symbol ("shl_load", NULL
, objfile
);
1226 if (dld_msymbol
!= NULL
)
1228 dld_cache
.load
.address
= SYMBOL_VALUE (dld_msymbol
);
1229 dld_cache
.load
.unwind
= find_unwind_entry (dld_cache
.load
.address
);
1232 dld_msymbol
= lookup_minimal_symbol_solib_trampoline ("shl_load",
1234 if (dld_msymbol
!= NULL
)
1236 if (SYMBOL_TYPE (dld_msymbol
) == mst_solib_trampoline
)
1238 u
= find_unwind_entry (SYMBOL_VALUE (dld_msymbol
));
1239 if ((u
!= NULL
) && (u
->stub_unwind
.stub_type
== EXPORT
))
1241 dld_cache
.load_stub
.address
= SYMBOL_VALUE (dld_msymbol
);
1242 dld_cache
.load_stub
.unwind
= u
;
1247 dld_msymbol
= lookup_minimal_symbol ("shl_unload", NULL
, objfile
);
1248 if (dld_msymbol
!= NULL
)
1250 dld_cache
.unload
.address
= SYMBOL_VALUE (dld_msymbol
);
1251 dld_cache
.unload
.unwind
= find_unwind_entry (dld_cache
.unload
.address
);
1253 /* ??rehrauer: I'm not sure exactly what this is, but it appears
1254 that on some HPUX 10.x versions, there's two unwind regions to
1255 cover the body of "shl_unload", the second being 4 bytes past
1256 the end of the first. This is a large hack to handle that
1257 case, but since I don't seem to have any legitimate way to
1258 look for this thing via the symbol table...
1260 if (dld_cache
.unload
.unwind
!= NULL
)
1262 u
= find_unwind_entry (dld_cache
.unload
.unwind
->region_end
+ 4);
1265 dld_cache
.unload2
.address
= u
->region_start
;
1266 dld_cache
.unload2
.unwind
= u
;
1271 dld_msymbol
= lookup_minimal_symbol_solib_trampoline ("shl_unload",
1273 if (dld_msymbol
!= NULL
)
1275 if (SYMBOL_TYPE (dld_msymbol
) == mst_solib_trampoline
)
1277 u
= find_unwind_entry (SYMBOL_VALUE (dld_msymbol
));
1278 if ((u
!= NULL
) && (u
->stub_unwind
.stub_type
== EXPORT
))
1280 dld_cache
.unload_stub
.address
= SYMBOL_VALUE (dld_msymbol
);
1281 dld_cache
.unload_stub
.unwind
= u
;
1286 /* Did we find everything we were looking for? If so, stop. */
1287 if ((dld_cache
.load
.address
!= 0)
1288 && (dld_cache
.load_stub
.address
!= 0)
1289 && (dld_cache
.unload
.address
!= 0)
1290 && (dld_cache
.unload_stub
.address
!= 0))
1292 dld_cache
.is_valid
= 1;
1297 dld_cache
.hook
.unwind
= find_unwind_entry (dld_cache
.hook
.address
);
1298 dld_cache
.hook_stub
.unwind
= find_unwind_entry (dld_cache
.hook_stub
.address
);
1300 /* We're prepared not to find some of these symbols, which is why
1301 this function is a "desire" operation, and not a "require".
1306 som_solib_in_dynamic_linker (int pid
, CORE_ADDR pc
)
1308 struct unwind_table_entry
*u_pc
;
1310 /* Are we in the dld itself?
1312 ??rehrauer: Large hack -- We'll assume that any address in a
1313 shared text region is the dld's text. This would obviously
1314 fall down if the user attached to a process, whose shlibs
1315 weren't mapped to a (writeable) private region. However, in
1316 that case the debugger probably isn't able to set the fundamental
1317 breakpoint in the dld callback anyways, so this hack should be
1320 if ((pc
& (CORE_ADDR
) 0xc0000000) == (CORE_ADDR
) 0xc0000000)
1323 /* Cache the address of some symbols that are part of the dynamic
1324 linker, if not already known.
1326 som_solib_desire_dynamic_linker_symbols ();
1328 /* Are we in the dld callback? Or its export stub? */
1329 u_pc
= find_unwind_entry (pc
);
1333 if ((u_pc
== dld_cache
.hook
.unwind
) || (u_pc
== dld_cache
.hook_stub
.unwind
))
1336 /* Or the interface of the dld (i.e., "shl_load" or friends)? */
1337 if ((u_pc
== dld_cache
.load
.unwind
)
1338 || (u_pc
== dld_cache
.unload
.unwind
)
1339 || (u_pc
== dld_cache
.unload2
.unwind
)
1340 || (u_pc
== dld_cache
.load_stub
.unwind
)
1341 || (u_pc
== dld_cache
.unload_stub
.unwind
))
1344 /* Apparently this address isn't part of the dld's text. */
1349 /* Return the GOT value for the shared library in which ADDR belongs. If
1350 ADDR isn't in any known shared library, return zero. */
1353 som_solib_get_got_by_pc (CORE_ADDR addr
)
1355 struct so_list
*so_list
= so_list_head
;
1356 CORE_ADDR got_value
= 0;
1360 if (so_list
->som_solib
.text_addr
<= addr
1361 && so_list
->som_solib
.text_end
> addr
)
1363 got_value
= so_list
->som_solib
.got_value
;
1366 so_list
= so_list
->next
;
1372 Return the address of the handle of the shared library
1373 in which ADDR belongs. If
1374 ADDR isn't in any known shared library, return zero. */
1375 /* this function is used in hppa_fix_call_dummy in hppa-tdep.c */
1378 som_solib_get_solib_by_pc (CORE_ADDR addr
)
1380 struct so_list
*so_list
= so_list_head
;
1384 if (so_list
->som_solib
.text_addr
<= addr
1385 && so_list
->som_solib
.text_end
> addr
)
1389 so_list
= so_list
->next
;
1392 return so_list
->solib_addr
;
1399 som_solib_section_offsets (struct objfile
*objfile
,
1400 struct section_offsets
*offsets
)
1402 struct so_list
*so_list
= so_list_head
;
1406 /* Oh what a pain! We need the offsets before so_list->objfile
1407 is valid. The BFDs will never match. Make a best guess. */
1408 if (strstr (objfile
->name
, so_list
->som_solib
.name
))
1410 asection
*private_section
;
1412 /* The text offset is easy. */
1413 offsets
->offsets
[SECT_OFF_TEXT (objfile
)]
1414 = (so_list
->som_solib
.text_addr
1415 - so_list
->som_solib
.text_link_addr
);
1416 offsets
->offsets
[SECT_OFF_RODATA (objfile
)]
1417 = ANOFFSET (offsets
, SECT_OFF_TEXT (objfile
));
1419 /* We should look at presumed_dp in the SOM header, but
1420 that's not easily available. This should be OK though. */
1421 private_section
= bfd_get_section_by_name (objfile
->obfd
,
1423 if (!private_section
)
1425 warning ("Unable to find $PRIVATE$ in shared library!");
1426 offsets
->offsets
[SECT_OFF_DATA (objfile
)] = 0;
1427 offsets
->offsets
[SECT_OFF_BSS (objfile
)] = 0;
1430 offsets
->offsets
[SECT_OFF_DATA (objfile
)]
1431 = (so_list
->som_solib
.data_start
- private_section
->vma
);
1432 offsets
->offsets
[SECT_OFF_BSS (objfile
)]
1433 = ANOFFSET (offsets
, SECT_OFF_DATA (objfile
));
1436 so_list
= so_list
->next
;
1441 /* Dump information about all the currently loaded shared libraries. */
1444 som_sharedlibrary_info_command (char *ignore
, int from_tty
)
1446 struct so_list
*so_list
= so_list_head
;
1448 if (exec_bfd
== NULL
)
1450 printf_unfiltered ("No executable file.\n");
1454 if (so_list
== NULL
)
1456 printf_unfiltered ("No shared libraries loaded at this time.\n");
1460 printf_unfiltered ("Shared Object Libraries\n");
1461 printf_unfiltered (" %-12s%-12s%-12s%-12s%-12s%-12s\n",
1462 " flags", " tstart", " tend", " dstart", " dend", " dlt");
1467 flags
= so_list
->som_solib
.struct_version
<< 24;
1468 flags
|= so_list
->som_solib
.bind_mode
<< 16;
1469 flags
|= so_list
->som_solib
.library_version
;
1470 printf_unfiltered ("%s", so_list
->som_solib
.name
);
1471 if (so_list
->objfile
== NULL
)
1472 printf_unfiltered (" (symbols not loaded)");
1473 printf_unfiltered ("\n");
1474 printf_unfiltered (" %-12s", hex_string_custom (flags
, 8));
1475 printf_unfiltered ("%-12s",
1476 hex_string_custom (so_list
->som_solib
.text_addr
, 8));
1477 printf_unfiltered ("%-12s",
1478 hex_string_custom (so_list
->som_solib
.text_end
, 8));
1479 printf_unfiltered ("%-12s",
1480 hex_string_custom (so_list
->som_solib
.data_start
, 8));
1481 printf_unfiltered ("%-12s",
1482 hex_string_custom (so_list
->som_solib
.data_end
, 8));
1483 printf_unfiltered ("%-12s\n",
1484 hex_string_custom (so_list
->som_solib
.got_value
, 8));
1485 so_list
= so_list
->next
;
1490 som_solib_sharedlibrary_command (char *args
, int from_tty
)
1493 som_solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1499 som_solib_address (CORE_ADDR addr
)
1501 struct so_list
*so
= so_list_head
;
1505 /* Is this address within this shlib's text range? If so,
1506 return the shlib's name.
1508 if ((addr
>= so
->som_solib
.text_addr
) && (addr
<= so
->som_solib
.text_end
))
1509 return so
->som_solib
.name
;
1511 /* Nope, keep looking... */
1515 /* No, we couldn't prove that the address is within a shlib. */
1521 som_solib_restart (void)
1523 struct so_list
*sl
= so_list_head
;
1525 /* Before the shlib info vanishes, use it to disable any breakpoints
1526 that may still be active in those shlibs.
1528 disable_breakpoints_in_shlibs (0);
1530 /* Discard all the shlib descriptors.
1534 struct so_list
*next_sl
= sl
->next
;
1538 so_list_head
= NULL
;
1540 som_solib_total_st_size
= (LONGEST
) 0;
1541 som_solib_st_size_threshold_exceeded
= 0;
1543 dld_cache
.is_valid
= 0;
1545 dld_cache
.hook
.address
= 0;
1546 dld_cache
.hook
.unwind
= NULL
;
1548 dld_cache
.hook_stub
.address
= 0;
1549 dld_cache
.hook_stub
.unwind
= NULL
;
1551 dld_cache
.load
.address
= 0;
1552 dld_cache
.load
.unwind
= NULL
;
1554 dld_cache
.load_stub
.address
= 0;
1555 dld_cache
.load_stub
.unwind
= NULL
;
1557 dld_cache
.unload
.address
= 0;
1558 dld_cache
.unload
.unwind
= NULL
;
1560 dld_cache
.unload2
.address
= 0;
1561 dld_cache
.unload2
.unwind
= NULL
;
1563 dld_cache
.unload_stub
.address
= 0;
1564 dld_cache
.unload_stub
.unwind
= NULL
;
1569 _initialize_som_solib (void)
1571 add_com ("sharedlibrary", class_files
, som_solib_sharedlibrary_command
,
1572 "Load shared object library symbols for files matching REGEXP.");
1573 add_info ("sharedlibrary", som_sharedlibrary_info_command
,
1574 "Status of loaded shared object libraries.");
1576 deprecated_add_show_from_set
1577 (add_set_cmd ("auto-solib-add", class_support
, var_boolean
,
1578 (char *) &auto_solib_add
,
1579 "Set autoloading of shared library symbols.\n\
1580 If \"on\", symbols from all shared object libraries will be loaded\n\
1581 automatically when the inferior begins execution, when the dynamic linker\n\
1582 informs gdb that a new library has been loaded, or when attaching to the\n\
1583 inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
1587 deprecated_add_show_from_set
1588 (add_set_cmd ("auto-solib-limit", class_support
, var_zinteger
,
1589 (char *) &auto_solib_limit
,
1590 "Set threshold (in Mb) for autoloading shared library symbols.\n\
1591 When shared library autoloading is enabled, new libraries will be loaded\n\
1592 only until the total size of shared library symbols exceeds this\n\
1593 threshold in megabytes. Is ignored when using `sharedlibrary'.",
1597 /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how
1598 much data space a process can use. We ought to be reading
1599 MAXDSIZ and setting auto_solib_limit to some large fraction of
1600 that value. If not that, we maybe ought to be setting it smaller
1601 than the default for MAXDSIZ (that being 64Mb, I believe).
1602 However, [1] this threshold is only crudely approximated rather
1603 than actually measured, and [2] 50 Mbytes is too small for
1604 debugging gdb itself. Thus, the arbitrary 100 figure. */
1605 auto_solib_limit
= 100; /* Megabytes */
1607 som_solib_restart ();
1610 /* Get some HPUX-specific data from a shared lib.
1613 som_solib_thread_start_addr (struct so_list
*so
)
1615 return so
->som_solib
.tsd_start_addr
;