1 /* Handle shared libraries for GDB, the GNU Debugger.
2
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
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.
12
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.
17
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. */
22
23 #include "defs.h"
24
25 #include <sys/types.h>
26 #include <fcntl.h>
27 #include "gdb_string.h"
28 #include "symtab.h"
29 #include "bfd.h"
30 #include "symfile.h"
31 #include "objfiles.h"
32 #include "gdbcore.h"
33 #include "command.h"
34 #include "target.h"
35 #include "frame.h"
36 #include "gdb_regex.h"
37 #include "inferior.h"
38 #include "environ.h"
39 #include "language.h"
40 #include "gdbcmd.h"
41 #include "completer.h"
42 #include "filenames.h" /* for DOSish file names */
43 #include "exec.h"
44 #include "solist.h"
45 #include "observer.h"
46 #include "readline/readline.h"
47
48 /* external data declarations */
49
50 /* FIXME: gdbarch needs to control this variable */
51 struct target_so_ops *current_target_so_ops;
52
53 /* local data declarations */
54
55 static struct so_list *so_list_head; /* List of known shared objects */
56
57 static int solib_cleanup_queued = 0; /* make_run_cleanup called */
58
59 /* Local function prototypes */
60
61 static void do_clear_solib (void *);
62
63 /* If non-zero, this is a prefix that will be added to the front of the name
64 shared libraries with an absolute filename for loading. */
65 static char *solib_absolute_prefix = NULL;
66
67 /* If non-empty, this is a search path for loading non-absolute shared library
68 symbol files. This takes precedence over the environment variables PATH
69 and LD_LIBRARY_PATH. */
70 static char *solib_search_path = NULL;
71
72 void add_to_target_sections (int, struct target_ops *, struct so_list *);
73
74 /*
75
76 GLOBAL FUNCTION
77
78 solib_open -- Find a shared library file and open it.
79
80 SYNOPSIS
81
82 int solib_open (char *in_patname, char **found_pathname);
83
84 DESCRIPTION
85
86 Global variable SOLIB_ABSOLUTE_PREFIX is used as a prefix directory
87 to search for shared libraries if they have an absolute path.
88
89 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
90 (or set of directories, as in LD_LIBRARY_PATH) to search for all
91 shared libraries if not found in SOLIB_ABSOLUTE_PREFIX.
92
93 Search algorithm:
94 * If there is a solib_absolute_prefix and path is absolute:
95 * Search for solib_absolute_prefix/path.
96 * else
97 * Look for it literally (unmodified).
98 * Look in SOLIB_SEARCH_PATH.
99 * If available, use target defined search function.
100 * If solib_absolute_prefix is NOT set, perform the following two searches:
101 * Look in inferior's $PATH.
102 * Look in inferior's $LD_LIBRARY_PATH.
103 *
104 * The last check avoids doing this search when targetting remote
105 * machines since solib_absolute_prefix will almost always be set.
106
107 RETURNS
108
109 file handle for opened solib, or -1 for failure. */
110
111 int
solib_open(char * in_pathname,char ** found_pathname)112 solib_open (char *in_pathname, char **found_pathname)
113 {
114 int found_file = -1;
115 char *temp_pathname = NULL;
116 char *p = in_pathname;
117
118 while (*p && !IS_DIR_SEPARATOR (*p))
119 p++;
120
121 if (*p)
122 {
123 if (! IS_ABSOLUTE_PATH (in_pathname) || solib_absolute_prefix == NULL)
124 temp_pathname = in_pathname;
125 else
126 {
127 int prefix_len = strlen (solib_absolute_prefix);
128
129 /* Remove trailing slashes from absolute prefix. */
130 while (prefix_len > 0
131 && IS_DIR_SEPARATOR (solib_absolute_prefix[prefix_len - 1]))
132 prefix_len--;
133
134 /* Cat the prefixed pathname together. */
135 temp_pathname = alloca (prefix_len + strlen (in_pathname) + 1);
136 strncpy (temp_pathname, solib_absolute_prefix, prefix_len);
137 temp_pathname[prefix_len] = '\0';
138 strcat (temp_pathname, in_pathname);
139 }
140
141 /* Now see if we can open it. */
142 found_file = open (temp_pathname, O_RDONLY, 0);
143 }
144
145 /* If the search in solib_absolute_prefix failed, and the path name is
146 absolute at this point, make it relative. (openp will try and open the
147 file according to its absolute path otherwise, which is not what we want.)
148 Affects subsequent searches for this solib. */
149 if (found_file < 0 && IS_ABSOLUTE_PATH (in_pathname))
150 {
151 /* First, get rid of any drive letters etc. */
152 while (!IS_DIR_SEPARATOR (*in_pathname))
153 in_pathname++;
154
155 /* Next, get rid of all leading dir separators. */
156 while (IS_DIR_SEPARATOR (*in_pathname))
157 in_pathname++;
158 }
159
160 /* If not found, search the solib_search_path (if any). */
161 if (found_file < 0 && solib_search_path != NULL)
162 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST,
163 in_pathname, O_RDONLY, 0, &temp_pathname);
164
165 /* If not found, next search the solib_search_path (if any) for the basename
166 only (ignoring the path). This is to allow reading solibs from a path
167 that differs from the opened path. */
168 if (found_file < 0 && solib_search_path != NULL)
169 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST,
170 lbasename (in_pathname), O_RDONLY, 0,
171 &temp_pathname);
172
173 /* If not found, try to use target supplied solib search method */
174 if (found_file < 0 && TARGET_SO_FIND_AND_OPEN_SOLIB != NULL)
175 found_file = TARGET_SO_FIND_AND_OPEN_SOLIB
176 (in_pathname, O_RDONLY, &temp_pathname);
177
178 /* If not found, next search the inferior's $PATH environment variable. */
179 if (found_file < 0 && solib_absolute_prefix == NULL)
180 found_file = openp (get_in_environ (inferior_environ, "PATH"),
181 OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY, 0,
182 &temp_pathname);
183
184 /* If not found, next search the inferior's $LD_LIBRARY_PATH
185 environment variable. */
186 if (found_file < 0 && solib_absolute_prefix == NULL)
187 found_file = openp (get_in_environ (inferior_environ, "LD_LIBRARY_PATH"),
188 OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY, 0,
189 &temp_pathname);
190
191 /* Done. If not found, tough luck. Return found_file and
192 (optionally) found_pathname. */
193 if (found_pathname != NULL && temp_pathname != NULL)
194 *found_pathname = xstrdup (temp_pathname);
195 return found_file;
196 }
197
198
199 /*
200
201 LOCAL FUNCTION
202
203 solib_map_sections -- open bfd and build sections for shared lib
204
205 SYNOPSIS
206
207 static int solib_map_sections (struct so_list *so)
208
209 DESCRIPTION
210
211 Given a pointer to one of the shared objects in our list
212 of mapped objects, use the recorded name to open a bfd
213 descriptor for the object, build a section table, and then
214 relocate all the section addresses by the base address at
215 which the shared object was mapped.
216
217 FIXMES
218
219 In most (all?) cases the shared object file name recorded in the
220 dynamic linkage tables will be a fully qualified pathname. For
221 cases where it isn't, do we really mimic the systems search
222 mechanism correctly in the below code (particularly the tilde
223 expansion stuff?).
224 */
225
226 static int
solib_map_sections(void * arg)227 solib_map_sections (void *arg)
228 {
229 struct so_list *so = (struct so_list *) arg; /* catch_errors bogon */
230 char *filename;
231 char *scratch_pathname;
232 int scratch_chan;
233 struct section_table *p;
234 struct cleanup *old_chain;
235 bfd *abfd;
236
237 filename = tilde_expand (so->so_name);
238
239 old_chain = make_cleanup (xfree, filename);
240 scratch_chan = solib_open (filename, &scratch_pathname);
241
242 if (scratch_chan < 0)
243 {
244 perror_with_name (filename);
245 }
246
247 /* Leave scratch_pathname allocated. abfd->name will point to it. */
248 abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
249 if (!abfd)
250 {
251 close (scratch_chan);
252 error ("Could not open `%s' as an executable file: %s",
253 scratch_pathname, bfd_errmsg (bfd_get_error ()));
254 }
255
256 /* Leave bfd open, core_xfer_memory and "info files" need it. */
257 so->abfd = abfd;
258 bfd_set_cacheable (abfd, 1);
259
260 /* copy full path name into so_name, so that later symbol_file_add
261 can find it */
262 if (strlen (scratch_pathname) >= SO_NAME_MAX_PATH_SIZE)
263 error ("Full path name length of shared library exceeds SO_NAME_MAX_PATH_SIZE in so_list structure.");
264 strcpy (so->so_name, scratch_pathname);
265
266 if (!bfd_check_format (abfd, bfd_object))
267 {
268 error ("\"%s\": not in executable format: %s.",
269 scratch_pathname, bfd_errmsg (bfd_get_error ()));
270 }
271 if (build_section_table (abfd, &so->sections, &so->sections_end))
272 {
273 error ("Can't find the file sections in `%s': %s",
274 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
275 }
276
277 for (p = so->sections; p < so->sections_end; p++)
278 {
279 /* Relocate the section binding addresses as recorded in the shared
280 object's file by the base address to which the object was actually
281 mapped. */
282 TARGET_SO_RELOCATE_SECTION_ADDRESSES (so, p);
283 if (strcmp (p->the_bfd_section->name, ".text") == 0)
284 {
285 so->textsection = p;
286 }
287 }
288
289 /* Free the file names, close the file now. */
290 do_cleanups (old_chain);
291
292 return (1);
293 }
294
295 /* LOCAL FUNCTION
296
297 free_so --- free a `struct so_list' object
298
299 SYNOPSIS
300
301 void free_so (struct so_list *so)
302
303 DESCRIPTION
304
305 Free the storage associated with the `struct so_list' object SO.
306 If we have opened a BFD for SO, close it.
307
308 The caller is responsible for removing SO from whatever list it is
309 a member of. If we have placed SO's sections in some target's
310 section table, the caller is responsible for removing them.
311
312 This function doesn't mess with objfiles at all. If there is an
313 objfile associated with SO that needs to be removed, the caller is
314 responsible for taking care of that. */
315
316 void
free_so(struct so_list * so)317 free_so (struct so_list *so)
318 {
319 char *bfd_filename = 0;
320
321 if (so->sections)
322 xfree (so->sections);
323
324 if (so->abfd)
325 {
326 bfd_filename = bfd_get_filename (so->abfd);
327 if (! bfd_close (so->abfd))
328 warning ("cannot close \"%s\": %s",
329 bfd_filename, bfd_errmsg (bfd_get_error ()));
330 }
331
332 if (bfd_filename)
333 xfree (bfd_filename);
334
335 TARGET_SO_FREE_SO (so);
336
337 xfree (so);
338 }
339
340
341 /* Return address of first so_list entry in master shared object list. */
342 struct so_list *
master_so_list(void)343 master_so_list (void)
344 {
345 return so_list_head;
346 }
347
348
349 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
350
351 static int
symbol_add_stub(void * arg)352 symbol_add_stub (void *arg)
353 {
354 struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
355 struct section_addr_info *sap;
356
357 /* Have we already loaded this shared object? */
358 ALL_OBJFILES (so->objfile)
359 {
360 /* Found an already loaded shared library. */
361 if (strcmp (so->objfile->name, so->so_name) == 0
362 && !so->main)
363 return 1;
364 /* Found an already loaded main executable. This could happen in
365 two circumstances.
366 First case: the main file has already been read in
367 as the first thing that gdb does at startup, and the file
368 hasn't been relocated properly yet. Therefor we need to read
369 it in with the proper section info.
370 Second case: it has been read in with the correct relocation,
371 and therefore we need to skip it. */
372 if (strcmp (so->objfile->name, so->so_name) == 0
373 && so->main
374 && so->main_relocated)
375 return 1;
376 }
377
378 sap = build_section_addr_info_from_section_table (so->sections,
379 so->sections_end);
380
381 if (so->main)
382 {
383 so->objfile = symbol_file_add (so->so_name, /*so->from_tty*/ 0,
384 sap, 1, 0);
385 so->main_relocated = 1;
386 }
387 else
388 so->objfile = symbol_file_add (so->so_name, so->from_tty,
389 sap, 0, OBJF_SHARED);
390
391 free_section_addr_info (sap);
392
393 return (1);
394 }
395
396 /* Read in symbols for shared object SO. If FROM_TTY is non-zero, be
397 chatty about it. Return non-zero if any symbols were actually
398 loaded. */
399
400 int
solib_read_symbols(struct so_list * so,int from_tty)401 solib_read_symbols (struct so_list *so, int from_tty)
402 {
403 if (so->symbols_loaded)
404 {
405 if (from_tty)
406 printf_unfiltered (_("Symbols already loaded for %s\n"), so->so_name);
407 }
408 else
409 {
410 if (catch_errors (symbol_add_stub, so,
411 "Error while reading shared library symbols:\n",
412 RETURN_MASK_ALL))
413 {
414 if (from_tty)
415 printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name);
416 so->symbols_loaded = 1;
417 return 1;
418 }
419 }
420
421 return 0;
422 }
423
424 /* LOCAL FUNCTION
425
426 update_solib_list --- synchronize GDB's shared object list with inferior's
427
428 SYNOPSIS
429
430 void update_solib_list (int from_tty, struct target_ops *TARGET)
431
432 Extract the list of currently loaded shared objects from the
433 inferior, and compare it with the list of shared objects currently
434 in GDB's so_list_head list. Edit so_list_head to bring it in sync
435 with the inferior's new list.
436
437 If we notice that the inferior has unloaded some shared objects,
438 free any symbolic info GDB had read about those shared objects.
439
440 Don't load symbolic info for any new shared objects; just add them
441 to the list, and leave their symbols_loaded flag clear.
442
443 If FROM_TTY is non-null, feel free to print messages about what
444 we're doing.
445
446 If TARGET is non-null, add the sections of all new shared objects
447 to TARGET's section table. Note that this doesn't remove any
448 sections for shared objects that have been unloaded, and it
449 doesn't check to see if the new shared objects are already present in
450 the section table. But we only use this for core files and
451 processes we've just attached to, so that's okay. */
452
453 static void
update_solib_list(int from_tty,struct target_ops * target)454 update_solib_list (int from_tty, struct target_ops *target)
455 {
456 struct so_list *inferior = TARGET_SO_CURRENT_SOS ();
457 struct so_list *gdb, **gdb_link;
458
459 /* If we are attaching to a running process for which we
460 have not opened a symbol file, we may be able to get its
461 symbols now! */
462 if (attach_flag &&
463 symfile_objfile == NULL)
464 catch_errors (TARGET_SO_OPEN_SYMBOL_FILE_OBJECT, &from_tty,
465 "Error reading attached process's symbol file.\n",
466 RETURN_MASK_ALL);
467
468 /* Since this function might actually add some elements to the
469 so_list_head list, arrange for it to be cleaned up when
470 appropriate. */
471 if (!solib_cleanup_queued)
472 {
473 make_run_cleanup (do_clear_solib, NULL);
474 solib_cleanup_queued = 1;
475 }
476
477 /* GDB and the inferior's dynamic linker each maintain their own
478 list of currently loaded shared objects; we want to bring the
479 former in sync with the latter. Scan both lists, seeing which
480 shared objects appear where. There are three cases:
481
482 - A shared object appears on both lists. This means that GDB
483 knows about it already, and it's still loaded in the inferior.
484 Nothing needs to happen.
485
486 - A shared object appears only on GDB's list. This means that
487 the inferior has unloaded it. We should remove the shared
488 object from GDB's tables.
489
490 - A shared object appears only on the inferior's list. This
491 means that it's just been loaded. We should add it to GDB's
492 tables.
493
494 So we walk GDB's list, checking each entry to see if it appears
495 in the inferior's list too. If it does, no action is needed, and
496 we remove it from the inferior's list. If it doesn't, the
497 inferior has unloaded it, and we remove it from GDB's list. By
498 the time we're done walking GDB's list, the inferior's list
499 contains only the new shared objects, which we then add. */
500
501 gdb = so_list_head;
502 gdb_link = &so_list_head;
503 while (gdb)
504 {
505 struct so_list *i = inferior;
506 struct so_list **i_link = &inferior;
507
508 /* Check to see whether the shared object *gdb also appears in
509 the inferior's current list. */
510 while (i)
511 {
512 if (! strcmp (gdb->so_original_name, i->so_original_name))
513 break;
514
515 i_link = &i->next;
516 i = *i_link;
517 }
518
519 /* If the shared object appears on the inferior's list too, then
520 it's still loaded, so we don't need to do anything. Delete
521 it from the inferior's list, and leave it on GDB's list. */
522 if (i)
523 {
524 *i_link = i->next;
525 free_so (i);
526 gdb_link = &gdb->next;
527 gdb = *gdb_link;
528 }
529
530 /* If it's not on the inferior's list, remove it from GDB's tables. */
531 else
532 {
533 /* Notify any observer that the SO has been unloaded
534 before we remove it from the gdb tables. */
535 observer_notify_solib_unloaded (gdb);
536
537 *gdb_link = gdb->next;
538
539 /* Unless the user loaded it explicitly, free SO's objfile. */
540 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED))
541 free_objfile (gdb->objfile);
542
543 /* Some targets' section tables might be referring to
544 sections from so->abfd; remove them. */
545 remove_target_sections (gdb->abfd);
546
547 free_so (gdb);
548 gdb = *gdb_link;
549 }
550 }
551
552 /* Now the inferior's list contains only shared objects that don't
553 appear in GDB's list --- those that are newly loaded. Add them
554 to GDB's shared object list. */
555 if (inferior)
556 {
557 struct so_list *i;
558
559 /* Add the new shared objects to GDB's list. */
560 *gdb_link = inferior;
561
562 /* Fill in the rest of each of the `struct so_list' nodes. */
563 for (i = inferior; i; i = i->next)
564 {
565 add_to_target_sections (from_tty, target, i);
566 }
567 }
568 }
569
570 void
add_to_target_sections(int from_tty,struct target_ops * target,struct so_list * solib)571 add_to_target_sections (int from_tty, struct target_ops *target, struct so_list *solib)
572 {
573 /* If this is set, then the sections have been already added to the
574 target list. */
575 if (solib->main)
576 return;
577
578 solib->from_tty = from_tty;
579
580 /* Fill in the rest of the `struct so_list' node. */
581 catch_errors (solib_map_sections, solib,
582 "Error while mapping shared library sections:\n",
583 RETURN_MASK_ALL);
584
585 /* If requested, add the shared object's sections to the TARGET's
586 section table. Do this immediately after mapping the object so
587 that later nodes in the list can query this object, as is needed
588 in solib-osf.c. */
589 if (target)
590 {
591 int count = (solib->sections_end - solib->sections);
592 if (count > 0)
593 {
594 int space = target_resize_to_sections (target, count);
595 memcpy (target->to_sections + space,
596 solib->sections,
597 count * sizeof (solib->sections[0]));
598 }
599 }
600 /* Notify any observer that the shared object has been
601 loaded now that we've added it to GDB's tables. */
602 observer_notify_solib_loaded (solib);
603 }
604
605
606 /* GLOBAL FUNCTION
607
608 solib_add -- read in symbol info for newly added shared libraries
609
610 SYNOPSIS
611
612 void solib_add (char *pattern, int from_tty, struct target_ops
613 *TARGET, int readsyms)
614
615 DESCRIPTION
616
617 Read in symbolic information for any shared objects whose names
618 match PATTERN. (If we've already read a shared object's symbol
619 info, leave it alone.) If PATTERN is zero, read them all.
620
621 If READSYMS is 0, defer reading symbolic information until later
622 but still do any needed low level processing.
623
624 FROM_TTY and TARGET are as described for update_solib_list, above. */
625
626 void
solib_add(char * pattern,int from_tty,struct target_ops * target,int readsyms)627 solib_add (char *pattern, int from_tty, struct target_ops *target, int readsyms)
628 {
629 struct so_list *gdb;
630
631 if (pattern)
632 {
633 char *re_err = re_comp (pattern);
634
635 if (re_err)
636 error ("Invalid regexp: %s", re_err);
637 }
638
639 update_solib_list (from_tty, target);
640
641 /* Walk the list of currently loaded shared libraries, and read
642 symbols for any that match the pattern --- or any whose symbols
643 aren't already loaded, if no pattern was given. */
644 {
645 int any_matches = 0;
646 int loaded_any_symbols = 0;
647
648 for (gdb = so_list_head; gdb; gdb = gdb->next)
649 if (! pattern || re_exec (gdb->so_name))
650 {
651 any_matches = 1;
652 if (readsyms && solib_read_symbols (gdb, from_tty))
653 loaded_any_symbols = 1;
654 }
655
656 if (from_tty && pattern && ! any_matches)
657 printf_unfiltered
658 ("No loaded shared libraries match the pattern `%s'.\n", pattern);
659
660 if (loaded_any_symbols)
661 {
662 /* Getting new symbols may change our opinion about what is
663 frameless. */
664 reinit_frame_cache ();
665
666 TARGET_SO_SPECIAL_SYMBOL_HANDLING ();
667 }
668 }
669 }
670
671
672 /*
673
674 LOCAL FUNCTION
675
676 info_sharedlibrary_command -- code for "info sharedlibrary"
677
678 SYNOPSIS
679
680 static void info_sharedlibrary_command ()
681
682 DESCRIPTION
683
684 Walk through the shared library list and print information
685 about each attached library.
686 */
687
688 static void
info_sharedlibrary_command(char * ignore,int from_tty)689 info_sharedlibrary_command (char *ignore, int from_tty)
690 {
691 struct so_list *so = NULL; /* link map state variable */
692 int header_done = 0;
693 int addr_width;
694
695 if (TARGET_PTR_BIT == 32)
696 addr_width = 8 + 4;
697 else if (TARGET_PTR_BIT == 64)
698 addr_width = 16 + 4;
699 else
700 {
701 internal_error (__FILE__, __LINE__,
702 "TARGET_PTR_BIT returned unknown size %d",
703 TARGET_PTR_BIT);
704 }
705
706 update_solib_list (from_tty, 0);
707
708 for (so = so_list_head; so; so = so->next)
709 {
710 if (so->so_name[0])
711 {
712 if (!header_done)
713 {
714 printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From",
715 addr_width, "To", "Syms Read",
716 "Shared Object Library");
717 header_done++;
718 }
719
720 printf_unfiltered ("%-*s", addr_width,
721 so->textsection != NULL
722 ? hex_string_custom (
723 (LONGEST) so->textsection->addr,
724 addr_width - 4)
725 : "");
726 printf_unfiltered ("%-*s", addr_width,
727 so->textsection != NULL
728 ? hex_string_custom (
729 (LONGEST) so->textsection->endaddr,
730 addr_width - 4)
731 : "");
732 printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
733 printf_unfiltered ("%s\n", so->so_name);
734 }
735 }
736 if (so_list_head == NULL)
737 {
738 printf_unfiltered ("No shared libraries loaded at this time.\n");
739 }
740 }
741
742 /*
743
744 GLOBAL FUNCTION
745
746 solib_address -- check to see if an address is in a shared lib
747
748 SYNOPSIS
749
750 char * solib_address (CORE_ADDR address)
751
752 DESCRIPTION
753
754 Provides a hook for other gdb routines to discover whether or
755 not a particular address is within the mapped address space of
756 a shared library.
757
758 For example, this routine is called at one point to disable
759 breakpoints which are in shared libraries that are not currently
760 mapped in.
761 */
762
763 char *
solib_address(CORE_ADDR address)764 solib_address (CORE_ADDR address)
765 {
766 struct so_list *so = 0; /* link map state variable */
767
768 for (so = so_list_head; so; so = so->next)
769 {
770 struct section_table *p;
771
772 for (p = so->sections; p < so->sections_end; p++)
773 {
774 if (p->addr <= address && address < p->endaddr)
775 return (so->so_name);
776 }
777 }
778
779 return (0);
780 }
781
782 /* Called by free_all_symtabs */
783
784 void
clear_solib(void)785 clear_solib (void)
786 {
787 /* This function is expected to handle ELF shared libraries. It is
788 also used on Solaris, which can run either ELF or a.out binaries
789 (for compatibility with SunOS 4), both of which can use shared
790 libraries. So we don't know whether we have an ELF executable or
791 an a.out executable until the user chooses an executable file.
792
793 ELF shared libraries don't get mapped into the address space
794 until after the program starts, so we'd better not try to insert
795 breakpoints in them immediately. We have to wait until the
796 dynamic linker has loaded them; we'll hit a bp_shlib_event
797 breakpoint (look for calls to create_solib_event_breakpoint) when
798 it's ready.
799
800 SunOS shared libraries seem to be different --- they're present
801 as soon as the process begins execution, so there's no need to
802 put off inserting breakpoints. There's also nowhere to put a
803 bp_shlib_event breakpoint, so if we put it off, we'll never get
804 around to it.
805
806 So: disable breakpoints only if we're using ELF shared libs. */
807 if (exec_bfd != NULL
808 && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
809 disable_breakpoints_in_shlibs (1);
810
811 while (so_list_head)
812 {
813 struct so_list *so = so_list_head;
814 so_list_head = so->next;
815 if (so->abfd)
816 remove_target_sections (so->abfd);
817 free_so (so);
818 }
819
820 TARGET_SO_CLEAR_SOLIB ();
821 }
822
823 static void
do_clear_solib(void * dummy)824 do_clear_solib (void *dummy)
825 {
826 solib_cleanup_queued = 0;
827 clear_solib ();
828 }
829
830 /* GLOBAL FUNCTION
831
832 solib_create_inferior_hook -- shared library startup support
833
834 SYNOPSIS
835
836 void solib_create_inferior_hook()
837
838 DESCRIPTION
839
840 When gdb starts up the inferior, it nurses it along (through the
841 shell) until it is ready to execute it's first instruction. At this
842 point, this function gets called via expansion of the macro
843 SOLIB_CREATE_INFERIOR_HOOK. */
844
845 void
solib_create_inferior_hook(void)846 solib_create_inferior_hook (void)
847 {
848 TARGET_SO_SOLIB_CREATE_INFERIOR_HOOK ();
849 }
850
851 /* GLOBAL FUNCTION
852
853 in_solib_dynsym_resolve_code -- check to see if an address is in
854 dynamic loader's dynamic symbol
855 resolution code
856
857 SYNOPSIS
858
859 int in_solib_dynsym_resolve_code (CORE_ADDR pc)
860
861 DESCRIPTION
862
863 Determine if PC is in the dynamic linker's symbol resolution
864 code. Return 1 if so, 0 otherwise.
865 */
866
867 int
in_solib_dynsym_resolve_code(CORE_ADDR pc)868 in_solib_dynsym_resolve_code (CORE_ADDR pc)
869 {
870 return TARGET_SO_IN_DYNSYM_RESOLVE_CODE (pc);
871 }
872
873 /*
874
875 LOCAL FUNCTION
876
877 sharedlibrary_command -- handle command to explicitly add library
878
879 SYNOPSIS
880
881 static void sharedlibrary_command (char *args, int from_tty)
882
883 DESCRIPTION
884
885 */
886
887 static void
sharedlibrary_command(char * args,int from_tty)888 sharedlibrary_command (char *args, int from_tty)
889 {
890 dont_repeat ();
891 solib_add (args, from_tty, (struct target_ops *) 0, 1);
892 }
893
894 /* LOCAL FUNCTION
895
896 no_shared_libraries -- handle command to explicitly discard symbols
897 from shared libraries.
898
899 DESCRIPTION
900
901 Implements the command "nosharedlibrary", which discards symbols
902 that have been auto-loaded from shared libraries. Symbols from
903 shared libraries that were added by explicit request of the user
904 are not discarded. Also called from remote.c. */
905
906 void
no_shared_libraries(char * ignored,int from_tty)907 no_shared_libraries (char *ignored, int from_tty)
908 {
909 objfile_purge_solibs ();
910 do_clear_solib (NULL);
911 }
912
913 static void
reload_shared_libraries(char * ignored,int from_tty)914 reload_shared_libraries (char *ignored, int from_tty)
915 {
916 no_shared_libraries (NULL, from_tty);
917 solib_add (NULL, from_tty, NULL, auto_solib_add);
918 }
919
920 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
921
922 void
_initialize_solib(void)923 _initialize_solib (void)
924 {
925 struct cmd_list_element *c;
926
927 add_com ("sharedlibrary", class_files, sharedlibrary_command,
928 "Load shared object library symbols for files matching REGEXP.");
929 add_info ("sharedlibrary", info_sharedlibrary_command,
930 "Status of loaded shared object libraries.");
931 add_com ("nosharedlibrary", class_files, no_shared_libraries,
932 "Unload all shared object library symbols.");
933
934 deprecated_add_show_from_set
935 (add_set_cmd ("auto-solib-add", class_support, var_boolean,
936 (char *) &auto_solib_add,
937 "Set autoloading of shared library symbols.\n\
938 If \"on\", symbols from all shared object libraries will be loaded\n\
939 automatically when the inferior begins execution, when the dynamic linker\n\
940 informs gdb that a new library has been loaded, or when attaching to the\n\
941 inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
942 &setlist),
943 &showlist);
944
945 c = add_set_cmd ("solib-absolute-prefix", class_support, var_filename,
946 (char *) &solib_absolute_prefix,
947 "Set prefix for loading absolute shared library symbol files.\n\
948 For other (relative) files, you can add values using `set solib-search-path'.",
949 &setlist);
950 deprecated_add_show_from_set (c, &showlist);
951 set_cmd_cfunc (c, reload_shared_libraries);
952 set_cmd_completer (c, filename_completer);
953
954 /* Set the default value of "solib-absolute-prefix" from the sysroot, if
955 one is set. */
956 solib_absolute_prefix = xstrdup (gdb_sysroot);
957
958 c = add_set_cmd ("solib-search-path", class_support, var_string,
959 (char *) &solib_search_path,
960 "Set the search path for loading non-absolute shared library symbol files.\n\
961 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
962 &setlist);
963 deprecated_add_show_from_set (c, &showlist);
964 set_cmd_cfunc (c, reload_shared_libraries);
965 set_cmd_completer (c, filename_completer);
966 }
967