1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2012 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
35 #include "breakpoint.h"
37 #include "complaints.h"
41 #include "filenames.h" /* for DOSish file names */
42 #include "gdb-stabs.h"
43 #include "gdb_obstack.h"
44 #include "completer.h"
47 #include "readline/readline.h"
48 #include "gdb_assert.h"
52 #include "parser-defs.h"
60 #include <sys/types.h>
62 #include "gdb_string.h"
70 int (*deprecated_ui_load_progress_hook) (const char *section,
72 void (*deprecated_show_load_progress) (const char *section,
73 unsigned long section_sent,
74 unsigned long section_size,
75 unsigned long total_sent,
76 unsigned long total_size);
77 void (*deprecated_pre_add_symbol_hook) (const char *);
78 void (*deprecated_post_add_symbol_hook) (void);
80 static void clear_symtab_users_cleanup (void *ignore);
82 /* Global variables owned by this file. */
83 int readnow_symbol_files; /* Read full symbols immediately. */
85 /* Functions this file defines. */
87 static void load_command (char *, int);
89 static void symbol_file_add_main_1 (char *args, int from_tty, int flags);
91 static void add_symbol_file_command (char *, int);
93 bfd *symfile_bfd_open (char *);
95 int get_section_index (struct objfile *, char *);
97 static const struct sym_fns *find_sym_fns (bfd *);
99 static void decrement_reading_symtab (void *);
101 static void overlay_invalidate_all (void);
103 void list_overlays_command (char *, int);
105 void map_overlay_command (char *, int);
107 void unmap_overlay_command (char *, int);
109 static void overlay_auto_command (char *, int);
111 static void overlay_manual_command (char *, int);
113 static void overlay_off_command (char *, int);
115 static void overlay_load_command (char *, int);
117 static void overlay_command (char *, int);
119 static void simple_free_overlay_table (void);
121 static void read_target_long_array (CORE_ADDR, unsigned int *, int, int,
124 static int simple_read_overlay_table (void);
126 static int simple_overlay_update_1 (struct obj_section *);
128 static void add_filename_language (char *ext, enum language lang);
130 static void info_ext_lang_command (char *args, int from_tty);
132 static void init_filename_language_table (void);
134 static void symfile_find_segment_sections (struct objfile *objfile);
136 void _initialize_symfile (void);
138 /* List of all available sym_fns. On gdb startup, each object file reader
139 calls add_symtab_fns() to register information on each format it is
142 typedef const struct sym_fns *sym_fns_ptr;
143 DEF_VEC_P (sym_fns_ptr);
145 static VEC (sym_fns_ptr) *symtab_fns = NULL;
147 /* If non-zero, shared library symbols will be added automatically
148 when the inferior is created, new libraries are loaded, or when
149 attaching to the inferior. This is almost always what users will
150 want to have happen; but for very large programs, the startup time
151 will be excessive, and so if this is a problem, the user can clear
152 this flag and then add the shared library symbols as needed. Note
153 that there is a potential for confusion, since if the shared
154 library symbols are not loaded, commands like "info fun" will *not*
155 report all the functions that are actually present. */
157 int auto_solib_add = 1;
160 /* Make a null terminated copy of the string at PTR with SIZE characters in
161 the obstack pointed to by OBSTACKP . Returns the address of the copy.
162 Note that the string at PTR does not have to be null terminated, I.e. it
163 may be part of a larger string and we are only saving a substring. */
166 obsavestring (const char *ptr, int size, struct obstack *obstackp)
168 char *p = (char *) obstack_alloc (obstackp, size + 1);
169 /* Open-coded memcpy--saves function call time. These strings are usually
170 short. FIXME: Is this really still true with a compiler that can
173 const char *p1 = ptr;
175 const char *end = ptr + size;
184 /* Concatenate NULL terminated variable argument list of `const char *'
185 strings; return the new string. Space is found in the OBSTACKP.
186 Argument list must be terminated by a sentinel expression `(char *)
190 obconcat (struct obstack *obstackp, ...)
194 va_start (ap, obstackp);
197 const char *s = va_arg (ap, const char *);
202 obstack_grow_str (obstackp, s);
205 obstack_1grow (obstackp, 0);
207 return obstack_finish (obstackp);
210 /* True if we are reading a symbol table. */
212 int currently_reading_symtab = 0;
215 decrement_reading_symtab (void *dummy)
217 currently_reading_symtab--;
220 /* Increment currently_reading_symtab and return a cleanup that can be
221 used to decrement it. */
223 increment_reading_symtab (void)
225 ++currently_reading_symtab;
226 return make_cleanup (decrement_reading_symtab, NULL);
229 /* Remember the lowest-addressed loadable section we've seen.
230 This function is called via bfd_map_over_sections.
232 In case of equal vmas, the section with the largest size becomes the
233 lowest-addressed loadable section.
235 If the vmas and sizes are equal, the last section is considered the
236 lowest-addressed loadable section. */
239 find_lowest_section (bfd *abfd, asection *sect, void *obj)
241 asection **lowest = (asection **) obj;
243 if (0 == (bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD)))
246 *lowest = sect; /* First loadable section */
247 else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect))
248 *lowest = sect; /* A lower loadable section */
249 else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect)
250 && (bfd_section_size (abfd, (*lowest))
251 <= bfd_section_size (abfd, sect)))
255 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
257 struct section_addr_info *
258 alloc_section_addr_info (size_t num_sections)
260 struct section_addr_info *sap;
263 size = (sizeof (struct section_addr_info)
264 + sizeof (struct other_sections) * (num_sections - 1));
265 sap = (struct section_addr_info *) xmalloc (size);
266 memset (sap, 0, size);
267 sap->num_sections = num_sections;
272 /* Build (allocate and populate) a section_addr_info struct from
273 an existing section table. */
275 extern struct section_addr_info *
276 build_section_addr_info_from_section_table (const struct target_section *start,
277 const struct target_section *end)
279 struct section_addr_info *sap;
280 const struct target_section *stp;
283 sap = alloc_section_addr_info (end - start);
285 for (stp = start, oidx = 0; stp != end; stp++)
287 if (bfd_get_section_flags (stp->bfd,
288 stp->the_bfd_section) & (SEC_ALLOC | SEC_LOAD)
289 && oidx < end - start)
291 sap->other[oidx].addr = stp->addr;
292 sap->other[oidx].name
293 = xstrdup (bfd_section_name (stp->bfd, stp->the_bfd_section));
294 sap->other[oidx].sectindex = stp->the_bfd_section->index;
302 /* Create a section_addr_info from section offsets in ABFD. */
304 static struct section_addr_info *
305 build_section_addr_info_from_bfd (bfd *abfd)
307 struct section_addr_info *sap;
309 struct bfd_section *sec;
311 sap = alloc_section_addr_info (bfd_count_sections (abfd));
312 for (i = 0, sec = abfd->sections; sec != NULL; sec = sec->next)
313 if (bfd_get_section_flags (abfd, sec) & (SEC_ALLOC | SEC_LOAD))
315 sap->other[i].addr = bfd_get_section_vma (abfd, sec);
316 sap->other[i].name = xstrdup (bfd_get_section_name (abfd, sec));
317 sap->other[i].sectindex = sec->index;
323 /* Create a section_addr_info from section offsets in OBJFILE. */
325 struct section_addr_info *
326 build_section_addr_info_from_objfile (const struct objfile *objfile)
328 struct section_addr_info *sap;
331 /* Before reread_symbols gets rewritten it is not safe to call:
332 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
334 sap = build_section_addr_info_from_bfd (objfile->obfd);
335 for (i = 0; i < sap->num_sections && sap->other[i].name; i++)
337 int sectindex = sap->other[i].sectindex;
339 sap->other[i].addr += objfile->section_offsets->offsets[sectindex];
344 /* Free all memory allocated by build_section_addr_info_from_section_table. */
347 free_section_addr_info (struct section_addr_info *sap)
351 for (idx = 0; idx < sap->num_sections; idx++)
352 if (sap->other[idx].name)
353 xfree (sap->other[idx].name);
358 /* Initialize OBJFILE's sect_index_* members. */
360 init_objfile_sect_indices (struct objfile *objfile)
365 sect = bfd_get_section_by_name (objfile->obfd, ".text");
367 objfile->sect_index_text = sect->index;
369 sect = bfd_get_section_by_name (objfile->obfd, ".data");
371 objfile->sect_index_data = sect->index;
373 sect = bfd_get_section_by_name (objfile->obfd, ".bss");
375 objfile->sect_index_bss = sect->index;
377 sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
379 objfile->sect_index_rodata = sect->index;
381 /* This is where things get really weird... We MUST have valid
382 indices for the various sect_index_* members or gdb will abort.
383 So if for example, there is no ".text" section, we have to
384 accomodate that. First, check for a file with the standard
385 one or two segments. */
387 symfile_find_segment_sections (objfile);
389 /* Except when explicitly adding symbol files at some address,
390 section_offsets contains nothing but zeros, so it doesn't matter
391 which slot in section_offsets the individual sect_index_* members
392 index into. So if they are all zero, it is safe to just point
393 all the currently uninitialized indices to the first slot. But
394 beware: if this is the main executable, it may be relocated
395 later, e.g. by the remote qOffsets packet, and then this will
396 be wrong! That's why we try segments first. */
398 for (i = 0; i < objfile->num_sections; i++)
400 if (ANOFFSET (objfile->section_offsets, i) != 0)
405 if (i == objfile->num_sections)
407 if (objfile->sect_index_text == -1)
408 objfile->sect_index_text = 0;
409 if (objfile->sect_index_data == -1)
410 objfile->sect_index_data = 0;
411 if (objfile->sect_index_bss == -1)
412 objfile->sect_index_bss = 0;
413 if (objfile->sect_index_rodata == -1)
414 objfile->sect_index_rodata = 0;
418 /* The arguments to place_section. */
420 struct place_section_arg
422 struct section_offsets *offsets;
426 /* Find a unique offset to use for loadable section SECT if
427 the user did not provide an offset. */
430 place_section (bfd *abfd, asection *sect, void *obj)
432 struct place_section_arg *arg = obj;
433 CORE_ADDR *offsets = arg->offsets->offsets, start_addr;
435 ULONGEST align = ((ULONGEST) 1) << bfd_get_section_alignment (abfd, sect);
437 /* We are only interested in allocated sections. */
438 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
441 /* If the user specified an offset, honor it. */
442 if (offsets[sect->index] != 0)
445 /* Otherwise, let's try to find a place for the section. */
446 start_addr = (arg->lowest + align - 1) & -align;
453 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
455 int indx = cur_sec->index;
457 /* We don't need to compare against ourself. */
461 /* We can only conflict with allocated sections. */
462 if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0)
465 /* If the section offset is 0, either the section has not been placed
466 yet, or it was the lowest section placed (in which case LOWEST
467 will be past its end). */
468 if (offsets[indx] == 0)
471 /* If this section would overlap us, then we must move up. */
472 if (start_addr + bfd_get_section_size (sect) > offsets[indx]
473 && start_addr < offsets[indx] + bfd_get_section_size (cur_sec))
475 start_addr = offsets[indx] + bfd_get_section_size (cur_sec);
476 start_addr = (start_addr + align - 1) & -align;
481 /* Otherwise, we appear to be OK. So far. */
486 offsets[sect->index] = start_addr;
487 arg->lowest = start_addr + bfd_get_section_size (sect);
490 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
491 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
495 relative_addr_info_to_section_offsets (struct section_offsets *section_offsets,
497 struct section_addr_info *addrs)
501 memset (section_offsets, 0, SIZEOF_N_SECTION_OFFSETS (num_sections));
503 /* Now calculate offsets for section that were specified by the caller. */
504 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
506 struct other_sections *osp;
508 osp = &addrs->other[i];
509 if (osp->sectindex == -1)
512 /* Record all sections in offsets. */
513 /* The section_offsets in the objfile are here filled in using
515 section_offsets->offsets[osp->sectindex] = osp->addr;
519 /* Transform section name S for a name comparison. prelink can split section
520 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
521 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
522 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
523 (`.sbss') section has invalid (increased) virtual address. */
526 addr_section_name (const char *s)
528 if (strcmp (s, ".dynbss") == 0)
530 if (strcmp (s, ".sdynbss") == 0)
536 /* qsort comparator for addrs_section_sort. Sort entries in ascending order by
537 their (name, sectindex) pair. sectindex makes the sort by name stable. */
540 addrs_section_compar (const void *ap, const void *bp)
542 const struct other_sections *a = *((struct other_sections **) ap);
543 const struct other_sections *b = *((struct other_sections **) bp);
546 retval = strcmp (addr_section_name (a->name), addr_section_name (b->name));
550 return a->sectindex - b->sectindex;
553 /* Provide sorted array of pointers to sections of ADDRS. The array is
554 terminated by NULL. Caller is responsible to call xfree for it. */
556 static struct other_sections **
557 addrs_section_sort (struct section_addr_info *addrs)
559 struct other_sections **array;
562 /* `+ 1' for the NULL terminator. */
563 array = xmalloc (sizeof (*array) * (addrs->num_sections + 1));
564 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
565 array[i] = &addrs->other[i];
568 qsort (array, i, sizeof (*array), addrs_section_compar);
573 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
574 also SECTINDEXes specific to ABFD there. This function can be used to
575 rebase ADDRS to start referencing different BFD than before. */
578 addr_info_make_relative (struct section_addr_info *addrs, bfd *abfd)
580 asection *lower_sect;
581 CORE_ADDR lower_offset;
583 struct cleanup *my_cleanup;
584 struct section_addr_info *abfd_addrs;
585 struct other_sections **addrs_sorted, **abfd_addrs_sorted;
586 struct other_sections **addrs_to_abfd_addrs;
588 /* Find lowest loadable section to be used as starting point for
589 continguous sections. */
591 bfd_map_over_sections (abfd, find_lowest_section, &lower_sect);
592 if (lower_sect == NULL)
594 warning (_("no loadable sections found in added symbol-file %s"),
595 bfd_get_filename (abfd));
599 lower_offset = bfd_section_vma (bfd_get_filename (abfd), lower_sect);
601 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
602 in ABFD. Section names are not unique - there can be multiple sections of
603 the same name. Also the sections of the same name do not have to be
604 adjacent to each other. Some sections may be present only in one of the
605 files. Even sections present in both files do not have to be in the same
608 Use stable sort by name for the sections in both files. Then linearly
609 scan both lists matching as most of the entries as possible. */
611 addrs_sorted = addrs_section_sort (addrs);
612 my_cleanup = make_cleanup (xfree, addrs_sorted);
614 abfd_addrs = build_section_addr_info_from_bfd (abfd);
615 make_cleanup_free_section_addr_info (abfd_addrs);
616 abfd_addrs_sorted = addrs_section_sort (abfd_addrs);
617 make_cleanup (xfree, abfd_addrs_sorted);
619 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
620 ABFD_ADDRS_SORTED. */
622 addrs_to_abfd_addrs = xzalloc (sizeof (*addrs_to_abfd_addrs)
623 * addrs->num_sections);
624 make_cleanup (xfree, addrs_to_abfd_addrs);
626 while (*addrs_sorted)
628 const char *sect_name = addr_section_name ((*addrs_sorted)->name);
630 while (*abfd_addrs_sorted
631 && strcmp (addr_section_name ((*abfd_addrs_sorted)->name),
635 if (*abfd_addrs_sorted
636 && strcmp (addr_section_name ((*abfd_addrs_sorted)->name),
641 /* Make the found item directly addressable from ADDRS. */
642 index_in_addrs = *addrs_sorted - addrs->other;
643 gdb_assert (addrs_to_abfd_addrs[index_in_addrs] == NULL);
644 addrs_to_abfd_addrs[index_in_addrs] = *abfd_addrs_sorted;
646 /* Never use the same ABFD entry twice. */
653 /* Calculate offsets for the loadable sections.
654 FIXME! Sections must be in order of increasing loadable section
655 so that contiguous sections can use the lower-offset!!!
657 Adjust offsets if the segments are not contiguous.
658 If the section is contiguous, its offset should be set to
659 the offset of the highest loadable section lower than it
660 (the loadable section directly below it in memory).
661 this_offset = lower_offset = lower_addr - lower_orig_addr */
663 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
665 struct other_sections *sect = addrs_to_abfd_addrs[i];
669 /* This is the index used by BFD. */
670 addrs->other[i].sectindex = sect->sectindex;
672 if (addrs->other[i].addr != 0)
674 addrs->other[i].addr -= sect->addr;
675 lower_offset = addrs->other[i].addr;
678 addrs->other[i].addr = lower_offset;
682 /* addr_section_name transformation is not used for SECT_NAME. */
683 const char *sect_name = addrs->other[i].name;
685 /* This section does not exist in ABFD, which is normally
686 unexpected and we want to issue a warning.
688 However, the ELF prelinker does create a few sections which are
689 marked in the main executable as loadable (they are loaded in
690 memory from the DYNAMIC segment) and yet are not present in
691 separate debug info files. This is fine, and should not cause
692 a warning. Shared libraries contain just the section
693 ".gnu.liblist" but it is not marked as loadable there. There is
694 no other way to identify them than by their name as the sections
695 created by prelink have no special flags.
697 For the sections `.bss' and `.sbss' see addr_section_name. */
699 if (!(strcmp (sect_name, ".gnu.liblist") == 0
700 || strcmp (sect_name, ".gnu.conflict") == 0
701 || (strcmp (sect_name, ".bss") == 0
703 && strcmp (addrs->other[i - 1].name, ".dynbss") == 0
704 && addrs_to_abfd_addrs[i - 1] != NULL)
705 || (strcmp (sect_name, ".sbss") == 0
707 && strcmp (addrs->other[i - 1].name, ".sdynbss") == 0
708 && addrs_to_abfd_addrs[i - 1] != NULL)))
709 warning (_("section %s not found in %s"), sect_name,
710 bfd_get_filename (abfd));
712 addrs->other[i].addr = 0;
713 addrs->other[i].sectindex = -1;
717 do_cleanups (my_cleanup);
720 /* Parse the user's idea of an offset for dynamic linking, into our idea
721 of how to represent it for fast symbol reading. This is the default
722 version of the sym_fns.sym_offsets function for symbol readers that
723 don't need to do anything special. It allocates a section_offsets table
724 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
727 default_symfile_offsets (struct objfile *objfile,
728 struct section_addr_info *addrs)
730 objfile->num_sections = bfd_count_sections (objfile->obfd);
731 objfile->section_offsets = (struct section_offsets *)
732 obstack_alloc (&objfile->objfile_obstack,
733 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
734 relative_addr_info_to_section_offsets (objfile->section_offsets,
735 objfile->num_sections, addrs);
737 /* For relocatable files, all loadable sections will start at zero.
738 The zero is meaningless, so try to pick arbitrary addresses such
739 that no loadable sections overlap. This algorithm is quadratic,
740 but the number of sections in a single object file is generally
742 if ((bfd_get_file_flags (objfile->obfd) & (EXEC_P | DYNAMIC)) == 0)
744 struct place_section_arg arg;
745 bfd *abfd = objfile->obfd;
748 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
749 /* We do not expect this to happen; just skip this step if the
750 relocatable file has a section with an assigned VMA. */
751 if (bfd_section_vma (abfd, cur_sec) != 0)
756 CORE_ADDR *offsets = objfile->section_offsets->offsets;
758 /* Pick non-overlapping offsets for sections the user did not
760 arg.offsets = objfile->section_offsets;
762 bfd_map_over_sections (objfile->obfd, place_section, &arg);
764 /* Correctly filling in the section offsets is not quite
765 enough. Relocatable files have two properties that
766 (most) shared objects do not:
768 - Their debug information will contain relocations. Some
769 shared libraries do also, but many do not, so this can not
772 - If there are multiple code sections they will be loaded
773 at different relative addresses in memory than they are
774 in the objfile, since all sections in the file will start
777 Because GDB has very limited ability to map from an
778 address in debug info to the correct code section,
779 it relies on adding SECT_OFF_TEXT to things which might be
780 code. If we clear all the section offsets, and set the
781 section VMAs instead, then symfile_relocate_debug_section
782 will return meaningful debug information pointing at the
785 GDB has too many different data structures for section
786 addresses - a bfd, objfile, and so_list all have section
787 tables, as does exec_ops. Some of these could probably
790 for (cur_sec = abfd->sections; cur_sec != NULL;
791 cur_sec = cur_sec->next)
793 if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0)
796 bfd_set_section_vma (abfd, cur_sec, offsets[cur_sec->index]);
797 exec_set_section_address (bfd_get_filename (abfd),
799 offsets[cur_sec->index]);
800 offsets[cur_sec->index] = 0;
805 /* Remember the bfd indexes for the .text, .data, .bss and
807 init_objfile_sect_indices (objfile);
811 /* Divide the file into segments, which are individual relocatable units.
812 This is the default version of the sym_fns.sym_segments function for
813 symbol readers that do not have an explicit representation of segments.
814 It assumes that object files do not have segments, and fully linked
815 files have a single segment. */
817 struct symfile_segment_data *
818 default_symfile_segments (bfd *abfd)
822 struct symfile_segment_data *data;
825 /* Relocatable files contain enough information to position each
826 loadable section independently; they should not be relocated
828 if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) == 0)
831 /* Make sure there is at least one loadable section in the file. */
832 for (sect = abfd->sections; sect != NULL; sect = sect->next)
834 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
842 low = bfd_get_section_vma (abfd, sect);
843 high = low + bfd_get_section_size (sect);
845 data = XZALLOC (struct symfile_segment_data);
846 data->num_segments = 1;
847 data->segment_bases = XCALLOC (1, CORE_ADDR);
848 data->segment_sizes = XCALLOC (1, CORE_ADDR);
850 num_sections = bfd_count_sections (abfd);
851 data->segment_info = XCALLOC (num_sections, int);
853 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
857 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
860 vma = bfd_get_section_vma (abfd, sect);
863 if (vma + bfd_get_section_size (sect) > high)
864 high = vma + bfd_get_section_size (sect);
866 data->segment_info[i] = 1;
869 data->segment_bases[0] = low;
870 data->segment_sizes[0] = high - low;
875 /* This is a convenience function to call sym_read for OBJFILE and
876 possibly force the partial symbols to be read. */
879 read_symbols (struct objfile *objfile, int add_flags)
881 (*objfile->sf->sym_read) (objfile, add_flags);
882 if (!objfile_has_partial_symbols (objfile))
884 bfd *abfd = find_separate_debug_file_in_section (objfile);
885 struct cleanup *cleanup = make_cleanup_bfd_unref (abfd);
888 symbol_file_add_separate (abfd, add_flags, objfile);
890 do_cleanups (cleanup);
892 if ((add_flags & SYMFILE_NO_READ) == 0)
893 require_partial_symbols (objfile, 0);
896 /* Process a symbol file, as either the main file or as a dynamically
899 OBJFILE is where the symbols are to be read from.
901 ADDRS is the list of section load addresses. If the user has given
902 an 'add-symbol-file' command, then this is the list of offsets and
903 addresses he or she provided as arguments to the command; or, if
904 we're handling a shared library, these are the actual addresses the
905 sections are loaded at, according to the inferior's dynamic linker
906 (as gleaned by GDB's shared library code). We convert each address
907 into an offset from the section VMA's as it appears in the object
908 file, and then call the file's sym_offsets function to convert this
909 into a format-specific offset table --- a `struct section_offsets'.
910 If ADDRS is non-zero, OFFSETS must be zero.
912 OFFSETS is a table of section offsets already in the right
913 format-specific representation. NUM_OFFSETS is the number of
914 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
915 assume this is the proper table the call to sym_offsets described
916 above would produce. Instead of calling sym_offsets, we just dump
917 it right into objfile->section_offsets. (When we're re-reading
918 symbols from an objfile, we don't have the original load address
919 list any more; all we have is the section offset table.) If
920 OFFSETS is non-zero, ADDRS must be zero.
922 ADD_FLAGS encodes verbosity level, whether this is main symbol or
923 an extra symbol file such as dynamically loaded code, and wether
924 breakpoint reset should be deferred. */
927 syms_from_objfile (struct objfile *objfile,
928 struct section_addr_info *addrs,
929 struct section_offsets *offsets,
933 struct section_addr_info *local_addr = NULL;
934 struct cleanup *old_chain;
935 const int mainline = add_flags & SYMFILE_MAINLINE;
937 gdb_assert (! (addrs && offsets));
939 init_entry_point_info (objfile);
940 objfile->sf = find_sym_fns (objfile->obfd);
942 if (objfile->sf == NULL)
943 return; /* No symbols. */
945 /* Make sure that partially constructed symbol tables will be cleaned up
946 if an error occurs during symbol reading. */
947 old_chain = make_cleanup_free_objfile (objfile);
949 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
950 list. We now establish the convention that an addr of zero means
951 no load address was specified. */
952 if (! addrs && ! offsets)
955 = alloc_section_addr_info (bfd_count_sections (objfile->obfd));
956 make_cleanup (xfree, local_addr);
960 /* Now either addrs or offsets is non-zero. */
964 /* We will modify the main symbol table, make sure that all its users
965 will be cleaned up if an error occurs during symbol reading. */
966 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
968 /* Since no error yet, throw away the old symbol table. */
970 if (symfile_objfile != NULL)
972 free_objfile (symfile_objfile);
973 gdb_assert (symfile_objfile == NULL);
976 /* Currently we keep symbols from the add-symbol-file command.
977 If the user wants to get rid of them, they should do "symbol-file"
978 without arguments first. Not sure this is the best behavior
981 (*objfile->sf->sym_new_init) (objfile);
984 /* Convert addr into an offset rather than an absolute address.
985 We find the lowest address of a loaded segment in the objfile,
986 and assume that <addr> is where that got loaded.
988 We no longer warn if the lowest section is not a text segment (as
989 happens for the PA64 port. */
990 if (addrs && addrs->other[0].name)
991 addr_info_make_relative (addrs, objfile->obfd);
993 /* Initialize symbol reading routines for this objfile, allow complaints to
994 appear for this new file, and record how verbose to be, then do the
995 initial symbol reading for this file. */
997 (*objfile->sf->sym_init) (objfile);
998 clear_complaints (&symfile_complaints, 1, add_flags & SYMFILE_VERBOSE);
1001 (*objfile->sf->sym_offsets) (objfile, addrs);
1004 size_t size = SIZEOF_N_SECTION_OFFSETS (num_offsets);
1006 /* Just copy in the offset table directly as given to us. */
1007 objfile->num_sections = num_offsets;
1008 objfile->section_offsets
1009 = ((struct section_offsets *)
1010 obstack_alloc (&objfile->objfile_obstack, size));
1011 memcpy (objfile->section_offsets, offsets, size);
1013 init_objfile_sect_indices (objfile);
1016 read_symbols (objfile, add_flags);
1018 /* Discard cleanups as symbol reading was successful. */
1020 discard_cleanups (old_chain);
1024 /* Perform required actions after either reading in the initial
1025 symbols for a new objfile, or mapping in the symbols from a reusable
1026 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1029 new_symfile_objfile (struct objfile *objfile, int add_flags)
1031 /* If this is the main symbol file we have to clean up all users of the
1032 old main symbol file. Otherwise it is sufficient to fixup all the
1033 breakpoints that may have been redefined by this symbol file. */
1034 if (add_flags & SYMFILE_MAINLINE)
1036 /* OK, make it the "real" symbol file. */
1037 symfile_objfile = objfile;
1039 clear_symtab_users (add_flags);
1041 else if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
1043 breakpoint_re_set ();
1046 /* We're done reading the symbol file; finish off complaints. */
1047 clear_complaints (&symfile_complaints, 0, add_flags & SYMFILE_VERBOSE);
1050 /* Process a symbol file, as either the main file or as a dynamically
1053 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1054 A new reference is acquired by this function.
1056 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1057 extra, such as dynamically loaded code, and what to do with breakpoins.
1059 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
1060 syms_from_objfile, above.
1061 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1063 PARENT is the original objfile if ABFD is a separate debug info file.
1064 Otherwise PARENT is NULL.
1066 Upon success, returns a pointer to the objfile that was added.
1067 Upon failure, jumps back to command level (never returns). */
1069 static struct objfile *
1070 symbol_file_add_with_addrs_or_offsets (bfd *abfd,
1072 struct section_addr_info *addrs,
1073 struct section_offsets *offsets,
1075 int flags, struct objfile *parent)
1077 struct objfile *objfile;
1078 const char *name = bfd_get_filename (abfd);
1079 const int from_tty = add_flags & SYMFILE_VERBOSE;
1080 const int mainline = add_flags & SYMFILE_MAINLINE;
1081 const int should_print = ((from_tty || info_verbose)
1082 && (readnow_symbol_files
1083 || (add_flags & SYMFILE_NO_READ) == 0));
1085 if (readnow_symbol_files)
1087 flags |= OBJF_READNOW;
1088 add_flags &= ~SYMFILE_NO_READ;
1091 /* Give user a chance to burp if we'd be
1092 interactively wiping out any existing symbols. */
1094 if ((have_full_symbols () || have_partial_symbols ())
1097 && !query (_("Load new symbol table from \"%s\"? "), name))
1098 error (_("Not confirmed."));
1100 objfile = allocate_objfile (abfd, flags | (mainline ? OBJF_MAINLINE : 0));
1103 add_separate_debug_objfile (objfile, parent);
1105 /* We either created a new mapped symbol table, mapped an existing
1106 symbol table file which has not had initial symbol reading
1107 performed, or need to read an unmapped symbol table. */
1110 if (deprecated_pre_add_symbol_hook)
1111 deprecated_pre_add_symbol_hook (name);
1114 printf_unfiltered (_("Reading symbols from %s..."), name);
1116 gdb_flush (gdb_stdout);
1119 syms_from_objfile (objfile, addrs, offsets, num_offsets,
1122 /* We now have at least a partial symbol table. Check to see if the
1123 user requested that all symbols be read on initial access via either
1124 the gdb startup command line or on a per symbol file basis. Expand
1125 all partial symbol tables for this objfile if so. */
1127 if ((flags & OBJF_READNOW))
1131 printf_unfiltered (_("expanding to full symbols..."));
1133 gdb_flush (gdb_stdout);
1137 objfile->sf->qf->expand_all_symtabs (objfile);
1140 if (should_print && !objfile_has_symbols (objfile))
1143 printf_unfiltered (_("(no debugging symbols found)..."));
1149 if (deprecated_post_add_symbol_hook)
1150 deprecated_post_add_symbol_hook ();
1152 printf_unfiltered (_("done.\n"));
1155 /* We print some messages regardless of whether 'from_tty ||
1156 info_verbose' is true, so make sure they go out at the right
1158 gdb_flush (gdb_stdout);
1160 if (objfile->sf == NULL)
1162 observer_notify_new_objfile (objfile);
1163 return objfile; /* No symbols. */
1166 new_symfile_objfile (objfile, add_flags);
1168 observer_notify_new_objfile (objfile);
1170 bfd_cache_close_all ();
1174 /* Add BFD as a separate debug file for OBJFILE. */
1177 symbol_file_add_separate (bfd *bfd, int symfile_flags, struct objfile *objfile)
1179 struct objfile *new_objfile;
1180 struct section_addr_info *sap;
1181 struct cleanup *my_cleanup;
1183 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1184 because sections of BFD may not match sections of OBJFILE and because
1185 vma may have been modified by tools such as prelink. */
1186 sap = build_section_addr_info_from_objfile (objfile);
1187 my_cleanup = make_cleanup_free_section_addr_info (sap);
1189 new_objfile = symbol_file_add_with_addrs_or_offsets
1190 (bfd, symfile_flags,
1192 objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW
1196 do_cleanups (my_cleanup);
1199 /* Process the symbol file ABFD, as either the main file or as a
1200 dynamically loaded file.
1202 See symbol_file_add_with_addrs_or_offsets's comments for
1205 symbol_file_add_from_bfd (bfd *abfd, int add_flags,
1206 struct section_addr_info *addrs,
1207 int flags, struct objfile *parent)
1209 return symbol_file_add_with_addrs_or_offsets (abfd, add_flags, addrs, 0, 0,
1214 /* Process a symbol file, as either the main file or as a dynamically
1215 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1218 symbol_file_add (char *name, int add_flags, struct section_addr_info *addrs,
1221 bfd *bfd = symfile_bfd_open (name);
1222 struct cleanup *cleanup = make_cleanup_bfd_unref (bfd);
1223 struct objfile *objf;
1225 objf = symbol_file_add_from_bfd (bfd, add_flags, addrs, flags, NULL);
1226 do_cleanups (cleanup);
1231 /* Call symbol_file_add() with default values and update whatever is
1232 affected by the loading of a new main().
1233 Used when the file is supplied in the gdb command line
1234 and by some targets with special loading requirements.
1235 The auxiliary function, symbol_file_add_main_1(), has the flags
1236 argument for the switches that can only be specified in the symbol_file
1240 symbol_file_add_main (char *args, int from_tty)
1242 symbol_file_add_main_1 (args, from_tty, 0);
1246 symbol_file_add_main_1 (char *args, int from_tty, int flags)
1248 const int add_flags = (current_inferior ()->symfile_flags
1249 | SYMFILE_MAINLINE | (from_tty ? SYMFILE_VERBOSE : 0));
1251 symbol_file_add (args, add_flags, NULL, flags);
1253 /* Getting new symbols may change our opinion about
1254 what is frameless. */
1255 reinit_frame_cache ();
1257 if ((flags & SYMFILE_NO_READ) == 0)
1258 set_initial_language ();
1262 symbol_file_clear (int from_tty)
1264 if ((have_full_symbols () || have_partial_symbols ())
1267 ? !query (_("Discard symbol table from `%s'? "),
1268 symfile_objfile->name)
1269 : !query (_("Discard symbol table? "))))
1270 error (_("Not confirmed."));
1272 /* solib descriptors may have handles to objfiles. Wipe them before their
1273 objfiles get stale by free_all_objfiles. */
1274 no_shared_libraries (NULL, from_tty);
1276 free_all_objfiles ();
1278 gdb_assert (symfile_objfile == NULL);
1280 printf_unfiltered (_("No symbol file now.\n"));
1284 get_debug_link_info (struct objfile *objfile, unsigned long *crc32_out)
1287 bfd_size_type debuglink_size;
1288 unsigned long crc32;
1292 sect = bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink");
1297 debuglink_size = bfd_section_size (objfile->obfd, sect);
1299 contents = xmalloc (debuglink_size);
1300 bfd_get_section_contents (objfile->obfd, sect, contents,
1301 (file_ptr)0, (bfd_size_type)debuglink_size);
1303 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1304 crc_offset = strlen (contents) + 1;
1305 crc_offset = (crc_offset + 3) & ~3;
1307 crc32 = bfd_get_32 (objfile->obfd, (bfd_byte *) (contents + crc_offset));
1313 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
1314 return 1. Otherwise print a warning and return 0. ABFD seek position is
1318 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
1320 unsigned long file_crc = 0;
1322 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
1324 warning (_("Problem reading \"%s\" for CRC: %s"),
1325 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
1331 gdb_byte buffer[8 * 1024];
1332 bfd_size_type count;
1334 count = bfd_bread (buffer, sizeof (buffer), abfd);
1335 if (count == (bfd_size_type) -1)
1337 warning (_("Problem reading \"%s\" for CRC: %s"),
1338 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
1343 file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
1346 *file_crc_return = file_crc;
1351 separate_debug_file_exists (const char *name, unsigned long crc,
1352 struct objfile *parent_objfile)
1354 unsigned long file_crc;
1357 struct stat parent_stat, abfd_stat;
1358 int verified_as_different;
1360 /* Find a separate debug info file as if symbols would be present in
1361 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1362 section can contain just the basename of PARENT_OBJFILE without any
1363 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1364 the separate debug infos with the same basename can exist. */
1366 if (filename_cmp (name, parent_objfile->name) == 0)
1369 abfd = gdb_bfd_open_maybe_remote (name);
1374 /* Verify symlinks were not the cause of filename_cmp name difference above.
1376 Some operating systems, e.g. Windows, do not provide a meaningful
1377 st_ino; they always set it to zero. (Windows does provide a
1378 meaningful st_dev.) Do not indicate a duplicate library in that
1379 case. While there is no guarantee that a system that provides
1380 meaningful inode numbers will never set st_ino to zero, this is
1381 merely an optimization, so we do not need to worry about false
1384 if (bfd_stat (abfd, &abfd_stat) == 0
1385 && abfd_stat.st_ino != 0
1386 && bfd_stat (parent_objfile->obfd, &parent_stat) == 0)
1388 if (abfd_stat.st_dev == parent_stat.st_dev
1389 && abfd_stat.st_ino == parent_stat.st_ino)
1391 gdb_bfd_unref (abfd);
1394 verified_as_different = 1;
1397 verified_as_different = 0;
1399 file_crc_p = get_file_crc (abfd, &file_crc);
1401 gdb_bfd_unref (abfd);
1406 if (crc != file_crc)
1408 /* If one (or both) the files are accessed for example the via "remote:"
1409 gdbserver way it does not support the bfd_stat operation. Verify
1410 whether those two files are not the same manually. */
1412 if (!verified_as_different && !parent_objfile->crc32_p)
1414 parent_objfile->crc32_p = get_file_crc (parent_objfile->obfd,
1415 &parent_objfile->crc32);
1416 if (!parent_objfile->crc32_p)
1420 if (verified_as_different || parent_objfile->crc32 != file_crc)
1421 warning (_("the debug information found in \"%s\""
1422 " does not match \"%s\" (CRC mismatch).\n"),
1423 name, parent_objfile->name);
1431 char *debug_file_directory = NULL;
1433 show_debug_file_directory (struct ui_file *file, int from_tty,
1434 struct cmd_list_element *c, const char *value)
1436 fprintf_filtered (file,
1437 _("The directory where separate debug "
1438 "symbols are searched for is \"%s\".\n"),
1442 #if ! defined (DEBUG_SUBDIRECTORY)
1443 #define DEBUG_SUBDIRECTORY ".debug"
1446 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1447 where the original file resides (may not be the same as
1448 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1449 looking for. Returns the name of the debuginfo, of NULL. */
1452 find_separate_debug_file (const char *dir,
1453 const char *canon_dir,
1454 const char *debuglink,
1455 unsigned long crc32, struct objfile *objfile)
1460 VEC (char_ptr) *debugdir_vec;
1461 struct cleanup *back_to;
1464 /* Set I to max (strlen (canon_dir), strlen (dir)). */
1466 if (canon_dir != NULL && strlen (canon_dir) > i)
1467 i = strlen (canon_dir);
1469 debugfile = xmalloc (strlen (debug_file_directory) + 1
1471 + strlen (DEBUG_SUBDIRECTORY)
1473 + strlen (debuglink)
1476 /* First try in the same directory as the original file. */
1477 strcpy (debugfile, dir);
1478 strcat (debugfile, debuglink);
1480 if (separate_debug_file_exists (debugfile, crc32, objfile))
1483 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1484 strcpy (debugfile, dir);
1485 strcat (debugfile, DEBUG_SUBDIRECTORY);
1486 strcat (debugfile, "/");
1487 strcat (debugfile, debuglink);
1489 if (separate_debug_file_exists (debugfile, crc32, objfile))
1492 /* Then try in the global debugfile directories.
1494 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1495 cause "/..." lookups. */
1497 debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory);
1498 back_to = make_cleanup_free_char_ptr_vec (debugdir_vec);
1500 for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix)
1502 strcpy (debugfile, debugdir);
1503 strcat (debugfile, "/");
1504 strcat (debugfile, dir);
1505 strcat (debugfile, debuglink);
1507 if (separate_debug_file_exists (debugfile, crc32, objfile))
1510 /* If the file is in the sysroot, try using its base path in the
1511 global debugfile directory. */
1512 if (canon_dir != NULL
1513 && filename_ncmp (canon_dir, gdb_sysroot,
1514 strlen (gdb_sysroot)) == 0
1515 && IS_DIR_SEPARATOR (canon_dir[strlen (gdb_sysroot)]))
1517 strcpy (debugfile, debugdir);
1518 strcat (debugfile, canon_dir + strlen (gdb_sysroot));
1519 strcat (debugfile, "/");
1520 strcat (debugfile, debuglink);
1522 if (separate_debug_file_exists (debugfile, crc32, objfile))
1527 do_cleanups (back_to);
1532 /* Modify PATH to contain only "directory/" part of PATH.
1533 If there were no directory separators in PATH, PATH will be empty
1534 string on return. */
1537 terminate_after_last_dir_separator (char *path)
1541 /* Strip off the final filename part, leaving the directory name,
1542 followed by a slash. The directory can be relative or absolute. */
1543 for (i = strlen(path) - 1; i >= 0; i--)
1544 if (IS_DIR_SEPARATOR (path[i]))
1547 /* If I is -1 then no directory is present there and DIR will be "". */
1551 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1552 Returns pathname, or NULL. */
1555 find_separate_debug_file_by_debuglink (struct objfile *objfile)
1558 char *dir, *canon_dir;
1560 unsigned long crc32;
1561 struct cleanup *cleanups;
1563 debuglink = get_debug_link_info (objfile, &crc32);
1565 if (debuglink == NULL)
1567 /* There's no separate debug info, hence there's no way we could
1568 load it => no warning. */
1572 cleanups = make_cleanup (xfree, debuglink);
1573 dir = xstrdup (objfile->name);
1574 make_cleanup (xfree, dir);
1575 terminate_after_last_dir_separator (dir);
1576 canon_dir = lrealpath (dir);
1578 debugfile = find_separate_debug_file (dir, canon_dir, debuglink,
1582 if (debugfile == NULL)
1585 /* For PR gdb/9538, try again with realpath (if different from the
1590 if (lstat (objfile->name, &st_buf) == 0 && S_ISLNK(st_buf.st_mode))
1594 symlink_dir = lrealpath (objfile->name);
1595 if (symlink_dir != NULL)
1597 make_cleanup (xfree, symlink_dir);
1598 terminate_after_last_dir_separator (symlink_dir);
1599 if (strcmp (dir, symlink_dir) != 0)
1601 /* Different directory, so try using it. */
1602 debugfile = find_separate_debug_file (symlink_dir,
1610 #endif /* HAVE_LSTAT */
1613 do_cleanups (cleanups);
1618 /* This is the symbol-file command. Read the file, analyze its
1619 symbols, and add a struct symtab to a symtab list. The syntax of
1620 the command is rather bizarre:
1622 1. The function buildargv implements various quoting conventions
1623 which are undocumented and have little or nothing in common with
1624 the way things are quoted (or not quoted) elsewhere in GDB.
1626 2. Options are used, which are not generally used in GDB (perhaps
1627 "set mapped on", "set readnow on" would be better)
1629 3. The order of options matters, which is contrary to GNU
1630 conventions (because it is confusing and inconvenient). */
1633 symbol_file_command (char *args, int from_tty)
1639 symbol_file_clear (from_tty);
1643 char **argv = gdb_buildargv (args);
1644 int flags = OBJF_USERLOADED;
1645 struct cleanup *cleanups;
1648 cleanups = make_cleanup_freeargv (argv);
1649 while (*argv != NULL)
1651 if (strcmp (*argv, "-readnow") == 0)
1652 flags |= OBJF_READNOW;
1653 else if (**argv == '-')
1654 error (_("unknown option `%s'"), *argv);
1657 symbol_file_add_main_1 (*argv, from_tty, flags);
1665 error (_("no symbol file name was specified"));
1667 do_cleanups (cleanups);
1671 /* Set the initial language.
1673 FIXME: A better solution would be to record the language in the
1674 psymtab when reading partial symbols, and then use it (if known) to
1675 set the language. This would be a win for formats that encode the
1676 language in an easily discoverable place, such as DWARF. For
1677 stabs, we can jump through hoops looking for specially named
1678 symbols or try to intuit the language from the specific type of
1679 stabs we find, but we can't do that until later when we read in
1683 set_initial_language (void)
1685 enum language lang = language_unknown;
1687 if (language_of_main != language_unknown)
1688 lang = language_of_main;
1691 const char *filename;
1693 filename = find_main_filename ();
1694 if (filename != NULL)
1695 lang = deduce_language_from_filename (filename);
1698 if (lang == language_unknown)
1700 /* Make C the default language */
1704 set_language (lang);
1705 expected_language = current_language; /* Don't warn the user. */
1708 /* If NAME is a remote name open the file using remote protocol, otherwise
1709 open it normally. Returns a new reference to the BFD. On error,
1710 returns NULL with the BFD error set. */
1713 gdb_bfd_open_maybe_remote (const char *name)
1717 if (remote_filename_p (name))
1718 result = remote_bfd_open (name, gnutarget);
1720 result = gdb_bfd_open (name, gnutarget, -1);
1726 /* Open the file specified by NAME and hand it off to BFD for
1727 preliminary analysis. Return a newly initialized bfd *, which
1728 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1729 absolute). In case of trouble, error() is called. */
1732 symfile_bfd_open (char *name)
1736 char *absolute_name;
1738 if (remote_filename_p (name))
1740 sym_bfd = remote_bfd_open (name, gnutarget);
1742 error (_("`%s': can't open to read symbols: %s."), name,
1743 bfd_errmsg (bfd_get_error ()));
1745 if (!bfd_check_format (sym_bfd, bfd_object))
1747 make_cleanup_bfd_unref (sym_bfd);
1748 error (_("`%s': can't read symbols: %s."), name,
1749 bfd_errmsg (bfd_get_error ()));
1755 name = tilde_expand (name); /* Returns 1st new malloc'd copy. */
1757 /* Look down path for it, allocate 2nd new malloc'd copy. */
1758 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, name,
1759 O_RDONLY | O_BINARY, &absolute_name);
1760 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1763 char *exename = alloca (strlen (name) + 5);
1765 strcat (strcpy (exename, name), ".exe");
1766 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
1767 O_RDONLY | O_BINARY, &absolute_name);
1772 make_cleanup (xfree, name);
1773 perror_with_name (name);
1777 name = absolute_name;
1778 make_cleanup (xfree, name);
1780 sym_bfd = gdb_bfd_open (name, gnutarget, desc);
1783 make_cleanup (xfree, name);
1784 error (_("`%s': can't open to read symbols: %s."), name,
1785 bfd_errmsg (bfd_get_error ()));
1787 bfd_set_cacheable (sym_bfd, 1);
1789 if (!bfd_check_format (sym_bfd, bfd_object))
1791 make_cleanup_bfd_unref (sym_bfd);
1792 error (_("`%s': can't read symbols: %s."), name,
1793 bfd_errmsg (bfd_get_error ()));
1799 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1800 the section was not found. */
1803 get_section_index (struct objfile *objfile, char *section_name)
1805 asection *sect = bfd_get_section_by_name (objfile->obfd, section_name);
1813 /* Link SF into the global symtab_fns list. Called on startup by the
1814 _initialize routine in each object file format reader, to register
1815 information about each format the reader is prepared to handle. */
1818 add_symtab_fns (const struct sym_fns *sf)
1820 VEC_safe_push (sym_fns_ptr, symtab_fns, sf);
1823 /* Initialize OBJFILE to read symbols from its associated BFD. It
1824 either returns or calls error(). The result is an initialized
1825 struct sym_fns in the objfile structure, that contains cached
1826 information about the symbol file. */
1828 static const struct sym_fns *
1829 find_sym_fns (bfd *abfd)
1831 const struct sym_fns *sf;
1832 enum bfd_flavour our_flavour = bfd_get_flavour (abfd);
1835 if (our_flavour == bfd_target_srec_flavour
1836 || our_flavour == bfd_target_ihex_flavour
1837 || our_flavour == bfd_target_tekhex_flavour)
1838 return NULL; /* No symbols. */
1840 for (i = 0; VEC_iterate (sym_fns_ptr, symtab_fns, i, sf); ++i)
1841 if (our_flavour == sf->sym_flavour)
1844 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1845 bfd_get_target (abfd));
1849 /* This function runs the load command of our current target. */
1852 load_command (char *arg, int from_tty)
1856 /* The user might be reloading because the binary has changed. Take
1857 this opportunity to check. */
1858 reopen_exec_file ();
1866 parg = arg = get_exec_file (1);
1868 /* Count how many \ " ' tab space there are in the name. */
1869 while ((parg = strpbrk (parg, "\\\"'\t ")))
1877 /* We need to quote this string so buildargv can pull it apart. */
1878 char *temp = xmalloc (strlen (arg) + count + 1 );
1882 make_cleanup (xfree, temp);
1885 while ((parg = strpbrk (parg, "\\\"'\t ")))
1887 strncpy (ptemp, prev, parg - prev);
1888 ptemp += parg - prev;
1892 strcpy (ptemp, prev);
1898 target_load (arg, from_tty);
1900 /* After re-loading the executable, we don't really know which
1901 overlays are mapped any more. */
1902 overlay_cache_invalid = 1;
1905 /* This version of "load" should be usable for any target. Currently
1906 it is just used for remote targets, not inftarg.c or core files,
1907 on the theory that only in that case is it useful.
1909 Avoiding xmodem and the like seems like a win (a) because we don't have
1910 to worry about finding it, and (b) On VMS, fork() is very slow and so
1911 we don't want to run a subprocess. On the other hand, I'm not sure how
1912 performance compares. */
1914 static int validate_download = 0;
1916 /* Callback service function for generic_load (bfd_map_over_sections). */
1919 add_section_size_callback (bfd *abfd, asection *asec, void *data)
1921 bfd_size_type *sum = data;
1923 *sum += bfd_get_section_size (asec);
1926 /* Opaque data for load_section_callback. */
1927 struct load_section_data {
1928 unsigned long load_offset;
1929 struct load_progress_data *progress_data;
1930 VEC(memory_write_request_s) *requests;
1933 /* Opaque data for load_progress. */
1934 struct load_progress_data {
1935 /* Cumulative data. */
1936 unsigned long write_count;
1937 unsigned long data_count;
1938 bfd_size_type total_size;
1941 /* Opaque data for load_progress for a single section. */
1942 struct load_progress_section_data {
1943 struct load_progress_data *cumulative;
1945 /* Per-section data. */
1946 const char *section_name;
1947 ULONGEST section_sent;
1948 ULONGEST section_size;
1953 /* Target write callback routine for progress reporting. */
1956 load_progress (ULONGEST bytes, void *untyped_arg)
1958 struct load_progress_section_data *args = untyped_arg;
1959 struct load_progress_data *totals;
1962 /* Writing padding data. No easy way to get at the cumulative
1963 stats, so just ignore this. */
1966 totals = args->cumulative;
1968 if (bytes == 0 && args->section_sent == 0)
1970 /* The write is just starting. Let the user know we've started
1972 ui_out_message (current_uiout, 0, "Loading section %s, size %s lma %s\n",
1973 args->section_name, hex_string (args->section_size),
1974 paddress (target_gdbarch (), args->lma));
1978 if (validate_download)
1980 /* Broken memories and broken monitors manifest themselves here
1981 when bring new computers to life. This doubles already slow
1983 /* NOTE: cagney/1999-10-18: A more efficient implementation
1984 might add a verify_memory() method to the target vector and
1985 then use that. remote.c could implement that method using
1986 the ``qCRC'' packet. */
1987 gdb_byte *check = xmalloc (bytes);
1988 struct cleanup *verify_cleanups = make_cleanup (xfree, check);
1990 if (target_read_memory (args->lma, check, bytes) != 0)
1991 error (_("Download verify read failed at %s"),
1992 paddress (target_gdbarch (), args->lma));
1993 if (memcmp (args->buffer, check, bytes) != 0)
1994 error (_("Download verify compare failed at %s"),
1995 paddress (target_gdbarch (), args->lma));
1996 do_cleanups (verify_cleanups);
1998 totals->data_count += bytes;
2000 args->buffer += bytes;
2001 totals->write_count += 1;
2002 args->section_sent += bytes;
2003 if (check_quit_flag ()
2004 || (deprecated_ui_load_progress_hook != NULL
2005 && deprecated_ui_load_progress_hook (args->section_name,
2006 args->section_sent)))
2007 error (_("Canceled the download"));
2009 if (deprecated_show_load_progress != NULL)
2010 deprecated_show_load_progress (args->section_name,
2014 totals->total_size);
2017 /* Callback service function for generic_load (bfd_map_over_sections). */
2020 load_section_callback (bfd *abfd, asection *asec, void *data)
2022 struct memory_write_request *new_request;
2023 struct load_section_data *args = data;
2024 struct load_progress_section_data *section_data;
2025 bfd_size_type size = bfd_get_section_size (asec);
2027 const char *sect_name = bfd_get_section_name (abfd, asec);
2029 if ((bfd_get_section_flags (abfd, asec) & SEC_LOAD) == 0)
2035 new_request = VEC_safe_push (memory_write_request_s,
2036 args->requests, NULL);
2037 memset (new_request, 0, sizeof (struct memory_write_request));
2038 section_data = xcalloc (1, sizeof (struct load_progress_section_data));
2039 new_request->begin = bfd_section_lma (abfd, asec) + args->load_offset;
2040 new_request->end = new_request->begin + size; /* FIXME Should size
2042 new_request->data = xmalloc (size);
2043 new_request->baton = section_data;
2045 buffer = new_request->data;
2047 section_data->cumulative = args->progress_data;
2048 section_data->section_name = sect_name;
2049 section_data->section_size = size;
2050 section_data->lma = new_request->begin;
2051 section_data->buffer = buffer;
2053 bfd_get_section_contents (abfd, asec, buffer, 0, size);
2056 /* Clean up an entire memory request vector, including load
2057 data and progress records. */
2060 clear_memory_write_data (void *arg)
2062 VEC(memory_write_request_s) **vec_p = arg;
2063 VEC(memory_write_request_s) *vec = *vec_p;
2065 struct memory_write_request *mr;
2067 for (i = 0; VEC_iterate (memory_write_request_s, vec, i, mr); ++i)
2072 VEC_free (memory_write_request_s, vec);
2076 generic_load (char *args, int from_tty)
2079 struct timeval start_time, end_time;
2081 struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
2082 struct load_section_data cbdata;
2083 struct load_progress_data total_progress;
2084 struct ui_out *uiout = current_uiout;
2089 memset (&cbdata, 0, sizeof (cbdata));
2090 memset (&total_progress, 0, sizeof (total_progress));
2091 cbdata.progress_data = &total_progress;
2093 make_cleanup (clear_memory_write_data, &cbdata.requests);
2096 error_no_arg (_("file to load"));
2098 argv = gdb_buildargv (args);
2099 make_cleanup_freeargv (argv);
2101 filename = tilde_expand (argv[0]);
2102 make_cleanup (xfree, filename);
2104 if (argv[1] != NULL)
2108 cbdata.load_offset = strtoul (argv[1], &endptr, 0);
2110 /* If the last word was not a valid number then
2111 treat it as a file name with spaces in. */
2112 if (argv[1] == endptr)
2113 error (_("Invalid download offset:%s."), argv[1]);
2115 if (argv[2] != NULL)
2116 error (_("Too many parameters."));
2119 /* Open the file for loading. */
2120 loadfile_bfd = gdb_bfd_open (filename, gnutarget, -1);
2121 if (loadfile_bfd == NULL)
2123 perror_with_name (filename);
2127 make_cleanup_bfd_unref (loadfile_bfd);
2129 if (!bfd_check_format (loadfile_bfd, bfd_object))
2131 error (_("\"%s\" is not an object file: %s"), filename,
2132 bfd_errmsg (bfd_get_error ()));
2135 bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
2136 (void *) &total_progress.total_size);
2138 bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
2140 gettimeofday (&start_time, NULL);
2142 if (target_write_memory_blocks (cbdata.requests, flash_discard,
2143 load_progress) != 0)
2144 error (_("Load failed"));
2146 gettimeofday (&end_time, NULL);
2148 entry = bfd_get_start_address (loadfile_bfd);
2149 entry = gdbarch_addr_bits_remove (target_gdbarch (), entry);
2150 ui_out_text (uiout, "Start address ");
2151 ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch (), entry));
2152 ui_out_text (uiout, ", load size ");
2153 ui_out_field_fmt (uiout, "load-size", "%lu", total_progress.data_count);
2154 ui_out_text (uiout, "\n");
2155 /* We were doing this in remote-mips.c, I suspect it is right
2156 for other targets too. */
2157 regcache_write_pc (get_current_regcache (), entry);
2159 /* Reset breakpoints, now that we have changed the load image. For
2160 instance, breakpoints may have been set (or reset, by
2161 post_create_inferior) while connected to the target but before we
2162 loaded the program. In that case, the prologue analyzer could
2163 have read instructions from the target to find the right
2164 breakpoint locations. Loading has changed the contents of that
2167 breakpoint_re_set ();
2169 /* FIXME: are we supposed to call symbol_file_add or not? According
2170 to a comment from remote-mips.c (where a call to symbol_file_add
2171 was commented out), making the call confuses GDB if more than one
2172 file is loaded in. Some targets do (e.g., remote-vx.c) but
2173 others don't (or didn't - perhaps they have all been deleted). */
2175 print_transfer_performance (gdb_stdout, total_progress.data_count,
2176 total_progress.write_count,
2177 &start_time, &end_time);
2179 do_cleanups (old_cleanups);
2182 /* Report how fast the transfer went. */
2185 print_transfer_performance (struct ui_file *stream,
2186 unsigned long data_count,
2187 unsigned long write_count,
2188 const struct timeval *start_time,
2189 const struct timeval *end_time)
2191 ULONGEST time_count;
2192 struct ui_out *uiout = current_uiout;
2194 /* Compute the elapsed time in milliseconds, as a tradeoff between
2195 accuracy and overflow. */
2196 time_count = (end_time->tv_sec - start_time->tv_sec) * 1000;
2197 time_count += (end_time->tv_usec - start_time->tv_usec) / 1000;
2199 ui_out_text (uiout, "Transfer rate: ");
2202 unsigned long rate = ((ULONGEST) data_count * 1000) / time_count;
2204 if (ui_out_is_mi_like_p (uiout))
2206 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate * 8);
2207 ui_out_text (uiout, " bits/sec");
2209 else if (rate < 1024)
2211 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate);
2212 ui_out_text (uiout, " bytes/sec");
2216 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate / 1024);
2217 ui_out_text (uiout, " KB/sec");
2222 ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8));
2223 ui_out_text (uiout, " bits in <1 sec");
2225 if (write_count > 0)
2227 ui_out_text (uiout, ", ");
2228 ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count);
2229 ui_out_text (uiout, " bytes/write");
2231 ui_out_text (uiout, ".\n");
2234 /* This function allows the addition of incrementally linked object files.
2235 It does not modify any state in the target, only in the debugger. */
2236 /* Note: ezannoni 2000-04-13 This function/command used to have a
2237 special case syntax for the rombug target (Rombug is the boot
2238 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2239 rombug case, the user doesn't need to supply a text address,
2240 instead a call to target_link() (in target.c) would supply the
2241 value to use. We are now discontinuing this type of ad hoc syntax. */
2244 add_symbol_file_command (char *args, int from_tty)
2246 struct gdbarch *gdbarch = get_current_arch ();
2247 char *filename = NULL;
2248 int flags = OBJF_USERLOADED;
2250 int section_index = 0;
2254 int expecting_sec_name = 0;
2255 int expecting_sec_addr = 0;
2264 struct section_addr_info *section_addrs;
2265 struct sect_opt *sect_opts = NULL;
2266 size_t num_sect_opts = 0;
2267 struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL);
2270 sect_opts = (struct sect_opt *) xmalloc (num_sect_opts
2271 * sizeof (struct sect_opt));
2276 error (_("add-symbol-file takes a file name and an address"));
2278 argv = gdb_buildargv (args);
2279 make_cleanup_freeargv (argv);
2281 for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt])
2283 /* Process the argument. */
2286 /* The first argument is the file name. */
2287 filename = tilde_expand (arg);
2288 make_cleanup (xfree, filename);
2293 /* The second argument is always the text address at which
2294 to load the program. */
2295 sect_opts[section_index].name = ".text";
2296 sect_opts[section_index].value = arg;
2297 if (++section_index >= num_sect_opts)
2300 sect_opts = ((struct sect_opt *)
2301 xrealloc (sect_opts,
2303 * sizeof (struct sect_opt)));
2308 /* It's an option (starting with '-') or it's an argument
2313 if (strcmp (arg, "-readnow") == 0)
2314 flags |= OBJF_READNOW;
2315 else if (strcmp (arg, "-s") == 0)
2317 expecting_sec_name = 1;
2318 expecting_sec_addr = 1;
2323 if (expecting_sec_name)
2325 sect_opts[section_index].name = arg;
2326 expecting_sec_name = 0;
2329 if (expecting_sec_addr)
2331 sect_opts[section_index].value = arg;
2332 expecting_sec_addr = 0;
2333 if (++section_index >= num_sect_opts)
2336 sect_opts = ((struct sect_opt *)
2337 xrealloc (sect_opts,
2339 * sizeof (struct sect_opt)));
2343 error (_("USAGE: add-symbol-file <filename> <textaddress>"
2344 " [-readnow] [-s <secname> <addr>]*"));
2349 /* This command takes at least two arguments. The first one is a
2350 filename, and the second is the address where this file has been
2351 loaded. Abort now if this address hasn't been provided by the
2353 if (section_index < 1)
2354 error (_("The address where %s has been loaded is missing"), filename);
2356 /* Print the prompt for the query below. And save the arguments into
2357 a sect_addr_info structure to be passed around to other
2358 functions. We have to split this up into separate print
2359 statements because hex_string returns a local static
2362 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename);
2363 section_addrs = alloc_section_addr_info (section_index);
2364 make_cleanup (xfree, section_addrs);
2365 for (i = 0; i < section_index; i++)
2368 char *val = sect_opts[i].value;
2369 char *sec = sect_opts[i].name;
2371 addr = parse_and_eval_address (val);
2373 /* Here we store the section offsets in the order they were
2374 entered on the command line. */
2375 section_addrs->other[sec_num].name = sec;
2376 section_addrs->other[sec_num].addr = addr;
2377 printf_unfiltered ("\t%s_addr = %s\n", sec,
2378 paddress (gdbarch, addr));
2381 /* The object's sections are initialized when a
2382 call is made to build_objfile_section_table (objfile).
2383 This happens in reread_symbols.
2384 At this point, we don't know what file type this is,
2385 so we can't determine what section names are valid. */
2388 if (from_tty && (!query ("%s", "")))
2389 error (_("Not confirmed."));
2391 symbol_file_add (filename, from_tty ? SYMFILE_VERBOSE : 0,
2392 section_addrs, flags);
2394 /* Getting new symbols may change our opinion about what is
2396 reinit_frame_cache ();
2397 do_cleanups (my_cleanups);
2401 typedef struct objfile *objfilep;
2403 DEF_VEC_P (objfilep);
2405 /* Re-read symbols if a symbol-file has changed. */
2407 reread_symbols (void)
2409 struct objfile *objfile;
2411 struct stat new_statbuf;
2413 VEC (objfilep) *new_objfiles = NULL;
2414 struct cleanup *all_cleanups;
2416 all_cleanups = make_cleanup (VEC_cleanup (objfilep), &new_objfiles);
2418 /* With the addition of shared libraries, this should be modified,
2419 the load time should be saved in the partial symbol tables, since
2420 different tables may come from different source files. FIXME.
2421 This routine should then walk down each partial symbol table
2422 and see if the symbol table that it originates from has been changed. */
2424 for (objfile = object_files; objfile; objfile = objfile->next)
2426 /* solib-sunos.c creates one objfile with obfd. */
2427 if (objfile->obfd == NULL)
2430 /* Separate debug objfiles are handled in the main objfile. */
2431 if (objfile->separate_debug_objfile_backlink)
2434 /* If this object is from an archive (what you usually create with
2435 `ar', often called a `static library' on most systems, though
2436 a `shared library' on AIX is also an archive), then you should
2437 stat on the archive name, not member name. */
2438 if (objfile->obfd->my_archive)
2439 res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
2441 res = stat (objfile->name, &new_statbuf);
2444 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2445 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2449 new_modtime = new_statbuf.st_mtime;
2450 if (new_modtime != objfile->mtime)
2452 struct cleanup *old_cleanups;
2453 struct section_offsets *offsets;
2455 char *obfd_filename;
2457 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2460 /* There are various functions like symbol_file_add,
2461 symfile_bfd_open, syms_from_objfile, etc., which might
2462 appear to do what we want. But they have various other
2463 effects which we *don't* want. So we just do stuff
2464 ourselves. We don't worry about mapped files (for one thing,
2465 any mapped file will be out of date). */
2467 /* If we get an error, blow away this objfile (not sure if
2468 that is the correct response for things like shared
2470 old_cleanups = make_cleanup_free_objfile (objfile);
2471 /* We need to do this whenever any symbols go away. */
2472 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
2474 if (exec_bfd != NULL
2475 && filename_cmp (bfd_get_filename (objfile->obfd),
2476 bfd_get_filename (exec_bfd)) == 0)
2478 /* Reload EXEC_BFD without asking anything. */
2480 exec_file_attach (bfd_get_filename (objfile->obfd), 0);
2483 /* Keep the calls order approx. the same as in free_objfile. */
2485 /* Free the separate debug objfiles. It will be
2486 automatically recreated by sym_read. */
2487 free_objfile_separate_debug (objfile);
2489 /* Remove any references to this objfile in the global
2491 preserve_values (objfile);
2493 /* Nuke all the state that we will re-read. Much of the following
2494 code which sets things to NULL really is necessary to tell
2495 other parts of GDB that there is nothing currently there.
2497 Try to keep the freeing order compatible with free_objfile. */
2499 if (objfile->sf != NULL)
2501 (*objfile->sf->sym_finish) (objfile);
2504 clear_objfile_data (objfile);
2506 /* Clean up any state BFD has sitting around. */
2508 struct bfd *obfd = objfile->obfd;
2510 obfd_filename = bfd_get_filename (objfile->obfd);
2511 /* Open the new BFD before freeing the old one, so that
2512 the filename remains live. */
2513 objfile->obfd = gdb_bfd_open_maybe_remote (obfd_filename);
2514 if (objfile->obfd == NULL)
2516 /* We have to make a cleanup and error here, rather
2517 than erroring later, because once we unref OBFD,
2518 OBFD_FILENAME will be freed. */
2519 make_cleanup_bfd_unref (obfd);
2520 error (_("Can't open %s to read symbols."), obfd_filename);
2522 gdb_bfd_unref (obfd);
2525 objfile->name = bfd_get_filename (objfile->obfd);
2526 /* bfd_openr sets cacheable to true, which is what we want. */
2527 if (!bfd_check_format (objfile->obfd, bfd_object))
2528 error (_("Can't read symbols from %s: %s."), objfile->name,
2529 bfd_errmsg (bfd_get_error ()));
2531 /* Save the offsets, we will nuke them with the rest of the
2533 num_offsets = objfile->num_sections;
2534 offsets = ((struct section_offsets *)
2535 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets)));
2536 memcpy (offsets, objfile->section_offsets,
2537 SIZEOF_N_SECTION_OFFSETS (num_offsets));
2539 /* FIXME: Do we have to free a whole linked list, or is this
2541 if (objfile->global_psymbols.list)
2542 xfree (objfile->global_psymbols.list);
2543 memset (&objfile->global_psymbols, 0,
2544 sizeof (objfile->global_psymbols));
2545 if (objfile->static_psymbols.list)
2546 xfree (objfile->static_psymbols.list);
2547 memset (&objfile->static_psymbols, 0,
2548 sizeof (objfile->static_psymbols));
2550 /* Free the obstacks for non-reusable objfiles. */
2551 psymbol_bcache_free (objfile->psymbol_cache);
2552 objfile->psymbol_cache = psymbol_bcache_init ();
2553 if (objfile->demangled_names_hash != NULL)
2555 htab_delete (objfile->demangled_names_hash);
2556 objfile->demangled_names_hash = NULL;
2558 obstack_free (&objfile->objfile_obstack, 0);
2559 objfile->sections = NULL;
2560 objfile->symtabs = NULL;
2561 objfile->psymtabs = NULL;
2562 objfile->psymtabs_addrmap = NULL;
2563 objfile->free_psymtabs = NULL;
2564 objfile->template_symbols = NULL;
2565 objfile->msymbols = NULL;
2566 objfile->minimal_symbol_count = 0;
2567 memset (&objfile->msymbol_hash, 0,
2568 sizeof (objfile->msymbol_hash));
2569 memset (&objfile->msymbol_demangled_hash, 0,
2570 sizeof (objfile->msymbol_demangled_hash));
2572 set_objfile_per_bfd (objfile);
2574 /* obstack_init also initializes the obstack so it is
2575 empty. We could use obstack_specify_allocation but
2576 gdb_obstack.h specifies the alloc/dealloc functions. */
2577 obstack_init (&objfile->objfile_obstack);
2578 build_objfile_section_table (objfile);
2579 terminate_minimal_symbol_table (objfile);
2581 /* We use the same section offsets as from last time. I'm not
2582 sure whether that is always correct for shared libraries. */
2583 objfile->section_offsets = (struct section_offsets *)
2584 obstack_alloc (&objfile->objfile_obstack,
2585 SIZEOF_N_SECTION_OFFSETS (num_offsets));
2586 memcpy (objfile->section_offsets, offsets,
2587 SIZEOF_N_SECTION_OFFSETS (num_offsets));
2588 objfile->num_sections = num_offsets;
2590 /* What the hell is sym_new_init for, anyway? The concept of
2591 distinguishing between the main file and additional files
2592 in this way seems rather dubious. */
2593 if (objfile == symfile_objfile)
2595 (*objfile->sf->sym_new_init) (objfile);
2598 (*objfile->sf->sym_init) (objfile);
2599 clear_complaints (&symfile_complaints, 1, 1);
2601 objfile->flags &= ~OBJF_PSYMTABS_READ;
2602 read_symbols (objfile, 0);
2604 if (!objfile_has_symbols (objfile))
2607 printf_unfiltered (_("(no debugging symbols found)\n"));
2611 /* We're done reading the symbol file; finish off complaints. */
2612 clear_complaints (&symfile_complaints, 0, 1);
2614 /* Getting new symbols may change our opinion about what is
2617 reinit_frame_cache ();
2619 /* Discard cleanups as symbol reading was successful. */
2620 discard_cleanups (old_cleanups);
2622 /* If the mtime has changed between the time we set new_modtime
2623 and now, we *want* this to be out of date, so don't call stat
2625 objfile->mtime = new_modtime;
2626 init_entry_point_info (objfile);
2628 VEC_safe_push (objfilep, new_objfiles, objfile);
2636 /* Notify objfiles that we've modified objfile sections. */
2637 objfiles_changed ();
2639 clear_symtab_users (0);
2641 /* clear_objfile_data for each objfile was called before freeing it and
2642 observer_notify_new_objfile (NULL) has been called by
2643 clear_symtab_users above. Notify the new files now. */
2644 for (ix = 0; VEC_iterate (objfilep, new_objfiles, ix, objfile); ix++)
2645 observer_notify_new_objfile (objfile);
2647 /* At least one objfile has changed, so we can consider that
2648 the executable we're debugging has changed too. */
2649 observer_notify_executable_changed ();
2652 do_cleanups (all_cleanups);
2664 static filename_language *filename_language_table;
2665 static int fl_table_size, fl_table_next;
2668 add_filename_language (char *ext, enum language lang)
2670 if (fl_table_next >= fl_table_size)
2672 fl_table_size += 10;
2673 filename_language_table =
2674 xrealloc (filename_language_table,
2675 fl_table_size * sizeof (*filename_language_table));
2678 filename_language_table[fl_table_next].ext = xstrdup (ext);
2679 filename_language_table[fl_table_next].lang = lang;
2683 static char *ext_args;
2685 show_ext_args (struct ui_file *file, int from_tty,
2686 struct cmd_list_element *c, const char *value)
2688 fprintf_filtered (file,
2689 _("Mapping between filename extension "
2690 "and source language is \"%s\".\n"),
2695 set_ext_lang_command (char *args, int from_tty, struct cmd_list_element *e)
2698 char *cp = ext_args;
2701 /* First arg is filename extension, starting with '.' */
2703 error (_("'%s': Filename extension must begin with '.'"), ext_args);
2705 /* Find end of first arg. */
2706 while (*cp && !isspace (*cp))
2710 error (_("'%s': two arguments required -- "
2711 "filename extension and language"),
2714 /* Null-terminate first arg. */
2717 /* Find beginning of second arg, which should be a source language. */
2718 while (*cp && isspace (*cp))
2722 error (_("'%s': two arguments required -- "
2723 "filename extension and language"),
2726 /* Lookup the language from among those we know. */
2727 lang = language_enum (cp);
2729 /* Now lookup the filename extension: do we already know it? */
2730 for (i = 0; i < fl_table_next; i++)
2731 if (0 == strcmp (ext_args, filename_language_table[i].ext))
2734 if (i >= fl_table_next)
2736 /* New file extension. */
2737 add_filename_language (ext_args, lang);
2741 /* Redefining a previously known filename extension. */
2744 /* query ("Really make files of type %s '%s'?", */
2745 /* ext_args, language_str (lang)); */
2747 xfree (filename_language_table[i].ext);
2748 filename_language_table[i].ext = xstrdup (ext_args);
2749 filename_language_table[i].lang = lang;
2754 info_ext_lang_command (char *args, int from_tty)
2758 printf_filtered (_("Filename extensions and the languages they represent:"));
2759 printf_filtered ("\n\n");
2760 for (i = 0; i < fl_table_next; i++)
2761 printf_filtered ("\t%s\t- %s\n",
2762 filename_language_table[i].ext,
2763 language_str (filename_language_table[i].lang));
2767 init_filename_language_table (void)
2769 if (fl_table_size == 0) /* Protect against repetition. */
2773 filename_language_table =
2774 xmalloc (fl_table_size * sizeof (*filename_language_table));
2775 add_filename_language (".c", language_c);
2776 add_filename_language (".d", language_d);
2777 add_filename_language (".C", language_cplus);
2778 add_filename_language (".cc", language_cplus);
2779 add_filename_language (".cp", language_cplus);
2780 add_filename_language (".cpp", language_cplus);
2781 add_filename_language (".cxx", language_cplus);
2782 add_filename_language (".c++", language_cplus);
2783 add_filename_language (".java", language_java);
2784 add_filename_language (".class", language_java);
2785 add_filename_language (".m", language_objc);
2786 add_filename_language (".f", language_fortran);
2787 add_filename_language (".F", language_fortran);
2788 add_filename_language (".for", language_fortran);
2789 add_filename_language (".FOR", language_fortran);
2790 add_filename_language (".ftn", language_fortran);
2791 add_filename_language (".FTN", language_fortran);
2792 add_filename_language (".fpp", language_fortran);
2793 add_filename_language (".FPP", language_fortran);
2794 add_filename_language (".f90", language_fortran);
2795 add_filename_language (".F90", language_fortran);
2796 add_filename_language (".f95", language_fortran);
2797 add_filename_language (".F95", language_fortran);
2798 add_filename_language (".f03", language_fortran);
2799 add_filename_language (".F03", language_fortran);
2800 add_filename_language (".f08", language_fortran);
2801 add_filename_language (".F08", language_fortran);
2802 add_filename_language (".s", language_asm);
2803 add_filename_language (".sx", language_asm);
2804 add_filename_language (".S", language_asm);
2805 add_filename_language (".pas", language_pascal);
2806 add_filename_language (".p", language_pascal);
2807 add_filename_language (".pp", language_pascal);
2808 add_filename_language (".adb", language_ada);
2809 add_filename_language (".ads", language_ada);
2810 add_filename_language (".a", language_ada);
2811 add_filename_language (".ada", language_ada);
2812 add_filename_language (".dg", language_ada);
2817 deduce_language_from_filename (const char *filename)
2822 if (filename != NULL)
2823 if ((cp = strrchr (filename, '.')) != NULL)
2824 for (i = 0; i < fl_table_next; i++)
2825 if (strcmp (cp, filename_language_table[i].ext) == 0)
2826 return filename_language_table[i].lang;
2828 return language_unknown;
2833 Allocate and partly initialize a new symbol table. Return a pointer
2834 to it. error() if no space.
2836 Caller must set these fields:
2845 allocate_symtab (const char *filename, struct objfile *objfile)
2847 struct symtab *symtab;
2849 symtab = (struct symtab *)
2850 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symtab));
2851 memset (symtab, 0, sizeof (*symtab));
2852 symtab->filename = (char *) bcache (filename, strlen (filename) + 1,
2853 objfile->per_bfd->filename_cache);
2854 symtab->fullname = NULL;
2855 symtab->language = deduce_language_from_filename (filename);
2856 symtab->debugformat = "unknown";
2858 /* Hook it to the objfile it comes from. */
2860 symtab->objfile = objfile;
2861 symtab->next = objfile->symtabs;
2862 objfile->symtabs = symtab;
2864 if (symtab_create_debug)
2866 /* Be a bit clever with debugging messages, and don't print objfile
2867 every time, only when it changes. */
2868 static char *last_objfile_name = NULL;
2870 if (last_objfile_name == NULL
2871 || strcmp (last_objfile_name, objfile->name) != 0)
2873 xfree (last_objfile_name);
2874 last_objfile_name = xstrdup (objfile->name);
2875 fprintf_unfiltered (gdb_stdlog,
2876 "Creating one or more symtabs for objfile %s ...\n",
2879 fprintf_unfiltered (gdb_stdlog,
2880 "Created symtab %s for module %s.\n",
2881 host_address_to_string (symtab), filename);
2888 /* Reset all data structures in gdb which may contain references to symbol
2889 table data. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
2892 clear_symtab_users (int add_flags)
2894 /* Someday, we should do better than this, by only blowing away
2895 the things that really need to be blown. */
2897 /* Clear the "current" symtab first, because it is no longer valid.
2898 breakpoint_re_set may try to access the current symtab. */
2899 clear_current_source_symtab_and_line ();
2902 if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
2903 breakpoint_re_set ();
2904 clear_last_displayed_sal ();
2905 clear_pc_function_cache ();
2906 observer_notify_new_objfile (NULL);
2908 /* Clear globals which might have pointed into a removed objfile.
2909 FIXME: It's not clear which of these are supposed to persist
2910 between expressions and which ought to be reset each time. */
2911 expression_context_block = NULL;
2912 innermost_block = NULL;
2914 /* Varobj may refer to old symbols, perform a cleanup. */
2915 varobj_invalidate ();
2920 clear_symtab_users_cleanup (void *ignore)
2922 clear_symtab_users (0);
2926 The following code implements an abstraction for debugging overlay sections.
2928 The target model is as follows:
2929 1) The gnu linker will permit multiple sections to be mapped into the
2930 same VMA, each with its own unique LMA (or load address).
2931 2) It is assumed that some runtime mechanism exists for mapping the
2932 sections, one by one, from the load address into the VMA address.
2933 3) This code provides a mechanism for gdb to keep track of which
2934 sections should be considered to be mapped from the VMA to the LMA.
2935 This information is used for symbol lookup, and memory read/write.
2936 For instance, if a section has been mapped then its contents
2937 should be read from the VMA, otherwise from the LMA.
2939 Two levels of debugger support for overlays are available. One is
2940 "manual", in which the debugger relies on the user to tell it which
2941 overlays are currently mapped. This level of support is
2942 implemented entirely in the core debugger, and the information about
2943 whether a section is mapped is kept in the objfile->obj_section table.
2945 The second level of support is "automatic", and is only available if
2946 the target-specific code provides functionality to read the target's
2947 overlay mapping table, and translate its contents for the debugger
2948 (by updating the mapped state information in the obj_section tables).
2950 The interface is as follows:
2952 overlay map <name> -- tell gdb to consider this section mapped
2953 overlay unmap <name> -- tell gdb to consider this section unmapped
2954 overlay list -- list the sections that GDB thinks are mapped
2955 overlay read-target -- get the target's state of what's mapped
2956 overlay off/manual/auto -- set overlay debugging state
2957 Functional interface:
2958 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2959 section, return that section.
2960 find_pc_overlay(pc): find any overlay section that contains
2961 the pc, either in its VMA or its LMA
2962 section_is_mapped(sect): true if overlay is marked as mapped
2963 section_is_overlay(sect): true if section's VMA != LMA
2964 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2965 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2966 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2967 overlay_mapped_address(...): map an address from section's LMA to VMA
2968 overlay_unmapped_address(...): map an address from section's VMA to LMA
2969 symbol_overlayed_address(...): Return a "current" address for symbol:
2970 either in VMA or LMA depending on whether
2971 the symbol's section is currently mapped. */
2973 /* Overlay debugging state: */
2975 enum overlay_debugging_state overlay_debugging = ovly_off;
2976 int overlay_cache_invalid = 0; /* True if need to refresh mapped state. */
2978 /* Function: section_is_overlay (SECTION)
2979 Returns true if SECTION has VMA not equal to LMA, ie.
2980 SECTION is loaded at an address different from where it will "run". */
2983 section_is_overlay (struct obj_section *section)
2985 if (overlay_debugging && section)
2987 bfd *abfd = section->objfile->obfd;
2988 asection *bfd_section = section->the_bfd_section;
2990 if (bfd_section_lma (abfd, bfd_section) != 0
2991 && bfd_section_lma (abfd, bfd_section)
2992 != bfd_section_vma (abfd, bfd_section))
2999 /* Function: overlay_invalidate_all (void)
3000 Invalidate the mapped state of all overlay sections (mark it as stale). */
3003 overlay_invalidate_all (void)
3005 struct objfile *objfile;
3006 struct obj_section *sect;
3008 ALL_OBJSECTIONS (objfile, sect)
3009 if (section_is_overlay (sect))
3010 sect->ovly_mapped = -1;
3013 /* Function: section_is_mapped (SECTION)
3014 Returns true if section is an overlay, and is currently mapped.
3016 Access to the ovly_mapped flag is restricted to this function, so
3017 that we can do automatic update. If the global flag
3018 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3019 overlay_invalidate_all. If the mapped state of the particular
3020 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3023 section_is_mapped (struct obj_section *osect)
3025 struct gdbarch *gdbarch;
3027 if (osect == 0 || !section_is_overlay (osect))
3030 switch (overlay_debugging)
3034 return 0; /* overlay debugging off */
3035 case ovly_auto: /* overlay debugging automatic */
3036 /* Unles there is a gdbarch_overlay_update function,
3037 there's really nothing useful to do here (can't really go auto). */
3038 gdbarch = get_objfile_arch (osect->objfile);
3039 if (gdbarch_overlay_update_p (gdbarch))
3041 if (overlay_cache_invalid)
3043 overlay_invalidate_all ();
3044 overlay_cache_invalid = 0;
3046 if (osect->ovly_mapped == -1)
3047 gdbarch_overlay_update (gdbarch, osect);
3049 /* fall thru to manual case */
3050 case ovly_on: /* overlay debugging manual */
3051 return osect->ovly_mapped == 1;
3055 /* Function: pc_in_unmapped_range
3056 If PC falls into the lma range of SECTION, return true, else false. */
3059 pc_in_unmapped_range (CORE_ADDR pc, struct obj_section *section)
3061 if (section_is_overlay (section))
3063 bfd *abfd = section->objfile->obfd;
3064 asection *bfd_section = section->the_bfd_section;
3066 /* We assume the LMA is relocated by the same offset as the VMA. */
3067 bfd_vma size = bfd_get_section_size (bfd_section);
3068 CORE_ADDR offset = obj_section_offset (section);
3070 if (bfd_get_section_lma (abfd, bfd_section) + offset <= pc
3071 && pc < bfd_get_section_lma (abfd, bfd_section) + offset + size)
3078 /* Function: pc_in_mapped_range
3079 If PC falls into the vma range of SECTION, return true, else false. */
3082 pc_in_mapped_range (CORE_ADDR pc, struct obj_section *section)
3084 if (section_is_overlay (section))
3086 if (obj_section_addr (section) <= pc
3087 && pc < obj_section_endaddr (section))
3095 /* Return true if the mapped ranges of sections A and B overlap, false
3098 sections_overlap (struct obj_section *a, struct obj_section *b)
3100 CORE_ADDR a_start = obj_section_addr (a);
3101 CORE_ADDR a_end = obj_section_endaddr (a);
3102 CORE_ADDR b_start = obj_section_addr (b);
3103 CORE_ADDR b_end = obj_section_endaddr (b);
3105 return (a_start < b_end && b_start < a_end);
3108 /* Function: overlay_unmapped_address (PC, SECTION)
3109 Returns the address corresponding to PC in the unmapped (load) range.
3110 May be the same as PC. */
3113 overlay_unmapped_address (CORE_ADDR pc, struct obj_section *section)
3115 if (section_is_overlay (section) && pc_in_mapped_range (pc, section))
3117 bfd *abfd = section->objfile->obfd;
3118 asection *bfd_section = section->the_bfd_section;
3120 return pc + bfd_section_lma (abfd, bfd_section)
3121 - bfd_section_vma (abfd, bfd_section);
3127 /* Function: overlay_mapped_address (PC, SECTION)
3128 Returns the address corresponding to PC in the mapped (runtime) range.
3129 May be the same as PC. */
3132 overlay_mapped_address (CORE_ADDR pc, struct obj_section *section)
3134 if (section_is_overlay (section) && pc_in_unmapped_range (pc, section))
3136 bfd *abfd = section->objfile->obfd;
3137 asection *bfd_section = section->the_bfd_section;
3139 return pc + bfd_section_vma (abfd, bfd_section)
3140 - bfd_section_lma (abfd, bfd_section);
3147 /* Function: symbol_overlayed_address
3148 Return one of two addresses (relative to the VMA or to the LMA),
3149 depending on whether the section is mapped or not. */
3152 symbol_overlayed_address (CORE_ADDR address, struct obj_section *section)
3154 if (overlay_debugging)
3156 /* If the symbol has no section, just return its regular address. */
3159 /* If the symbol's section is not an overlay, just return its
3161 if (!section_is_overlay (section))
3163 /* If the symbol's section is mapped, just return its address. */
3164 if (section_is_mapped (section))
3167 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3168 * then return its LOADED address rather than its vma address!!
3170 return overlay_unmapped_address (address, section);
3175 /* Function: find_pc_overlay (PC)
3176 Return the best-match overlay section for PC:
3177 If PC matches a mapped overlay section's VMA, return that section.
3178 Else if PC matches an unmapped section's VMA, return that section.
3179 Else if PC matches an unmapped section's LMA, return that section. */
3181 struct obj_section *
3182 find_pc_overlay (CORE_ADDR pc)
3184 struct objfile *objfile;
3185 struct obj_section *osect, *best_match = NULL;
3187 if (overlay_debugging)
3188 ALL_OBJSECTIONS (objfile, osect)
3189 if (section_is_overlay (osect))
3191 if (pc_in_mapped_range (pc, osect))
3193 if (section_is_mapped (osect))
3198 else if (pc_in_unmapped_range (pc, osect))
3204 /* Function: find_pc_mapped_section (PC)
3205 If PC falls into the VMA address range of an overlay section that is
3206 currently marked as MAPPED, return that section. Else return NULL. */
3208 struct obj_section *
3209 find_pc_mapped_section (CORE_ADDR pc)
3211 struct objfile *objfile;
3212 struct obj_section *osect;
3214 if (overlay_debugging)
3215 ALL_OBJSECTIONS (objfile, osect)
3216 if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
3222 /* Function: list_overlays_command
3223 Print a list of mapped sections and their PC ranges. */
3226 list_overlays_command (char *args, int from_tty)
3229 struct objfile *objfile;
3230 struct obj_section *osect;
3232 if (overlay_debugging)
3233 ALL_OBJSECTIONS (objfile, osect)
3234 if (section_is_mapped (osect))
3236 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3241 vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
3242 lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
3243 size = bfd_get_section_size (osect->the_bfd_section);
3244 name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
3246 printf_filtered ("Section %s, loaded at ", name);
3247 fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
3248 puts_filtered (" - ");
3249 fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
3250 printf_filtered (", mapped at ");
3251 fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
3252 puts_filtered (" - ");
3253 fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
3254 puts_filtered ("\n");
3259 printf_filtered (_("No sections are mapped.\n"));
3262 /* Function: map_overlay_command
3263 Mark the named section as mapped (ie. residing at its VMA address). */
3266 map_overlay_command (char *args, int from_tty)
3268 struct objfile *objfile, *objfile2;
3269 struct obj_section *sec, *sec2;
3271 if (!overlay_debugging)
3272 error (_("Overlay debugging not enabled. Use "
3273 "either the 'overlay auto' or\n"
3274 "the 'overlay manual' command."));
3276 if (args == 0 || *args == 0)
3277 error (_("Argument required: name of an overlay section"));
3279 /* First, find a section matching the user supplied argument. */
3280 ALL_OBJSECTIONS (objfile, sec)
3281 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
3283 /* Now, check to see if the section is an overlay. */
3284 if (!section_is_overlay (sec))
3285 continue; /* not an overlay section */
3287 /* Mark the overlay as "mapped". */
3288 sec->ovly_mapped = 1;
3290 /* Next, make a pass and unmap any sections that are
3291 overlapped by this new section: */
3292 ALL_OBJSECTIONS (objfile2, sec2)
3293 if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec, sec2))
3296 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3297 bfd_section_name (objfile->obfd,
3298 sec2->the_bfd_section));
3299 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2. */
3303 error (_("No overlay section called %s"), args);
3306 /* Function: unmap_overlay_command
3307 Mark the overlay section as unmapped
3308 (ie. resident in its LMA address range, rather than the VMA range). */
3311 unmap_overlay_command (char *args, int from_tty)
3313 struct objfile *objfile;
3314 struct obj_section *sec;
3316 if (!overlay_debugging)
3317 error (_("Overlay debugging not enabled. "
3318 "Use either the 'overlay auto' or\n"
3319 "the 'overlay manual' command."));
3321 if (args == 0 || *args == 0)
3322 error (_("Argument required: name of an overlay section"));
3324 /* First, find a section matching the user supplied argument. */
3325 ALL_OBJSECTIONS (objfile, sec)
3326 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
3328 if (!sec->ovly_mapped)
3329 error (_("Section %s is not mapped"), args);
3330 sec->ovly_mapped = 0;
3333 error (_("No overlay section called %s"), args);
3336 /* Function: overlay_auto_command
3337 A utility command to turn on overlay debugging.
3338 Possibly this should be done via a set/show command. */
3341 overlay_auto_command (char *args, int from_tty)
3343 overlay_debugging = ovly_auto;
3344 enable_overlay_breakpoints ();
3346 printf_unfiltered (_("Automatic overlay debugging enabled."));
3349 /* Function: overlay_manual_command
3350 A utility command to turn on overlay debugging.
3351 Possibly this should be done via a set/show command. */
3354 overlay_manual_command (char *args, int from_tty)
3356 overlay_debugging = ovly_on;
3357 disable_overlay_breakpoints ();
3359 printf_unfiltered (_("Overlay debugging enabled."));
3362 /* Function: overlay_off_command
3363 A utility command to turn on overlay debugging.
3364 Possibly this should be done via a set/show command. */
3367 overlay_off_command (char *args, int from_tty)
3369 overlay_debugging = ovly_off;
3370 disable_overlay_breakpoints ();
3372 printf_unfiltered (_("Overlay debugging disabled."));
3376 overlay_load_command (char *args, int from_tty)
3378 struct gdbarch *gdbarch = get_current_arch ();
3380 if (gdbarch_overlay_update_p (gdbarch))
3381 gdbarch_overlay_update (gdbarch, NULL);
3383 error (_("This target does not know how to read its overlay state."));
3386 /* Function: overlay_command
3387 A place-holder for a mis-typed command. */
3389 /* Command list chain containing all defined "overlay" subcommands. */
3390 static struct cmd_list_element *overlaylist;
3393 overlay_command (char *args, int from_tty)
3396 ("\"overlay\" must be followed by the name of an overlay command.\n");
3397 help_list (overlaylist, "overlay ", -1, gdb_stdout);
3401 /* Target Overlays for the "Simplest" overlay manager:
3403 This is GDB's default target overlay layer. It works with the
3404 minimal overlay manager supplied as an example by Cygnus. The
3405 entry point is via a function pointer "gdbarch_overlay_update",
3406 so targets that use a different runtime overlay manager can
3407 substitute their own overlay_update function and take over the
3410 The overlay_update function pokes around in the target's data structures
3411 to see what overlays are mapped, and updates GDB's overlay mapping with
3414 In this simple implementation, the target data structures are as follows:
3415 unsigned _novlys; /# number of overlay sections #/
3416 unsigned _ovly_table[_novlys][4] = {
3417 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3418 {..., ..., ..., ...},
3420 unsigned _novly_regions; /# number of overlay regions #/
3421 unsigned _ovly_region_table[_novly_regions][3] = {
3422 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3425 These functions will attempt to update GDB's mappedness state in the
3426 symbol section table, based on the target's mappedness state.
3428 To do this, we keep a cached copy of the target's _ovly_table, and
3429 attempt to detect when the cached copy is invalidated. The main
3430 entry point is "simple_overlay_update(SECT), which looks up SECT in
3431 the cached table and re-reads only the entry for that section from
3432 the target (whenever possible). */
3434 /* Cached, dynamically allocated copies of the target data structures: */
3435 static unsigned (*cache_ovly_table)[4] = 0;
3436 static unsigned cache_novlys = 0;
3437 static CORE_ADDR cache_ovly_table_base = 0;
3440 VMA, SIZE, LMA, MAPPED
3443 /* Throw away the cached copy of _ovly_table. */
3445 simple_free_overlay_table (void)
3447 if (cache_ovly_table)
3448 xfree (cache_ovly_table);
3450 cache_ovly_table = NULL;
3451 cache_ovly_table_base = 0;
3454 /* Read an array of ints of size SIZE from the target into a local buffer.
3455 Convert to host order. int LEN is number of ints. */
3457 read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr,
3458 int len, int size, enum bfd_endian byte_order)
3460 /* FIXME (alloca): Not safe if array is very large. */
3461 gdb_byte *buf = alloca (len * size);
3464 read_memory (memaddr, buf, len * size);
3465 for (i = 0; i < len; i++)
3466 myaddr[i] = extract_unsigned_integer (size * i + buf, size, byte_order);
3469 /* Find and grab a copy of the target _ovly_table
3470 (and _novlys, which is needed for the table's size). */
3472 simple_read_overlay_table (void)
3474 struct minimal_symbol *novlys_msym, *ovly_table_msym;
3475 struct gdbarch *gdbarch;
3477 enum bfd_endian byte_order;
3479 simple_free_overlay_table ();
3480 novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
3483 error (_("Error reading inferior's overlay table: "
3484 "couldn't find `_novlys' variable\n"
3485 "in inferior. Use `overlay manual' mode."));
3489 ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
3490 if (! ovly_table_msym)
3492 error (_("Error reading inferior's overlay table: couldn't find "
3493 "`_ovly_table' array\n"
3494 "in inferior. Use `overlay manual' mode."));
3498 gdbarch = get_objfile_arch (msymbol_objfile (ovly_table_msym));
3499 word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3500 byte_order = gdbarch_byte_order (gdbarch);
3502 cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym),
3505 = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
3506 cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
3507 read_target_long_array (cache_ovly_table_base,
3508 (unsigned int *) cache_ovly_table,
3509 cache_novlys * 4, word_size, byte_order);
3511 return 1; /* SUCCESS */
3514 /* Function: simple_overlay_update_1
3515 A helper function for simple_overlay_update. Assuming a cached copy
3516 of _ovly_table exists, look through it to find an entry whose vma,
3517 lma and size match those of OSECT. Re-read the entry and make sure
3518 it still matches OSECT (else the table may no longer be valid).
3519 Set OSECT's mapped state to match the entry. Return: 1 for
3520 success, 0 for failure. */
3523 simple_overlay_update_1 (struct obj_section *osect)
3526 bfd *obfd = osect->objfile->obfd;
3527 asection *bsect = osect->the_bfd_section;
3528 struct gdbarch *gdbarch = get_objfile_arch (osect->objfile);
3529 int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3530 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3532 size = bfd_get_section_size (osect->the_bfd_section);
3533 for (i = 0; i < cache_novlys; i++)
3534 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3535 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3536 /* && cache_ovly_table[i][SIZE] == size */ )
3538 read_target_long_array (cache_ovly_table_base + i * word_size,
3539 (unsigned int *) cache_ovly_table[i],
3540 4, word_size, byte_order);
3541 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3542 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3543 /* && cache_ovly_table[i][SIZE] == size */ )
3545 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3548 else /* Warning! Warning! Target's ovly table has changed! */
3554 /* Function: simple_overlay_update
3555 If OSECT is NULL, then update all sections' mapped state
3556 (after re-reading the entire target _ovly_table).
3557 If OSECT is non-NULL, then try to find a matching entry in the
3558 cached ovly_table and update only OSECT's mapped state.
3559 If a cached entry can't be found or the cache isn't valid, then
3560 re-read the entire cache, and go ahead and update all sections. */
3563 simple_overlay_update (struct obj_section *osect)
3565 struct objfile *objfile;
3567 /* Were we given an osect to look up? NULL means do all of them. */
3569 /* Have we got a cached copy of the target's overlay table? */
3570 if (cache_ovly_table != NULL)
3572 /* Does its cached location match what's currently in the
3574 struct minimal_symbol *minsym
3575 = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
3578 error (_("Error reading inferior's overlay table: couldn't "
3579 "find `_ovly_table' array\n"
3580 "in inferior. Use `overlay manual' mode."));
3582 if (cache_ovly_table_base == SYMBOL_VALUE_ADDRESS (minsym))
3583 /* Then go ahead and try to look up this single section in
3585 if (simple_overlay_update_1 (osect))
3586 /* Found it! We're done. */
3590 /* Cached table no good: need to read the entire table anew.
3591 Or else we want all the sections, in which case it's actually
3592 more efficient to read the whole table in one block anyway. */
3594 if (! simple_read_overlay_table ())
3597 /* Now may as well update all sections, even if only one was requested. */
3598 ALL_OBJSECTIONS (objfile, osect)
3599 if (section_is_overlay (osect))
3602 bfd *obfd = osect->objfile->obfd;
3603 asection *bsect = osect->the_bfd_section;
3605 size = bfd_get_section_size (bsect);
3606 for (i = 0; i < cache_novlys; i++)
3607 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3608 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3609 /* && cache_ovly_table[i][SIZE] == size */ )
3610 { /* obj_section matches i'th entry in ovly_table. */
3611 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3612 break; /* finished with inner for loop: break out. */
3617 /* Set the output sections and output offsets for section SECTP in
3618 ABFD. The relocation code in BFD will read these offsets, so we
3619 need to be sure they're initialized. We map each section to itself,
3620 with no offset; this means that SECTP->vma will be honored. */
3623 symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy)
3625 sectp->output_section = sectp;
3626 sectp->output_offset = 0;
3629 /* Default implementation for sym_relocate. */
3633 default_symfile_relocate (struct objfile *objfile, asection *sectp,
3636 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3638 bfd *abfd = sectp->owner;
3640 /* We're only interested in sections with relocation
3642 if ((sectp->flags & SEC_RELOC) == 0)
3645 /* We will handle section offsets properly elsewhere, so relocate as if
3646 all sections begin at 0. */
3647 bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL);
3649 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
3652 /* Relocate the contents of a debug section SECTP in ABFD. The
3653 contents are stored in BUF if it is non-NULL, or returned in a
3654 malloc'd buffer otherwise.
3656 For some platforms and debug info formats, shared libraries contain
3657 relocations against the debug sections (particularly for DWARF-2;
3658 one affected platform is PowerPC GNU/Linux, although it depends on
3659 the version of the linker in use). Also, ELF object files naturally
3660 have unresolved relocations for their debug sections. We need to apply
3661 the relocations in order to get the locations of symbols correct.
3662 Another example that may require relocation processing, is the
3663 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3667 symfile_relocate_debug_section (struct objfile *objfile,
3668 asection *sectp, bfd_byte *buf)
3670 gdb_assert (objfile->sf->sym_relocate);
3672 return (*objfile->sf->sym_relocate) (objfile, sectp, buf);
3675 struct symfile_segment_data *
3676 get_symfile_segment_data (bfd *abfd)
3678 const struct sym_fns *sf = find_sym_fns (abfd);
3683 return sf->sym_segments (abfd);
3687 free_symfile_segment_data (struct symfile_segment_data *data)
3689 xfree (data->segment_bases);
3690 xfree (data->segment_sizes);
3691 xfree (data->segment_info);
3697 - DATA, containing segment addresses from the object file ABFD, and
3698 the mapping from ABFD's sections onto the segments that own them,
3700 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3701 segment addresses reported by the target,
3702 store the appropriate offsets for each section in OFFSETS.
3704 If there are fewer entries in SEGMENT_BASES than there are segments
3705 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3707 If there are more entries, then ignore the extra. The target may
3708 not be able to distinguish between an empty data segment and a
3709 missing data segment; a missing text segment is less plausible. */
3711 symfile_map_offsets_to_segments (bfd *abfd, struct symfile_segment_data *data,
3712 struct section_offsets *offsets,
3713 int num_segment_bases,
3714 const CORE_ADDR *segment_bases)
3719 /* It doesn't make sense to call this function unless you have some
3720 segment base addresses. */
3721 gdb_assert (num_segment_bases > 0);
3723 /* If we do not have segment mappings for the object file, we
3724 can not relocate it by segments. */
3725 gdb_assert (data != NULL);
3726 gdb_assert (data->num_segments > 0);
3728 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3730 int which = data->segment_info[i];
3732 gdb_assert (0 <= which && which <= data->num_segments);
3734 /* Don't bother computing offsets for sections that aren't
3735 loaded as part of any segment. */
3739 /* Use the last SEGMENT_BASES entry as the address of any extra
3740 segments mentioned in DATA->segment_info. */
3741 if (which > num_segment_bases)
3742 which = num_segment_bases;
3744 offsets->offsets[i] = (segment_bases[which - 1]
3745 - data->segment_bases[which - 1]);
3752 symfile_find_segment_sections (struct objfile *objfile)
3754 bfd *abfd = objfile->obfd;
3757 struct symfile_segment_data *data;
3759 data = get_symfile_segment_data (objfile->obfd);
3763 if (data->num_segments != 1 && data->num_segments != 2)
3765 free_symfile_segment_data (data);
3769 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3771 int which = data->segment_info[i];
3775 if (objfile->sect_index_text == -1)
3776 objfile->sect_index_text = sect->index;
3778 if (objfile->sect_index_rodata == -1)
3779 objfile->sect_index_rodata = sect->index;
3781 else if (which == 2)
3783 if (objfile->sect_index_data == -1)
3784 objfile->sect_index_data = sect->index;
3786 if (objfile->sect_index_bss == -1)
3787 objfile->sect_index_bss = sect->index;
3791 free_symfile_segment_data (data);
3795 _initialize_symfile (void)
3797 struct cmd_list_element *c;
3799 c = add_cmd ("symbol-file", class_files, symbol_file_command, _("\
3800 Load symbol table from executable file FILE.\n\
3801 The `file' command can also load symbol tables, as well as setting the file\n\
3802 to execute."), &cmdlist);
3803 set_cmd_completer (c, filename_completer);
3805 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\
3806 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3807 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\
3808 ...]\nADDR is the starting address of the file's text.\n\
3809 The optional arguments are section-name section-address pairs and\n\
3810 should be specified if the data and bss segments are not contiguous\n\
3811 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3813 set_cmd_completer (c, filename_completer);
3815 c = add_cmd ("load", class_files, load_command, _("\
3816 Dynamically load FILE into the running program, and record its symbols\n\
3817 for access from GDB.\n\
3818 A load OFFSET may also be given."), &cmdlist);
3819 set_cmd_completer (c, filename_completer);
3821 add_prefix_cmd ("overlay", class_support, overlay_command,
3822 _("Commands for debugging overlays."), &overlaylist,
3823 "overlay ", 0, &cmdlist);
3825 add_com_alias ("ovly", "overlay", class_alias, 1);
3826 add_com_alias ("ov", "overlay", class_alias, 1);
3828 add_cmd ("map-overlay", class_support, map_overlay_command,
3829 _("Assert that an overlay section is mapped."), &overlaylist);
3831 add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
3832 _("Assert that an overlay section is unmapped."), &overlaylist);
3834 add_cmd ("list-overlays", class_support, list_overlays_command,
3835 _("List mappings of overlay sections."), &overlaylist);
3837 add_cmd ("manual", class_support, overlay_manual_command,
3838 _("Enable overlay debugging."), &overlaylist);
3839 add_cmd ("off", class_support, overlay_off_command,
3840 _("Disable overlay debugging."), &overlaylist);
3841 add_cmd ("auto", class_support, overlay_auto_command,
3842 _("Enable automatic overlay debugging."), &overlaylist);
3843 add_cmd ("load-target", class_support, overlay_load_command,
3844 _("Read the overlay mapping state from the target."), &overlaylist);
3846 /* Filename extension to source language lookup table: */
3847 init_filename_language_table ();
3848 add_setshow_string_noescape_cmd ("extension-language", class_files,
3850 Set mapping between filename extension and source language."), _("\
3851 Show mapping between filename extension and source language."), _("\
3852 Usage: set extension-language .foo bar"),
3853 set_ext_lang_command,
3855 &setlist, &showlist);
3857 add_info ("extensions", info_ext_lang_command,
3858 _("All filename extensions associated with a source language."));
3860 add_setshow_optional_filename_cmd ("debug-file-directory", class_support,
3861 &debug_file_directory, _("\
3862 Set the directories where separate debug symbols are searched for."), _("\
3863 Show the directories where separate debug symbols are searched for."), _("\
3864 Separate debug symbols are first searched for in the same\n\
3865 directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\
3866 and lastly at the path of the directory of the binary with\n\
3867 each global debug-file-directory component prepended."),
3869 show_debug_file_directory,
3870 &setlist, &showlist);