1 /* Handle HP SOM shared libraries for GDB, the GNU Debugger.
2 Copyright 1993, 1996, 1999, 2001 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,
19 Boston, MA 02111-1307, USA.
21 Written by the Center for Software Science at the Univerity of Utah
22 and by Cygnus Support. */
33 #include "breakpoint.h"
37 #include "gdb-stabs.h"
50 /* Uncomment this to turn on some debugging output.
53 /* #define SOLIB_DEBUG
56 /* Defined in exec.c; used to prevent dangling pointer bug.
58 extern struct target_ops exec_ops
;
60 /* This lives in hppa-tdep.c. */
61 extern struct unwind_table_entry
*find_unwind_entry (CORE_ADDR pc
);
63 /* These ought to be defined in some public interface, but aren't. They
64 define the meaning of the various bits in the distinguished __dld_flags
65 variable that is declared in every debuggable a.out on HP-UX, and that
66 is shared between the debugger and the dynamic linker.
68 #define DLD_FLAGS_MAPPRIVATE 0x1
69 #define DLD_FLAGS_HOOKVALID 0x2
70 #define DLD_FLAGS_LISTVALID 0x4
71 #define DLD_FLAGS_BOR_ENABLE 0x8
75 * Most of this code should work for hp300 shared libraries. Does
76 anyone care enough to weed out any SOM-isms.
78 * Support for hpux8 dynamic linker. */
80 /* The basic structure which describes a dynamically loaded object. This
81 data structure is private to the dynamic linker and isn't found in
82 any HPUX include file. */
84 struct som_solib_mapped_entry
86 /* The name of the library. */
89 /* Version of this structure (it is expected to change again in hpux10). */
90 unsigned char struct_version
;
92 /* Binding mode for this library. */
93 unsigned char bind_mode
;
95 /* Version of this library. */
96 short library_version
;
98 /* Start of text address,
99 * link-time text location (length of text area),
100 * end of text address. */
102 CORE_ADDR text_link_addr
;
105 /* Start of data, start of bss and end of data. */
106 CORE_ADDR data_start
;
110 /* Value of linkage pointer (%r19). */
114 struct som_solib_mapped_entry
*next
;
116 /* There are other fields, but I don't have information as to what is
117 contained in them. */
119 /* For versions from HPUX-10.30 and up */
121 /* Address in target of offset from thread-local register of
122 * start of this thread's data. I.e., the first thread-local
123 * variable in this shared library starts at *(tsd_start_addr)
124 * from that area pointed to by cr27 (mpsfu_hi).
126 * We do the indirection as soon as we read it, so from then
127 * on it's the offset itself.
129 CORE_ADDR tsd_start_addr
;
131 /* Following this are longwords holding:
133 * ?, ?, ?, ptr to -1, ptr to-1, ptr to lib name (leaf name),
134 * ptr to __data_start, ptr to __data_end
140 /* A structure to keep track of all the known shared objects. */
143 struct som_solib_mapped_entry som_solib
;
144 struct objfile
*objfile
;
146 struct section_table
*sections
;
147 struct section_table
*sections_end
;
148 /* elz: added this field to store the address in target space (in the
149 library) of the library descriptor (handle) which we read into
150 som_solib_mapped_entry structure */
151 CORE_ADDR solib_addr
;
152 struct so_list
*next
;
156 static struct so_list
*so_list_head
;
159 /* This is the cumulative size in bytes of the symbol tables of all
160 shared objects on the so_list_head list. (When we say size, here
161 we mean of the information before it is brought into memory and
162 potentially expanded by GDB.) When adding a new shlib, this value
163 is compared against the threshold size, held by auto_solib_add
164 (in megabytes). If adding symbols for the new shlib would cause
165 the total size to exceed the threshold, then the new shlib's symbols
168 static LONGEST som_solib_total_st_size
;
170 /* When the threshold is reached for any shlib, we refuse to add
171 symbols for subsequent shlibs, even if those shlibs' symbols would
172 be small enough to fit under the threshold. (Although this may
173 result in one, early large shlib preventing the loading of later,
174 smalller shlibs' symbols, it allows us to issue one informational
175 message. The alternative, to issue a message for each shlib whose
176 symbols aren't loaded, could be a big annoyance where the threshold
177 is exceeded due to a very large number of shlibs.)
179 static int som_solib_st_size_threshold_exceeded
;
181 /* These addresses should be filled in by som_solib_create_inferior_hook.
182 They are also used elsewhere in this module.
187 struct unwind_table_entry
*unwind
;
191 /* When adding fields, be sure to clear them in _initialize_som_solib. */
195 addr_and_unwind_t hook
;
196 addr_and_unwind_t hook_stub
;
197 addr_and_unwind_t load
;
198 addr_and_unwind_t load_stub
;
199 addr_and_unwind_t unload
;
200 addr_and_unwind_t unload2
;
201 addr_and_unwind_t unload_stub
;
207 static void som_sharedlibrary_info_command (char *, int);
209 static void som_solib_sharedlibrary_command (char *, int);
212 som_solib_sizeof_symbol_table (char *filename
)
217 LONGEST st_size
= (LONGEST
) 0;
220 /* We believe that filename was handed to us by the dynamic linker, and
221 is therefore always an absolute path.
223 desc
= openp (getenv ("PATH"), 1, filename
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
226 perror_with_name (filename
);
228 filename
= absolute_name
;
230 abfd
= bfd_fdopenr (filename
, gnutarget
, desc
);
234 make_cleanup (xfree
, filename
);
235 error ("\"%s\": can't open to read symbols: %s.", filename
,
236 bfd_errmsg (bfd_get_error ()));
239 if (!bfd_check_format (abfd
, bfd_object
)) /* Reads in section info */
241 bfd_close (abfd
); /* This also closes desc */
242 make_cleanup (xfree
, filename
);
243 error ("\"%s\": can't read symbols: %s.", filename
,
244 bfd_errmsg (bfd_get_error ()));
247 /* Sum the sizes of the various sections that compose debug info. */
249 /* This contains non-DOC information. */
250 sect
= bfd_get_section_by_name (abfd
, "$DEBUG$");
252 st_size
+= (LONGEST
) bfd_section_size (abfd
, sect
);
254 /* This contains DOC information. */
255 sect
= bfd_get_section_by_name (abfd
, "$PINFO$");
257 st_size
+= (LONGEST
) bfd_section_size (abfd
, sect
);
259 bfd_close (abfd
); /* This also closes desc */
262 /* Unfortunately, just summing the sizes of various debug info
263 sections isn't a very accurate measurement of how much heap
264 space the debugger will need to hold them. It also doesn't
265 account for space needed by linker (aka "minimal") symbols.
267 Anecdotal evidence suggests that just summing the sizes of
268 debug-info-related sections understates the heap space needed
269 to represent it internally by about an order of magnitude.
271 Since it's not exactly brain surgery we're doing here, rather
272 than attempt to more accurately measure the size of a shlib's
273 symbol table in GDB's heap, we'll just apply a 10x fudge-
274 factor to the debug info sections' size-sum. No, this doesn't
275 account for minimal symbols in non-debuggable shlibs. But it
276 all roughly washes out in the end.
278 return st_size
* (LONGEST
) 10;
283 som_solib_add_solib_objfile (struct so_list
*so
, char *name
, int from_tty
,
286 obj_private_data_t
*obj_private
;
287 struct obj_section
*s
;
289 so
->objfile
= symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
290 so
->abfd
= so
->objfile
->obfd
;
292 /* syms_from_objfile has bizarre section offset code,
293 so I do my own right here. */
294 for (s
= so
->objfile
->sections
; s
< so
->objfile
->sections_end
; s
++)
296 flagword aflag
= bfd_get_section_flags(so
->abfd
, s
->the_bfd_section
);
297 if (aflag
& SEC_CODE
)
299 s
->addr
+= so
->som_solib
.text_addr
- so
->som_solib
.text_link_addr
;
300 s
->endaddr
+= so
->som_solib
.text_addr
- so
->som_solib
.text_link_addr
;
302 else if (aflag
& SEC_DATA
)
304 s
->addr
+= so
->som_solib
.data_start
;
305 s
->endaddr
+= so
->som_solib
.data_start
;
311 /* Mark this as a shared library and save private data.
313 so
->objfile
->flags
|= OBJF_SHARED
;
315 if (so
->objfile
->obj_private
== NULL
)
317 obj_private
= (obj_private_data_t
*)
318 obstack_alloc (&so
->objfile
->psymbol_obstack
,
319 sizeof (obj_private_data_t
));
320 obj_private
->unwind_info
= NULL
;
321 obj_private
->so_info
= NULL
;
322 so
->objfile
->obj_private
= (PTR
) obj_private
;
325 obj_private
= (obj_private_data_t
*) so
->objfile
->obj_private
;
326 obj_private
->so_info
= so
;
328 if (!bfd_check_format (so
->abfd
, bfd_object
))
330 error ("\"%s\": not in executable format: %s.",
331 name
, bfd_errmsg (bfd_get_error ()));
337 som_solib_load_symbols (struct so_list
*so
, char *name
, int from_tty
,
338 CORE_ADDR text_addr
, struct target_ops
*target
)
340 struct section_table
*p
;
343 CORE_ADDR presumed_data_start
;
346 printf ("--Adding symbols for shared library \"%s\"\n", name
);
349 som_solib_add_solib_objfile (so
, name
, from_tty
, text_addr
);
351 /* Now we need to build a section table for this library since
352 we might be debugging a core file from a dynamically linked
353 executable in which the libraries were not privately mapped. */
354 if (build_section_table (so
->abfd
,
358 error ("Unable to build section table for shared library\n.");
362 /* Relocate all the sections based on where they got loaded. */
363 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
365 if (p
->the_bfd_section
->flags
& SEC_CODE
)
367 p
->addr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_TEXT (so
->objfile
));
368 p
->endaddr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_TEXT (so
->objfile
));
370 else if (p
->the_bfd_section
->flags
& SEC_DATA
)
372 p
->addr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_DATA (so
->objfile
));
373 p
->endaddr
+= ANOFFSET (so
->objfile
->section_offsets
, SECT_OFF_DATA (so
->objfile
));
377 /* Now see if we need to map in the text and data for this shared
378 library (for example debugging a core file which does not use
379 private shared libraries.).
381 Carefully peek at the first text address in the library. If the
382 read succeeds, then the libraries were privately mapped and were
383 included in the core dump file.
385 If the peek failed, then the libraries were not privately mapped
386 and are not in the core file, we'll have to read them in ourselves. */
387 status
= target_read_memory (text_addr
, buf
, 4);
392 new = so
->sections_end
- so
->sections
;
394 old
= target_resize_to_sections (target
, new);
396 /* Copy over the old data before it gets clobbered. */
397 memcpy ((char *) (target
->to_sections
+ old
),
399 ((sizeof (struct section_table
)) * new));
404 /* Add symbols from shared libraries into the symtab list, unless the
405 size threshold (specified by auto_solib_add, in megabytes) would
409 som_solib_add (char *arg_string
, int from_tty
, struct target_ops
*target
)
411 struct minimal_symbol
*msymbol
;
412 struct so_list
*so_list_tail
;
414 asection
*shlib_info
;
416 unsigned int dld_flags
;
417 char buf
[4], *re_err
;
418 int threshold_warning_given
= 0;
420 /* First validate our arguments. */
421 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
423 error ("Invalid regexp: %s", re_err
);
426 /* If we're debugging a core file, or have attached to a running
427 process, then som_solib_create_inferior_hook will not have been
430 We need to first determine if we're dealing with a dynamically
431 linked executable. If not, then return without an error or warning.
433 We also need to examine __dld_flags to determine if the shared library
434 list is valid and to determine if the libraries have been privately
436 if (symfile_objfile
== NULL
)
439 /* First see if the objfile was dynamically linked. */
440 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
444 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
445 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
448 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
451 error ("Unable to find __dld_flags symbol in object file.\n");
455 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
456 /* Read the current contents. */
457 status
= target_read_memory (addr
, buf
, 4);
460 error ("Unable to read __dld_flags\n");
463 dld_flags
= extract_unsigned_integer (buf
, 4);
465 /* __dld_list may not be valid. If not, then we punt, warning the user if
466 we were called as a result of the add-symfile command.
468 if ((dld_flags
& DLD_FLAGS_LISTVALID
) == 0)
471 error ("__dld_list is not valid according to __dld_flags.\n");
475 /* If the libraries were not mapped private, warn the user. */
476 if ((dld_flags
& DLD_FLAGS_MAPPRIVATE
) == 0)
477 warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
479 msymbol
= lookup_minimal_symbol ("__dld_list", NULL
, NULL
);
482 /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
483 but the data is still available if you know where to look. */
484 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
487 error ("Unable to find dynamic library list.\n");
490 addr
= SYMBOL_VALUE_ADDRESS (msymbol
) - 8;
493 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
495 status
= target_read_memory (addr
, buf
, 4);
498 error ("Unable to find dynamic library list.\n");
502 addr
= extract_unsigned_integer (buf
, 4);
504 /* If addr is zero, then we're using an old dynamic loader which
505 doesn't maintain __dld_list. We'll have to use a completely
506 different approach to get shared library information. */
510 /* Using the information in __dld_list is the preferred method
511 to get at shared library information. It doesn't depend on
512 any functions in /opt/langtools/lib/end.o and has a chance of working
513 with hpux10 when it is released. */
514 status
= target_read_memory (addr
, buf
, 4);
517 error ("Unable to find dynamic library list.\n");
521 /* addr now holds the address of the first entry in the dynamic
523 addr
= extract_unsigned_integer (buf
, 4);
525 /* Now that we have a pointer to the dynamic library list, walk
526 through it and add the symbols for each library. */
528 so_list_tail
= so_list_head
;
529 /* Find the end of the list of shared objects. */
530 while (so_list_tail
&& so_list_tail
->next
)
531 so_list_tail
= so_list_tail
->next
;
534 printf ("--About to read shared library list data\n");
537 /* "addr" will always point to the base of the
538 * current data entry describing the current
543 CORE_ADDR name_addr
, text_addr
;
544 unsigned int name_len
;
546 struct so_list
*new_so
;
547 struct so_list
*so_list
= so_list_head
;
555 /* Get a pointer to the name of this library. */
556 status
= target_read_memory (addr
, buf
, 4);
560 name_addr
= extract_unsigned_integer (buf
, 4);
564 target_read_memory (name_addr
+ name_len
, buf
, 1);
572 name
= alloca (name_len
);
573 status
= target_read_memory (name_addr
, name
, name_len
);
577 /* See if we've already loaded something with this name. */
580 if (!strcmp (so_list
->som_solib
.name
, name
))
582 so_list
= so_list
->next
;
585 /* See if the file exists. If not, give a warning, but don't
587 status
= stat (name
, &statbuf
);
590 warning ("Can't find file %s referenced in dld_list.", name
);
592 status
= target_read_memory (addr
+ 36, buf
, 4);
596 addr
= (CORE_ADDR
) extract_unsigned_integer (buf
, 4);
600 /* If we've already loaded this one or it's the main program, skip it. */
601 is_main_program
= (strcmp (name
, symfile_objfile
->name
) == 0);
602 if (so_list
|| is_main_program
)
604 /* This is the "next" pointer in the strcuture.
606 status
= target_read_memory (addr
+ 36, buf
, 4);
610 addr
= (CORE_ADDR
) extract_unsigned_integer (buf
, 4);
612 /* Record the main program's symbol table size. */
613 if (is_main_program
&& !so_list
)
615 st_size
= som_solib_sizeof_symbol_table (name
);
616 som_solib_total_st_size
+= st_size
;
619 /* Was this a shlib that we noted but didn't load the symbols for?
620 If so, were we invoked this time from the command-line, via
621 a 'sharedlibrary' or 'add-symbol-file' command? If yes to
622 both, we'd better load the symbols this time.
624 if (from_tty
&& so_list
&& !is_main_program
&& (so_list
->objfile
== NULL
))
625 som_solib_load_symbols (so_list
,
628 so_list
->som_solib
.text_addr
,
634 name
= obsavestring (name
, name_len
- 1,
635 &symfile_objfile
->symbol_obstack
);
637 status
= target_read_memory (addr
+ 8, buf
, 4);
641 text_addr
= extract_unsigned_integer (buf
, 4);
643 new_so
= (struct so_list
*) xmalloc (sizeof (struct so_list
));
644 memset ((char *) new_so
, 0, sizeof (struct so_list
));
645 if (so_list_head
== NULL
)
647 so_list_head
= new_so
;
648 so_list_tail
= new_so
;
652 so_list_tail
->next
= new_so
;
653 so_list_tail
= new_so
;
656 /* Fill in all the entries in GDB's shared library list.
659 new_so
->solib_addr
= addr
;
660 new_so
->som_solib
.name
= name
;
661 status
= target_read_memory (addr
+ 4, buf
, 4);
665 new_so
->som_solib
.struct_version
= extract_unsigned_integer (buf
+ 3, 1);
666 new_so
->som_solib
.bind_mode
= extract_unsigned_integer (buf
+ 2, 1);
667 /* Following is "high water mark", highest version number
668 * seen, rather than plain version number.
670 new_so
->som_solib
.library_version
= extract_unsigned_integer (buf
, 2);
671 new_so
->som_solib
.text_addr
= text_addr
;
673 /* Q: What about longword at "addr + 8"?
674 * A: It's read above, out of order, into "text_addr".
677 status
= target_read_memory (addr
+ 12, buf
, 4);
681 new_so
->som_solib
.text_link_addr
= extract_unsigned_integer (buf
, 4);
683 status
= target_read_memory (addr
+ 16, buf
, 4);
687 new_so
->som_solib
.text_end
= extract_unsigned_integer (buf
, 4);
689 status
= target_read_memory (addr
+ 20, buf
, 4);
693 new_so
->som_solib
.data_start
= extract_unsigned_integer (buf
, 4);
695 status
= target_read_memory (addr
+ 24, buf
, 4);
699 new_so
->som_solib
.bss_start
= extract_unsigned_integer (buf
, 4);
701 status
= target_read_memory (addr
+ 28, buf
, 4);
705 new_so
->som_solib
.data_end
= extract_unsigned_integer (buf
, 4);
707 status
= target_read_memory (addr
+ 32, buf
, 4);
711 new_so
->som_solib
.got_value
= extract_unsigned_integer (buf
, 4);
713 status
= target_read_memory (addr
+ 36, buf
, 4);
717 new_so
->som_solib
.next
= (void *) extract_unsigned_integer (buf
, 4);
719 /* Note that we don't re-set "addr" to the next pointer
720 * until after we've read the trailing data.
723 status
= target_read_memory (addr
+ 40, buf
, 4);
724 new_so
->som_solib
.tsd_start_addr
= extract_unsigned_integer (buf
, 4);
728 /* Now indirect via that value!
730 status
= target_read_memory (new_so
->som_solib
.tsd_start_addr
, buf
, 4);
731 new_so
->som_solib
.tsd_start_addr
= extract_unsigned_integer (buf
, 4);
735 printf ("\n+ library \"%s\" is described at 0x%x\n", name
, addr
);
736 printf (" 'version' is %d\n", new_so
->som_solib
.struct_version
);
737 printf (" 'bind_mode' is %d\n", new_so
->som_solib
.bind_mode
);
738 printf (" 'library_version' is %d\n", new_so
->som_solib
.library_version
);
739 printf (" 'text_addr' is 0x%x\n", new_so
->som_solib
.text_addr
);
740 printf (" 'text_link_addr' is 0x%x\n", new_so
->som_solib
.text_link_addr
);
741 printf (" 'text_end' is 0x%x\n", new_so
->som_solib
.text_end
);
742 printf (" 'data_start' is 0x%x\n", new_so
->som_solib
.data_start
);
743 printf (" 'bss_start' is 0x%x\n", new_so
->som_solib
.bss_start
);
744 printf (" 'data_end' is 0x%x\n", new_so
->som_solib
.data_end
);
745 printf (" 'got_value' is %x\n", new_so
->som_solib
.got_value
);
746 printf (" 'next' is 0x%x\n", new_so
->som_solib
.next
);
747 printf (" 'tsd_start_addr' is 0x%x\n", new_so
->som_solib
.tsd_start_addr
);
750 /* Go on to the next shared library descriptor.
752 addr
= (CORE_ADDR
) new_so
->som_solib
.next
;
756 /* At this point, we have essentially hooked the shlib into the
757 "info share" command. However, we haven't yet loaded its
758 symbol table. We must now decide whether we ought to, i.e.,
759 whether doing so would exceed the symbol table size threshold.
761 If the threshold has just now been exceeded, then we'll issue
762 a warning message (which explains how to load symbols manually,
763 if the user so desires).
765 If the threshold has just now or previously been exceeded,
766 we'll just add the shlib to the list of object files, but won't
767 actually load its symbols. (This is more useful than it might
768 sound, for it allows us to e.g., still load and use the shlibs'
769 unwind information for stack tracebacks.)
772 /* Note that we DON'T want to preclude the user from using the
773 add-symbol-file command! Thus, we only worry about the threshold
774 when we're invoked for other reasons.
776 st_size
= som_solib_sizeof_symbol_table (name
);
777 som_solib_st_size_threshold_exceeded
=
779 ((st_size
+ som_solib_total_st_size
) > (auto_solib_add
* (LONGEST
) 1000000));
781 if (som_solib_st_size_threshold_exceeded
)
783 if (!threshold_warning_given
)
784 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");
785 threshold_warning_given
= 1;
787 /* We'll still make note of this shlib, even if we don't
788 read its symbols. This allows us to use its unwind
789 information well enough to know how to e.g., correctly
790 do a traceback from a PC within the shlib, even if we
791 can't symbolize those PCs...
793 som_solib_add_solib_objfile (new_so
, name
, from_tty
, text_addr
);
797 som_solib_total_st_size
+= st_size
;
799 /* This fills in new_so->objfile, among others. */
800 som_solib_load_symbols (new_so
, name
, from_tty
, text_addr
, target
);
804 printf ("--Done reading shared library data\n");
807 /* Getting new symbols may change our opinion about what is
809 reinit_frame_cache ();
813 error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
817 error ("Error while reading dynamic library list.\n");
822 /* This hook gets called just before the first instruction in the
823 inferior process is executed.
825 This is our opportunity to set magic flags in the inferior so
826 that GDB can be notified when a shared library is mapped in and
827 to tell the dynamic linker that a private copy of the library is
828 needed (so GDB can set breakpoints in the library).
830 __dld_flags is the location of the magic flags; as of this implementation
831 there are 3 flags of interest:
833 bit 0 when set indicates that private copies of the libraries are needed
834 bit 1 when set indicates that the callback hook routine is valid
835 bit 2 when set indicates that the dynamic linker should maintain the
836 __dld_list structure when loading/unloading libraries.
838 Note that shared libraries are not mapped in at this time, so we have
839 run the inferior until the libraries are mapped in. Typically this
840 means running until the "_start" is called. */
843 som_solib_create_inferior_hook (void)
845 struct minimal_symbol
*msymbol
;
846 unsigned int dld_flags
, status
, have_endo
;
847 asection
*shlib_info
;
849 struct objfile
*objfile
;
852 /* First, remove all the solib event breakpoints. Their addresses
853 may have changed since the last time we ran the program. */
854 remove_solib_event_breakpoints ();
856 if (symfile_objfile
== NULL
)
859 /* First see if the objfile was dynamically linked. */
860 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
864 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
865 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
869 /* Slam the pid of the process into __d_pid; failing is only a warning! */
870 msymbol
= lookup_minimal_symbol ("__d_pid", NULL
, symfile_objfile
);
873 warning ("Unable to find __d_pid symbol in object file.");
874 warning ("Suggest linking with /opt/langtools/lib/end.o.");
875 warning ("GDB will be unable to track shl_load/shl_unload calls");
879 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
880 store_unsigned_integer (buf
, 4, inferior_pid
);
881 status
= target_write_memory (anaddr
, buf
, 4);
884 warning ("Unable to write __d_pid");
885 warning ("Suggest linking with /opt/langtools/lib/end.o.");
886 warning ("GDB will be unable to track shl_load/shl_unload calls");
890 /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
891 This will force the dynamic linker to call __d_trap when significant
894 Note that the above is the pre-HP-UX 9.0 behaviour. At 9.0 and above,
895 the dld provides an export stub named "__d_trap" as well as the
896 function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
897 We'll look first for the old flavor and then the new.
899 msymbol
= lookup_minimal_symbol ("_DLD_HOOK", NULL
, symfile_objfile
);
901 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
904 warning ("Unable to find _DLD_HOOK symbol in object file.");
905 warning ("Suggest linking with /opt/langtools/lib/end.o.");
906 warning ("GDB will be unable to track shl_load/shl_unload calls");
909 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
910 dld_cache
.hook
.address
= anaddr
;
912 /* Grrr, this might not be an export symbol! We have to find the
914 ALL_OBJFILES (objfile
)
916 struct unwind_table_entry
*u
;
917 struct minimal_symbol
*msymbol2
;
920 msymbol2
= lookup_minimal_symbol_solib_trampoline (SYMBOL_NAME (msymbol
),
922 /* Found a symbol with the right name. */
925 struct unwind_table_entry
*u
;
926 /* It must be a shared library trampoline. */
927 if (SYMBOL_TYPE (msymbol2
) != mst_solib_trampoline
)
930 /* It must also be an export stub. */
931 u
= find_unwind_entry (SYMBOL_VALUE (msymbol2
));
932 if (!u
|| u
->stub_unwind
.stub_type
!= EXPORT
)
935 /* OK. Looks like the correct import stub. */
936 anaddr
= SYMBOL_VALUE (msymbol2
);
937 dld_cache
.hook_stub
.address
= anaddr
;
940 store_unsigned_integer (buf
, 4, anaddr
);
942 msymbol
= lookup_minimal_symbol ("__dld_hook", NULL
, symfile_objfile
);
945 warning ("Unable to find __dld_hook symbol in object file.");
946 warning ("Suggest linking with /opt/langtools/lib/end.o.");
947 warning ("GDB will be unable to track shl_load/shl_unload calls");
950 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
951 status
= target_write_memory (anaddr
, buf
, 4);
953 /* Now set a shlib_event breakpoint at __d_trap so we can track
954 significant shared library events. */
955 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
958 warning ("Unable to find __dld_d_trap symbol in object file.");
959 warning ("Suggest linking with /opt/langtools/lib/end.o.");
960 warning ("GDB will be unable to track shl_load/shl_unload calls");
963 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
965 /* We have all the support usually found in end.o, so we can track
966 shl_load and shl_unload calls. */
971 /* Get the address of __dld_flags, if no such symbol exists, then we can
972 not debug the shared code. */
973 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
976 error ("Unable to find __dld_flags symbol in object file.\n");
979 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
981 /* Read the current contents. */
982 status
= target_read_memory (anaddr
, buf
, 4);
985 error ("Unable to read __dld_flags\n");
987 dld_flags
= extract_unsigned_integer (buf
, 4);
989 /* Turn on the flags we care about. */
990 dld_flags
|= DLD_FLAGS_MAPPRIVATE
;
992 dld_flags
|= DLD_FLAGS_HOOKVALID
;
993 store_unsigned_integer (buf
, 4, dld_flags
);
994 status
= target_write_memory (anaddr
, buf
, 4);
997 error ("Unable to write __dld_flags\n");
1000 /* Now find the address of _start and set a breakpoint there.
1001 We still need this code for two reasons:
1003 * Not all sites have /opt/langtools/lib/end.o, so it's not always
1004 possible to track the dynamic linker's events.
1006 * At this time no events are triggered for shared libraries
1007 loaded at startup time (what a crock). */
1009 msymbol
= lookup_minimal_symbol ("_start", NULL
, symfile_objfile
);
1010 if (msymbol
== NULL
)
1012 error ("Unable to find _start symbol in object file.\n");
1015 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1017 /* Make the breakpoint at "_start" a shared library event breakpoint. */
1018 create_solib_event_breakpoint (anaddr
);
1020 /* Wipe out all knowledge of old shared libraries since their
1021 mapping can change from one exec to another! */
1022 while (so_list_head
)
1024 struct so_list
*temp
;
1026 temp
= so_list_head
;
1027 xfree (so_list_head
);
1028 so_list_head
= temp
->next
;
1030 clear_symtab_users ();
1035 reset_inferior_pid (int saved_inferior_pid
)
1037 inferior_pid
= saved_inferior_pid
;
1041 /* This operation removes the "hook" between GDB and the dynamic linker,
1042 which causes the dld to notify GDB of shared library events.
1044 After this operation completes, the dld will no longer notify GDB of
1045 shared library events. To resume notifications, GDB must call
1046 som_solib_create_inferior_hook.
1048 This operation does not remove any knowledge of shared libraries which
1049 GDB may already have been notified of.
1052 som_solib_remove_inferior_hook (int pid
)
1055 struct minimal_symbol
*msymbol
;
1057 char dld_flags_buffer
[TARGET_INT_BIT
/ TARGET_CHAR_BIT
];
1058 unsigned int dld_flags_value
;
1059 int saved_inferior_pid
= inferior_pid
;
1060 struct cleanup
*old_cleanups
= make_cleanup (reset_inferior_pid
, saved_inferior_pid
);
1062 /* Ensure that we're really operating on the specified process. */
1065 /* We won't bother to remove the solib breakpoints from this process.
1067 In fact, on PA64 the breakpoint is hard-coded into the dld callback,
1068 and thus we're not supposed to remove it.
1070 Rather, we'll merely clear the dld_flags bit that enables callbacks.
1072 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
1074 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1075 status
= target_read_memory (addr
, dld_flags_buffer
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
);
1077 dld_flags_value
= extract_unsigned_integer (dld_flags_buffer
,
1078 sizeof (dld_flags_value
));
1080 dld_flags_value
&= ~DLD_FLAGS_HOOKVALID
;
1081 store_unsigned_integer (dld_flags_buffer
,
1082 sizeof (dld_flags_value
),
1084 status
= target_write_memory (addr
, dld_flags_buffer
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
);
1086 do_cleanups (old_cleanups
);
1090 /* This function creates a breakpoint on the dynamic linker hook, which
1091 is called when e.g., a shl_load or shl_unload call is made. This
1092 breakpoint will only trigger when a shl_load call is made.
1094 If filename is NULL, then loads of any dll will be caught. Else,
1095 only loads of the file whose pathname is the string contained by
1096 filename will be caught.
1098 Undefined behaviour is guaranteed if this function is called before
1099 som_solib_create_inferior_hook.
1102 som_solib_create_catch_load_hook (int pid
, int tempflag
, char *filename
,
1105 create_solib_load_event_breakpoint ("__d_trap", tempflag
, filename
, cond_string
);
1108 /* This function creates a breakpoint on the dynamic linker hook, which
1109 is called when e.g., a shl_load or shl_unload call is made. This
1110 breakpoint will only trigger when a shl_unload call is made.
1112 If filename is NULL, then unloads of any dll will be caught. Else,
1113 only unloads of the file whose pathname is the string contained by
1114 filename will be caught.
1116 Undefined behaviour is guaranteed if this function is called before
1117 som_solib_create_inferior_hook.
1120 som_solib_create_catch_unload_hook (int pid
, int tempflag
, char *filename
,
1123 create_solib_unload_event_breakpoint ("__d_trap", tempflag
, filename
, cond_string
);
1127 som_solib_have_load_event (int pid
)
1129 CORE_ADDR event_kind
;
1131 event_kind
= read_register (ARG0_REGNUM
);
1132 return (event_kind
== SHL_LOAD
);
1136 som_solib_have_unload_event (int pid
)
1138 CORE_ADDR event_kind
;
1140 event_kind
= read_register (ARG0_REGNUM
);
1141 return (event_kind
== SHL_UNLOAD
);
1145 som_solib_library_pathname (int pid
)
1147 CORE_ADDR dll_handle_address
;
1148 CORE_ADDR dll_pathname_address
;
1149 struct som_solib_mapped_entry dll_descriptor
;
1151 static char dll_pathname
[1024];
1153 /* Read the descriptor of this newly-loaded library. */
1154 dll_handle_address
= read_register (ARG1_REGNUM
);
1155 read_memory (dll_handle_address
, (char *) &dll_descriptor
, sizeof (dll_descriptor
));
1157 /* We can find a pointer to the dll's pathname within the descriptor. */
1158 dll_pathname_address
= (CORE_ADDR
) dll_descriptor
.name
;
1160 /* Read the pathname, one byte at a time. */
1165 read_memory (dll_pathname_address
++, (char *) &b
, 1);
1171 return dll_pathname
;
1175 som_solib_loaded_library_pathname (int pid
)
1177 if (!som_solib_have_load_event (pid
))
1178 error ("Must have a load event to use this query");
1180 return som_solib_library_pathname (pid
);
1184 som_solib_unloaded_library_pathname (int pid
)
1186 if (!som_solib_have_unload_event (pid
))
1187 error ("Must have an unload event to use this query");
1189 return som_solib_library_pathname (pid
);
1193 som_solib_desire_dynamic_linker_symbols (void)
1195 struct objfile
*objfile
;
1196 struct unwind_table_entry
*u
;
1197 struct minimal_symbol
*dld_msymbol
;
1199 /* Do we already know the value of these symbols? If so, then
1200 we've no work to do.
1202 (If you add clauses to this test, be sure to likewise update the
1203 test within the loop.)
1205 if (dld_cache
.is_valid
)
1208 ALL_OBJFILES (objfile
)
1210 dld_msymbol
= lookup_minimal_symbol ("shl_load", NULL
, objfile
);
1211 if (dld_msymbol
!= NULL
)
1213 dld_cache
.load
.address
= SYMBOL_VALUE (dld_msymbol
);
1214 dld_cache
.load
.unwind
= find_unwind_entry (dld_cache
.load
.address
);
1217 dld_msymbol
= lookup_minimal_symbol_solib_trampoline ("shl_load",
1220 if (dld_msymbol
!= NULL
)
1222 if (SYMBOL_TYPE (dld_msymbol
) == mst_solib_trampoline
)
1224 u
= find_unwind_entry (SYMBOL_VALUE (dld_msymbol
));
1225 if ((u
!= NULL
) && (u
->stub_unwind
.stub_type
== EXPORT
))
1227 dld_cache
.load_stub
.address
= SYMBOL_VALUE (dld_msymbol
);
1228 dld_cache
.load_stub
.unwind
= u
;
1233 dld_msymbol
= lookup_minimal_symbol ("shl_unload", NULL
, objfile
);
1234 if (dld_msymbol
!= NULL
)
1236 dld_cache
.unload
.address
= SYMBOL_VALUE (dld_msymbol
);
1237 dld_cache
.unload
.unwind
= find_unwind_entry (dld_cache
.unload
.address
);
1239 /* ??rehrauer: I'm not sure exactly what this is, but it appears
1240 that on some HPUX 10.x versions, there's two unwind regions to
1241 cover the body of "shl_unload", the second being 4 bytes past
1242 the end of the first. This is a large hack to handle that
1243 case, but since I don't seem to have any legitimate way to
1244 look for this thing via the symbol table...
1246 if (dld_cache
.unload
.unwind
!= NULL
)
1248 u
= find_unwind_entry (dld_cache
.unload
.unwind
->region_end
+ 4);
1251 dld_cache
.unload2
.address
= u
->region_start
;
1252 dld_cache
.unload2
.unwind
= u
;
1257 dld_msymbol
= lookup_minimal_symbol_solib_trampoline ("shl_unload",
1260 if (dld_msymbol
!= NULL
)
1262 if (SYMBOL_TYPE (dld_msymbol
) == mst_solib_trampoline
)
1264 u
= find_unwind_entry (SYMBOL_VALUE (dld_msymbol
));
1265 if ((u
!= NULL
) && (u
->stub_unwind
.stub_type
== EXPORT
))
1267 dld_cache
.unload_stub
.address
= SYMBOL_VALUE (dld_msymbol
);
1268 dld_cache
.unload_stub
.unwind
= u
;
1273 /* Did we find everything we were looking for? If so, stop. */
1274 if ((dld_cache
.load
.address
!= NULL
) && (dld_cache
.load_stub
.address
!= NULL
)
1275 && (dld_cache
.unload
.address
!= NULL
) && (dld_cache
.unload_stub
.address
!= NULL
))
1277 dld_cache
.is_valid
= 1;
1282 dld_cache
.hook
.unwind
= find_unwind_entry (dld_cache
.hook
.address
);
1283 dld_cache
.hook_stub
.unwind
= find_unwind_entry (dld_cache
.hook_stub
.address
);
1285 /* We're prepared not to find some of these symbols, which is why
1286 this function is a "desire" operation, and not a "require".
1291 som_solib_in_dynamic_linker (int pid
, CORE_ADDR pc
)
1293 struct unwind_table_entry
*u_pc
;
1295 /* Are we in the dld itself?
1297 ??rehrauer: Large hack -- We'll assume that any address in a
1298 shared text region is the dld's text. This would obviously
1299 fall down if the user attached to a process, whose shlibs
1300 weren't mapped to a (writeable) private region. However, in
1301 that case the debugger probably isn't able to set the fundamental
1302 breakpoint in the dld callback anyways, so this hack should be
1305 if ((pc
& (CORE_ADDR
) 0xc0000000) == (CORE_ADDR
) 0xc0000000)
1308 /* Cache the address of some symbols that are part of the dynamic
1309 linker, if not already known.
1311 som_solib_desire_dynamic_linker_symbols ();
1313 /* Are we in the dld callback? Or its export stub? */
1314 u_pc
= find_unwind_entry (pc
);
1318 if ((u_pc
== dld_cache
.hook
.unwind
) || (u_pc
== dld_cache
.hook_stub
.unwind
))
1321 /* Or the interface of the dld (i.e., "shl_load" or friends)? */
1322 if ((u_pc
== dld_cache
.load
.unwind
)
1323 || (u_pc
== dld_cache
.unload
.unwind
)
1324 || (u_pc
== dld_cache
.unload2
.unwind
)
1325 || (u_pc
== dld_cache
.load_stub
.unwind
)
1326 || (u_pc
== dld_cache
.unload_stub
.unwind
))
1329 /* Apparently this address isn't part of the dld's text. */
1334 /* Return the GOT value for the shared library in which ADDR belongs. If
1335 ADDR isn't in any known shared library, return zero. */
1338 som_solib_get_got_by_pc (CORE_ADDR addr
)
1340 struct so_list
*so_list
= so_list_head
;
1341 CORE_ADDR got_value
= 0;
1345 if (so_list
->som_solib
.text_addr
<= addr
1346 && so_list
->som_solib
.text_end
> addr
)
1348 got_value
= so_list
->som_solib
.got_value
;
1351 so_list
= so_list
->next
;
1357 Return the address of the handle of the shared library
1358 in which ADDR belongs. If
1359 ADDR isn't in any known shared library, return zero. */
1360 /* this function is used in hppa_fix_call_dummy in hppa-tdep.c */
1363 som_solib_get_solib_by_pc (CORE_ADDR addr
)
1365 struct so_list
*so_list
= so_list_head
;
1369 if (so_list
->som_solib
.text_addr
<= addr
1370 && so_list
->som_solib
.text_end
> addr
)
1374 so_list
= so_list
->next
;
1377 return so_list
->solib_addr
;
1384 som_solib_section_offsets (struct objfile
*objfile
,
1385 struct section_offsets
*offsets
)
1387 struct so_list
*so_list
= so_list_head
;
1391 /* Oh what a pain! We need the offsets before so_list->objfile
1392 is valid. The BFDs will never match. Make a best guess. */
1393 if (strstr (objfile
->name
, so_list
->som_solib
.name
))
1395 asection
*private_section
;
1397 /* The text offset is easy. */
1398 offsets
->offsets
[SECT_OFF_TEXT (objfile
)]
1399 = (so_list
->som_solib
.text_addr
1400 - so_list
->som_solib
.text_link_addr
);
1401 offsets
->offsets
[SECT_OFF_RODATA (objfile
)]
1402 = ANOFFSET (offsets
, SECT_OFF_TEXT (objfile
));
1404 /* We should look at presumed_dp in the SOM header, but
1405 that's not easily available. This should be OK though. */
1406 private_section
= bfd_get_section_by_name (objfile
->obfd
,
1408 if (!private_section
)
1410 warning ("Unable to find $PRIVATE$ in shared library!");
1411 offsets
->offsets
[SECT_OFF_DATA (objfile
)] = 0;
1412 offsets
->offsets
[SECT_OFF_BSS (objfile
)] = 0;
1415 offsets
->offsets
[SECT_OFF_DATA (objfile
)]
1416 = (so_list
->som_solib
.data_start
- private_section
->vma
);
1417 offsets
->offsets
[SECT_OFF_BSS (objfile
)]
1418 = ANOFFSET (offsets
, SECT_OFF_DATA (objfile
));
1421 so_list
= so_list
->next
;
1426 /* Dump information about all the currently loaded shared libraries. */
1429 som_sharedlibrary_info_command (char *ignore
, int from_tty
)
1431 struct so_list
*so_list
= so_list_head
;
1433 if (exec_bfd
== NULL
)
1435 printf_unfiltered ("No executable file.\n");
1439 if (so_list
== NULL
)
1441 printf_unfiltered ("No shared libraries loaded at this time.\n");
1445 printf_unfiltered ("Shared Object Libraries\n");
1446 printf_unfiltered (" %-12s%-12s%-12s%-12s%-12s%-12s\n",
1447 " flags", " tstart", " tend", " dstart", " dend", " dlt");
1452 flags
= so_list
->som_solib
.struct_version
<< 24;
1453 flags
|= so_list
->som_solib
.bind_mode
<< 16;
1454 flags
|= so_list
->som_solib
.library_version
;
1455 printf_unfiltered ("%s", so_list
->som_solib
.name
);
1456 if (so_list
->objfile
== NULL
)
1457 printf_unfiltered (" (symbols not loaded)");
1458 printf_unfiltered ("\n");
1459 printf_unfiltered (" %-12s", local_hex_string_custom (flags
, "08l"));
1460 printf_unfiltered ("%-12s",
1461 local_hex_string_custom (so_list
->som_solib
.text_addr
, "08l"));
1462 printf_unfiltered ("%-12s",
1463 local_hex_string_custom (so_list
->som_solib
.text_end
, "08l"));
1464 printf_unfiltered ("%-12s",
1465 local_hex_string_custom (so_list
->som_solib
.data_start
, "08l"));
1466 printf_unfiltered ("%-12s",
1467 local_hex_string_custom (so_list
->som_solib
.data_end
, "08l"));
1468 printf_unfiltered ("%-12s\n",
1469 local_hex_string_custom (so_list
->som_solib
.got_value
, "08l"));
1470 so_list
= so_list
->next
;
1475 som_solib_sharedlibrary_command (char *args
, int from_tty
)
1478 som_solib_add (args
, from_tty
, (struct target_ops
*) 0);
1484 som_solib_address (CORE_ADDR addr
)
1486 struct so_list
*so
= so_list_head
;
1490 /* Is this address within this shlib's text range? If so,
1491 return the shlib's name.
1493 if ((addr
>= so
->som_solib
.text_addr
) && (addr
<= so
->som_solib
.text_end
))
1494 return so
->som_solib
.name
;
1496 /* Nope, keep looking... */
1500 /* No, we couldn't prove that the address is within a shlib. */
1506 som_solib_restart (void)
1508 struct so_list
*sl
= so_list_head
;
1510 /* Before the shlib info vanishes, use it to disable any breakpoints
1511 that may still be active in those shlibs.
1513 disable_breakpoints_in_shlibs (0);
1515 /* Discard all the shlib descriptors.
1519 struct so_list
*next_sl
= sl
->next
;
1523 so_list_head
= NULL
;
1525 som_solib_total_st_size
= (LONGEST
) 0;
1526 som_solib_st_size_threshold_exceeded
= 0;
1528 dld_cache
.is_valid
= 0;
1530 dld_cache
.hook
.address
= 0;
1531 dld_cache
.hook
.unwind
= NULL
;
1533 dld_cache
.hook_stub
.address
= 0;
1534 dld_cache
.hook_stub
.unwind
= NULL
;
1536 dld_cache
.load
.address
= 0;
1537 dld_cache
.load
.unwind
= NULL
;
1539 dld_cache
.load_stub
.address
= 0;
1540 dld_cache
.load_stub
.unwind
= NULL
;
1542 dld_cache
.unload
.address
= 0;
1543 dld_cache
.unload
.unwind
= NULL
;
1545 dld_cache
.unload2
.address
= 0;
1546 dld_cache
.unload2
.unwind
= NULL
;
1548 dld_cache
.unload_stub
.address
= 0;
1549 dld_cache
.unload_stub
.unwind
= NULL
;
1555 _initialize_som_solib (void)
1557 add_com ("sharedlibrary", class_files
, som_solib_sharedlibrary_command
,
1558 "Load shared object library symbols for files matching REGEXP.");
1559 add_info ("sharedlibrary", som_sharedlibrary_info_command
,
1560 "Status of loaded shared object libraries.");
1562 (add_set_cmd ("auto-solib-add", class_support
, var_zinteger
,
1563 (char *) &auto_solib_add
,
1564 "Set autoloading size threshold (in megabytes) of shared library symbols.\n\
1565 If nonzero, symbols from all shared object libraries will be loaded\n\
1566 automatically when the inferior begins execution or when the dynamic linker\n\
1567 informs gdb that a new library has been loaded, until the symbol table\n\
1568 of the program and libraries exceeds this threshold.\n\
1569 Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
1573 /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how much
1574 data space a process can use. We ought to be reading MAXDSIZ and
1575 setting auto_solib_add to some large fraction of that value. If
1576 not that, we maybe ought to be setting it smaller than the default
1577 for MAXDSIZ (that being 64Mb, I believe). However, [1] this threshold
1578 is only crudely approximated rather than actually measured, and [2]
1579 50 Mbytes is too small for debugging gdb itself. Thus, the arbitrary
1582 auto_solib_add
= 100; /* Megabytes */
1584 som_solib_restart ();
1587 /* Get some HPUX-specific data from a shared lib.
1590 so_lib_thread_start_addr (struct so_list
*so
)
1592 return so
->som_solib
.tsd_start_addr
;