Add casts to memory allocation related calls
[deliverable/binutils-gdb.git] / gdb / solib.c
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 *
66 solib_ops (struct gdbarch *gdbarch)
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 \f
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. */
88 struct target_so_ops *current_target_so_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. */
169 if (is_target_filename (sysroot) && target_filesystem_is_local ())
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. */
190 if (!DOS_BASED_FILE_SYSTEM && fskind == file_system_kind_dos_based)
191 {
192 char *p;
193
194 /* Avoid clobbering our input. */
195 p = (char *) 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,
333 OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH,
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,
342 OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH,
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 = (char *) 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
422 = gdbarch_solib_symbols_extension (target_gdbarch ());
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
438 = (char *) alloca (p - in_pathname + 1
439 + strlen (solib_symbols_extension) + 1);
440 memcpy (new_pathname, in_pathname, p - in_pathname + 1);
441 strcpy (new_pathname + (p - in_pathname) + 1,
442 solib_symbols_extension);
443
444 in_pathname = new_pathname;
445 }
446 }
447
448 return solib_find_1 (in_pathname, fd, 1);
449 }
450
451 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
452 it is used as file handle to open the file. Throws an error if the file
453 could not be opened. Handles both local and remote file access.
454
455 PATHNAME must be malloc'ed by the caller. It will be freed by this
456 function. If unsuccessful, the FD will be closed (unless FD was
457 -1). */
458
459 bfd *
460 solib_bfd_fopen (char *pathname, int fd)
461 {
462 bfd *abfd = gdb_bfd_open (pathname, gnutarget, fd);
463
464 if (abfd != NULL && !gdb_bfd_has_target_filename (abfd))
465 bfd_set_cacheable (abfd, 1);
466
467 if (!abfd)
468 {
469 make_cleanup (xfree, pathname);
470 error (_("Could not open `%s' as an executable file: %s"),
471 pathname, bfd_errmsg (bfd_get_error ()));
472 }
473
474 xfree (pathname);
475
476 return abfd;
477 }
478
479 /* Find shared library PATHNAME and open a BFD for it. */
480
481 bfd *
482 solib_bfd_open (char *pathname)
483 {
484 char *found_pathname;
485 int found_file;
486 bfd *abfd;
487 const struct bfd_arch_info *b;
488
489 /* Search for shared library file. */
490 found_pathname = solib_find (pathname, &found_file);
491 if (found_pathname == NULL)
492 {
493 /* Return failure if the file could not be found, so that we can
494 accumulate messages about missing libraries. */
495 if (errno == ENOENT)
496 return NULL;
497
498 perror_with_name (pathname);
499 }
500
501 /* Open bfd for shared library. */
502 abfd = solib_bfd_fopen (found_pathname, found_file);
503
504 /* Check bfd format. */
505 if (!bfd_check_format (abfd, bfd_object))
506 {
507 make_cleanup_bfd_unref (abfd);
508 error (_("`%s': not in executable format: %s"),
509 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
510 }
511
512 /* Check bfd arch. */
513 b = gdbarch_bfd_arch_info (target_gdbarch ());
514 if (!b->compatible (b, bfd_get_arch_info (abfd)))
515 warning (_("`%s': Shared library architecture %s is not compatible "
516 "with target architecture %s."), bfd_get_filename (abfd),
517 bfd_get_arch_info (abfd)->printable_name, b->printable_name);
518
519 return abfd;
520 }
521
522 /* Given a pointer to one of the shared objects in our list of mapped
523 objects, use the recorded name to open a bfd descriptor for the
524 object, build a section table, relocate all the section addresses
525 by the base address at which the shared object was mapped, and then
526 add the sections to the target's section table.
527
528 FIXME: In most (all?) cases the shared object file name recorded in
529 the dynamic linkage tables will be a fully qualified pathname. For
530 cases where it isn't, do we really mimic the systems search
531 mechanism correctly in the below code (particularly the tilde
532 expansion stuff?). */
533
534 static int
535 solib_map_sections (struct so_list *so)
536 {
537 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
538 char *filename;
539 struct target_section *p;
540 struct cleanup *old_chain;
541 bfd *abfd;
542
543 filename = tilde_expand (so->so_name);
544 old_chain = make_cleanup (xfree, filename);
545 abfd = ops->bfd_open (filename);
546 do_cleanups (old_chain);
547
548 if (abfd == NULL)
549 return 0;
550
551 /* Leave bfd open, core_xfer_memory and "info files" need it. */
552 so->abfd = abfd;
553
554 /* Copy the full path name into so_name, allowing symbol_file_add
555 to find it later. This also affects the =library-loaded GDB/MI
556 event, and in particular the part of that notification providing
557 the library's host-side path. If we let the target dictate
558 that objfile's path, and the target is different from the host,
559 GDB/MI will not provide the correct host-side path. */
560 if (strlen (bfd_get_filename (abfd)) >= SO_NAME_MAX_PATH_SIZE)
561 error (_("Shared library file name is too long."));
562 strcpy (so->so_name, bfd_get_filename (abfd));
563
564 if (build_section_table (abfd, &so->sections, &so->sections_end))
565 {
566 error (_("Can't find the file sections in `%s': %s"),
567 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
568 }
569
570 for (p = so->sections; p < so->sections_end; p++)
571 {
572 /* Relocate the section binding addresses as recorded in the shared
573 object's file by the base address to which the object was actually
574 mapped. */
575 ops->relocate_section_addresses (so, p);
576
577 /* If the target didn't provide information about the address
578 range of the shared object, assume we want the location of
579 the .text section. */
580 if (so->addr_low == 0 && so->addr_high == 0
581 && strcmp (p->the_bfd_section->name, ".text") == 0)
582 {
583 so->addr_low = p->addr;
584 so->addr_high = p->endaddr;
585 }
586 }
587
588 /* Add the shared object's sections to the current set of file
589 section tables. Do this immediately after mapping the object so
590 that later nodes in the list can query this object, as is needed
591 in solib-osf.c. */
592 add_target_sections (so, so->sections, so->sections_end);
593
594 return 1;
595 }
596
597 /* Free symbol-file related contents of SO and reset for possible reloading
598 of SO. If we have opened a BFD for SO, close it. If we have placed SO's
599 sections in some target's section table, the caller is responsible for
600 removing them.
601
602 This function doesn't mess with objfiles at all. If there is an
603 objfile associated with SO that needs to be removed, the caller is
604 responsible for taking care of that. */
605
606 static void
607 clear_so (struct so_list *so)
608 {
609 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
610
611 if (so->sections)
612 {
613 xfree (so->sections);
614 so->sections = so->sections_end = NULL;
615 }
616
617 gdb_bfd_unref (so->abfd);
618 so->abfd = NULL;
619
620 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
621 so->symbols_loaded = 0;
622 so->objfile = NULL;
623
624 so->addr_low = so->addr_high = 0;
625
626 /* Restore the target-supplied file name. SO_NAME may be the path
627 of the symbol file. */
628 strcpy (so->so_name, so->so_original_name);
629
630 /* Do the same for target-specific data. */
631 if (ops->clear_so != NULL)
632 ops->clear_so (so);
633 }
634
635 /* Free the storage associated with the `struct so_list' object SO.
636 If we have opened a BFD for SO, close it.
637
638 The caller is responsible for removing SO from whatever list it is
639 a member of. If we have placed SO's sections in some target's
640 section table, the caller is responsible for removing them.
641
642 This function doesn't mess with objfiles at all. If there is an
643 objfile associated with SO that needs to be removed, the caller is
644 responsible for taking care of that. */
645
646 void
647 free_so (struct so_list *so)
648 {
649 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
650
651 clear_so (so);
652 ops->free_so (so);
653
654 xfree (so);
655 }
656
657
658 /* Return address of first so_list entry in master shared object list. */
659 struct so_list *
660 master_so_list (void)
661 {
662 return so_list_head;
663 }
664
665 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
666 be chatty about it. Return non-zero if any symbols were actually
667 loaded. */
668
669 int
670 solib_read_symbols (struct so_list *so, int flags)
671 {
672 if (so->symbols_loaded)
673 {
674 /* If needed, we've already warned in our caller. */
675 }
676 else if (so->abfd == NULL)
677 {
678 /* We've already warned about this library, when trying to open
679 it. */
680 }
681 else
682 {
683
684 flags |= current_inferior ()->symfile_flags;
685
686 TRY
687 {
688 struct section_addr_info *sap;
689
690 /* Have we already loaded this shared object? */
691 ALL_OBJFILES (so->objfile)
692 {
693 if (filename_cmp (objfile_name (so->objfile), so->so_name) == 0
694 && so->objfile->addr_low == so->addr_low)
695 break;
696 }
697 if (so->objfile != NULL)
698 break;
699
700 sap = build_section_addr_info_from_section_table (so->sections,
701 so->sections_end);
702 so->objfile = symbol_file_add_from_bfd (so->abfd, so->so_name,
703 flags, sap, OBJF_SHARED,
704 NULL);
705 so->objfile->addr_low = so->addr_low;
706 free_section_addr_info (sap);
707
708 so->symbols_loaded = 1;
709 }
710 CATCH (e, RETURN_MASK_ERROR)
711 {
712 exception_fprintf (gdb_stderr, e, _("Error while reading shared"
713 " library symbols for %s:\n"),
714 so->so_name);
715 }
716 END_CATCH
717
718 return 1;
719 }
720
721 return 0;
722 }
723
724 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
725 SO_LIST_HEAD list. Return 0 otherwise. */
726
727 static int
728 solib_used (const struct so_list *const known)
729 {
730 const struct so_list *pivot;
731
732 for (pivot = so_list_head; pivot != NULL; pivot = pivot->next)
733 if (pivot != known && pivot->objfile == known->objfile)
734 return 1;
735 return 0;
736 }
737
738 /* Synchronize GDB's shared object list with inferior's.
739
740 Extract the list of currently loaded shared objects from the
741 inferior, and compare it with the list of shared objects currently
742 in GDB's so_list_head list. Edit so_list_head to bring it in sync
743 with the inferior's new list.
744
745 If we notice that the inferior has unloaded some shared objects,
746 free any symbolic info GDB had read about those shared objects.
747
748 Don't load symbolic info for any new shared objects; just add them
749 to the list, and leave their symbols_loaded flag clear.
750
751 If FROM_TTY is non-null, feel free to print messages about what
752 we're doing.
753
754 If TARGET is non-null, add the sections of all new shared objects
755 to TARGET's section table. Note that this doesn't remove any
756 sections for shared objects that have been unloaded, and it
757 doesn't check to see if the new shared objects are already present in
758 the section table. But we only use this for core files and
759 processes we've just attached to, so that's okay. */
760
761 static void
762 update_solib_list (int from_tty, struct target_ops *target)
763 {
764 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
765 struct so_list *inferior = ops->current_sos();
766 struct so_list *gdb, **gdb_link;
767
768 /* We can reach here due to changing solib-search-path or the
769 sysroot, before having any inferior. */
770 if (target_has_execution && !ptid_equal (inferior_ptid, null_ptid))
771 {
772 struct inferior *inf = current_inferior ();
773
774 /* If we are attaching to a running process for which we
775 have not opened a symbol file, we may be able to get its
776 symbols now! */
777 if (inf->attach_flag && symfile_objfile == NULL)
778 catch_errors (ops->open_symbol_file_object, &from_tty,
779 "Error reading attached process's symbol file.\n",
780 RETURN_MASK_ALL);
781 }
782
783 /* GDB and the inferior's dynamic linker each maintain their own
784 list of currently loaded shared objects; we want to bring the
785 former in sync with the latter. Scan both lists, seeing which
786 shared objects appear where. There are three cases:
787
788 - A shared object appears on both lists. This means that GDB
789 knows about it already, and it's still loaded in the inferior.
790 Nothing needs to happen.
791
792 - A shared object appears only on GDB's list. This means that
793 the inferior has unloaded it. We should remove the shared
794 object from GDB's tables.
795
796 - A shared object appears only on the inferior's list. This
797 means that it's just been loaded. We should add it to GDB's
798 tables.
799
800 So we walk GDB's list, checking each entry to see if it appears
801 in the inferior's list too. If it does, no action is needed, and
802 we remove it from the inferior's list. If it doesn't, the
803 inferior has unloaded it, and we remove it from GDB's list. By
804 the time we're done walking GDB's list, the inferior's list
805 contains only the new shared objects, which we then add. */
806
807 gdb = so_list_head;
808 gdb_link = &so_list_head;
809 while (gdb)
810 {
811 struct so_list *i = inferior;
812 struct so_list **i_link = &inferior;
813
814 /* Check to see whether the shared object *gdb also appears in
815 the inferior's current list. */
816 while (i)
817 {
818 if (ops->same)
819 {
820 if (ops->same (gdb, i))
821 break;
822 }
823 else
824 {
825 if (! filename_cmp (gdb->so_original_name, i->so_original_name))
826 break;
827 }
828
829 i_link = &i->next;
830 i = *i_link;
831 }
832
833 /* If the shared object appears on the inferior's list too, then
834 it's still loaded, so we don't need to do anything. Delete
835 it from the inferior's list, and leave it on GDB's list. */
836 if (i)
837 {
838 *i_link = i->next;
839 free_so (i);
840 gdb_link = &gdb->next;
841 gdb = *gdb_link;
842 }
843
844 /* If it's not on the inferior's list, remove it from GDB's tables. */
845 else
846 {
847 /* Notify any observer that the shared object has been
848 unloaded before we remove it from GDB's tables. */
849 observer_notify_solib_unloaded (gdb);
850
851 VEC_safe_push (char_ptr, current_program_space->deleted_solibs,
852 xstrdup (gdb->so_name));
853
854 *gdb_link = gdb->next;
855
856 /* Unless the user loaded it explicitly, free SO's objfile. */
857 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)
858 && !solib_used (gdb))
859 free_objfile (gdb->objfile);
860
861 /* Some targets' section tables might be referring to
862 sections from so->abfd; remove them. */
863 remove_target_sections (gdb);
864
865 free_so (gdb);
866 gdb = *gdb_link;
867 }
868 }
869
870 /* Now the inferior's list contains only shared objects that don't
871 appear in GDB's list --- those that are newly loaded. Add them
872 to GDB's shared object list. */
873 if (inferior)
874 {
875 int not_found = 0;
876 const char *not_found_filename = NULL;
877
878 struct so_list *i;
879
880 /* Add the new shared objects to GDB's list. */
881 *gdb_link = inferior;
882
883 /* Fill in the rest of each of the `struct so_list' nodes. */
884 for (i = inferior; i; i = i->next)
885 {
886
887 i->pspace = current_program_space;
888 VEC_safe_push (so_list_ptr, current_program_space->added_solibs, i);
889
890 TRY
891 {
892 /* Fill in the rest of the `struct so_list' node. */
893 if (!solib_map_sections (i))
894 {
895 not_found++;
896 if (not_found_filename == NULL)
897 not_found_filename = i->so_original_name;
898 }
899 }
900
901 CATCH (e, RETURN_MASK_ERROR)
902 {
903 exception_fprintf (gdb_stderr, e,
904 _("Error while mapping shared "
905 "library sections:\n"));
906 }
907 END_CATCH
908
909 /* Notify any observer that the shared object has been
910 loaded now that we've added it to GDB's tables. */
911 observer_notify_solib_loaded (i);
912 }
913
914 /* If a library was not found, issue an appropriate warning
915 message. We have to use a single call to warning in case the
916 front end does something special with warnings, e.g., pop up
917 a dialog box. It Would Be Nice if we could get a "warning: "
918 prefix on each line in the CLI front end, though - it doesn't
919 stand out well. */
920
921 if (not_found == 1)
922 warning (_("Could not load shared library symbols for %s.\n"
923 "Do you need \"set solib-search-path\" "
924 "or \"set sysroot\"?"),
925 not_found_filename);
926 else if (not_found > 1)
927 warning (_("\
928 Could not load shared library symbols for %d libraries, e.g. %s.\n\
929 Use the \"info sharedlibrary\" command to see the complete listing.\n\
930 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
931 not_found, not_found_filename);
932 }
933 }
934
935
936 /* Return non-zero if NAME is the libpthread shared library.
937
938 Uses a fairly simplistic heuristic approach where we check
939 the file name against "/libpthread". This can lead to false
940 positives, but this should be good enough in practice. */
941
942 int
943 libpthread_name_p (const char *name)
944 {
945 return (strstr (name, "/libpthread") != NULL);
946 }
947
948 /* Return non-zero if SO is the libpthread shared library. */
949
950 static int
951 libpthread_solib_p (struct so_list *so)
952 {
953 return libpthread_name_p (so->so_name);
954 }
955
956 /* Read in symbolic information for any shared objects whose names
957 match PATTERN. (If we've already read a shared object's symbol
958 info, leave it alone.) If PATTERN is zero, read them all.
959
960 If READSYMS is 0, defer reading symbolic information until later
961 but still do any needed low level processing.
962
963 FROM_TTY and TARGET are as described for update_solib_list, above. */
964
965 void
966 solib_add (const char *pattern, int from_tty,
967 struct target_ops *target, int readsyms)
968 {
969 struct so_list *gdb;
970
971 if (print_symbol_loading_p (from_tty, 0, 0))
972 {
973 if (pattern != NULL)
974 {
975 printf_unfiltered (_("Loading symbols for shared libraries: %s\n"),
976 pattern);
977 }
978 else
979 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
980 }
981
982 current_program_space->solib_add_generation++;
983
984 if (pattern)
985 {
986 char *re_err = re_comp (pattern);
987
988 if (re_err)
989 error (_("Invalid regexp: %s"), re_err);
990 }
991
992 update_solib_list (from_tty, target);
993
994 /* Walk the list of currently loaded shared libraries, and read
995 symbols for any that match the pattern --- or any whose symbols
996 aren't already loaded, if no pattern was given. */
997 {
998 int any_matches = 0;
999 int loaded_any_symbols = 0;
1000 const int flags =
1001 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0);
1002
1003 for (gdb = so_list_head; gdb; gdb = gdb->next)
1004 if (! pattern || re_exec (gdb->so_name))
1005 {
1006 /* Normally, we would read the symbols from that library
1007 only if READSYMS is set. However, we're making a small
1008 exception for the pthread library, because we sometimes
1009 need the library symbols to be loaded in order to provide
1010 thread support (x86-linux for instance). */
1011 const int add_this_solib =
1012 (readsyms || libpthread_solib_p (gdb));
1013
1014 any_matches = 1;
1015 if (add_this_solib)
1016 {
1017 if (gdb->symbols_loaded)
1018 {
1019 /* If no pattern was given, be quiet for shared
1020 libraries we have already loaded. */
1021 if (pattern && (from_tty || info_verbose))
1022 printf_unfiltered (_("Symbols already loaded for %s\n"),
1023 gdb->so_name);
1024 }
1025 else if (solib_read_symbols (gdb, flags))
1026 loaded_any_symbols = 1;
1027 }
1028 }
1029
1030 if (loaded_any_symbols)
1031 breakpoint_re_set ();
1032
1033 if (from_tty && pattern && ! any_matches)
1034 printf_unfiltered
1035 ("No loaded shared libraries match the pattern `%s'.\n", pattern);
1036
1037 if (loaded_any_symbols)
1038 {
1039 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1040
1041 /* Getting new symbols may change our opinion about what is
1042 frameless. */
1043 reinit_frame_cache ();
1044
1045 ops->special_symbol_handling ();
1046 }
1047 }
1048 }
1049
1050 /* Implement the "info sharedlibrary" command. Walk through the
1051 shared library list and print information about each attached
1052 library matching PATTERN. If PATTERN is elided, print them
1053 all. */
1054
1055 static void
1056 info_sharedlibrary_command (char *pattern, int from_tty)
1057 {
1058 struct so_list *so = NULL; /* link map state variable */
1059 int so_missing_debug_info = 0;
1060 int addr_width;
1061 int nr_libs;
1062 struct cleanup *table_cleanup;
1063 struct gdbarch *gdbarch = target_gdbarch ();
1064 struct ui_out *uiout = current_uiout;
1065
1066 if (pattern)
1067 {
1068 char *re_err = re_comp (pattern);
1069
1070 if (re_err)
1071 error (_("Invalid regexp: %s"), re_err);
1072 }
1073
1074 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1075 addr_width = 4 + (gdbarch_ptr_bit (gdbarch) / 4);
1076
1077 update_solib_list (from_tty, 0);
1078
1079 /* make_cleanup_ui_out_table_begin_end needs to know the number of
1080 rows, so we need to make two passes over the libs. */
1081
1082 for (nr_libs = 0, so = so_list_head; so; so = so->next)
1083 {
1084 if (so->so_name[0])
1085 {
1086 if (pattern && ! re_exec (so->so_name))
1087 continue;
1088 ++nr_libs;
1089 }
1090 }
1091
1092 table_cleanup =
1093 make_cleanup_ui_out_table_begin_end (uiout, 4, nr_libs,
1094 "SharedLibraryTable");
1095
1096 /* The "- 1" is because ui_out adds one space between columns. */
1097 ui_out_table_header (uiout, addr_width - 1, ui_left, "from", "From");
1098 ui_out_table_header (uiout, addr_width - 1, ui_left, "to", "To");
1099 ui_out_table_header (uiout, 12 - 1, ui_left, "syms-read", "Syms Read");
1100 ui_out_table_header (uiout, 0, ui_noalign,
1101 "name", "Shared Object Library");
1102
1103 ui_out_table_body (uiout);
1104
1105 for (so = so_list_head; so; so = so->next)
1106 {
1107 struct cleanup *lib_cleanup;
1108
1109 if (! so->so_name[0])
1110 continue;
1111 if (pattern && ! re_exec (so->so_name))
1112 continue;
1113
1114 lib_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "lib");
1115
1116 if (so->addr_high != 0)
1117 {
1118 ui_out_field_core_addr (uiout, "from", gdbarch, so->addr_low);
1119 ui_out_field_core_addr (uiout, "to", gdbarch, so->addr_high);
1120 }
1121 else
1122 {
1123 ui_out_field_skip (uiout, "from");
1124 ui_out_field_skip (uiout, "to");
1125 }
1126
1127 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1128 && so->symbols_loaded
1129 && !objfile_has_symbols (so->objfile))
1130 {
1131 so_missing_debug_info = 1;
1132 ui_out_field_string (uiout, "syms-read", "Yes (*)");
1133 }
1134 else
1135 ui_out_field_string (uiout, "syms-read",
1136 so->symbols_loaded ? "Yes" : "No");
1137
1138 ui_out_field_string (uiout, "name", so->so_name);
1139
1140 ui_out_text (uiout, "\n");
1141
1142 do_cleanups (lib_cleanup);
1143 }
1144
1145 do_cleanups (table_cleanup);
1146
1147 if (nr_libs == 0)
1148 {
1149 if (pattern)
1150 ui_out_message (uiout, 0,
1151 _("No shared libraries matched.\n"));
1152 else
1153 ui_out_message (uiout, 0,
1154 _("No shared libraries loaded at this time.\n"));
1155 }
1156 else
1157 {
1158 if (so_missing_debug_info)
1159 ui_out_message (uiout, 0,
1160 _("(*): Shared library is missing "
1161 "debugging information.\n"));
1162 }
1163 }
1164
1165 /* Return 1 if ADDRESS lies within SOLIB. */
1166
1167 int
1168 solib_contains_address_p (const struct so_list *const solib,
1169 CORE_ADDR address)
1170 {
1171 struct target_section *p;
1172
1173 for (p = solib->sections; p < solib->sections_end; p++)
1174 if (p->addr <= address && address < p->endaddr)
1175 return 1;
1176
1177 return 0;
1178 }
1179
1180 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1181 name.
1182
1183 Provides a hook for other gdb routines to discover whether or not a
1184 particular address is within the mapped address space of a shared
1185 library.
1186
1187 For example, this routine is called at one point to disable
1188 breakpoints which are in shared libraries that are not currently
1189 mapped in. */
1190
1191 char *
1192 solib_name_from_address (struct program_space *pspace, CORE_ADDR address)
1193 {
1194 struct so_list *so = NULL;
1195
1196 for (so = pspace->so_list; so; so = so->next)
1197 if (solib_contains_address_p (so, address))
1198 return (so->so_name);
1199
1200 return (0);
1201 }
1202
1203 /* Return whether the data starting at VADDR, size SIZE, must be kept
1204 in a core file for shared libraries loaded before "gcore" is used
1205 to be handled correctly when the core file is loaded. This only
1206 applies when the section would otherwise not be kept in the core
1207 file (in particular, for readonly sections). */
1208
1209 int
1210 solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
1211 {
1212 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1213
1214 if (ops->keep_data_in_core)
1215 return ops->keep_data_in_core (vaddr, size);
1216 else
1217 return 0;
1218 }
1219
1220 /* Called by free_all_symtabs */
1221
1222 void
1223 clear_solib (void)
1224 {
1225 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1226
1227 /* This function is expected to handle ELF shared libraries. It is
1228 also used on Solaris, which can run either ELF or a.out binaries
1229 (for compatibility with SunOS 4), both of which can use shared
1230 libraries. So we don't know whether we have an ELF executable or
1231 an a.out executable until the user chooses an executable file.
1232
1233 ELF shared libraries don't get mapped into the address space
1234 until after the program starts, so we'd better not try to insert
1235 breakpoints in them immediately. We have to wait until the
1236 dynamic linker has loaded them; we'll hit a bp_shlib_event
1237 breakpoint (look for calls to create_solib_event_breakpoint) when
1238 it's ready.
1239
1240 SunOS shared libraries seem to be different --- they're present
1241 as soon as the process begins execution, so there's no need to
1242 put off inserting breakpoints. There's also nowhere to put a
1243 bp_shlib_event breakpoint, so if we put it off, we'll never get
1244 around to it.
1245
1246 So: disable breakpoints only if we're using ELF shared libs. */
1247 if (exec_bfd != NULL
1248 && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
1249 disable_breakpoints_in_shlibs ();
1250
1251 while (so_list_head)
1252 {
1253 struct so_list *so = so_list_head;
1254
1255 so_list_head = so->next;
1256 observer_notify_solib_unloaded (so);
1257 remove_target_sections (so);
1258 free_so (so);
1259 }
1260
1261 ops->clear_solib ();
1262 }
1263
1264 /* Shared library startup support. When GDB starts up the inferior,
1265 it nurses it along (through the shell) until it is ready to execute
1266 its first instruction. At this point, this function gets
1267 called. */
1268
1269 void
1270 solib_create_inferior_hook (int from_tty)
1271 {
1272 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1273
1274 ops->solib_create_inferior_hook (from_tty);
1275 }
1276
1277 /* Check to see if an address is in the dynamic loader's dynamic
1278 symbol resolution code. Return 1 if so, 0 otherwise. */
1279
1280 int
1281 in_solib_dynsym_resolve_code (CORE_ADDR pc)
1282 {
1283 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1284
1285 return ops->in_dynsym_resolve_code (pc);
1286 }
1287
1288 /* Implements the "sharedlibrary" command. */
1289
1290 static void
1291 sharedlibrary_command (char *args, int from_tty)
1292 {
1293 dont_repeat ();
1294 solib_add (args, from_tty, (struct target_ops *) 0, 1);
1295 }
1296
1297 /* Implements the command "nosharedlibrary", which discards symbols
1298 that have been auto-loaded from shared libraries. Symbols from
1299 shared libraries that were added by explicit request of the user
1300 are not discarded. Also called from remote.c. */
1301
1302 void
1303 no_shared_libraries (char *ignored, int from_tty)
1304 {
1305 /* The order of the two routines below is important: clear_solib notifies
1306 the solib_unloaded observers, and some of these observers might need
1307 access to their associated objfiles. Therefore, we can not purge the
1308 solibs' objfiles before clear_solib has been called. */
1309
1310 clear_solib ();
1311 objfile_purge_solibs ();
1312 }
1313
1314 /* See solib.h. */
1315
1316 void
1317 update_solib_breakpoints (void)
1318 {
1319 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1320
1321 if (ops->update_breakpoints != NULL)
1322 ops->update_breakpoints ();
1323 }
1324
1325 /* See solib.h. */
1326
1327 void
1328 handle_solib_event (void)
1329 {
1330 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1331
1332 if (ops->handle_event != NULL)
1333 ops->handle_event ();
1334
1335 clear_program_space_solib_cache (current_inferior ()->pspace);
1336
1337 /* Check for any newly added shared libraries if we're supposed to
1338 be adding them automatically. Switch terminal for any messages
1339 produced by breakpoint_re_set. */
1340 target_terminal_ours_for_output ();
1341 solib_add (NULL, 0, &current_target, auto_solib_add);
1342 target_terminal_inferior ();
1343 }
1344
1345 /* Reload shared libraries, but avoid reloading the same symbol file
1346 we already have loaded. */
1347
1348 static void
1349 reload_shared_libraries_1 (int from_tty)
1350 {
1351 struct so_list *so;
1352 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1353
1354 if (print_symbol_loading_p (from_tty, 0, 0))
1355 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
1356
1357 for (so = so_list_head; so != NULL; so = so->next)
1358 {
1359 char *filename, *found_pathname = NULL;
1360 bfd *abfd;
1361 int was_loaded = so->symbols_loaded;
1362 const int flags =
1363 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0);
1364
1365 filename = tilde_expand (so->so_original_name);
1366 make_cleanup (xfree, filename);
1367 abfd = solib_bfd_open (filename);
1368 if (abfd != NULL)
1369 {
1370 found_pathname = xstrdup (bfd_get_filename (abfd));
1371 make_cleanup (xfree, found_pathname);
1372 gdb_bfd_unref (abfd);
1373 }
1374
1375 /* If this shared library is no longer associated with its previous
1376 symbol file, close that. */
1377 if ((found_pathname == NULL && was_loaded)
1378 || (found_pathname != NULL
1379 && filename_cmp (found_pathname, so->so_name) != 0))
1380 {
1381 if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED)
1382 && !solib_used (so))
1383 free_objfile (so->objfile);
1384 remove_target_sections (so);
1385 clear_so (so);
1386 }
1387
1388 /* If this shared library is now associated with a new symbol
1389 file, open it. */
1390 if (found_pathname != NULL
1391 && (!was_loaded
1392 || filename_cmp (found_pathname, so->so_name) != 0))
1393 {
1394 int got_error = 0;
1395
1396 TRY
1397 {
1398 solib_map_sections (so);
1399 }
1400
1401 CATCH (e, RETURN_MASK_ERROR)
1402 {
1403 exception_fprintf (gdb_stderr, e,
1404 _("Error while mapping "
1405 "shared library sections:\n"));
1406 got_error = 1;
1407 }
1408 END_CATCH
1409
1410 if (!got_error
1411 && (auto_solib_add || was_loaded || libpthread_solib_p (so)))
1412 solib_read_symbols (so, flags);
1413 }
1414 }
1415
1416 do_cleanups (old_chain);
1417 }
1418
1419 static void
1420 reload_shared_libraries (char *ignored, int from_tty,
1421 struct cmd_list_element *e)
1422 {
1423 const struct target_so_ops *ops;
1424
1425 reload_shared_libraries_1 (from_tty);
1426
1427 ops = solib_ops (target_gdbarch ());
1428
1429 /* Creating inferior hooks here has two purposes. First, if we reload
1430 shared libraries then the address of solib breakpoint we've computed
1431 previously might be no longer valid. For example, if we forgot to set
1432 solib-absolute-prefix and are setting it right now, then the previous
1433 breakpoint address is plain wrong. Second, installing solib hooks
1434 also implicitly figures were ld.so is and loads symbols for it.
1435 Absent this call, if we've just connected to a target and set
1436 solib-absolute-prefix or solib-search-path, we'll lose all information
1437 about ld.so. */
1438 if (target_has_execution)
1439 {
1440 /* Reset or free private data structures not associated with
1441 so_list entries. */
1442 ops->clear_solib ();
1443
1444 /* Remove any previous solib event breakpoint. This is usually
1445 done in common code, at breakpoint_init_inferior time, but
1446 we're not really starting up the inferior here. */
1447 remove_solib_event_breakpoints ();
1448
1449 solib_create_inferior_hook (from_tty);
1450 }
1451
1452 /* Sometimes the platform-specific hook loads initial shared
1453 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1454 incorrectly 0 but such solib targets should be fixed anyway. If we
1455 made all the inferior hook methods consistent, this call could be
1456 removed. Call it only after the solib target has been initialized by
1457 solib_create_inferior_hook. */
1458
1459 solib_add (NULL, 0, NULL, auto_solib_add);
1460
1461 breakpoint_re_set ();
1462
1463 /* We may have loaded or unloaded debug info for some (or all)
1464 shared libraries. However, frames may still reference them. For
1465 example, a frame's unwinder might still point at DWARF FDE
1466 structures that are now freed. Also, getting new symbols may
1467 change our opinion about what is frameless. */
1468 reinit_frame_cache ();
1469
1470 ops->special_symbol_handling ();
1471 }
1472
1473 /* Wrapper for reload_shared_libraries that replaces "remote:"
1474 at the start of gdb_sysroot with "target:". */
1475
1476 static void
1477 gdb_sysroot_changed (char *ignored, int from_tty,
1478 struct cmd_list_element *e)
1479 {
1480 const char *old_prefix = "remote:";
1481 const char *new_prefix = TARGET_SYSROOT_PREFIX;
1482
1483 if (startswith (gdb_sysroot, old_prefix))
1484 {
1485 static int warning_issued = 0;
1486
1487 gdb_assert (strlen (old_prefix) == strlen (new_prefix));
1488 memcpy (gdb_sysroot, new_prefix, strlen (new_prefix));
1489
1490 if (!warning_issued)
1491 {
1492 warning (_("\"%s\" is deprecated, use \"%s\" instead."),
1493 old_prefix, new_prefix);
1494 warning (_("sysroot set to \"%s\"."), gdb_sysroot);
1495
1496 warning_issued = 1;
1497 }
1498 }
1499
1500 reload_shared_libraries (ignored, from_tty, e);
1501 }
1502
1503 static void
1504 show_auto_solib_add (struct ui_file *file, int from_tty,
1505 struct cmd_list_element *c, const char *value)
1506 {
1507 fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"),
1508 value);
1509 }
1510
1511
1512 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1513 the library-specific handler if it is installed for the current target. */
1514
1515 struct block_symbol
1516 solib_global_lookup (struct objfile *objfile,
1517 const char *name,
1518 const domain_enum domain)
1519 {
1520 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1521
1522 if (ops->lookup_lib_global_symbol != NULL)
1523 return ops->lookup_lib_global_symbol (objfile, name, domain);
1524 return (struct block_symbol) {NULL, NULL};
1525 }
1526
1527 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1528 up symbol from ABFD. MATCH_SYM is a callback function to determine
1529 whether to pick up a symbol. DATA is the input of this callback
1530 function. Return NULL if symbol is not found. */
1531
1532 CORE_ADDR
1533 gdb_bfd_lookup_symbol_from_symtab (bfd *abfd,
1534 int (*match_sym) (asymbol *, void *),
1535 void *data)
1536 {
1537 long storage_needed = bfd_get_symtab_upper_bound (abfd);
1538 CORE_ADDR symaddr = 0;
1539
1540 if (storage_needed > 0)
1541 {
1542 unsigned int i;
1543
1544 asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
1545 struct cleanup *back_to = make_cleanup (xfree, symbol_table);
1546 unsigned int number_of_symbols =
1547 bfd_canonicalize_symtab (abfd, symbol_table);
1548
1549 for (i = 0; i < number_of_symbols; i++)
1550 {
1551 asymbol *sym = *symbol_table++;
1552
1553 if (match_sym (sym, data))
1554 {
1555 struct gdbarch *gdbarch = target_gdbarch ();
1556 symaddr = sym->value;
1557
1558 /* Some ELF targets fiddle with addresses of symbols they
1559 consider special. They use minimal symbols to do that
1560 and this is needed for correct breakpoint placement,
1561 but we do not have full data here to build a complete
1562 minimal symbol, so just set the address and let the
1563 targets cope with that. */
1564 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1565 && gdbarch_elf_make_msymbol_special_p (gdbarch))
1566 {
1567 struct minimal_symbol msym;
1568
1569 memset (&msym, 0, sizeof (msym));
1570 SET_MSYMBOL_VALUE_ADDRESS (&msym, symaddr);
1571 gdbarch_elf_make_msymbol_special (gdbarch, sym, &msym);
1572 symaddr = MSYMBOL_VALUE_RAW_ADDRESS (&msym);
1573 }
1574
1575 /* BFD symbols are section relative. */
1576 symaddr += sym->section->vma;
1577 break;
1578 }
1579 }
1580 do_cleanups (back_to);
1581 }
1582
1583 return symaddr;
1584 }
1585
1586 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1587 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1588 up a symbol. DATA is the input of this callback function. Return NULL
1589 if symbol is not found. */
1590
1591 static CORE_ADDR
1592 bfd_lookup_symbol_from_dyn_symtab (bfd *abfd,
1593 int (*match_sym) (asymbol *, void *),
1594 void *data)
1595 {
1596 long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1597 CORE_ADDR symaddr = 0;
1598
1599 if (storage_needed > 0)
1600 {
1601 unsigned int i;
1602 asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
1603 struct cleanup *back_to = make_cleanup (xfree, symbol_table);
1604 unsigned int number_of_symbols =
1605 bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
1606
1607 for (i = 0; i < number_of_symbols; i++)
1608 {
1609 asymbol *sym = *symbol_table++;
1610
1611 if (match_sym (sym, data))
1612 {
1613 /* BFD symbols are section relative. */
1614 symaddr = sym->value + sym->section->vma;
1615 break;
1616 }
1617 }
1618 do_cleanups (back_to);
1619 }
1620 return symaddr;
1621 }
1622
1623 /* Lookup the value for a specific symbol from symbol table and dynamic
1624 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1625 function to determine whether to pick up a symbol. DATA is the
1626 input of this callback function. Return NULL if symbol is not
1627 found. */
1628
1629 CORE_ADDR
1630 gdb_bfd_lookup_symbol (bfd *abfd,
1631 int (*match_sym) (asymbol *, void *),
1632 void *data)
1633 {
1634 CORE_ADDR symaddr = gdb_bfd_lookup_symbol_from_symtab (abfd, match_sym, data);
1635
1636 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1637 have to check the dynamic string table too. */
1638 if (symaddr == 0)
1639 symaddr = bfd_lookup_symbol_from_dyn_symtab (abfd, match_sym, data);
1640
1641 return symaddr;
1642 }
1643
1644 /* SO_LIST_HEAD may contain user-loaded object files that can be removed
1645 out-of-band by the user. So upon notification of free_objfile remove
1646 all references to any user-loaded file that is about to be freed. */
1647
1648 static void
1649 remove_user_added_objfile (struct objfile *objfile)
1650 {
1651 struct so_list *so;
1652
1653 if (objfile != 0 && objfile->flags & OBJF_USERLOADED)
1654 {
1655 for (so = so_list_head; so != NULL; so = so->next)
1656 if (so->objfile == objfile)
1657 so->objfile = NULL;
1658 }
1659 }
1660
1661 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
1662
1663 void
1664 _initialize_solib (void)
1665 {
1666 solib_data = gdbarch_data_register_pre_init (solib_init);
1667
1668 observer_attach_free_objfile (remove_user_added_objfile);
1669
1670 add_com ("sharedlibrary", class_files, sharedlibrary_command,
1671 _("Load shared object library symbols for files matching REGEXP."));
1672 add_info ("sharedlibrary", info_sharedlibrary_command,
1673 _("Status of loaded shared object libraries."));
1674 add_info_alias ("dll", "sharedlibrary", 1);
1675 add_com ("nosharedlibrary", class_files, no_shared_libraries,
1676 _("Unload all shared object library symbols."));
1677
1678 add_setshow_boolean_cmd ("auto-solib-add", class_support,
1679 &auto_solib_add, _("\
1680 Set autoloading of shared library symbols."), _("\
1681 Show autoloading of shared library symbols."), _("\
1682 If \"on\", symbols from all shared object libraries will be loaded\n\
1683 automatically when the inferior begins execution, when the dynamic linker\n\
1684 informs gdb that a new library has been loaded, or when attaching to the\n\
1685 inferior. Otherwise, symbols must be loaded manually, using \
1686 `sharedlibrary'."),
1687 NULL,
1688 show_auto_solib_add,
1689 &setlist, &showlist);
1690
1691 add_setshow_optional_filename_cmd ("sysroot", class_support,
1692 &gdb_sysroot, _("\
1693 Set an alternate system root."), _("\
1694 Show the current system root."), _("\
1695 The system root is used to load absolute shared library symbol files.\n\
1696 For other (relative) files, you can add directories using\n\
1697 `set solib-search-path'."),
1698 gdb_sysroot_changed,
1699 NULL,
1700 &setlist, &showlist);
1701
1702 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
1703 &setlist);
1704 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
1705 &showlist);
1706
1707 add_setshow_optional_filename_cmd ("solib-search-path", class_support,
1708 &solib_search_path, _("\
1709 Set the search path for loading non-absolute shared library symbol files."),
1710 _("\
1711 Show the search path for loading non-absolute shared library symbol files."),
1712 _("\
1713 This takes precedence over the environment variables \
1714 PATH and LD_LIBRARY_PATH."),
1715 reload_shared_libraries,
1716 show_solib_search_path,
1717 &setlist, &showlist);
1718 }
This page took 0.06651 seconds and 5 git commands to generate.