1 /* Handle SunOS shared libraries for GDB, the GNU Debugger.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
4 2000, 2001, 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. */
25 #include <sys/types.h>
27 #include "gdb_string.h"
28 #include <sys/param.h>
31 /* SunOS shared libs need the nlist structure. */
45 /* The shared library implementation found on BSD a.out systems is
46 very similar to the SunOS implementation. However, the data
47 structures defined in <link.h> are named very differently. Make up
48 for those differences here. */
50 #ifdef HAVE_STRUCT_SO_MAP_WITH_SOM_MEMBERS
52 /* FIXME: Temporary until the equivalent defines have been removed
53 from all nm-*bsd*.h files. */
56 /* Map `struct link_map' and its members. */
57 #define link_map so_map
58 #define lm_addr som_addr
59 #define lm_name som_path
60 #define lm_next som_next
62 /* Map `struct link_dynamic_2' and its members. */
63 #define link_dynamic_2 section_dispatch_table
64 #define ld_loaded sdt_loaded
66 /* Map `struct rtc_symb' and its members. */
67 #define rtc_symb rt_symbol
69 #define rtc_next rt_next
71 /* Map `struct ld_debug' and its members. */
72 #define ld_debug so_debug
73 #define ldd_in_debugger dd_in_debugger
74 #define ldd_bp_addr dd_bpt_addr
75 #define ldd_bp_inst dd_bpt_shadow
78 /* Map `struct link_dynamic' and its members. */
79 #define link_dynamic _dynamic
80 #define ld_version d_version
89 /* Link map info to include in an allocated so_list entry */
93 /* Pointer to copy of link map from inferior. The type is char *
94 rather than void *, so that we may use byte offsets to find the
95 various fields without the need for a cast. */
100 /* Symbols which are used to locate the base of the link map structures. */
102 static char *debug_base_symbols[] =
109 static char *main_name_list[] =
115 /* Macro to extract an address from a solib structure. When GDB is
116 configured for some 32-bit targets (e.g. Solaris 2.7 sparc), BFD is
117 configured to handle 64-bit targets, so CORE_ADDR is 64 bits. We
118 have to extract only the significant bits of addresses to get the
119 right address when accessing the core file BFD.
121 Assume that the address is unsigned. */
123 #define SOLIB_EXTRACT_ADDRESS(MEMBER) \
124 extract_unsigned_integer (&(MEMBER), sizeof (MEMBER))
126 /* local data declarations */
128 static struct link_dynamic dynamic_copy;
129 static struct link_dynamic_2 ld_2_copy;
130 static struct ld_debug debug_copy;
131 static CORE_ADDR debug_addr;
132 static CORE_ADDR flag_addr;
135 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
137 #define fieldsize(TYPE, MEMBER) (sizeof (((TYPE *)0)->MEMBER))
139 /* link map access functions */
142 LM_ADDR (struct so_list *so)
144 int lm_addr_offset = offsetof (struct link_map, lm_addr);
145 int lm_addr_size = fieldsize (struct link_map, lm_addr);
147 return (CORE_ADDR) extract_signed_integer (so->lm_info->lm + lm_addr_offset,
152 LM_NEXT (struct so_list *so)
154 int lm_next_offset = offsetof (struct link_map, lm_next);
155 int lm_next_size = fieldsize (struct link_map, lm_next);
157 /* Assume that the address is unsigned. */
158 return extract_unsigned_integer (so->lm_info->lm + lm_next_offset,
163 LM_NAME (struct so_list *so)
165 int lm_name_offset = offsetof (struct link_map, lm_name);
166 int lm_name_size = fieldsize (struct link_map, lm_name);
168 /* Assume that the address is unsigned. */
169 return extract_unsigned_integer (so->lm_info->lm + lm_name_offset,
173 static CORE_ADDR debug_base; /* Base of dynamic linker structures */
175 /* Local function prototypes */
177 static int match_main (char *);
179 /* Allocate the runtime common object file. */
182 allocate_rt_common_objfile (void)
184 struct objfile *objfile;
185 struct objfile *last_one;
187 objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
188 memset (objfile, 0, sizeof (struct objfile));
190 objfile->psymbol_cache = bcache_xmalloc ();
191 objfile->macro_cache = bcache_xmalloc ();
192 obstack_init (&objfile->objfile_obstack);
193 objfile->name = xstrdup ("rt_common");
195 /* Add this file onto the tail of the linked list of other such files. */
197 objfile->next = NULL;
198 if (object_files == NULL)
199 object_files = objfile;
202 for (last_one = object_files;
204 last_one = last_one->next);
205 last_one->next = objfile;
208 rt_common_objfile = objfile;
211 /* Read all dynamically loaded common symbol definitions from the inferior
212 and put them into the minimal symbol table for the runtime common
216 solib_add_common_symbols (CORE_ADDR rtc_symp)
218 struct rtc_symb inferior_rtc_symb;
219 struct nlist inferior_rtc_nlist;
223 /* Remove any runtime common symbols from previous runs. */
225 if (rt_common_objfile != NULL && rt_common_objfile->minimal_symbol_count)
227 obstack_free (&rt_common_objfile->objfile_obstack, 0);
228 obstack_init (&rt_common_objfile->objfile_obstack);
229 rt_common_objfile->minimal_symbol_count = 0;
230 rt_common_objfile->msymbols = NULL;
231 terminate_minimal_symbol_table (rt_common_objfile);
234 init_minimal_symbol_collection ();
235 make_cleanup_discard_minimal_symbols ();
239 read_memory (rtc_symp,
240 (char *) &inferior_rtc_symb,
241 sizeof (inferior_rtc_symb));
242 read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_sp),
243 (char *) &inferior_rtc_nlist,
244 sizeof (inferior_rtc_nlist));
245 if (inferior_rtc_nlist.n_type == N_COMM)
247 /* FIXME: The length of the symbol name is not available, but in the
248 current implementation the common symbol is allocated immediately
249 behind the name of the symbol. */
250 len = inferior_rtc_nlist.n_value - inferior_rtc_nlist.n_un.n_strx;
252 name = xmalloc (len);
253 read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_nlist.n_un.n_name),
256 /* Allocate the runtime common objfile if necessary. */
257 if (rt_common_objfile == NULL)
258 allocate_rt_common_objfile ();
260 prim_record_minimal_symbol (name, inferior_rtc_nlist.n_value,
261 mst_bss, rt_common_objfile);
264 rtc_symp = SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_next);
267 /* Install any minimal symbols that have been collected as the current
268 minimal symbols for the runtime common objfile. */
270 install_minimal_symbols (rt_common_objfile);
278 locate_base -- locate the base address of dynamic linker structs
282 CORE_ADDR locate_base (void)
286 For both the SunOS and SVR4 shared library implementations, if the
287 inferior executable has been linked dynamically, there is a single
288 address somewhere in the inferior's data space which is the key to
289 locating all of the dynamic linker's runtime structures. This
290 address is the value of the debug base symbol. The job of this
291 function is to find and return that address, or to return 0 if there
292 is no such address (the executable is statically linked for example).
294 For SunOS, the job is almost trivial, since the dynamic linker and
295 all of it's structures are statically linked to the executable at
296 link time. Thus the symbol for the address we are looking for has
297 already been added to the minimal symbol table for the executable's
298 objfile at the time the symbol file's symbols were read, and all we
299 have to do is look it up there. Note that we explicitly do NOT want
300 to find the copies in the shared library.
302 The SVR4 version is a bit more complicated because the address
303 is contained somewhere in the dynamic info section. We have to go
304 to a lot more work to discover the address of the debug base symbol.
305 Because of this complexity, we cache the value we find and return that
306 value on subsequent invocations. Note there is no copy in the
307 executable symbol tables.
314 struct minimal_symbol *msymbol;
315 CORE_ADDR address = 0;
318 /* For SunOS, we want to limit the search for the debug base symbol to the
319 executable being debugged, since there is a duplicate named symbol in the
320 shared library. We don't want the shared library versions. */
322 for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++)
324 msymbol = lookup_minimal_symbol (*symbolp, NULL, symfile_objfile);
325 if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
327 address = SYMBOL_VALUE_ADDRESS (msymbol);
338 first_link_map_member -- locate first member in dynamic linker's map
342 static CORE_ADDR first_link_map_member (void)
346 Find the first element in the inferior's dynamic link map, and
347 return its address in the inferior. This function doesn't copy the
348 link map entry itself into our address space; current_sos actually
352 first_link_map_member (void)
356 read_memory (debug_base, (char *) &dynamic_copy, sizeof (dynamic_copy));
357 if (dynamic_copy.ld_version >= 2)
359 /* It is a version that we can deal with, so read in the secondary
360 structure and find the address of the link map list from it. */
361 read_memory (SOLIB_EXTRACT_ADDRESS (dynamic_copy.ld_un.ld_2),
362 (char *) &ld_2_copy, sizeof (struct link_dynamic_2));
363 lm = SOLIB_EXTRACT_ADDRESS (ld_2_copy.ld_loaded);
369 open_symbol_file_object (void *from_ttyp)
377 current_sos -- build a list of currently loaded shared objects
381 struct so_list *current_sos ()
385 Build a list of `struct so_list' objects describing the shared
386 objects currently loaded in the inferior. This list does not
387 include an entry for the main executable file.
389 Note that we only gather information directly available from the
390 inferior --- we don't examine any of the shared library files
391 themselves. The declaration of `struct so_list' says which fields
392 we provide values for. */
394 static struct so_list *
395 sunos_current_sos (void)
398 struct so_list *head = 0;
399 struct so_list **link_ptr = &head;
403 /* Make sure we've looked up the inferior's dynamic linker's base
407 debug_base = locate_base ();
409 /* If we can't find the dynamic linker's base structure, this
410 must not be a dynamically linked executable. Hmm. */
415 /* Walk the inferior's link map list, and build our list of
416 `struct so_list' nodes. */
417 lm = first_link_map_member ();
421 = (struct so_list *) xmalloc (sizeof (struct so_list));
422 struct cleanup *old_chain = make_cleanup (xfree, new);
424 memset (new, 0, sizeof (*new));
426 new->lm_info = xmalloc (sizeof (struct lm_info));
427 make_cleanup (xfree, new->lm_info);
429 new->lm_info->lm = xmalloc (sizeof (struct link_map));
430 make_cleanup (xfree, new->lm_info->lm);
431 memset (new->lm_info->lm, 0, sizeof (struct link_map));
433 read_memory (lm, new->lm_info->lm, sizeof (struct link_map));
437 /* Extract this shared object's name. */
438 target_read_string (LM_NAME (new), &buffer,
439 SO_NAME_MAX_PATH_SIZE - 1, &errcode);
441 warning (_("Can't read pathname for load map: %s."),
442 safe_strerror (errcode));
445 strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
446 new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
448 strcpy (new->so_original_name, new->so_name);
451 /* If this entry has no name, or its name matches the name
452 for the main executable, don't include it in the list. */
453 if (! new->so_name[0]
454 || match_main (new->so_name))
460 link_ptr = &new->next;
463 discard_cleanups (old_chain);
470 /* On some systems, the only way to recognize the link map entry for
471 the main executable file is by looking at its name. Return
472 non-zero iff SONAME matches one of the known main executable names. */
475 match_main (char *soname)
479 for (mainp = main_name_list; *mainp != NULL; mainp++)
481 if (strcmp (soname, *mainp) == 0)
490 sunos_in_dynsym_resolve_code (CORE_ADDR pc)
499 disable_break -- remove the "mapping changed" breakpoint
503 static int disable_break ()
507 Removes the breakpoint that gets hit when the dynamic linker
508 completes a mapping change.
515 CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */
519 /* Read the debugger structure from the inferior to retrieve the
520 address of the breakpoint and the original contents of the
521 breakpoint address. Remove the breakpoint by writing the original
524 read_memory (debug_addr, (char *) &debug_copy, sizeof (debug_copy));
526 /* Set `in_debugger' to zero now. */
528 write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
530 breakpoint_addr = SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_bp_addr);
531 write_memory (breakpoint_addr, (char *) &debug_copy.ldd_bp_inst,
532 sizeof (debug_copy.ldd_bp_inst));
534 /* For the SVR4 version, we always know the breakpoint address. For the
535 SunOS version we don't know it until the above code is executed.
536 Grumble if we are stopped anywhere besides the breakpoint address. */
538 if (stop_pc != breakpoint_addr)
540 warning (_("stopped at unknown breakpoint while handling shared libraries"));
551 enable_break -- arrange for dynamic linker to hit breakpoint
555 int enable_break (void)
559 Both the SunOS and the SVR4 dynamic linkers have, as part of their
560 debugger interface, support for arranging for the inferior to hit
561 a breakpoint after mapping in the shared libraries. This function
562 enables that breakpoint.
564 For SunOS, there is a special flag location (in_debugger) which we
565 set to 1. When the dynamic linker sees this flag set, it will set
566 a breakpoint at a location known only to itself, after saving the
567 original contents of that place and the breakpoint address itself,
568 in it's own internal structures. When we resume the inferior, it
569 will eventually take a SIGTRAP when it runs into the breakpoint.
570 We handle this (in a different place) by restoring the contents of
571 the breakpointed location (which is only known after it stops),
572 chasing around to locate the shared libraries that have been
573 loaded, then resuming.
575 For SVR4, the debugger interface structure contains a member (r_brk)
576 which is statically initialized at the time the shared library is
577 built, to the offset of a function (_r_debug_state) which is guaran-
578 teed to be called once before mapping in a library, and again when
579 the mapping is complete. At the time we are examining this member,
580 it contains only the unrelocated offset of the function, so we have
581 to do our own relocation. Later, when the dynamic linker actually
582 runs, it relocates r_brk to be the actual address of _r_debug_state().
584 The debugger interface structure also contains an enumeration which
585 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
586 depending upon whether or not the library is being mapped or unmapped,
587 and then set to RT_CONSISTENT after the library is mapped/unmapped.
597 /* Get link_dynamic structure */
599 j = target_read_memory (debug_base, (char *) &dynamic_copy,
600 sizeof (dynamic_copy));
607 /* Calc address of debugger interface structure */
609 debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
611 /* Calc address of `in_debugger' member of debugger interface structure */
613 flag_addr = debug_addr + (CORE_ADDR) ((char *) &debug_copy.ldd_in_debugger -
614 (char *) &debug_copy);
616 /* Write a value of 1 to this member. */
619 write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
629 special_symbol_handling -- additional shared library symbol handling
633 void special_symbol_handling ()
637 Once the symbols from a shared object have been loaded in the usual
638 way, we are called to do any system specific symbol handling that
641 For SunOS4, this consists of grunging around in the dynamic
642 linkers structures to find symbol definitions for "common" symbols
643 and adding them to the minimal symbol table for the runtime common
649 sunos_special_symbol_handling (void)
655 /* Get link_dynamic structure */
657 j = target_read_memory (debug_base, (char *) &dynamic_copy,
658 sizeof (dynamic_copy));
665 /* Calc address of debugger interface structure */
666 /* FIXME, this needs work for cross-debugging of core files
667 (byteorder, size, alignment, etc). */
669 debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
672 /* Read the debugger structure from the inferior, just to make sure
673 we have a current copy. */
675 j = target_read_memory (debug_addr, (char *) &debug_copy,
676 sizeof (debug_copy));
678 return; /* unreadable */
680 /* Get common symbol definitions for the loaded object. */
682 if (debug_copy.ldd_cp)
684 solib_add_common_symbols (SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_cp));
692 sunos_solib_create_inferior_hook -- shared library startup support
696 void sunos_solib_create_inferior_hook ()
700 When gdb starts up the inferior, it nurses it along (through the
701 shell) until it is ready to execute it's first instruction. At this
702 point, this function gets called via expansion of the macro
703 SOLIB_CREATE_INFERIOR_HOOK.
705 For SunOS executables, this first instruction is typically the
706 one at "_start", or a similar text label, regardless of whether
707 the executable is statically or dynamically linked. The runtime
708 startup code takes care of dynamically linking in any shared
709 libraries, once gdb allows the inferior to continue.
711 For SVR4 executables, this first instruction is either the first
712 instruction in the dynamic linker (for dynamically linked
713 executables) or the instruction at "start" for statically linked
714 executables. For dynamically linked executables, the system
715 first exec's /lib/libc.so.N, which contains the dynamic linker,
716 and starts it running. The dynamic linker maps in any needed
717 shared libraries, maps in the actual user executable, and then
718 jumps to "start" in the user executable.
720 For both SunOS shared libraries, and SVR4 shared libraries, we
721 can arrange to cooperate with the dynamic linker to discover the
722 names of shared libraries that are dynamically linked, and the
723 base addresses to which they are linked.
725 This function is responsible for discovering those names and
726 addresses, and saving sufficient information about them to allow
727 their symbols to be read at a later time.
731 Between enable_break() and disable_break(), this code does not
732 properly handle hitting breakpoints which the user might have
733 set in the startup code or in the dynamic linker itself. Proper
734 handling will probably have to wait until the implementation is
735 changed to use the "breakpoint handler function" method.
737 Also, what if child has exit()ed? Must exit loop somehow.
741 sunos_solib_create_inferior_hook (void)
743 if ((debug_base = locate_base ()) == 0)
745 /* Can't find the symbol or the executable is statically linked. */
749 if (!enable_break ())
751 warning (_("shared library handler failed to enable breakpoint"));
755 /* SCO and SunOS need the loop below, other systems should be using the
756 special shared library breakpoints and the shared library breakpoint
759 Now run the target. It will eventually hit the breakpoint, at
760 which point all of the libraries will have been mapped in and we
761 can go groveling around in the dynamic linker structures to find
762 out what we need to know about them. */
764 clear_proceed_status ();
765 stop_soon = STOP_QUIETLY;
766 stop_signal = TARGET_SIGNAL_0;
769 target_resume (pid_to_ptid (-1), 0, stop_signal);
770 wait_for_inferior ();
772 while (stop_signal != TARGET_SIGNAL_TRAP);
773 stop_soon = NO_STOP_QUIETLY;
775 /* We are now either at the "mapping complete" breakpoint (or somewhere
776 else, a condition we aren't prepared to deal with anyway), so adjust
777 the PC as necessary after a breakpoint, disable the breakpoint, and
778 add any shared libraries that were mapped in. */
780 if (DECR_PC_AFTER_BREAK)
782 stop_pc -= DECR_PC_AFTER_BREAK;
783 write_register (PC_REGNUM, stop_pc);
786 if (!disable_break ())
788 warning (_("shared library handler failed to disable breakpoint"));
791 solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add);
795 sunos_clear_solib (void)
801 sunos_free_so (struct so_list *so)
803 xfree (so->lm_info->lm);
808 sunos_relocate_section_addresses (struct so_list *so,
809 struct section_table *sec)
811 sec->addr += LM_ADDR (so);
812 sec->endaddr += LM_ADDR (so);
815 static struct target_so_ops sunos_so_ops;
818 _initialize_sunos_solib (void)
820 sunos_so_ops.relocate_section_addresses = sunos_relocate_section_addresses;
821 sunos_so_ops.free_so = sunos_free_so;
822 sunos_so_ops.clear_solib = sunos_clear_solib;
823 sunos_so_ops.solib_create_inferior_hook = sunos_solib_create_inferior_hook;
824 sunos_so_ops.special_symbol_handling = sunos_special_symbol_handling;
825 sunos_so_ops.current_sos = sunos_current_sos;
826 sunos_so_ops.open_symbol_file_object = open_symbol_file_object;
827 sunos_so_ops.in_dynsym_resolve_code = sunos_in_dynsym_resolve_code;
829 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
830 current_target_so_ops = &sunos_so_ops;