GDB (xrefs)
/tmp/gdb-7.10/gdb/solib.c
Go to the documentation of this file.
1 /* Handle shared libraries for GDB, the GNU Debugger.
2 
3  Copyright (C) 1990-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 
22 #include <sys/types.h>
23 #include <fcntl.h>
24 #include "symtab.h"
25 #include "bfd.h"
26 #include "symfile.h"
27 #include "objfiles.h"
28 #include "gdbcore.h"
29 #include "command.h"
30 #include "target.h"
31 #include "frame.h"
32 #include "gdb_regex.h"
33 #include "inferior.h"
34 #include "environ.h"
35 #include "language.h"
36 #include "gdbcmd.h"
37 #include "completer.h"
38 #include "filenames.h" /* for DOSish file names */
39 #include "exec.h"
40 #include "solist.h"
41 #include "observer.h"
42 #include "readline/readline.h"
43 #include "remote.h"
44 #include "solib.h"
45 #include "interps.h"
46 #include "filesystem.h"
47 #include "gdb_bfd.h"
48 #include "filestuff.h"
49 
50 /* Architecture-specific operations. */
51 
52 /* Per-architecture data key. */
53 static struct gdbarch_data *solib_data;
54 
55 static void *
56 solib_init (struct obstack *obstack)
57 {
58  struct target_so_ops **ops;
59 
60  ops = OBSTACK_ZALLOC (obstack, struct target_so_ops *);
61  *ops = current_target_so_ops;
62  return ops;
63 }
64 
65 static const struct target_so_ops *
67 {
68  const struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
69 
70  return *ops;
71 }
72 
73 /* Set the solib operations for GDBARCH to NEW_OPS. */
74 
75 void
76 set_solib_ops (struct gdbarch *gdbarch, const struct target_so_ops *new_ops)
77 {
78  const struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
79 
80  *ops = new_ops;
81 }
82 
83 
84 /* external data declarations */
85 
86 /* FIXME: gdbarch needs to control this variable, or else every
87  configuration needs to call set_solib_ops. */
89 
90 /* List of known shared objects */
91 #define so_list_head current_program_space->so_list
92 
93 /* Local function prototypes */
94 
95 /* If non-empty, this is a search path for loading non-absolute shared library
96  symbol files. This takes precedence over the environment variables PATH
97  and LD_LIBRARY_PATH. */
98 static char *solib_search_path = NULL;
99 static void
100 show_solib_search_path (struct ui_file *file, int from_tty,
101  struct cmd_list_element *c, const char *value)
102 {
103  fprintf_filtered (file, _("The search path for loading non-absolute "
104  "shared library symbol files is %s.\n"),
105  value);
106 }
107 
108 /* Same as HAVE_DOS_BASED_FILE_SYSTEM, but useable as an rvalue. */
109 #if (HAVE_DOS_BASED_FILE_SYSTEM)
110 # define DOS_BASED_FILE_SYSTEM 1
111 #else
112 # define DOS_BASED_FILE_SYSTEM 0
113 #endif
114 
115 /* Return the full pathname of a binary file (the main executable
116  or a shared library file), or NULL if not found. The returned
117  pathname is malloc'ed and must be freed by the caller. If FD
118  is non-NULL, *FD is set to either -1 or an open file handle for
119  the binary file.
120 
121  Global variable GDB_SYSROOT is used as a prefix directory
122  to search for binary files if they have an absolute path.
123  If GDB_SYSROOT starts with "target:" and target filesystem
124  is the local filesystem then the "target:" prefix will be
125  stripped before the search starts. This ensures that the
126  same search algorithm is used for local files regardless of
127  whether a "target:" prefix was used.
128 
129  Global variable SOLIB_SEARCH_PATH is used as a prefix directory
130  (or set of directories, as in LD_LIBRARY_PATH) to search for all
131  shared libraries if not found in either the sysroot (if set) or
132  the local filesystem. SOLIB_SEARCH_PATH is not used when searching
133  for the main executable.
134 
135  Search algorithm:
136  * If a sysroot is set and path is absolute:
137  * Search for sysroot/path.
138  * else
139  * Look for it literally (unmodified).
140  * If IS_SOLIB is non-zero:
141  * Look in SOLIB_SEARCH_PATH.
142  * If available, use target defined search function.
143  * If NO sysroot is set, perform the following two searches:
144  * Look in inferior's $PATH.
145  * If IS_SOLIB is non-zero:
146  * Look in inferior's $LD_LIBRARY_PATH.
147  *
148  * The last check avoids doing this search when targetting remote
149  * machines since a sysroot will almost always be set.
150 */
151 
152 static char *
153 solib_find_1 (char *in_pathname, int *fd, int is_solib)
154 {
155  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
156  int found_file = -1;
157  char *temp_pathname = NULL;
158  const char *fskind = effective_target_file_system_kind ();
159  struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
160  char *sysroot = gdb_sysroot;
161  int prefix_len, orig_prefix_len;
162 
163  /* If the absolute prefix starts with "target:" but the filesystem
164  accessed by the target_fileio_* methods is the local filesystem
165  then we strip the "target:" prefix now and work with the local
166  filesystem. This ensures that the same search algorithm is used
167  for all local files regardless of whether a "target:" prefix was
168  used. */
170  sysroot += strlen (TARGET_SYSROOT_PREFIX);
171 
172  /* Strip any trailing slashes from the absolute prefix. */
173  prefix_len = orig_prefix_len = strlen (sysroot);
174 
175  while (prefix_len > 0 && IS_DIR_SEPARATOR (sysroot[prefix_len - 1]))
176  prefix_len--;
177 
178  if (prefix_len == 0)
179  sysroot = NULL;
180  else if (prefix_len != orig_prefix_len)
181  {
182  sysroot = savestring (sysroot, prefix_len);
183  make_cleanup (xfree, sysroot);
184  }
185 
186  /* If we're on a non-DOS-based system, backslashes won't be
187  understood as directory separator, so, convert them to forward
188  slashes, iff we're supposed to handle DOS-based file system
189  semantics for target paths. */
191  {
192  char *p;
193 
194  /* Avoid clobbering our input. */
195  p = alloca (strlen (in_pathname) + 1);
196  strcpy (p, in_pathname);
197  in_pathname = p;
198 
199  for (; *p; p++)
200  {
201  if (*p == '\\')
202  *p = '/';
203  }
204  }
205 
206  /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not
207  IS_ABSOLUTE_PATH. The latter is for host paths only, while
208  IN_PATHNAME is a target path. For example, if we're supposed to
209  be handling DOS-like semantics we want to consider a
210  'c:/foo/bar.dll' path as an absolute path, even on a Unix box.
211  With such a path, before giving up on the sysroot, we'll try:
212 
213  1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll
214  2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll
215  3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll
216  */
217 
218  if (!IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname) || sysroot == NULL)
219  temp_pathname = xstrdup (in_pathname);
220  else
221  {
222  int need_dir_separator;
223 
224  /* Concatenate the sysroot and the target reported filename. We
225  may need to glue them with a directory separator. Cases to
226  consider:
227 
228  | sysroot | separator | in_pathname |
229  |-----------------+-----------+----------------|
230  | /some/dir | / | c:/foo/bar.dll |
231  | /some/dir | | /foo/bar.dll |
232  | target: | | c:/foo/bar.dll |
233  | target: | | /foo/bar.dll |
234  | target:some/dir | / | c:/foo/bar.dll |
235  | target:some/dir | | /foo/bar.dll |
236 
237  IOW, we don't need to add a separator if IN_PATHNAME already
238  has one, or when the the sysroot is exactly "target:".
239  There's no need to check for drive spec explicitly, as we only
240  get here if IN_PATHNAME is considered an absolute path. */
241  need_dir_separator = !(IS_DIR_SEPARATOR (in_pathname[0])
242  || strcmp (TARGET_SYSROOT_PREFIX, sysroot) == 0);
243 
244  /* Cat the prefixed pathname together. */
245  temp_pathname = concat (sysroot,
246  need_dir_separator ? SLASH_STRING : "",
247  in_pathname, (char *) NULL);
248  }
249 
250  /* Handle files to be accessed via the target. */
251  if (is_target_filename (temp_pathname))
252  {
253  if (fd != NULL)
254  *fd = -1;
255  do_cleanups (old_chain);
256  return temp_pathname;
257  }
258 
259  /* Now see if we can open it. */
260  found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
261  if (found_file < 0)
262  xfree (temp_pathname);
263 
264  /* If the search in gdb_sysroot failed, and the path name has a
265  drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
266  and retrying in the sysroot:
267  c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
268 
269  if (found_file < 0
270  && sysroot != NULL
271  && HAS_TARGET_DRIVE_SPEC (fskind, in_pathname))
272  {
273  int need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[2]);
274  char *drive = savestring (in_pathname, 1);
275 
276  temp_pathname = concat (sysroot,
277  SLASH_STRING,
278  drive,
279  need_dir_separator ? SLASH_STRING : "",
280  in_pathname + 2, (char *) NULL);
281  xfree (drive);
282 
283  found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
284  if (found_file < 0)
285  {
286  xfree (temp_pathname);
287 
288  /* If the search in gdb_sysroot still failed, try fully
289  stripping the drive spec, and trying once more in the
290  sysroot before giving up.
291 
292  c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
293 
294  temp_pathname = concat (sysroot,
295  need_dir_separator ? SLASH_STRING : "",
296  in_pathname + 2, (char *) NULL);
297 
298  found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
299  if (found_file < 0)
300  xfree (temp_pathname);
301  }
302  }
303 
304  do_cleanups (old_chain);
305 
306  /* We try to find the library in various ways. After each attempt,
307  either found_file >= 0 and temp_pathname is a malloc'd string, or
308  found_file < 0 and temp_pathname does not point to storage that
309  needs to be freed. */
310 
311  if (found_file < 0)
312  temp_pathname = NULL;
313 
314  /* If the search in gdb_sysroot failed, and the path name is
315  absolute at this point, make it relative. (openp will try and open the
316  file according to its absolute path otherwise, which is not what we want.)
317  Affects subsequent searches for this solib. */
318  if (found_file < 0 && IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname))
319  {
320  /* First, get rid of any drive letters etc. */
321  while (!IS_TARGET_DIR_SEPARATOR (fskind, *in_pathname))
322  in_pathname++;
323 
324  /* Next, get rid of all leading dir separators. */
325  while (IS_TARGET_DIR_SEPARATOR (fskind, *in_pathname))
326  in_pathname++;
327  }
328 
329  /* If not found, and we're looking for a solib, search the
330  solib_search_path (if any). */
331  if (is_solib && found_file < 0 && solib_search_path != NULL)
332  found_file = openp (solib_search_path,
334  in_pathname, O_RDONLY | O_BINARY, &temp_pathname);
335 
336  /* If not found, and we're looking for a solib, next search the
337  solib_search_path (if any) for the basename only (ignoring the
338  path). This is to allow reading solibs from a path that differs
339  from the opened path. */
340  if (is_solib && found_file < 0 && solib_search_path != NULL)
341  found_file = openp (solib_search_path,
343  target_lbasename (fskind, in_pathname),
344  O_RDONLY | O_BINARY, &temp_pathname);
345 
346  /* If not found, and we're looking for a solib, try to use target
347  supplied solib search method. */
348  if (is_solib && found_file < 0 && ops->find_and_open_solib)
349  found_file = ops->find_and_open_solib (in_pathname, O_RDONLY | O_BINARY,
350  &temp_pathname);
351 
352  /* If not found, next search the inferior's $PATH environment variable. */
353  if (found_file < 0 && sysroot == NULL)
354  found_file = openp (get_in_environ (current_inferior ()->environment,
355  "PATH"),
356  OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, in_pathname,
357  O_RDONLY | O_BINARY, &temp_pathname);
358 
359  /* If not found, and we're looking for a solib, next search the
360  inferior's $LD_LIBRARY_PATH environment variable. */
361  if (is_solib && found_file < 0 && sysroot == NULL)
362  found_file = openp (get_in_environ (current_inferior ()->environment,
363  "LD_LIBRARY_PATH"),
364  OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, in_pathname,
365  O_RDONLY | O_BINARY, &temp_pathname);
366 
367  if (fd == NULL)
368  {
369  if (found_file >= 0)
370  close (found_file);
371  }
372  else
373  *fd = found_file;
374 
375  return temp_pathname;
376 }
377 
378 /* Return the full pathname of the main executable, or NULL if not
379  found. The returned pathname is malloc'ed and must be freed by
380  the caller. If FD is non-NULL, *FD is set to either -1 or an open
381  file handle for the main executable.
382 
383  The search algorithm used is described in solib_find_1's comment
384  above. */
385 
386 char *
387 exec_file_find (char *in_pathname, int *fd)
388 {
389  char *result = solib_find_1 (in_pathname, fd, 0);
390 
391  if (result == NULL)
392  {
393  const char *fskind = effective_target_file_system_kind ();
394 
395  if (fskind == file_system_kind_dos_based)
396  {
397  char *new_pathname;
398 
399  new_pathname = alloca (strlen (in_pathname) + 5);
400  strcpy (new_pathname, in_pathname);
401  strcat (new_pathname, ".exe");
402 
403  result = solib_find_1 (new_pathname, fd, 0);
404  }
405  }
406 
407  return result;
408 }
409 
410 /* Return the full pathname of a shared library file, or NULL if not
411  found. The returned pathname is malloc'ed and must be freed by
412  the caller. If FD is non-NULL, *FD is set to either -1 or an open
413  file handle for the shared library.
414 
415  The search algorithm used is described in solib_find_1's comment
416  above. */
417 
418 char *
419 solib_find (char *in_pathname, int *fd)
420 {
421  const char *solib_symbols_extension
423 
424  /* If solib_symbols_extension is set, replace the file's
425  extension. */
426  if (solib_symbols_extension != NULL)
427  {
428  char *p = in_pathname + strlen (in_pathname);
429 
430  while (p > in_pathname && *p != '.')
431  p--;
432 
433  if (*p == '.')
434  {
435  char *new_pathname;
436 
437  new_pathname = alloca (p - in_pathname + 1
438  + strlen (solib_symbols_extension) + 1);
439  memcpy (new_pathname, in_pathname, p - in_pathname + 1);
440  strcpy (new_pathname + (p - in_pathname) + 1,
441  solib_symbols_extension);
442 
443  in_pathname = new_pathname;
444  }
445  }
446 
447  return solib_find_1 (in_pathname, fd, 1);
448 }
449 
450 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
451  it is used as file handle to open the file. Throws an error if the file
452  could not be opened. Handles both local and remote file access.
453 
454  PATHNAME must be malloc'ed by the caller. It will be freed by this
455  function. If unsuccessful, the FD will be closed (unless FD was
456  -1). */
457 
458 bfd *
459 solib_bfd_fopen (char *pathname, int fd)
460 {
461  bfd *abfd = gdb_bfd_open (pathname, gnutarget, fd);
462 
463  if (abfd != NULL && !gdb_bfd_has_target_filename (abfd))
464  bfd_set_cacheable (abfd, 1);
465 
466  if (!abfd)
467  {
468  make_cleanup (xfree, pathname);
469  error (_("Could not open `%s' as an executable file: %s"),
470  pathname, bfd_errmsg (bfd_get_error ()));
471  }
472 
473  xfree (pathname);
474 
475  return abfd;
476 }
477 
478 /* Find shared library PATHNAME and open a BFD for it. */
479 
480 bfd *
481 solib_bfd_open (char *pathname)
482 {
483  char *found_pathname;
484  int found_file;
485  bfd *abfd;
486  const struct bfd_arch_info *b;
487 
488  /* Search for shared library file. */
489  found_pathname = solib_find (pathname, &found_file);
490  if (found_pathname == NULL)
491  {
492  /* Return failure if the file could not be found, so that we can
493  accumulate messages about missing libraries. */
494  if (errno == ENOENT)
495  return NULL;
496 
497  perror_with_name (pathname);
498  }
499 
500  /* Open bfd for shared library. */
501  abfd = solib_bfd_fopen (found_pathname, found_file);
502 
503  /* Check bfd format. */
504  if (!bfd_check_format (abfd, bfd_object))
505  {
506  make_cleanup_bfd_unref (abfd);
507  error (_("`%s': not in executable format: %s"),
508  bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
509  }
510 
511  /* Check bfd arch. */
513  if (!b->compatible (b, bfd_get_arch_info (abfd)))
514  warning (_("`%s': Shared library architecture %s is not compatible "
515  "with target architecture %s."), bfd_get_filename (abfd),
516  bfd_get_arch_info (abfd)->printable_name, b->printable_name);
517 
518  return abfd;
519 }
520 
521 /* Given a pointer to one of the shared objects in our list of mapped
522  objects, use the recorded name to open a bfd descriptor for the
523  object, build a section table, relocate all the section addresses
524  by the base address at which the shared object was mapped, and then
525  add the sections to the target's section table.
526 
527  FIXME: In most (all?) cases the shared object file name recorded in
528  the dynamic linkage tables will be a fully qualified pathname. For
529  cases where it isn't, do we really mimic the systems search
530  mechanism correctly in the below code (particularly the tilde
531  expansion stuff?). */
532 
533 static int
535 {
536  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
537  char *filename;
538  struct target_section *p;
539  struct cleanup *old_chain;
540  bfd *abfd;
541 
542  filename = tilde_expand (so->so_name);
543  old_chain = make_cleanup (xfree, filename);
544  abfd = ops->bfd_open (filename);
545  do_cleanups (old_chain);
546 
547  if (abfd == NULL)
548  return 0;
549 
550  /* Leave bfd open, core_xfer_memory and "info files" need it. */
551  so->abfd = abfd;
552 
553  /* Copy the full path name into so_name, allowing symbol_file_add
554  to find it later. This also affects the =library-loaded GDB/MI
555  event, and in particular the part of that notification providing
556  the library's host-side path. If we let the target dictate
557  that objfile's path, and the target is different from the host,
558  GDB/MI will not provide the correct host-side path. */
559  if (strlen (bfd_get_filename (abfd)) >= SO_NAME_MAX_PATH_SIZE)
560  error (_("Shared library file name is too long."));
561  strcpy (so->so_name, bfd_get_filename (abfd));
562 
563  if (build_section_table (abfd, &so->sections, &so->sections_end))
564  {
565  error (_("Can't find the file sections in `%s': %s"),
566  bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
567  }
568 
569  for (p = so->sections; p < so->sections_end; p++)
570  {
571  /* Relocate the section binding addresses as recorded in the shared
572  object's file by the base address to which the object was actually
573  mapped. */
574  ops->relocate_section_addresses (so, p);
575 
576  /* If the target didn't provide information about the address
577  range of the shared object, assume we want the location of
578  the .text section. */
579  if (so->addr_low == 0 && so->addr_high == 0
580  && strcmp (p->the_bfd_section->name, ".text") == 0)
581  {
582  so->addr_low = p->addr;
583  so->addr_high = p->endaddr;
584  }
585  }
586 
587  /* Add the shared object's sections to the current set of file
588  section tables. Do this immediately after mapping the object so
589  that later nodes in the list can query this object, as is needed
590  in solib-osf.c. */
592 
593  return 1;
594 }
595 
596 /* Free symbol-file related contents of SO and reset for possible reloading
597  of SO. If we have opened a BFD for SO, close it. If we have placed SO's
598  sections in some target's section table, the caller is responsible for
599  removing them.
600 
601  This function doesn't mess with objfiles at all. If there is an
602  objfile associated with SO that needs to be removed, the caller is
603  responsible for taking care of that. */
604 
605 static void
606 clear_so (struct so_list *so)
607 {
608  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
609 
610  if (so->sections)
611  {
612  xfree (so->sections);
613  so->sections = so->sections_end = NULL;
614  }
615 
616  gdb_bfd_unref (so->abfd);
617  so->abfd = NULL;
618 
619  /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
620  so->symbols_loaded = 0;
621  so->objfile = NULL;
622 
623  so->addr_low = so->addr_high = 0;
624 
625  /* Restore the target-supplied file name. SO_NAME may be the path
626  of the symbol file. */
627  strcpy (so->so_name, so->so_original_name);
628 
629  /* Do the same for target-specific data. */
630  if (ops->clear_so != NULL)
631  ops->clear_so (so);
632 }
633 
634 /* Free the storage associated with the `struct so_list' object SO.
635  If we have opened a BFD for SO, close it.
636 
637  The caller is responsible for removing SO from whatever list it is
638  a member of. If we have placed SO's sections in some target's
639  section table, the caller is responsible for removing them.
640 
641  This function doesn't mess with objfiles at all. If there is an
642  objfile associated with SO that needs to be removed, the caller is
643  responsible for taking care of that. */
644 
645 void
646 free_so (struct so_list *so)
647 {
648  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
649 
650  clear_so (so);
651  ops->free_so (so);
652 
653  xfree (so);
654 }
655 
656 
657 /* Return address of first so_list entry in master shared object list. */
658 struct so_list *
660 {
661  return so_list_head;
662 }
663 
664 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
665  be chatty about it. Return non-zero if any symbols were actually
666  loaded. */
667 
668 int
670 {
671  if (so->symbols_loaded)
672  {
673  /* If needed, we've already warned in our caller. */
674  }
675  else if (so->abfd == NULL)
676  {
677  /* We've already warned about this library, when trying to open
678  it. */
679  }
680  else
681  {
682 
683  flags |= current_inferior ()->symfile_flags;
684 
685  TRY
686  {
687  struct section_addr_info *sap;
688 
689  /* Have we already loaded this shared object? */
690  ALL_OBJFILES (so->objfile)
691  {
692  if (filename_cmp (objfile_name (so->objfile), so->so_name) == 0
693  && so->objfile->addr_low == so->addr_low)
694  break;
695  }
696  if (so->objfile != NULL)
697  break;
698 
700  so->sections_end);
702  flags, sap, OBJF_SHARED,
703  NULL);
704  so->objfile->addr_low = so->addr_low;
706 
707  so->symbols_loaded = 1;
708  }
710  {
711  exception_fprintf (gdb_stderr, e, _("Error while reading shared"
712  " library symbols for %s:\n"),
713  so->so_name);
714  }
715  END_CATCH
716 
717  return 1;
718  }
719 
720  return 0;
721 }
722 
723 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
724  SO_LIST_HEAD list. Return 0 otherwise. */
725 
726 static int
727 solib_used (const struct so_list *const known)
728 {
729  const struct so_list *pivot;
730 
731  for (pivot = so_list_head; pivot != NULL; pivot = pivot->next)
732  if (pivot != known && pivot->objfile == known->objfile)
733  return 1;
734  return 0;
735 }
736 
737 /* Synchronize GDB's shared object list with inferior's.
738 
739  Extract the list of currently loaded shared objects from the
740  inferior, and compare it with the list of shared objects currently
741  in GDB's so_list_head list. Edit so_list_head to bring it in sync
742  with the inferior's new list.
743 
744  If we notice that the inferior has unloaded some shared objects,
745  free any symbolic info GDB had read about those shared objects.
746 
747  Don't load symbolic info for any new shared objects; just add them
748  to the list, and leave their symbols_loaded flag clear.
749 
750  If FROM_TTY is non-null, feel free to print messages about what
751  we're doing.
752 
753  If TARGET is non-null, add the sections of all new shared objects
754  to TARGET's section table. Note that this doesn't remove any
755  sections for shared objects that have been unloaded, and it
756  doesn't check to see if the new shared objects are already present in
757  the section table. But we only use this for core files and
758  processes we've just attached to, so that's okay. */
759 
760 static void
761 update_solib_list (int from_tty, struct target_ops *target)
762 {
763  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
764  struct so_list *inferior = ops->current_sos();
765  struct so_list *gdb, **gdb_link;
766 
767  /* We can reach here due to changing solib-search-path or the
768  sysroot, before having any inferior. */
770  {
771  struct inferior *inf = current_inferior ();
772 
773  /* If we are attaching to a running process for which we
774  have not opened a symbol file, we may be able to get its
775  symbols now! */
776  if (inf->attach_flag && symfile_objfile == NULL)
777  catch_errors (ops->open_symbol_file_object, &from_tty,
778  "Error reading attached process's symbol file.\n",
780  }
781 
782  /* GDB and the inferior's dynamic linker each maintain their own
783  list of currently loaded shared objects; we want to bring the
784  former in sync with the latter. Scan both lists, seeing which
785  shared objects appear where. There are three cases:
786 
787  - A shared object appears on both lists. This means that GDB
788  knows about it already, and it's still loaded in the inferior.
789  Nothing needs to happen.
790 
791  - A shared object appears only on GDB's list. This means that
792  the inferior has unloaded it. We should remove the shared
793  object from GDB's tables.
794 
795  - A shared object appears only on the inferior's list. This
796  means that it's just been loaded. We should add it to GDB's
797  tables.
798 
799  So we walk GDB's list, checking each entry to see if it appears
800  in the inferior's list too. If it does, no action is needed, and
801  we remove it from the inferior's list. If it doesn't, the
802  inferior has unloaded it, and we remove it from GDB's list. By
803  the time we're done walking GDB's list, the inferior's list
804  contains only the new shared objects, which we then add. */
805 
806  gdb = so_list_head;
807  gdb_link = &so_list_head;
808  while (gdb)
809  {
810  struct so_list *i = inferior;
811  struct so_list **i_link = &inferior;
812 
813  /* Check to see whether the shared object *gdb also appears in
814  the inferior's current list. */
815  while (i)
816  {
817  if (ops->same)
818  {
819  if (ops->same (gdb, i))
820  break;
821  }
822  else
823  {
824  if (! filename_cmp (gdb->so_original_name, i->so_original_name))
825  break;
826  }
827 
828  i_link = &i->next;
829  i = *i_link;
830  }
831 
832  /* If the shared object appears on the inferior's list too, then
833  it's still loaded, so we don't need to do anything. Delete
834  it from the inferior's list, and leave it on GDB's list. */
835  if (i)
836  {
837  *i_link = i->next;
838  free_so (i);
839  gdb_link = &gdb->next;
840  gdb = *gdb_link;
841  }
842 
843  /* If it's not on the inferior's list, remove it from GDB's tables. */
844  else
845  {
846  /* Notify any observer that the shared object has been
847  unloaded before we remove it from GDB's tables. */
849 
850  VEC_safe_push (char_ptr, current_program_space->deleted_solibs,
851  xstrdup (gdb->so_name));
852 
853  *gdb_link = gdb->next;
854 
855  /* Unless the user loaded it explicitly, free SO's objfile. */
856  if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)
857  && !solib_used (gdb))
858  free_objfile (gdb->objfile);
859 
860  /* Some targets' section tables might be referring to
861  sections from so->abfd; remove them. */
863 
864  free_so (gdb);
865  gdb = *gdb_link;
866  }
867  }
868 
869  /* Now the inferior's list contains only shared objects that don't
870  appear in GDB's list --- those that are newly loaded. Add them
871  to GDB's shared object list. */
872  if (inferior)
873  {
874  int not_found = 0;
875  const char *not_found_filename = NULL;
876 
877  struct so_list *i;
878 
879  /* Add the new shared objects to GDB's list. */
880  *gdb_link = inferior;
881 
882  /* Fill in the rest of each of the `struct so_list' nodes. */
883  for (i = inferior; i; i = i->next)
884  {
885 
887  VEC_safe_push (so_list_ptr, current_program_space->added_solibs, i);
888 
889  TRY
890  {
891  /* Fill in the rest of the `struct so_list' node. */
892  if (!solib_map_sections (i))
893  {
894  not_found++;
895  if (not_found_filename == NULL)
896  not_found_filename = i->so_original_name;
897  }
898  }
899 
901  {
903  _("Error while mapping shared "
904  "library sections:\n"));
905  }
906  END_CATCH
907 
908  /* Notify any observer that the shared object has been
909  loaded now that we've added it to GDB's tables. */
911  }
912 
913  /* If a library was not found, issue an appropriate warning
914  message. We have to use a single call to warning in case the
915  front end does something special with warnings, e.g., pop up
916  a dialog box. It Would Be Nice if we could get a "warning: "
917  prefix on each line in the CLI front end, though - it doesn't
918  stand out well. */
919 
920  if (not_found == 1)
921  warning (_("Could not load shared library symbols for %s.\n"
922  "Do you need \"set solib-search-path\" "
923  "or \"set sysroot\"?"),
924  not_found_filename);
925  else if (not_found > 1)
926  warning (_("\
927 Could not load shared library symbols for %d libraries, e.g. %s.\n\
928 Use the \"info sharedlibrary\" command to see the complete listing.\n\
929 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
930  not_found, not_found_filename);
931  }
932 }
933 
934 
935 /* Return non-zero if NAME is the libpthread shared library.
936 
937  Uses a fairly simplistic heuristic approach where we check
938  the file name against "/libpthread". This can lead to false
939  positives, but this should be good enough in practice. */
940 
941 int
942 libpthread_name_p (const char *name)
943 {
944  return (strstr (name, "/libpthread") != NULL);
945 }
946 
947 /* Return non-zero if SO is the libpthread shared library. */
948 
949 static int
951 {
952  return libpthread_name_p (so->so_name);
953 }
954 
955 /* Read in symbolic information for any shared objects whose names
956  match PATTERN. (If we've already read a shared object's symbol
957  info, leave it alone.) If PATTERN is zero, read them all.
958 
959  If READSYMS is 0, defer reading symbolic information until later
960  but still do any needed low level processing.
961 
962  FROM_TTY and TARGET are as described for update_solib_list, above. */
963 
964 void
965 solib_add (const char *pattern, int from_tty,
966  struct target_ops *target, int readsyms)
967 {
968  struct so_list *gdb;
969 
970  if (print_symbol_loading_p (from_tty, 0, 0))
971  {
972  if (pattern != NULL)
973  {
974  printf_unfiltered (_("Loading symbols for shared libraries: %s\n"),
975  pattern);
976  }
977  else
978  printf_unfiltered (_("Loading symbols for shared libraries.\n"));
979  }
980 
982 
983  if (pattern)
984  {
985  char *re_err = re_comp (pattern);
986 
987  if (re_err)
988  error (_("Invalid regexp: %s"), re_err);
989  }
990 
991  update_solib_list (from_tty, target);
992 
993  /* Walk the list of currently loaded shared libraries, and read
994  symbols for any that match the pattern --- or any whose symbols
995  aren't already loaded, if no pattern was given. */
996  {
997  int any_matches = 0;
998  int loaded_any_symbols = 0;
999  const int flags =
1000  SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0);
1001 
1002  for (gdb = so_list_head; gdb; gdb = gdb->next)
1003  if (! pattern || re_exec (gdb->so_name))
1004  {
1005  /* Normally, we would read the symbols from that library
1006  only if READSYMS is set. However, we're making a small
1007  exception for the pthread library, because we sometimes
1008  need the library symbols to be loaded in order to provide
1009  thread support (x86-linux for instance). */
1010  const int add_this_solib =
1011  (readsyms || libpthread_solib_p (gdb));
1012 
1013  any_matches = 1;
1014  if (add_this_solib)
1015  {
1016  if (gdb->symbols_loaded)
1017  {
1018  /* If no pattern was given, be quiet for shared
1019  libraries we have already loaded. */
1020  if (pattern && (from_tty || info_verbose))
1021  printf_unfiltered (_("Symbols already loaded for %s\n"),
1022  gdb->so_name);
1023  }
1024  else if (solib_read_symbols (gdb, flags))
1025  loaded_any_symbols = 1;
1026  }
1027  }
1028 
1029  if (loaded_any_symbols)
1030  breakpoint_re_set ();
1031 
1032  if (from_tty && pattern && ! any_matches)
1034  ("No loaded shared libraries match the pattern `%s'.\n", pattern);
1035 
1036  if (loaded_any_symbols)
1037  {
1038  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1039 
1040  /* Getting new symbols may change our opinion about what is
1041  frameless. */
1042  reinit_frame_cache ();
1043 
1044  ops->special_symbol_handling ();
1045  }
1046  }
1047 }
1048 
1049 /* Implement the "info sharedlibrary" command. Walk through the
1050  shared library list and print information about each attached
1051  library matching PATTERN. If PATTERN is elided, print them
1052  all. */
1053 
1054 static void
1055 info_sharedlibrary_command (char *pattern, int from_tty)
1056 {
1057  struct so_list *so = NULL; /* link map state variable */
1058  int so_missing_debug_info = 0;
1059  int addr_width;
1060  int nr_libs;
1061  struct cleanup *table_cleanup;
1062  struct gdbarch *gdbarch = target_gdbarch ();
1063  struct ui_out *uiout = current_uiout;
1064 
1065  if (pattern)
1066  {
1067  char *re_err = re_comp (pattern);
1068 
1069  if (re_err)
1070  error (_("Invalid regexp: %s"), re_err);
1071  }
1072 
1073  /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1074  addr_width = 4 + (gdbarch_ptr_bit (gdbarch) / 4);
1075 
1076  update_solib_list (from_tty, 0);
1077 
1078  /* make_cleanup_ui_out_table_begin_end needs to know the number of
1079  rows, so we need to make two passes over the libs. */
1080 
1081  for (nr_libs = 0, so = so_list_head; so; so = so->next)
1082  {
1083  if (so->so_name[0])
1084  {
1085  if (pattern && ! re_exec (so->so_name))
1086  continue;
1087  ++nr_libs;
1088  }
1089  }
1090 
1091  table_cleanup =
1092  make_cleanup_ui_out_table_begin_end (uiout, 4, nr_libs,
1093  "SharedLibraryTable");
1094 
1095  /* The "- 1" is because ui_out adds one space between columns. */
1096  ui_out_table_header (uiout, addr_width - 1, ui_left, "from", "From");
1097  ui_out_table_header (uiout, addr_width - 1, ui_left, "to", "To");
1098  ui_out_table_header (uiout, 12 - 1, ui_left, "syms-read", "Syms Read");
1099  ui_out_table_header (uiout, 0, ui_noalign,
1100  "name", "Shared Object Library");
1101 
1102  ui_out_table_body (uiout);
1103 
1104  for (so = so_list_head; so; so = so->next)
1105  {
1106  struct cleanup *lib_cleanup;
1107 
1108  if (! so->so_name[0])
1109  continue;
1110  if (pattern && ! re_exec (so->so_name))
1111  continue;
1112 
1113  lib_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "lib");
1114 
1115  if (so->addr_high != 0)
1116  {
1117  ui_out_field_core_addr (uiout, "from", gdbarch, so->addr_low);
1118  ui_out_field_core_addr (uiout, "to", gdbarch, so->addr_high);
1119  }
1120  else
1121  {
1122  ui_out_field_skip (uiout, "from");
1123  ui_out_field_skip (uiout, "to");
1124  }
1125 
1127  && so->symbols_loaded
1128  && !objfile_has_symbols (so->objfile))
1129  {
1130  so_missing_debug_info = 1;
1131  ui_out_field_string (uiout, "syms-read", "Yes (*)");
1132  }
1133  else
1134  ui_out_field_string (uiout, "syms-read",
1135  so->symbols_loaded ? "Yes" : "No");
1136 
1137  ui_out_field_string (uiout, "name", so->so_name);
1138 
1139  ui_out_text (uiout, "\n");
1140 
1141  do_cleanups (lib_cleanup);
1142  }
1143 
1144  do_cleanups (table_cleanup);
1145 
1146  if (nr_libs == 0)
1147  {
1148  if (pattern)
1149  ui_out_message (uiout, 0,
1150  _("No shared libraries matched.\n"));
1151  else
1152  ui_out_message (uiout, 0,
1153  _("No shared libraries loaded at this time.\n"));
1154  }
1155  else
1156  {
1157  if (so_missing_debug_info)
1158  ui_out_message (uiout, 0,
1159  _("(*): Shared library is missing "
1160  "debugging information.\n"));
1161  }
1162 }
1163 
1164 /* Return 1 if ADDRESS lies within SOLIB. */
1165 
1166 int
1167 solib_contains_address_p (const struct so_list *const solib,
1168  CORE_ADDR address)
1169 {
1170  struct target_section *p;
1171 
1172  for (p = solib->sections; p < solib->sections_end; p++)
1173  if (p->addr <= address && address < p->endaddr)
1174  return 1;
1175 
1176  return 0;
1177 }
1178 
1179 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1180  name.
1181 
1182  Provides a hook for other gdb routines to discover whether or not a
1183  particular address is within the mapped address space of a shared
1184  library.
1185 
1186  For example, this routine is called at one point to disable
1187  breakpoints which are in shared libraries that are not currently
1188  mapped in. */
1189 
1190 char *
1192 {
1193  struct so_list *so = NULL;
1194 
1195  for (so = pspace->so_list; so; so = so->next)
1196  if (solib_contains_address_p (so, address))
1197  return (so->so_name);
1198 
1199  return (0);
1200 }
1201 
1202 /* Return whether the data starting at VADDR, size SIZE, must be kept
1203  in a core file for shared libraries loaded before "gcore" is used
1204  to be handled correctly when the core file is loaded. This only
1205  applies when the section would otherwise not be kept in the core
1206  file (in particular, for readonly sections). */
1207 
1208 int
1210 {
1211  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1212 
1213  if (ops->keep_data_in_core)
1214  return ops->keep_data_in_core (vaddr, size);
1215  else
1216  return 0;
1217 }
1218 
1219 /* Called by free_all_symtabs */
1220 
1221 void
1223 {
1224  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1225 
1226  /* This function is expected to handle ELF shared libraries. It is
1227  also used on Solaris, which can run either ELF or a.out binaries
1228  (for compatibility with SunOS 4), both of which can use shared
1229  libraries. So we don't know whether we have an ELF executable or
1230  an a.out executable until the user chooses an executable file.
1231 
1232  ELF shared libraries don't get mapped into the address space
1233  until after the program starts, so we'd better not try to insert
1234  breakpoints in them immediately. We have to wait until the
1235  dynamic linker has loaded them; we'll hit a bp_shlib_event
1236  breakpoint (look for calls to create_solib_event_breakpoint) when
1237  it's ready.
1238 
1239  SunOS shared libraries seem to be different --- they're present
1240  as soon as the process begins execution, so there's no need to
1241  put off inserting breakpoints. There's also nowhere to put a
1242  bp_shlib_event breakpoint, so if we put it off, we'll never get
1243  around to it.
1244 
1245  So: disable breakpoints only if we're using ELF shared libs. */
1246  if (exec_bfd != NULL
1247  && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
1249 
1250  while (so_list_head)
1251  {
1252  struct so_list *so = so_list_head;
1253 
1254  so_list_head = so->next;
1257  free_so (so);
1258  }
1259 
1260  ops->clear_solib ();
1261 }
1262 
1263 /* Shared library startup support. When GDB starts up the inferior,
1264  it nurses it along (through the shell) until it is ready to execute
1265  its first instruction. At this point, this function gets
1266  called. */
1267 
1268 void
1270 {
1271  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1272 
1273  ops->solib_create_inferior_hook (from_tty);
1274 }
1275 
1276 /* Check to see if an address is in the dynamic loader's dynamic
1277  symbol resolution code. Return 1 if so, 0 otherwise. */
1278 
1279 int
1281 {
1282  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1283 
1284  return ops->in_dynsym_resolve_code (pc);
1285 }
1286 
1287 /* Implements the "sharedlibrary" command. */
1288 
1289 static void
1290 sharedlibrary_command (char *args, int from_tty)
1291 {
1292  dont_repeat ();
1293  solib_add (args, from_tty, (struct target_ops *) 0, 1);
1294 }
1295 
1296 /* Implements the command "nosharedlibrary", which discards symbols
1297  that have been auto-loaded from shared libraries. Symbols from
1298  shared libraries that were added by explicit request of the user
1299  are not discarded. Also called from remote.c. */
1300 
1301 void
1302 no_shared_libraries (char *ignored, int from_tty)
1303 {
1304  /* The order of the two routines below is important: clear_solib notifies
1305  the solib_unloaded observers, and some of these observers might need
1306  access to their associated objfiles. Therefore, we can not purge the
1307  solibs' objfiles before clear_solib has been called. */
1308 
1309  clear_solib ();
1311 }
1312 
1313 /* See solib.h. */
1314 
1315 void
1317 {
1318  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1319 
1320  if (ops->update_breakpoints != NULL)
1321  ops->update_breakpoints ();
1322 }
1323 
1324 /* See solib.h. */
1325 
1326 void
1328 {
1329  const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1330 
1331  if (ops->handle_event != NULL)
1332  ops->handle_event ();
1333 
1335 
1336  /* Check for any newly added shared libraries if we're supposed to
1337  be adding them automatically. Switch terminal for any messages
1338  produced by breakpoint_re_set. */
1342 }
1343 
1344 /* Reload shared libraries, but avoid reloading the same symbol file
1345  we already have loaded. */
1346 
1347 static void
1349 {
1350  struct so_list *so;
1351  struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1352 
1353  if (print_symbol_loading_p (from_tty, 0, 0))
1354  printf_unfiltered (_("Loading symbols for shared libraries.\n"));
1355 
1356  for (so = so_list_head; so != NULL; so = so->next)
1357  {
1358  char *filename, *found_pathname = NULL;
1359  bfd *abfd;
1360  int was_loaded = so->symbols_loaded;
1361  const int flags =
1362  SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0);
1363 
1364  filename = tilde_expand (so->so_original_name);
1365  make_cleanup (xfree, filename);
1366  abfd = solib_bfd_open (filename);
1367  if (abfd != NULL)
1368  {
1369  found_pathname = xstrdup (bfd_get_filename (abfd));
1370  make_cleanup (xfree, found_pathname);
1371  gdb_bfd_unref (abfd);
1372  }
1373 
1374  /* If this shared library is no longer associated with its previous
1375  symbol file, close that. */
1376  if ((found_pathname == NULL && was_loaded)
1377  || (found_pathname != NULL
1378  && filename_cmp (found_pathname, so->so_name) != 0))
1379  {
1380  if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED)
1381  && !solib_used (so))
1382  free_objfile (so->objfile);
1384  clear_so (so);
1385  }
1386 
1387  /* If this shared library is now associated with a new symbol
1388  file, open it. */
1389  if (found_pathname != NULL
1390  && (!was_loaded
1391  || filename_cmp (found_pathname, so->so_name) != 0))
1392  {
1393  int got_error = 0;
1394 
1395  TRY
1396  {
1397  solib_map_sections (so);
1398  }
1399 
1401  {
1403  _("Error while mapping "
1404  "shared library sections:\n"));
1405  got_error = 1;
1406  }
1407  END_CATCH
1408 
1409  if (!got_error
1410  && (auto_solib_add || was_loaded || libpthread_solib_p (so)))
1411  solib_read_symbols (so, flags);
1412  }
1413  }
1414 
1415  do_cleanups (old_chain);
1416 }
1417 
1418 static void
1419 reload_shared_libraries (char *ignored, int from_tty,
1420  struct cmd_list_element *e)
1421 {
1422  const struct target_so_ops *ops;
1423 
1424  reload_shared_libraries_1 (from_tty);
1425 
1426  ops = solib_ops (target_gdbarch ());
1427 
1428  /* Creating inferior hooks here has two purposes. First, if we reload
1429  shared libraries then the address of solib breakpoint we've computed
1430  previously might be no longer valid. For example, if we forgot to set
1431  solib-absolute-prefix and are setting it right now, then the previous
1432  breakpoint address is plain wrong. Second, installing solib hooks
1433  also implicitly figures were ld.so is and loads symbols for it.
1434  Absent this call, if we've just connected to a target and set
1435  solib-absolute-prefix or solib-search-path, we'll lose all information
1436  about ld.so. */
1438  {
1439  /* Reset or free private data structures not associated with
1440  so_list entries. */
1441  ops->clear_solib ();
1442 
1443  /* Remove any previous solib event breakpoint. This is usually
1444  done in common code, at breakpoint_init_inferior time, but
1445  we're not really starting up the inferior here. */
1447 
1448  solib_create_inferior_hook (from_tty);
1449  }
1450 
1451  /* Sometimes the platform-specific hook loads initial shared
1452  libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1453  incorrectly 0 but such solib targets should be fixed anyway. If we
1454  made all the inferior hook methods consistent, this call could be
1455  removed. Call it only after the solib target has been initialized by
1456  solib_create_inferior_hook. */
1457 
1458  solib_add (NULL, 0, NULL, auto_solib_add);
1459 
1460  breakpoint_re_set ();
1461 
1462  /* We may have loaded or unloaded debug info for some (or all)
1463  shared libraries. However, frames may still reference them. For
1464  example, a frame's unwinder might still point at DWARF FDE
1465  structures that are now freed. Also, getting new symbols may
1466  change our opinion about what is frameless. */
1467  reinit_frame_cache ();
1468 
1469  ops->special_symbol_handling ();
1470 }
1471 
1472 /* Wrapper for reload_shared_libraries that replaces "remote:"
1473  at the start of gdb_sysroot with "target:". */
1474 
1475 static void
1476 gdb_sysroot_changed (char *ignored, int from_tty,
1477  struct cmd_list_element *e)
1478 {
1479  const char *old_prefix = "remote:";
1480  const char *new_prefix = TARGET_SYSROOT_PREFIX;
1481 
1482  if (startswith (gdb_sysroot, old_prefix))
1483  {
1484  static int warning_issued = 0;
1485 
1486  gdb_assert (strlen (old_prefix) == strlen (new_prefix));
1487  memcpy (gdb_sysroot, new_prefix, strlen (new_prefix));
1488 
1489  if (!warning_issued)
1490  {
1491  warning (_("\"%s\" is deprecated, use \"%s\" instead."),
1492  old_prefix, new_prefix);
1493  warning (_("sysroot set to \"%s\"."), gdb_sysroot);
1494 
1495  warning_issued = 1;
1496  }
1497  }
1498 
1499  reload_shared_libraries (ignored, from_tty, e);
1500 }
1501 
1502 static void
1503 show_auto_solib_add (struct ui_file *file, int from_tty,
1504  struct cmd_list_element *c, const char *value)
1505 {
1506  fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"),
1507  value);
1508 }
1509 
1510 
1511 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1512  the library-specific handler if it is installed for the current target. */
1513 
1514 struct symbol *
1516  const char *name,
1517  const domain_enum domain)
1518 {
1519  const struct target_so_ops *ops = solib_ops (get_objfile_arch (objfile));
1520 
1521  if (ops->lookup_lib_global_symbol != NULL)
1522  return ops->lookup_lib_global_symbol (objfile, name, domain);
1523  return NULL;
1524 }
1525 
1526 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1527  up symbol from ABFD. MATCH_SYM is a callback function to determine
1528  whether to pick up a symbol. DATA is the input of this callback
1529  function. Return NULL if symbol is not found. */
1530 
1531 CORE_ADDR
1533  int (*match_sym) (asymbol *, void *),
1534  void *data)
1535 {
1536  long storage_needed = bfd_get_symtab_upper_bound (abfd);
1537  CORE_ADDR symaddr = 0;
1538 
1539  if (storage_needed > 0)
1540  {
1541  unsigned int i;
1542 
1543  asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
1544  struct cleanup *back_to = make_cleanup (xfree, symbol_table);
1545  unsigned int number_of_symbols =
1546  bfd_canonicalize_symtab (abfd, symbol_table);
1547 
1548  for (i = 0; i < number_of_symbols; i++)
1549  {
1550  asymbol *sym = *symbol_table++;
1551 
1552  if (match_sym (sym, data))
1553  {
1554  struct gdbarch *gdbarch = target_gdbarch ();
1555  symaddr = sym->value;
1556 
1557  /* Some ELF targets fiddle with addresses of symbols they
1558  consider special. They use minimal symbols to do that
1559  and this is needed for correct breakpoint placement,
1560  but we do not have full data here to build a complete
1561  minimal symbol, so just set the address and let the
1562  targets cope with that. */
1563  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1565  {
1566  struct minimal_symbol msym;
1567 
1568  memset (&msym, 0, sizeof (msym));
1569  SET_MSYMBOL_VALUE_ADDRESS (&msym, symaddr);
1570  gdbarch_elf_make_msymbol_special (gdbarch, sym, &msym);
1571  symaddr = MSYMBOL_VALUE_RAW_ADDRESS (&msym);
1572  }
1573 
1574  /* BFD symbols are section relative. */
1575  symaddr += sym->section->vma;
1576  break;
1577  }
1578  }
1579  do_cleanups (back_to);
1580  }
1581 
1582  return symaddr;
1583 }
1584 
1585 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1586  from ABFD. MATCH_SYM is a callback function to determine whether to pick
1587  up a symbol. DATA is the input of this callback function. Return NULL
1588  if symbol is not found. */
1589 
1590 static CORE_ADDR
1592  int (*match_sym) (asymbol *, void *),
1593  void *data)
1594 {
1595  long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1596  CORE_ADDR symaddr = 0;
1597 
1598  if (storage_needed > 0)
1599  {
1600  unsigned int i;
1601  asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
1602  struct cleanup *back_to = make_cleanup (xfree, symbol_table);
1603  unsigned int number_of_symbols =
1604  bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
1605 
1606  for (i = 0; i < number_of_symbols; i++)
1607  {
1608  asymbol *sym = *symbol_table++;
1609 
1610  if (match_sym (sym, data))
1611  {
1612  /* BFD symbols are section relative. */
1613  symaddr = sym->value + sym->section->vma;
1614  break;
1615  }
1616  }
1617  do_cleanups (back_to);
1618  }
1619  return symaddr;
1620 }
1621 
1622 /* Lookup the value for a specific symbol from symbol table and dynamic
1623  symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1624  function to determine whether to pick up a symbol. DATA is the
1625  input of this callback function. Return NULL if symbol is not
1626  found. */
1627 
1628 CORE_ADDR
1630  int (*match_sym) (asymbol *, void *),
1631  void *data)
1632 {
1633  CORE_ADDR symaddr = gdb_bfd_lookup_symbol_from_symtab (abfd, match_sym, data);
1634 
1635  /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1636  have to check the dynamic string table too. */
1637  if (symaddr == 0)
1638  symaddr = bfd_lookup_symbol_from_dyn_symtab (abfd, match_sym, data);
1639 
1640  return symaddr;
1641 }
1642 
1643 /* SO_LIST_HEAD may contain user-loaded object files that can be removed
1644  out-of-band by the user. So upon notification of free_objfile remove
1645  all references to any user-loaded file that is about to be freed. */
1646 
1647 static void
1649 {
1650  struct so_list *so;
1651 
1652  if (objfile != 0 && objfile->flags & OBJF_USERLOADED)
1653  {
1654  for (so = so_list_head; so != NULL; so = so->next)
1655  if (so->objfile == objfile)
1656  so->objfile = NULL;
1657  }
1658 }
1659 
1660 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
1661 
1662 void
1664 {
1666 
1668 
1669  add_com ("sharedlibrary", class_files, sharedlibrary_command,
1670  _("Load shared object library symbols for files matching REGEXP."));
1671  add_info ("sharedlibrary", info_sharedlibrary_command,
1672  _("Status of loaded shared object libraries."));
1673  add_info_alias ("dll", "sharedlibrary", 1);
1674  add_com ("nosharedlibrary", class_files, no_shared_libraries,
1675  _("Unload all shared object library symbols."));
1676 
1677  add_setshow_boolean_cmd ("auto-solib-add", class_support,
1678  &auto_solib_add, _("\
1679 Set autoloading of shared library symbols."), _("\
1680 Show autoloading of shared library symbols."), _("\
1681 If \"on\", symbols from all shared object libraries will be loaded\n\
1682 automatically when the inferior begins execution, when the dynamic linker\n\
1683 informs gdb that a new library has been loaded, or when attaching to the\n\
1684 inferior. Otherwise, symbols must be loaded manually, using \
1685 `sharedlibrary'."),
1686  NULL,
1688  &setlist, &showlist);
1689 
1691  &gdb_sysroot, _("\
1692 Set an alternate system root."), _("\
1693 Show the current system root."), _("\
1694 The system root is used to load absolute shared library symbol files.\n\
1695 For other (relative) files, you can add directories using\n\
1696 `set solib-search-path'."),
1698  NULL,
1699  &setlist, &showlist);
1700 
1701  add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
1702  &setlist);
1703  add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
1704  &showlist);
1705 
1706  add_setshow_optional_filename_cmd ("solib-search-path", class_support,
1707  &solib_search_path, _("\
1708 Set the search path for loading non-absolute shared library symbol files."),
1709  _("\
1710 Show the search path for loading non-absolute shared library symbol files."),
1711  _("\
1712 This takes precedence over the environment variables \
1713 PATH and LD_LIBRARY_PATH."),
1716  &setlist, &showlist);
1717 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define OBJF_USERLOADED
Definition: objfiles.h:445
#define IS_TARGET_ABSOLUTE_PATH(kind, p)
Definition: filesystem.h:38
struct symbol *(* lookup_lib_global_symbol)(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solist.h:140
static void reload_shared_libraries(char *ignored, int from_tty, struct cmd_list_element *e)
Definition: solib.c:1419
int in_solib_dynsym_resolve_code(CORE_ADDR pc)
Definition: solib.c:1280
#define OBJF_SHARED
Definition: objfiles.h:432
void handle_solib_event(void)
Definition: solib.c:1327
void remove_solib_event_breakpoints(void)
Definition: breakpoint.c:7681
#define HAS_TARGET_DRIVE_SPEC(kind, p)
Definition: filesystem.h:45
struct target_section * sections
Definition: solist.h:71
struct observer * observer_attach_free_objfile(observer_free_objfile_ftype *f)
static const struct target_so_ops * solib_ops(struct gdbarch *gdbarch)
Definition: solib.c:66
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
void xfree(void *)
Definition: common-utils.c:97
struct so_list * next
Definition: solist.h:36
void no_shared_libraries(char *ignored, int from_tty)
Definition: solib.c:1302
struct objfile * symbol_file_add_from_bfd(bfd *abfd, const char *name, int add_flags, struct section_addr_info *addrs, int flags, struct objfile *parent)
Definition: symfile.c:1276
static int solib_used(const struct so_list *const known)
Definition: solib.c:727
void set_solib_ops(struct gdbarch *gdbarch, const struct target_so_ops *new_ops)
Definition: solib.c:76
void warning(const char *fmt,...)
Definition: errors.c:26
int objfile_has_symbols(struct objfile *objfile)
Definition: objfiles.c:949
#define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value)
Definition: symtab.h:395
CORE_ADDR addr_low
Definition: objfiles.h:277
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
struct cleanup * make_cleanup_ui_out_table_begin_end(struct ui_out *ui_out, int nr_cols, int nr_rows, const char *tblid)
Definition: ui-out.c:369
void(* update_breakpoints)(void)
Definition: solist.h:164
int build_section_table(struct bfd *some_bfd, struct target_section **start, struct target_section **end)
Definition: exec.c:470
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
Definition: gdbarch.c:4845
initialize_file_ftype _initialize_solib
enum domain_enum_tag domain_enum
#define IS_TARGET_DIR_SEPARATOR(kind, c)
Definition: filesystem.h:31
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
Definition: solist.h:84
void(* solib_create_inferior_hook)(int from_tty)
Definition: solist.h:101
struct ui_out * interp_ui_out(struct interp *interp)
Definition: interps.c:229
struct so_list *(* current_sos)(void)
Definition: solist.h:116
int info_verbose
Definition: top.c:1699
int ui_out_is_mi_like_p(struct ui_out *uiout)
Definition: ui-out.c:655
bfd *(* bfd_open)(char *pathname)
Definition: solist.h:130
bfd * solib_bfd_fopen(char *pathname, int fd)
Definition: solib.c:459
int catch_errors(catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask)
Definition: exceptions.c:228
Definition: solist.h:30
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
struct gdbarch_data * gdbarch_data_register_pre_init(gdbarch_data_pre_init_ftype *pre_init)
Definition: gdbarch.c:4806
#define SO_NAME_MAX_PATH_SIZE
Definition: solist.h:22
#define _(String)
Definition: gdb_locale.h:40
struct bfd * gdb_bfd_open(const char *name, const char *target, int fd)
Definition: gdb_bfd.c:320
CORE_ADDR gdb_bfd_lookup_symbol_from_symtab(bfd *abfd, int(*match_sym)(asymbol *, void *), void *data)
Definition: solib.c:1532
Definition: ui-out.h:40
char * char_ptr
Definition: gdb_vecs.h:25
int(* keep_data_in_core)(CORE_ADDR vaddr, unsigned long size)
Definition: solist.h:156
void free_section_addr_info(struct section_addr_info *sap)
Definition: symfile.c:343
#define END_CATCH
struct symbol * solib_global_lookup(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solib.c:1515
Definition: ui-out.c:99
static int solib_map_sections(struct so_list *so)
Definition: solib.c:534
void ui_out_text(struct ui_out *uiout, const char *string)
Definition: ui-out.c:582
int(* open_symbol_file_object)(void *from_ttyp)
Definition: solist.h:123
void gdbarch_elf_make_msymbol_special(struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
Definition: gdbarch.c:3149
bfd * abfd
Definition: solist.h:63
struct target_section * sections_end
Definition: solist.h:72
#define TARGET_SYSROOT_PREFIX
Definition: gdb_bfd.h:30
const char file_system_kind_dos_based[]
Definition: filesystem.c:27
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
void null_cleanup(void *arg)
Definition: cleanups.c:295
void(* clear_solib)(void)
Definition: solist.h:98
char * solib_find(char *in_pathname, int *fd)
Definition: solib.c:419
#define TRY
#define MSYMBOL_VALUE_RAW_ADDRESS(symbol)
Definition: symtab.h:386
struct so_list * master_so_list(void)
Definition: solib.c:659
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
#define SLASH_STRING
Definition: host-defs.h:58
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
Definition: solist.h:127
void breakpoint_re_set(void)
Definition: breakpoint.c:14273
#define CATCH(EXCEPTION, MASK)
int solib_contains_address_p(const struct so_list *const solib, CORE_ADDR address)
Definition: solib.c:1167
#define OPF_TRY_CWD_FIRST
Definition: defs.h:317
const char * target_lbasename(const char *kind, const char *name)
Definition: filesystem.c:52
void ui_out_field_skip(struct ui_out *uiout, const char *fldname)
Definition: ui-out.c:528
void free_objfile(struct objfile *objfile)
Definition: objfiles.c:540
static void sharedlibrary_command(char *args, int from_tty)
Definition: solib.c:1290
char * gnutarget
Definition: corefile.c:437
#define so_list_head
Definition: solib.c:91
struct target_ops current_target
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
void initialize_file_ftype(void)
Definition: defs.h:281
struct cleanup * make_cleanup_ui_out_tuple_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:451
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, int(*match_sym)(asymbol *, void *), void *data)
Definition: solib.c:1629
void observer_notify_solib_unloaded(struct so_list *solib)
#define exec_bfd
Definition: exec.h:32
char * gdb_sysroot
Definition: main.c:57
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
int openp(const char *, int, const char *, int, char **)
Definition: source.c:739
#define DOS_BASED_FILE_SYSTEM
Definition: solib.c:112
void remove_target_sections(void *owner)
Definition: exec.c:568
void target_terminal_inferior(void)
Definition: target.c:470
static char * solib_find_1(char *in_pathname, int *fd, int is_solib)
Definition: solib.c:153
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
#define target_filesystem_is_local()
Definition: target.h:1987
void ui_out_message(struct ui_out *uiout, int verbosity, const char *format,...)
Definition: ui-out.c:589
struct so_list * so_list
Definition: progspace.h:196
void clear_solib(void)
Definition: solib.c:1222
char so_original_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:49
int solib_read_symbols(struct so_list *so, int flags)
Definition: solib.c:669
void free_so(struct so_list *so)
Definition: solib.c:646
void solib_add(const char *pattern, int from_tty, struct target_ops *target, int readsyms)
Definition: solib.c:965
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
void clear_program_space_solib_cache(struct program_space *pspace)
Definition: progspace.c:493
void(* handle_event)(void)
Definition: solist.h:170
char * solib_name_from_address(struct program_space *pspace, CORE_ADDR address)
Definition: solib.c:1191
static struct gdbarch_data * solib_data
Definition: solib.c:53
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:52
void(* clear_so)(struct so_list *so)
Definition: solist.h:94
struct cmd_list_element * add_info(const char *name, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:857
Definition: gnu-nat.c:163
#define gdb_assert(expr)
Definition: gdb_assert.h:33
int(* same)(struct so_list *gdb, struct so_list *inferior)
Definition: solist.h:149
char * get_in_environ(const struct gdb_environ *e, const char *var)
Definition: environ.c:100
void exception_fprintf(struct ui_file *file, struct gdb_exception e, const char *prefix,...)
Definition: exceptions.c:119
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
#define symfile_objfile
Definition: progspace.h:216
struct cmd_list_element * add_alias_cmd(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:286
void disable_breakpoints_in_shlibs(void)
Definition: breakpoint.c:7748
CORE_ADDR endaddr
Definition: target.h:2260
static void update_solib_list(int from_tty, struct target_ops *target)
Definition: solib.c:761
#define target_has_execution
Definition: target.h:1726
static char * solib_search_path
Definition: solib.c:98
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
unsigned solib_add_generation
Definition: progspace.h:199
struct bfd_section * the_bfd_section
Definition: target.h:2262
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
struct program_space * pspace
Definition: solist.h:55
void * xmalloc(YYSIZE_T)
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
Definition: __init__.py:1
void(* special_symbol_handling)(void)
Definition: solist.h:107
char symbols_loaded
Definition: solist.h:64
CORE_ADDR addr
Definition: target.h:2259
int symfile_flags
Definition: inferior.h:380
int attach_flag
Definition: inferior.h:340
Definition: value.c:172
static void remove_user_added_objfile(struct objfile *objfile)
Definition: solib.c:1648
void objfile_purge_solibs(void)
Definition: objfiles.c:1000
const char * effective_target_file_system_kind(void)
Definition: filesystem.c:38
static void show_solib_search_path(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: solib.c:100
CORE_ADDR addr_low
Definition: solist.h:77
#define O_BINARY
Definition: defs.h:100
ptid_t null_ptid
Definition: ptid.c:25
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
static CORE_ADDR bfd_lookup_symbol_from_dyn_symtab(bfd *abfd, int(*match_sym)(asymbol *, void *), void *data)
Definition: solib.c:1591
struct ui_file * gdb_stderr
Definition: main.c:72
ptid_t inferior_ptid
Definition: infcmd.c:124
void(* free_so)(struct so_list *so)
Definition: solist.h:89
void add_target_sections(void *owner, struct target_section *sections, struct target_section *sections_end)
Definition: exec.c:492
static void info_sharedlibrary_command(char *pattern, int from_tty)
Definition: solib.c:1055
void solib_create_inferior_hook(int from_tty)
Definition: solib.c:1269
int libpthread_name_p(const char *name)
Definition: solib.c:942
#define OPF_RETURN_REALPATH
Definition: defs.h:319
int print_symbol_loading_p(int from_tty, int exec, int full)
Definition: symfile.c:180
const char * gdbarch_solib_symbols_extension(struct gdbarch *gdbarch)
Definition: gdbarch.c:4448
struct section_addr_info * build_section_addr_info_from_section_table(const struct target_section *start, const struct target_section *end)
Definition: symfile.c:266
int gdbarch_elf_make_msymbol_special_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3142
char * exec_file_find(char *in_pathname, int *fd)
Definition: solib.c:387
void ui_out_table_header(struct ui_out *uiout, int width, enum ui_align alignment, const char *col_name, const char *colhdr)
Definition: ui-out.c:346
struct target_so_ops * current_target_so_ops
Definition: solib.c:88
int gdb_open_cloexec(const char *filename, int flags, unsigned long mode)
Definition: filestuff.c:291
struct inferior * current_inferior(void)
Definition: inferior.c:57
struct cmd_list_element * add_info_alias(const char *name, const char *oldname, int abbrev_flag)
Definition: cli-decode.c:865
EXTERN_C char * re_comp(const char *)
struct program_space * current_program_space
Definition: progspace.c:35
void ui_out_field_core_addr(struct ui_out *uiout, const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition: ui-out.c:499
char * savestring(const char *ptr, size_t len)
Definition: common-utils.c:148
static void * solib_init(struct obstack *obstack)
Definition: solib.c:56
int(* find_and_open_solib)(char *soname, unsigned o_flags, char **temp_pathname)
Definition: solist.h:136
struct interp * top_level_interpreter(void)
Definition: interps.c:476
static void gdb_sysroot_changed(char *ignored, int from_tty, struct cmd_list_element *e)
Definition: solib.c:1476
void update_solib_breakpoints(void)
Definition: solib.c:1316
void observer_notify_solib_loaded(struct so_list *solib)
Definition: symtab.h:703
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1411
void target_terminal_ours_for_output(void)
Definition: target.c:503
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
Definition: ui-out.c:541
CORE_ADDR addr_high
Definition: solist.h:77
unsigned short flags
Definition: objfiles.h:282
#define OBSTACK_ZALLOC(OBSTACK, TYPE)
Definition: gdb_obstack.h:27
void ui_out_table_body(struct ui_out *uiout)
Definition: ui-out.c:309
void dont_repeat(void)
Definition: top.c:582
void reinit_frame_cache(void)
Definition: frame.c:1687
struct ui_out * current_uiout
Definition: ui-out.c:233
static void reload_shared_libraries_1(int from_tty)
Definition: solib.c:1348
static void show_auto_solib_add(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: solib.c:1503
struct objfile * objfile
Definition: solist.h:69
static int libpthread_solib_p(struct so_list *so)
Definition: solib.c:950
int is_target_filename(const char *name)
Definition: gdb_bfd.c:145
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
void add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:626
bfd * solib_bfd_open(char *pathname)
Definition: solib.c:481
int auto_solib_add
Definition: symfile.c:168
int solib_keep_data_in_core(CORE_ADDR vaddr, unsigned long size)
Definition: solib.c:1209
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
static void clear_so(struct so_list *so)
Definition: solib.c:606
__extension__ enum domain_enum_tag domain
Definition: symtab.h:730
int gdb_bfd_has_target_filename(struct bfd *abfd)
Definition: gdb_bfd.c:153