1 /* Handle OSF/1 shared libraries for GDB, the GNU Debugger.
2 Copyright 1993, 94, 95, 96, 98, 1999 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 /* FIXME: Most of this code could be merged with solib.c by using
22 next_link_map_member and xfer_link_map_member in solib.c. */
26 #include <sys/types.h>
28 #include "gdb_string.h"
39 #include "gdb_regex.h"
44 #define MAX_PATH_SIZE 1024 /* FIXME: Should be dynamic */
46 /* When handling shared libraries, GDB has to find out the pathnames
47 of all shared libraries that are currently loaded (to read in their
48 symbols) and where the shared libraries are loaded in memory
49 (to relocate them properly from their prelinked addresses to the
50 current load address).
52 Under OSF/1 there are two possibilities to get at this information:
53 1) Peek around in the runtime loader structures.
54 These are not documented, and they are not defined in the system
55 header files. The definitions below were obtained by experimentation,
56 but they seem stable enough.
57 2) Use the undocumented libxproc.a library, which contains the
58 equivalent ldr_* routines.
59 This approach is somewhat cleaner, but it requires that the GDB
60 executable is dynamically linked. In addition it requires a
61 NAT_CLIBS= -lxproc -Wl,-expect_unresolved,ldr_process_context
62 linker specification for GDB and all applications that are using
64 We will use the peeking approach until it becomes unwieldy. */
66 #ifndef USE_LDR_ROUTINES
68 /* Definition of runtime loader structures, found by experimentation. */
69 #define RLD_CONTEXT_ADDRESS 0x3ffc0000000
77 CORE_ADDR modinfo_addr
;
82 CORE_ADDR regioninfo_addr
;
89 CORE_ADDR regionname_addr
;
107 static ldr_context_t ldr_context
;
112 static ldr_process_t fake_ldr_process
;
114 /* Called by ldr_* routines to read memory from the current target. */
116 static int ldr_read_memory (CORE_ADDR
, char *, int, int);
119 ldr_read_memory (memaddr
, myaddr
, len
, readstring
)
130 target_read_string (memaddr
, &buffer
, len
, &result
);
132 strcpy (myaddr
, buffer
);
136 result
= target_read_memory (memaddr
, myaddr
, len
);
145 /* Define our own link_map structure.
146 This will help to share code with solib.c. */
150 CORE_ADDR l_offset
; /* prelink to load address offset */
151 char *l_name
; /* full name of loaded object */
152 ldr_module_info_t module_info
; /* corresponding module info */
155 #define LM_OFFSET(so) ((so) -> lm.l_offset)
156 #define LM_NAME(so) ((so) -> lm.l_name)
160 struct so_list
*next
; /* next structure in linked list */
161 struct link_map lm
; /* copy of link map from inferior */
162 struct link_map
*lmaddr
; /* addr in inferior lm was read from */
163 CORE_ADDR lmend
; /* upper addr bound of mapped object */
164 char so_name
[MAX_PATH_SIZE
]; /* shared object lib name (FIXME) */
165 char symbols_loaded
; /* flag: symbols read in yet? */
166 char from_tty
; /* flag: print msgs? */
167 struct objfile
*objfile
; /* objfile for loaded lib */
168 struct section_table
*sections
;
169 struct section_table
*sections_end
;
170 struct section_table
*textsection
;
174 static struct so_list
*so_list_head
; /* List of known shared objects */
176 extern int fdmatch (int, int); /* In libiberty */
178 /* Local function prototypes */
180 static void sharedlibrary_command (char *, int);
182 static void info_sharedlibrary_command (char *, int);
184 static int symbol_add_stub (char *);
186 static struct so_list
*find_solib (struct so_list
*);
188 static struct link_map
*first_link_map_member (void);
190 static struct link_map
*next_link_map_member (struct so_list
*);
192 static void xfer_link_map_member (struct so_list
*, struct link_map
*);
194 static int solib_map_sections (char *);
200 solib_map_sections -- open bfd and build sections for shared lib
204 static int solib_map_sections (struct so_list *so)
208 Given a pointer to one of the shared objects in our list
209 of mapped objects, use the recorded name to open a bfd
210 descriptor for the object, build a section table, and then
211 relocate all the section addresses by the base address at
212 which the shared object was mapped.
216 In most (all?) cases the shared object file name recorded in the
217 dynamic linkage tables will be a fully qualified pathname. For
218 cases where it isn't, do we really mimic the systems search
219 mechanism correctly in the below code (particularly the tilde
224 solib_map_sections (arg
)
227 struct so_list
*so
= (struct so_list
*) arg
; /* catch_errors bogon */
229 char *scratch_pathname
;
231 struct section_table
*p
;
232 struct cleanup
*old_chain
;
235 filename
= tilde_expand (so
->so_name
);
236 old_chain
= make_cleanup (free
, filename
);
238 scratch_chan
= openp (getenv ("PATH"), 1, filename
, O_RDONLY
, 0,
240 if (scratch_chan
< 0)
242 scratch_chan
= openp (getenv ("LD_LIBRARY_PATH"), 1, filename
,
243 O_RDONLY
, 0, &scratch_pathname
);
245 if (scratch_chan
< 0)
247 perror_with_name (filename
);
249 /* Leave scratch_pathname allocated. bfd->name will point to it. */
251 abfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
254 close (scratch_chan
);
255 error ("Could not open `%s' as an executable file: %s",
256 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
258 /* Leave bfd open, core_xfer_memory and "info files" need it. */
260 abfd
->cacheable
= true;
262 if (!bfd_check_format (abfd
, bfd_object
))
264 error ("\"%s\": not in executable format: %s.",
265 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
267 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
269 error ("Can't find the file sections in `%s': %s",
270 bfd_get_filename (exec_bfd
), bfd_errmsg (bfd_get_error ()));
273 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
275 /* Relocate the section binding addresses as recorded in the shared
276 object's file by the offset to get the address to which the
277 object was actually mapped. */
278 p
->addr
+= LM_OFFSET (so
);
279 p
->endaddr
+= LM_OFFSET (so
);
280 so
->lmend
= (CORE_ADDR
) max (p
->endaddr
, so
->lmend
);
281 if (STREQ (p
->the_bfd_section
->name
, ".text"))
287 /* Free the file names, close the file now. */
288 do_cleanups (old_chain
);
297 first_link_map_member -- locate first member in dynamic linker's map
301 static struct link_map *first_link_map_member (void)
305 Read in a copy of the first member in the inferior's dynamic
306 link map from the inferior's dynamic linker structures, and return
307 a pointer to the copy in our address space.
310 static struct link_map
*
311 first_link_map_member ()
313 struct link_map
*lm
= NULL
;
314 static struct link_map first_lm
;
316 #ifdef USE_LDR_ROUTINES
317 ldr_module_t mod_id
= LDR_NULL_MODULE
;
320 fake_ldr_process
= ldr_core_process ();
321 ldr_set_core_reader (ldr_read_memory
);
322 ldr_xdetach (fake_ldr_process
);
323 if (ldr_xattach (fake_ldr_process
) != 0
324 || ldr_next_module (fake_ldr_process
, &mod_id
) != 0
325 || mod_id
== LDR_NULL_MODULE
326 || ldr_inq_module (fake_ldr_process
, mod_id
,
327 &first_lm
.module_info
, sizeof (ldr_module_info_t
),
331 CORE_ADDR ldr_context_addr
;
333 if (target_read_memory ((CORE_ADDR
) RLD_CONTEXT_ADDRESS
,
334 (char *) &ldr_context_addr
,
335 sizeof (CORE_ADDR
)) != 0
336 || target_read_memory (ldr_context_addr
,
337 (char *) &ldr_context
,
338 sizeof (ldr_context_t
)) != 0
339 || target_read_memory ((CORE_ADDR
) ldr_context
.head
,
340 (char *) &first_lm
.module_info
,
341 sizeof (ldr_module_info_t
)) != 0)
347 /* The first entry is for the main program and should be skipped. */
353 static struct link_map
*
354 next_link_map_member (so_list_ptr
)
355 struct so_list
*so_list_ptr
;
357 struct link_map
*lm
= NULL
;
358 static struct link_map next_lm
;
359 #ifdef USE_LDR_ROUTINES
360 ldr_module_t mod_id
= so_list_ptr
->lm
.module_info
.lmi_modid
;
363 if (ldr_next_module (fake_ldr_process
, &mod_id
) != 0
364 || mod_id
== LDR_NULL_MODULE
365 || ldr_inq_module (fake_ldr_process
, mod_id
,
366 &next_lm
.module_info
, sizeof (ldr_module_info_t
),
371 lm
->l_name
= lm
->module_info
.lmi_name
;
373 CORE_ADDR ldr_context_addr
;
375 /* Reread context in case ldr_context.tail was updated. */
377 if (target_read_memory ((CORE_ADDR
) RLD_CONTEXT_ADDRESS
,
378 (char *) &ldr_context_addr
,
379 sizeof (CORE_ADDR
)) != 0
380 || target_read_memory (ldr_context_addr
,
381 (char *) &ldr_context
,
382 sizeof (ldr_context_t
)) != 0
383 || so_list_ptr
->lm
.module_info
.modinfo_addr
== ldr_context
.tail
384 || target_read_memory (so_list_ptr
->lm
.module_info
.next
,
385 (char *) &next_lm
.module_info
,
386 sizeof (ldr_module_info_t
)) != 0)
390 lm
->l_name
= lm
->module_info
.module_name
;
396 xfer_link_map_member (so_list_ptr
, lm
)
397 struct so_list
*so_list_ptr
;
401 so_list_ptr
->lm
= *lm
;
403 /* OSF/1 shared libraries are pre-linked to particular addresses,
404 but the runtime loader may have to relocate them if the
405 address ranges of the libraries used by the target executable clash,
406 or if the target executable is linked with the -taso option.
407 The offset is the difference between the address where the shared
408 library is mapped and the pre-linked address of the shared library.
410 FIXME: GDB is currently unable to relocate the shared library
411 sections by different offsets. If sections are relocated by
412 different offsets, put out a warning and use the offset of the
413 first section for all remaining sections. */
414 LM_OFFSET (so_list_ptr
) = 0;
416 /* There is one entry that has no name (for the inferior executable)
417 since it is not a shared object. */
418 if (LM_NAME (so_list_ptr
) != 0)
421 #ifdef USE_LDR_ROUTINES
422 int len
= strlen (LM_NAME (so_list_ptr
) + 1);
424 if (len
> MAX_PATH_SIZE
)
426 strncpy (so_list_ptr
->so_name
, LM_NAME (so_list_ptr
), MAX_PATH_SIZE
);
427 so_list_ptr
->so_name
[MAX_PATH_SIZE
- 1] = '\0';
429 for (i
= 0; i
< lm
->module_info
.lmi_nregion
; i
++)
431 ldr_region_info_t region_info
;
433 CORE_ADDR region_offset
;
435 if (ldr_inq_region (fake_ldr_process
, lm
->module_info
.lmi_modid
,
436 i
, ®ion_info
, sizeof (region_info
),
439 region_offset
= (CORE_ADDR
) region_info
.lri_mapaddr
440 - (CORE_ADDR
) region_info
.lri_vaddr
;
442 LM_OFFSET (so_list_ptr
) = region_offset
;
443 else if (LM_OFFSET (so_list_ptr
) != region_offset
)
444 warning ("cannot handle shared library relocation for %s (%s)",
445 so_list_ptr
->so_name
, region_info
.lri_name
);
450 target_read_string ((CORE_ADDR
) LM_NAME (so_list_ptr
), &buffer
,
451 MAX_PATH_SIZE
- 1, &errcode
);
453 error ("xfer_link_map_member: Can't read pathname for load map: %s\n",
454 safe_strerror (errcode
));
455 strncpy (so_list_ptr
->so_name
, buffer
, MAX_PATH_SIZE
- 1);
457 so_list_ptr
->so_name
[MAX_PATH_SIZE
- 1] = '\0';
459 for (i
= 0; i
< lm
->module_info
.region_count
; i
++)
461 ldr_region_info_t region_info
;
462 CORE_ADDR region_offset
;
464 if (target_read_memory (lm
->module_info
.regioninfo_addr
465 + i
* sizeof (region_info
),
466 (char *) ®ion_info
,
467 sizeof (region_info
)) != 0)
469 region_offset
= region_info
.mapaddr
- region_info
.vaddr
;
471 LM_OFFSET (so_list_ptr
) = region_offset
;
472 else if (LM_OFFSET (so_list_ptr
) != region_offset
)
475 target_read_string (region_info
.regionname_addr
, &buffer
,
476 MAX_PATH_SIZE
- 1, &errcode
);
478 region_name
= buffer
;
481 warning ("cannot handle shared library relocation for %s (%s)",
482 so_list_ptr
->so_name
, region_name
);
488 catch_errors (solib_map_sections
, (char *) so_list_ptr
,
489 "Error while mapping shared library sections:\n",
498 find_solib -- step through list of shared objects
502 struct so_list *find_solib (struct so_list *so_list_ptr)
506 This module contains the routine which finds the names of any
507 loaded "images" in the current process. The argument in must be
508 NULL on the first call, and then the returned value must be passed
509 in on subsequent calls. This provides the capability to "step" down
510 the list of loaded objects. On the last object, a NULL value is
513 The arg and return value are "struct link_map" pointers, as defined
517 static struct so_list
*
518 find_solib (so_list_ptr
)
519 struct so_list
*so_list_ptr
; /* Last lm or NULL for first one */
521 struct so_list
*so_list_next
= NULL
;
522 struct link_map
*lm
= NULL
;
525 if (so_list_ptr
== NULL
)
527 /* We are setting up for a new scan through the loaded images. */
528 if ((so_list_next
= so_list_head
) == NULL
)
530 /* Find the first link map list member. */
531 lm
= first_link_map_member ();
536 /* We have been called before, and are in the process of walking
537 the shared library list. Advance to the next shared object. */
538 lm
= next_link_map_member (so_list_ptr
);
539 so_list_next
= so_list_ptr
->next
;
541 if ((so_list_next
== NULL
) && (lm
!= NULL
))
543 /* Get next link map structure from inferior image and build a local
544 abbreviated load_map structure */
545 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
546 memset ((char *) new, 0, sizeof (struct so_list
));
548 /* Add the new node as the next node in the list, or as the root
549 node if this is the first one. */
550 if (so_list_ptr
!= NULL
)
552 so_list_ptr
->next
= new;
559 xfer_link_map_member (new, lm
);
561 return (so_list_next
);
564 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
567 symbol_add_stub (arg
)
570 register struct so_list
*so
= (struct so_list
*) arg
; /* catch_errs bogon */
571 CORE_ADDR text_addr
= 0;
572 struct section_addr_info section_addrs
;
574 memset (§ion_addrs
, 0, sizeof (section_addrs
));
576 text_addr
= so
->textsection
->addr
;
577 else if (so
->abfd
!= NULL
)
579 asection
*lowest_sect
;
581 /* If we didn't find a mapped non zero sized .text section, set up
582 text_addr so that the relocation in symbol_file_add does no harm. */
584 lowest_sect
= bfd_get_section_by_name (so
->abfd
, ".text");
585 if (lowest_sect
== NULL
)
586 bfd_map_over_sections (so
->abfd
, find_lowest_section
,
589 text_addr
= bfd_section_vma (so
->abfd
, lowest_sect
) + LM_OFFSET (so
);
592 section_addrs
.other
[0].addr
= text_addr
;
593 section_addrs
.other
[0].name
= ".text";
594 so
->objfile
= symbol_file_add (so
->so_name
, so
->from_tty
,
595 §ion_addrs
, 0, OBJF_SHARED
);
603 solib_add -- add a shared library file to the symtab and section list
607 void solib_add (char *arg_string, int from_tty,
608 struct target_ops *target)
615 solib_add (arg_string
, from_tty
, target
)
618 struct target_ops
*target
;
620 register struct so_list
*so
= NULL
; /* link map state variable */
622 /* Last shared library that we read. */
623 struct so_list
*so_last
= NULL
;
629 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
631 error ("Invalid regexp: %s", re_err
);
635 /* Add the shared library sections to the section table of the
636 specified target, if any. */
639 /* Count how many new section_table entries there are. */
642 while ((so
= find_solib (so
)) != NULL
)
646 count
+= so
->sections_end
- so
->sections
;
652 /* Add these section table entries to the target's table. */
654 old
= target_resize_to_sections (target
, count
);
656 while ((so
= find_solib (so
)) != NULL
)
660 count
= so
->sections_end
- so
->sections
;
661 memcpy ((char *) (target
->to_sections
+ old
),
663 (sizeof (struct section_table
)) * count
);
670 /* Now add the symbol files. */
672 while ((so
= find_solib (so
)) != NULL
)
674 if (so
->so_name
[0] && re_exec (so
->so_name
))
676 so
->from_tty
= from_tty
;
677 if (so
->symbols_loaded
)
681 printf_unfiltered ("Symbols already loaded for %s\n", so
->so_name
);
684 else if (catch_errors
685 (symbol_add_stub
, (char *) so
,
686 "Error while reading shared library symbols:\n",
690 so
->symbols_loaded
= 1;
695 /* Getting new symbols may change our opinion about what is
698 reinit_frame_cache ();
705 info_sharedlibrary_command -- code for "info sharedlibrary"
709 static void info_sharedlibrary_command ()
713 Walk through the shared library list and print information
714 about each attached library.
718 info_sharedlibrary_command (ignore
, from_tty
)
722 register struct so_list
*so
= NULL
; /* link map state variable */
725 if (exec_bfd
== NULL
)
727 printf_unfiltered ("No executable file.\n");
730 while ((so
= find_solib (so
)) != NULL
)
734 unsigned long txt_start
= 0;
735 unsigned long txt_end
= 0;
739 printf_unfiltered ("%-20s%-20s%-12s%s\n", "From", "To", "Syms Read",
740 "Shared Object Library");
745 txt_start
= (unsigned long) so
->textsection
->addr
;
746 txt_end
= (unsigned long) so
->textsection
->endaddr
;
748 printf_unfiltered ("%-20s", local_hex_string_custom (txt_start
, "08l"));
749 printf_unfiltered ("%-20s", local_hex_string_custom (txt_end
, "08l"));
750 printf_unfiltered ("%-12s", so
->symbols_loaded
? "Yes" : "No");
751 printf_unfiltered ("%s\n", so
->so_name
);
754 if (so_list_head
== NULL
)
756 printf_unfiltered ("No shared libraries loaded at this time.\n");
764 solib_address -- check to see if an address is in a shared lib
768 char *solib_address (CORE_ADDR address)
772 Provides a hook for other gdb routines to discover whether or
773 not a particular address is within the mapped address space of
774 a shared library. Any address between the base mapping address
775 and the first address beyond the end of the last mapping, is
776 considered to be within the shared library address space, for
779 For example, this routine is called at one point to disable
780 breakpoints which are in shared libraries that are not currently
785 solib_address (address
)
788 register struct so_list
*so
= 0; /* link map state variable */
790 while ((so
= find_solib (so
)) != NULL
)
792 if (so
->so_name
[0] && so
->textsection
)
794 if ((address
>= (CORE_ADDR
) so
->textsection
->addr
) &&
795 (address
< (CORE_ADDR
) so
->textsection
->endaddr
))
796 return (so
->so_name
);
802 /* Called by free_all_symtabs */
807 struct so_list
*next
;
810 disable_breakpoints_in_shlibs (1);
814 if (so_list_head
->sections
)
816 free ((PTR
) so_list_head
->sections
);
818 if (so_list_head
->abfd
)
820 bfd_filename
= bfd_get_filename (so_list_head
->abfd
);
821 if (!bfd_close (so_list_head
->abfd
))
822 warning ("cannot close \"%s\": %s",
823 bfd_filename
, bfd_errmsg (bfd_get_error ()));
826 /* This happens for the executable on SVR4. */
829 next
= so_list_head
->next
;
831 free ((PTR
) bfd_filename
);
832 free ((PTR
) so_list_head
);
841 solib_create_inferior_hook -- shared library startup support
845 void solib_create_inferior_hook()
849 When gdb starts up the inferior, it nurses it along (through the
850 shell) until it is ready to execute it's first instruction. At this
851 point, this function gets called via expansion of the macro
852 SOLIB_CREATE_INFERIOR_HOOK.
853 For a statically bound executable, this first instruction is the
854 one at "_start", or a similar text label. No further processing is
856 For a dynamically bound executable, this first instruction is somewhere
857 in the rld, and the actual user executable is not yet mapped in.
858 We continue the inferior again, rld then maps in the actual user
859 executable and any needed shared libraries and then sends
861 At that point we discover the names of all shared libraries and
862 read their symbols in.
866 This code does not properly handle hitting breakpoints which the
867 user might have set in the rld itself. Proper handling would have
868 to check if the SIGTRAP happened due to a kill call.
870 Also, what if child has exit()ed? Must exit loop somehow.
874 solib_create_inferior_hook ()
877 /* Nothing to do for statically bound executables. */
879 if (symfile_objfile
== NULL
880 || symfile_objfile
->obfd
== NULL
881 || ((bfd_get_file_flags (symfile_objfile
->obfd
) & DYNAMIC
) == 0))
884 /* Now run the target. It will eventually get a SIGTRAP, at
885 which point all of the libraries will have been mapped in and we
886 can go groveling around in the rld structures to find
887 out what we need to know about them. */
889 clear_proceed_status ();
890 stop_soon_quietly
= 1;
891 stop_signal
= TARGET_SIGNAL_0
;
894 target_resume (-1, 0, stop_signal
);
895 wait_for_inferior ();
897 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
899 /* solib_add will call reinit_frame_cache.
900 But we are stopped in the runtime loader and we do not have symbols
901 for the runtime loader. So heuristic_proc_start will be called
902 and will put out an annoying warning.
903 Delaying the resetting of stop_soon_quietly until after symbol loading
904 suppresses the warning. */
906 solib_add ((char *) 0, 0, (struct target_ops
*) 0);
907 stop_soon_quietly
= 0;
915 sharedlibrary_command -- handle command to explicitly add library
919 static void sharedlibrary_command (char *args, int from_tty)
926 sharedlibrary_command (args
, from_tty
)
931 solib_add (args
, from_tty
, (struct target_ops
*) 0);
937 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
938 "Load shared object library symbols for files matching REGEXP.");
939 add_info ("sharedlibrary", info_sharedlibrary_command
,
940 "Status of loaded shared object libraries.");
943 (add_set_cmd ("auto-solib-add", class_support
, var_zinteger
,
944 (char *) &auto_solib_add
,
945 "Set autoloading of shared library symbols.\n\
946 If nonzero, symbols from all shared object libraries will be loaded\n\
947 automatically when the inferior begins execution or when the dynamic linker\n\
948 informs gdb that a new library has been loaded. Otherwise, symbols\n\
949 must be loaded manually, using `sharedlibrary'.",