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