1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support, using pieces from other GDB modules.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "arch-utils.h"
37 #include "breakpoint.h"
39 #include "complaints.h"
43 #include "filenames.h" /* for DOSish file names */
44 #include "gdb-stabs.h"
45 #include "gdb_obstack.h"
46 #include "completer.h"
49 #include "readline/readline.h"
50 #include "gdb_assert.h"
54 #include "parser-defs.h"
60 #include <sys/types.h>
62 #include "gdb_string.h"
70 int (*deprecated_ui_load_progress_hook) (const char *section, unsigned long num);
71 void (*deprecated_show_load_progress) (const char *section,
72 unsigned long section_sent,
73 unsigned long section_size,
74 unsigned long total_sent,
75 unsigned long total_size);
76 void (*deprecated_pre_add_symbol_hook) (const char *);
77 void (*deprecated_post_add_symbol_hook) (void);
79 static void clear_symtab_users_cleanup (void *ignore);
81 /* Global variables owned by this file */
82 int readnow_symbol_files; /* Read full symbols immediately */
84 /* External variables and functions referenced. */
86 extern void report_transfer_performance (unsigned long, time_t, time_t);
88 /* Functions this file defines */
91 static int simple_read_overlay_region_table (void);
92 static void simple_free_overlay_region_table (void);
95 static void load_command (char *, int);
97 static void symbol_file_add_main_1 (char *args, int from_tty, int flags);
99 static void add_symbol_file_command (char *, int);
101 bfd *symfile_bfd_open (char *);
103 int get_section_index (struct objfile *, char *);
105 static struct sym_fns *find_sym_fns (bfd *);
107 static void decrement_reading_symtab (void *);
109 static void overlay_invalidate_all (void);
111 void list_overlays_command (char *, int);
113 void map_overlay_command (char *, int);
115 void unmap_overlay_command (char *, int);
117 static void overlay_auto_command (char *, int);
119 static void overlay_manual_command (char *, int);
121 static void overlay_off_command (char *, int);
123 static void overlay_load_command (char *, int);
125 static void overlay_command (char *, int);
127 static void simple_free_overlay_table (void);
129 static void read_target_long_array (CORE_ADDR, unsigned int *, int, int,
132 static int simple_read_overlay_table (void);
134 static int simple_overlay_update_1 (struct obj_section *);
136 static void add_filename_language (char *ext, enum language lang);
138 static void info_ext_lang_command (char *args, int from_tty);
140 static void init_filename_language_table (void);
142 static void symfile_find_segment_sections (struct objfile *objfile);
144 void _initialize_symfile (void);
146 /* List of all available sym_fns. On gdb startup, each object file reader
147 calls add_symtab_fns() to register information on each format it is
150 static struct sym_fns *symtab_fns = NULL;
152 /* Flag for whether user will be reloading symbols multiple times.
153 Defaults to ON for VxWorks, otherwise OFF. */
155 #ifdef SYMBOL_RELOADING_DEFAULT
156 int symbol_reloading = SYMBOL_RELOADING_DEFAULT;
158 int symbol_reloading = 0;
161 show_symbol_reloading (struct ui_file *file, int from_tty,
162 struct cmd_list_element *c, const char *value)
164 fprintf_filtered (file, _("\
165 Dynamic symbol table reloading multiple times in one run is %s.\n"),
169 /* If non-zero, shared library symbols will be added automatically
170 when the inferior is created, new libraries are loaded, or when
171 attaching to the inferior. This is almost always what users will
172 want to have happen; but for very large programs, the startup time
173 will be excessive, and so if this is a problem, the user can clear
174 this flag and then add the shared library symbols as needed. Note
175 that there is a potential for confusion, since if the shared
176 library symbols are not loaded, commands like "info fun" will *not*
177 report all the functions that are actually present. */
179 int auto_solib_add = 1;
181 /* For systems that support it, a threshold size in megabytes. If
182 automatically adding a new library's symbol table to those already
183 known to the debugger would cause the total shared library symbol
184 size to exceed this threshhold, then the shlib's symbols are not
185 added. The threshold is ignored if the user explicitly asks for a
186 shlib to be added, such as when using the "sharedlibrary"
189 int auto_solib_limit;
192 /* Make a null terminated copy of the string at PTR with SIZE characters in
193 the obstack pointed to by OBSTACKP . Returns the address of the copy.
194 Note that the string at PTR does not have to be null terminated, I.E. it
195 may be part of a larger string and we are only saving a substring. */
198 obsavestring (const char *ptr, int size, struct obstack *obstackp)
200 char *p = (char *) obstack_alloc (obstackp, size + 1);
201 /* Open-coded memcpy--saves function call time. These strings are usually
202 short. FIXME: Is this really still true with a compiler that can
205 const char *p1 = ptr;
207 const char *end = ptr + size;
215 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
216 in the obstack pointed to by OBSTACKP. */
219 obconcat (struct obstack *obstackp, const char *s1, const char *s2,
222 int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
223 char *val = (char *) obstack_alloc (obstackp, len);
230 /* True if we are reading a symbol table. */
232 int currently_reading_symtab = 0;
235 decrement_reading_symtab (void *dummy)
237 currently_reading_symtab--;
240 /* Increment currently_reading_symtab and return a cleanup that can be
241 used to decrement it. */
243 increment_reading_symtab (void)
245 ++currently_reading_symtab;
246 return make_cleanup (decrement_reading_symtab, NULL);
249 /* Remember the lowest-addressed loadable section we've seen.
250 This function is called via bfd_map_over_sections.
252 In case of equal vmas, the section with the largest size becomes the
253 lowest-addressed loadable section.
255 If the vmas and sizes are equal, the last section is considered the
256 lowest-addressed loadable section. */
259 find_lowest_section (bfd *abfd, asection *sect, void *obj)
261 asection **lowest = (asection **) obj;
263 if (0 == (bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD)))
266 *lowest = sect; /* First loadable section */
267 else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect))
268 *lowest = sect; /* A lower loadable section */
269 else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect)
270 && (bfd_section_size (abfd, (*lowest))
271 <= bfd_section_size (abfd, sect)))
275 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
277 struct section_addr_info *
278 alloc_section_addr_info (size_t num_sections)
280 struct section_addr_info *sap;
283 size = (sizeof (struct section_addr_info)
284 + sizeof (struct other_sections) * (num_sections - 1));
285 sap = (struct section_addr_info *) xmalloc (size);
286 memset (sap, 0, size);
287 sap->num_sections = num_sections;
292 /* Build (allocate and populate) a section_addr_info struct from
293 an existing section table. */
295 extern struct section_addr_info *
296 build_section_addr_info_from_section_table (const struct target_section *start,
297 const struct target_section *end)
299 struct section_addr_info *sap;
300 const struct target_section *stp;
303 sap = alloc_section_addr_info (end - start);
305 for (stp = start, oidx = 0; stp != end; stp++)
307 if (bfd_get_section_flags (stp->bfd,
308 stp->the_bfd_section) & (SEC_ALLOC | SEC_LOAD)
309 && oidx < end - start)
311 sap->other[oidx].addr = stp->addr;
312 sap->other[oidx].name
313 = xstrdup (bfd_section_name (stp->bfd, stp->the_bfd_section));
314 sap->other[oidx].sectindex = stp->the_bfd_section->index;
322 /* Create a section_addr_info from section offsets in ABFD. */
324 static struct section_addr_info *
325 build_section_addr_info_from_bfd (bfd *abfd)
327 struct section_addr_info *sap;
329 struct bfd_section *sec;
331 sap = alloc_section_addr_info (bfd_count_sections (abfd));
332 for (i = 0, sec = abfd->sections; sec != NULL; sec = sec->next)
333 if (bfd_get_section_flags (abfd, sec) & (SEC_ALLOC | SEC_LOAD))
335 sap->other[i].addr = bfd_get_section_vma (abfd, sec);
336 sap->other[i].name = xstrdup (bfd_get_section_name (abfd, sec));
337 sap->other[i].sectindex = sec->index;
343 /* Create a section_addr_info from section offsets in OBJFILE. */
345 struct section_addr_info *
346 build_section_addr_info_from_objfile (const struct objfile *objfile)
348 struct section_addr_info *sap;
351 /* Before reread_symbols gets rewritten it is not safe to call:
352 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
354 sap = build_section_addr_info_from_bfd (objfile->obfd);
355 for (i = 0; i < sap->num_sections && sap->other[i].name; i++)
357 int sectindex = sap->other[i].sectindex;
359 sap->other[i].addr += objfile->section_offsets->offsets[sectindex];
364 /* Free all memory allocated by build_section_addr_info_from_section_table. */
367 free_section_addr_info (struct section_addr_info *sap)
371 for (idx = 0; idx < sap->num_sections; idx++)
372 if (sap->other[idx].name)
373 xfree (sap->other[idx].name);
378 /* Initialize OBJFILE's sect_index_* members. */
380 init_objfile_sect_indices (struct objfile *objfile)
385 sect = bfd_get_section_by_name (objfile->obfd, ".text");
387 objfile->sect_index_text = sect->index;
389 sect = bfd_get_section_by_name (objfile->obfd, ".data");
391 objfile->sect_index_data = sect->index;
393 sect = bfd_get_section_by_name (objfile->obfd, ".bss");
395 objfile->sect_index_bss = sect->index;
397 sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
399 objfile->sect_index_rodata = sect->index;
401 /* This is where things get really weird... We MUST have valid
402 indices for the various sect_index_* members or gdb will abort.
403 So if for example, there is no ".text" section, we have to
404 accomodate that. First, check for a file with the standard
405 one or two segments. */
407 symfile_find_segment_sections (objfile);
409 /* Except when explicitly adding symbol files at some address,
410 section_offsets contains nothing but zeros, so it doesn't matter
411 which slot in section_offsets the individual sect_index_* members
412 index into. So if they are all zero, it is safe to just point
413 all the currently uninitialized indices to the first slot. But
414 beware: if this is the main executable, it may be relocated
415 later, e.g. by the remote qOffsets packet, and then this will
416 be wrong! That's why we try segments first. */
418 for (i = 0; i < objfile->num_sections; i++)
420 if (ANOFFSET (objfile->section_offsets, i) != 0)
425 if (i == objfile->num_sections)
427 if (objfile->sect_index_text == -1)
428 objfile->sect_index_text = 0;
429 if (objfile->sect_index_data == -1)
430 objfile->sect_index_data = 0;
431 if (objfile->sect_index_bss == -1)
432 objfile->sect_index_bss = 0;
433 if (objfile->sect_index_rodata == -1)
434 objfile->sect_index_rodata = 0;
438 /* The arguments to place_section. */
440 struct place_section_arg
442 struct section_offsets *offsets;
446 /* Find a unique offset to use for loadable section SECT if
447 the user did not provide an offset. */
450 place_section (bfd *abfd, asection *sect, void *obj)
452 struct place_section_arg *arg = obj;
453 CORE_ADDR *offsets = arg->offsets->offsets, start_addr;
455 ULONGEST align = ((ULONGEST) 1) << bfd_get_section_alignment (abfd, sect);
457 /* We are only interested in allocated sections. */
458 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
461 /* If the user specified an offset, honor it. */
462 if (offsets[sect->index] != 0)
465 /* Otherwise, let's try to find a place for the section. */
466 start_addr = (arg->lowest + align - 1) & -align;
473 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
475 int indx = cur_sec->index;
476 CORE_ADDR cur_offset;
478 /* We don't need to compare against ourself. */
482 /* We can only conflict with allocated sections. */
483 if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0)
486 /* If the section offset is 0, either the section has not been placed
487 yet, or it was the lowest section placed (in which case LOWEST
488 will be past its end). */
489 if (offsets[indx] == 0)
492 /* If this section would overlap us, then we must move up. */
493 if (start_addr + bfd_get_section_size (sect) > offsets[indx]
494 && start_addr < offsets[indx] + bfd_get_section_size (cur_sec))
496 start_addr = offsets[indx] + bfd_get_section_size (cur_sec);
497 start_addr = (start_addr + align - 1) & -align;
502 /* Otherwise, we appear to be OK. So far. */
507 offsets[sect->index] = start_addr;
508 arg->lowest = start_addr + bfd_get_section_size (sect);
511 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
512 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
516 relative_addr_info_to_section_offsets (struct section_offsets *section_offsets,
518 struct section_addr_info *addrs)
522 memset (section_offsets, 0, SIZEOF_N_SECTION_OFFSETS (num_sections));
524 /* Now calculate offsets for section that were specified by the caller. */
525 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
527 struct other_sections *osp;
529 osp = &addrs->other[i];
533 /* Record all sections in offsets */
534 /* The section_offsets in the objfile are here filled in using
536 section_offsets->offsets[osp->sectindex] = osp->addr;
540 /* qsort comparator for addrs_section_sort. Sort entries in ascending order by
541 their (name, sectindex) pair. sectindex makes the sort by name stable. */
544 addrs_section_compar (const void *ap, const void *bp)
546 const struct other_sections *a = *((struct other_sections **) ap);
547 const struct other_sections *b = *((struct other_sections **) bp);
548 int retval, a_idx, b_idx;
550 retval = strcmp (a->name, b->name);
554 /* SECTINDEX is undefined iff ADDR is zero. */
555 a_idx = a->addr == 0 ? 0 : a->sectindex;
556 b_idx = b->addr == 0 ? 0 : b->sectindex;
557 return a_idx - b_idx;
560 /* Provide sorted array of pointers to sections of ADDRS. The array is
561 terminated by NULL. Caller is responsible to call xfree for it. */
563 static struct other_sections **
564 addrs_section_sort (struct section_addr_info *addrs)
566 struct other_sections **array;
569 /* `+ 1' for the NULL terminator. */
570 array = xmalloc (sizeof (*array) * (addrs->num_sections + 1));
571 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
572 array[i] = &addrs->other[i];
575 qsort (array, i, sizeof (*array), addrs_section_compar);
580 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
581 also SECTINDEXes specific to ABFD there. This function can be used to
582 rebase ADDRS to start referencing different BFD than before. */
585 addr_info_make_relative (struct section_addr_info *addrs, bfd *abfd)
587 asection *lower_sect;
588 CORE_ADDR lower_offset;
590 struct cleanup *my_cleanup;
591 struct section_addr_info *abfd_addrs;
592 struct other_sections **addrs_sorted, **abfd_addrs_sorted;
593 struct other_sections **addrs_to_abfd_addrs;
595 /* Find lowest loadable section to be used as starting point for
596 continguous sections. */
598 bfd_map_over_sections (abfd, find_lowest_section, &lower_sect);
599 if (lower_sect == NULL)
601 warning (_("no loadable sections found in added symbol-file %s"),
602 bfd_get_filename (abfd));
606 lower_offset = bfd_section_vma (bfd_get_filename (abfd), lower_sect);
608 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
609 in ABFD. Section names are not unique - there can be multiple sections of
610 the same name. Also the sections of the same name do not have to be
611 adjacent to each other. Some sections may be present only in one of the
612 files. Even sections present in both files do not have to be in the same
615 Use stable sort by name for the sections in both files. Then linearly
616 scan both lists matching as most of the entries as possible. */
618 addrs_sorted = addrs_section_sort (addrs);
619 my_cleanup = make_cleanup (xfree, addrs_sorted);
621 abfd_addrs = build_section_addr_info_from_bfd (abfd);
622 make_cleanup_free_section_addr_info (abfd_addrs);
623 abfd_addrs_sorted = addrs_section_sort (abfd_addrs);
624 make_cleanup (xfree, abfd_addrs_sorted);
626 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and ABFD_ADDRS_SORTED. */
628 addrs_to_abfd_addrs = xzalloc (sizeof (*addrs_to_abfd_addrs)
629 * addrs->num_sections);
630 make_cleanup (xfree, addrs_to_abfd_addrs);
632 while (*addrs_sorted)
634 const char *sect_name = (*addrs_sorted)->name;
636 while (*abfd_addrs_sorted
637 && strcmp ((*abfd_addrs_sorted)->name, sect_name) < 0)
640 if (*abfd_addrs_sorted
641 && strcmp ((*abfd_addrs_sorted)->name, sect_name) == 0)
645 /* Make the found item directly addressable from ADDRS. */
646 index_in_addrs = *addrs_sorted - addrs->other;
647 gdb_assert (addrs_to_abfd_addrs[index_in_addrs] == NULL);
648 addrs_to_abfd_addrs[index_in_addrs] = *abfd_addrs_sorted;
650 /* Never use the same ABFD entry twice. */
657 /* Calculate offsets for the loadable sections.
658 FIXME! Sections must be in order of increasing loadable section
659 so that contiguous sections can use the lower-offset!!!
661 Adjust offsets if the segments are not contiguous.
662 If the section is contiguous, its offset should be set to
663 the offset of the highest loadable section lower than it
664 (the loadable section directly below it in memory).
665 this_offset = lower_offset = lower_addr - lower_orig_addr */
667 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
669 const char *sect_name = addrs->other[i].name;
670 struct other_sections *sect = addrs_to_abfd_addrs[i];
674 /* This is the index used by BFD. */
675 addrs->other[i].sectindex = sect->sectindex;
677 if (addrs->other[i].addr != 0)
679 addrs->other[i].addr -= sect->addr;
680 lower_offset = addrs->other[i].addr;
683 addrs->other[i].addr = lower_offset;
687 /* This section does not exist in ABFD, which is normally
688 unexpected and we want to issue a warning.
690 However, the ELF prelinker does create a few sections which are
691 marked in the main executable as loadable (they are loaded in
692 memory from the DYNAMIC segment) and yet are not present in
693 separate debug info files. This is fine, and should not cause
694 a warning. Shared libraries contain just the section
695 ".gnu.liblist" but it is not marked as loadable there. There is
696 no other way to identify them than by their name as the sections
697 created by prelink have no special flags. */
699 if (!(strcmp (sect_name, ".gnu.liblist") == 0
700 || strcmp (sect_name, ".gnu.conflict") == 0
701 || strcmp (sect_name, ".dynbss") == 0
702 || strcmp (sect_name, ".sdynbss") == 0))
703 warning (_("section %s not found in %s"), sect_name,
704 bfd_get_filename (abfd));
706 addrs->other[i].addr = 0;
708 /* SECTINDEX is invalid if ADDR is zero. */
712 do_cleanups (my_cleanup);
715 /* Parse the user's idea of an offset for dynamic linking, into our idea
716 of how to represent it for fast symbol reading. This is the default
717 version of the sym_fns.sym_offsets function for symbol readers that
718 don't need to do anything special. It allocates a section_offsets table
719 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
722 default_symfile_offsets (struct objfile *objfile,
723 struct section_addr_info *addrs)
725 objfile->num_sections = bfd_count_sections (objfile->obfd);
726 objfile->section_offsets = (struct section_offsets *)
727 obstack_alloc (&objfile->objfile_obstack,
728 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
729 relative_addr_info_to_section_offsets (objfile->section_offsets,
730 objfile->num_sections, addrs);
732 /* For relocatable files, all loadable sections will start at zero.
733 The zero is meaningless, so try to pick arbitrary addresses such
734 that no loadable sections overlap. This algorithm is quadratic,
735 but the number of sections in a single object file is generally
737 if ((bfd_get_file_flags (objfile->obfd) & (EXEC_P | DYNAMIC)) == 0)
739 struct place_section_arg arg;
740 bfd *abfd = objfile->obfd;
742 CORE_ADDR lowest = 0;
744 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
745 /* We do not expect this to happen; just skip this step if the
746 relocatable file has a section with an assigned VMA. */
747 if (bfd_section_vma (abfd, cur_sec) != 0)
752 CORE_ADDR *offsets = objfile->section_offsets->offsets;
754 /* Pick non-overlapping offsets for sections the user did not
756 arg.offsets = objfile->section_offsets;
758 bfd_map_over_sections (objfile->obfd, place_section, &arg);
760 /* Correctly filling in the section offsets is not quite
761 enough. Relocatable files have two properties that
762 (most) shared objects do not:
764 - Their debug information will contain relocations. Some
765 shared libraries do also, but many do not, so this can not
768 - If there are multiple code sections they will be loaded
769 at different relative addresses in memory than they are
770 in the objfile, since all sections in the file will start
773 Because GDB has very limited ability to map from an
774 address in debug info to the correct code section,
775 it relies on adding SECT_OFF_TEXT to things which might be
776 code. If we clear all the section offsets, and set the
777 section VMAs instead, then symfile_relocate_debug_section
778 will return meaningful debug information pointing at the
781 GDB has too many different data structures for section
782 addresses - a bfd, objfile, and so_list all have section
783 tables, as does exec_ops. Some of these could probably
786 for (cur_sec = abfd->sections; cur_sec != NULL;
787 cur_sec = cur_sec->next)
789 if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0)
792 bfd_set_section_vma (abfd, cur_sec, offsets[cur_sec->index]);
793 exec_set_section_address (bfd_get_filename (abfd), cur_sec->index,
794 offsets[cur_sec->index]);
795 offsets[cur_sec->index] = 0;
800 /* Remember the bfd indexes for the .text, .data, .bss and
802 init_objfile_sect_indices (objfile);
806 /* Divide the file into segments, which are individual relocatable units.
807 This is the default version of the sym_fns.sym_segments function for
808 symbol readers that do not have an explicit representation of segments.
809 It assumes that object files do not have segments, and fully linked
810 files have a single segment. */
812 struct symfile_segment_data *
813 default_symfile_segments (bfd *abfd)
817 struct symfile_segment_data *data;
820 /* Relocatable files contain enough information to position each
821 loadable section independently; they should not be relocated
823 if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) == 0)
826 /* Make sure there is at least one loadable section in the file. */
827 for (sect = abfd->sections; sect != NULL; sect = sect->next)
829 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
837 low = bfd_get_section_vma (abfd, sect);
838 high = low + bfd_get_section_size (sect);
840 data = XZALLOC (struct symfile_segment_data);
841 data->num_segments = 1;
842 data->segment_bases = XCALLOC (1, CORE_ADDR);
843 data->segment_sizes = XCALLOC (1, CORE_ADDR);
845 num_sections = bfd_count_sections (abfd);
846 data->segment_info = XCALLOC (num_sections, int);
848 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
852 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
855 vma = bfd_get_section_vma (abfd, sect);
858 if (vma + bfd_get_section_size (sect) > high)
859 high = vma + bfd_get_section_size (sect);
861 data->segment_info[i] = 1;
864 data->segment_bases[0] = low;
865 data->segment_sizes[0] = high - low;
870 /* Process a symbol file, as either the main file or as a dynamically
873 OBJFILE is where the symbols are to be read from.
875 ADDRS is the list of section load addresses. If the user has given
876 an 'add-symbol-file' command, then this is the list of offsets and
877 addresses he or she provided as arguments to the command; or, if
878 we're handling a shared library, these are the actual addresses the
879 sections are loaded at, according to the inferior's dynamic linker
880 (as gleaned by GDB's shared library code). We convert each address
881 into an offset from the section VMA's as it appears in the object
882 file, and then call the file's sym_offsets function to convert this
883 into a format-specific offset table --- a `struct section_offsets'.
884 If ADDRS is non-zero, OFFSETS must be zero.
886 OFFSETS is a table of section offsets already in the right
887 format-specific representation. NUM_OFFSETS is the number of
888 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
889 assume this is the proper table the call to sym_offsets described
890 above would produce. Instead of calling sym_offsets, we just dump
891 it right into objfile->section_offsets. (When we're re-reading
892 symbols from an objfile, we don't have the original load address
893 list any more; all we have is the section offset table.) If
894 OFFSETS is non-zero, ADDRS must be zero.
896 ADD_FLAGS encodes verbosity level, whether this is main symbol or
897 an extra symbol file such as dynamically loaded code, and wether
898 breakpoint reset should be deferred. */
901 syms_from_objfile (struct objfile *objfile,
902 struct section_addr_info *addrs,
903 struct section_offsets *offsets,
907 struct section_addr_info *local_addr = NULL;
908 struct cleanup *old_chain;
909 const int mainline = add_flags & SYMFILE_MAINLINE;
911 gdb_assert (! (addrs && offsets));
913 init_entry_point_info (objfile);
914 objfile->sf = find_sym_fns (objfile->obfd);
916 if (objfile->sf == NULL)
917 return; /* No symbols. */
919 /* Make sure that partially constructed symbol tables will be cleaned up
920 if an error occurs during symbol reading. */
921 old_chain = make_cleanup_free_objfile (objfile);
923 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
924 list. We now establish the convention that an addr of zero means
925 no load address was specified. */
926 if (! addrs && ! offsets)
929 = alloc_section_addr_info (bfd_count_sections (objfile->obfd));
930 make_cleanup (xfree, local_addr);
934 /* Now either addrs or offsets is non-zero. */
938 /* We will modify the main symbol table, make sure that all its users
939 will be cleaned up if an error occurs during symbol reading. */
940 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
942 /* Since no error yet, throw away the old symbol table. */
944 if (symfile_objfile != NULL)
946 free_objfile (symfile_objfile);
947 gdb_assert (symfile_objfile == NULL);
950 /* Currently we keep symbols from the add-symbol-file command.
951 If the user wants to get rid of them, they should do "symbol-file"
952 without arguments first. Not sure this is the best behavior
955 (*objfile->sf->sym_new_init) (objfile);
958 /* Convert addr into an offset rather than an absolute address.
959 We find the lowest address of a loaded segment in the objfile,
960 and assume that <addr> is where that got loaded.
962 We no longer warn if the lowest section is not a text segment (as
963 happens for the PA64 port. */
964 if (addrs && addrs->other[0].name)
965 addr_info_make_relative (addrs, objfile->obfd);
967 /* Initialize symbol reading routines for this objfile, allow complaints to
968 appear for this new file, and record how verbose to be, then do the
969 initial symbol reading for this file. */
971 (*objfile->sf->sym_init) (objfile);
972 clear_complaints (&symfile_complaints, 1, add_flags & SYMFILE_VERBOSE);
975 (*objfile->sf->sym_offsets) (objfile, addrs);
978 size_t size = SIZEOF_N_SECTION_OFFSETS (num_offsets);
980 /* Just copy in the offset table directly as given to us. */
981 objfile->num_sections = num_offsets;
982 objfile->section_offsets
983 = ((struct section_offsets *)
984 obstack_alloc (&objfile->objfile_obstack, size));
985 memcpy (objfile->section_offsets, offsets, size);
987 init_objfile_sect_indices (objfile);
990 (*objfile->sf->sym_read) (objfile, add_flags);
992 /* Discard cleanups as symbol reading was successful. */
994 discard_cleanups (old_chain);
998 /* Perform required actions after either reading in the initial
999 symbols for a new objfile, or mapping in the symbols from a reusable
1003 new_symfile_objfile (struct objfile *objfile, int add_flags)
1006 /* If this is the main symbol file we have to clean up all users of the
1007 old main symbol file. Otherwise it is sufficient to fixup all the
1008 breakpoints that may have been redefined by this symbol file. */
1009 if (add_flags & SYMFILE_MAINLINE)
1011 /* OK, make it the "real" symbol file. */
1012 symfile_objfile = objfile;
1014 clear_symtab_users ();
1016 else if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
1018 breakpoint_re_set ();
1021 /* We're done reading the symbol file; finish off complaints. */
1022 clear_complaints (&symfile_complaints, 0, add_flags & SYMFILE_VERBOSE);
1025 /* Process a symbol file, as either the main file or as a dynamically
1028 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1029 This BFD will be closed on error, and is always consumed by this function.
1031 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1032 extra, such as dynamically loaded code, and what to do with breakpoins.
1034 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
1035 syms_from_objfile, above.
1036 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1038 Upon success, returns a pointer to the objfile that was added.
1039 Upon failure, jumps back to command level (never returns). */
1041 static struct objfile *
1042 symbol_file_add_with_addrs_or_offsets (bfd *abfd,
1044 struct section_addr_info *addrs,
1045 struct section_offsets *offsets,
1049 struct objfile *objfile;
1050 struct cleanup *my_cleanups;
1051 const char *name = bfd_get_filename (abfd);
1052 const int from_tty = add_flags & SYMFILE_VERBOSE;
1054 my_cleanups = make_cleanup_bfd_close (abfd);
1056 /* Give user a chance to burp if we'd be
1057 interactively wiping out any existing symbols. */
1059 if ((have_full_symbols () || have_partial_symbols ())
1060 && (add_flags & SYMFILE_MAINLINE)
1062 && !query (_("Load new symbol table from \"%s\"? "), name))
1063 error (_("Not confirmed."));
1065 objfile = allocate_objfile (abfd, flags);
1066 discard_cleanups (my_cleanups);
1068 /* We either created a new mapped symbol table, mapped an existing
1069 symbol table file which has not had initial symbol reading
1070 performed, or need to read an unmapped symbol table. */
1071 if (from_tty || info_verbose)
1073 if (deprecated_pre_add_symbol_hook)
1074 deprecated_pre_add_symbol_hook (name);
1077 printf_unfiltered (_("Reading symbols from %s..."), name);
1079 gdb_flush (gdb_stdout);
1082 syms_from_objfile (objfile, addrs, offsets, num_offsets,
1085 /* We now have at least a partial symbol table. Check to see if the
1086 user requested that all symbols be read on initial access via either
1087 the gdb startup command line or on a per symbol file basis. Expand
1088 all partial symbol tables for this objfile if so. */
1090 if ((flags & OBJF_READNOW) || readnow_symbol_files)
1092 if (from_tty || info_verbose)
1094 printf_unfiltered (_("expanding to full symbols..."));
1096 gdb_flush (gdb_stdout);
1100 objfile->sf->qf->expand_all_symtabs (objfile);
1103 if ((from_tty || info_verbose)
1104 && !objfile_has_symbols (objfile))
1107 printf_unfiltered (_("(no debugging symbols found)..."));
1111 if (from_tty || info_verbose)
1113 if (deprecated_post_add_symbol_hook)
1114 deprecated_post_add_symbol_hook ();
1116 printf_unfiltered (_("done.\n"));
1119 /* We print some messages regardless of whether 'from_tty ||
1120 info_verbose' is true, so make sure they go out at the right
1122 gdb_flush (gdb_stdout);
1124 do_cleanups (my_cleanups);
1126 if (objfile->sf == NULL)
1128 observer_notify_new_objfile (objfile);
1129 return objfile; /* No symbols. */
1132 new_symfile_objfile (objfile, add_flags);
1134 observer_notify_new_objfile (objfile);
1136 bfd_cache_close_all ();
1140 /* Add BFD as a separate debug file for OBJFILE. */
1143 symbol_file_add_separate (bfd *bfd, int symfile_flags, struct objfile *objfile)
1145 struct objfile *new_objfile;
1146 struct section_addr_info *sap;
1147 struct cleanup *my_cleanup;
1149 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1150 because sections of BFD may not match sections of OBJFILE and because
1151 vma may have been modified by tools such as prelink. */
1152 sap = build_section_addr_info_from_objfile (objfile);
1153 my_cleanup = make_cleanup_free_section_addr_info (sap);
1155 new_objfile = symbol_file_add_with_addrs_or_offsets
1156 (bfd, symfile_flags,
1158 objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW
1159 | OBJF_USERLOADED));
1161 do_cleanups (my_cleanup);
1163 add_separate_debug_objfile (new_objfile, objfile);
1166 /* Process the symbol file ABFD, as either the main file or as a
1167 dynamically loaded file.
1169 See symbol_file_add_with_addrs_or_offsets's comments for
1172 symbol_file_add_from_bfd (bfd *abfd, int add_flags,
1173 struct section_addr_info *addrs,
1176 return symbol_file_add_with_addrs_or_offsets (abfd, add_flags, addrs, 0, 0,
1181 /* Process a symbol file, as either the main file or as a dynamically
1182 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1185 symbol_file_add (char *name, int add_flags, struct section_addr_info *addrs,
1188 return symbol_file_add_from_bfd (symfile_bfd_open (name), add_flags, addrs,
1193 /* Call symbol_file_add() with default values and update whatever is
1194 affected by the loading of a new main().
1195 Used when the file is supplied in the gdb command line
1196 and by some targets with special loading requirements.
1197 The auxiliary function, symbol_file_add_main_1(), has the flags
1198 argument for the switches that can only be specified in the symbol_file
1202 symbol_file_add_main (char *args, int from_tty)
1204 symbol_file_add_main_1 (args, from_tty, 0);
1208 symbol_file_add_main_1 (char *args, int from_tty, int flags)
1210 const int add_flags = SYMFILE_MAINLINE | (from_tty ? SYMFILE_VERBOSE : 0);
1211 symbol_file_add (args, add_flags, NULL, flags);
1213 /* Getting new symbols may change our opinion about
1214 what is frameless. */
1215 reinit_frame_cache ();
1217 set_initial_language ();
1221 symbol_file_clear (int from_tty)
1223 if ((have_full_symbols () || have_partial_symbols ())
1226 ? !query (_("Discard symbol table from `%s'? "),
1227 symfile_objfile->name)
1228 : !query (_("Discard symbol table? "))))
1229 error (_("Not confirmed."));
1231 /* solib descriptors may have handles to objfiles. Wipe them before their
1232 objfiles get stale by free_all_objfiles. */
1233 no_shared_libraries (NULL, from_tty);
1235 free_all_objfiles ();
1237 gdb_assert (symfile_objfile == NULL);
1239 printf_unfiltered (_("No symbol file now.\n"));
1243 get_debug_link_info (struct objfile *objfile, unsigned long *crc32_out)
1246 bfd_size_type debuglink_size;
1247 unsigned long crc32;
1252 sect = bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink");
1257 debuglink_size = bfd_section_size (objfile->obfd, sect);
1259 contents = xmalloc (debuglink_size);
1260 bfd_get_section_contents (objfile->obfd, sect, contents,
1261 (file_ptr)0, (bfd_size_type)debuglink_size);
1263 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1264 crc_offset = strlen (contents) + 1;
1265 crc_offset = (crc_offset + 3) & ~3;
1267 crc32 = bfd_get_32 (objfile->obfd, (bfd_byte *) (contents + crc_offset));
1274 separate_debug_file_exists (const char *name, unsigned long crc,
1275 struct objfile *parent_objfile)
1277 unsigned long file_crc = 0;
1279 gdb_byte buffer[8*1024];
1281 struct stat parent_stat, abfd_stat;
1283 /* Find a separate debug info file as if symbols would be present in
1284 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1285 section can contain just the basename of PARENT_OBJFILE without any
1286 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1287 the separate debug infos with the same basename can exist. */
1289 if (strcmp (name, parent_objfile->name) == 0)
1292 abfd = bfd_open_maybe_remote (name);
1297 /* Verify symlinks were not the cause of strcmp name difference above.
1299 Some operating systems, e.g. Windows, do not provide a meaningful
1300 st_ino; they always set it to zero. (Windows does provide a
1301 meaningful st_dev.) Do not indicate a duplicate library in that
1302 case. While there is no guarantee that a system that provides
1303 meaningful inode numbers will never set st_ino to zero, this is
1304 merely an optimization, so we do not need to worry about false
1307 if (bfd_stat (abfd, &abfd_stat) == 0
1308 && bfd_stat (parent_objfile->obfd, &parent_stat) == 0
1309 && abfd_stat.st_dev == parent_stat.st_dev
1310 && abfd_stat.st_ino == parent_stat.st_ino
1311 && abfd_stat.st_ino != 0)
1317 while ((count = bfd_bread (buffer, sizeof (buffer), abfd)) > 0)
1318 file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
1322 if (crc != file_crc)
1324 warning (_("the debug information found in \"%s\""
1325 " does not match \"%s\" (CRC mismatch).\n"),
1326 name, parent_objfile->name);
1333 char *debug_file_directory = NULL;
1335 show_debug_file_directory (struct ui_file *file, int from_tty,
1336 struct cmd_list_element *c, const char *value)
1338 fprintf_filtered (file, _("\
1339 The directory where separate debug symbols are searched for is \"%s\".\n"),
1343 #if ! defined (DEBUG_SUBDIRECTORY)
1344 #define DEBUG_SUBDIRECTORY ".debug"
1348 find_separate_debug_file_by_debuglink (struct objfile *objfile)
1351 char *basename, *name_copy, *debugdir;
1353 char *debugfile = NULL;
1354 char *canon_name = NULL;
1355 bfd_size_type debuglink_size;
1356 unsigned long crc32;
1359 basename = get_debug_link_info (objfile, &crc32);
1361 if (basename == NULL)
1362 /* There's no separate debug info, hence there's no way we could
1363 load it => no warning. */
1364 goto cleanup_return_debugfile;
1366 dir = xstrdup (objfile->name);
1368 /* Strip off the final filename part, leaving the directory name,
1369 followed by a slash. Objfile names should always be absolute and
1370 tilde-expanded, so there should always be a slash in there
1372 for (i = strlen(dir) - 1; i >= 0; i--)
1374 if (IS_DIR_SEPARATOR (dir[i]))
1377 gdb_assert (i >= 0 && IS_DIR_SEPARATOR (dir[i]));
1380 /* Set I to max (strlen (canon_name), strlen (dir)). */
1381 canon_name = lrealpath (dir);
1383 if (canon_name && strlen (canon_name) > i)
1384 i = strlen (canon_name);
1386 debugfile = xmalloc (strlen (debug_file_directory) + 1
1388 + strlen (DEBUG_SUBDIRECTORY)
1393 /* First try in the same directory as the original file. */
1394 strcpy (debugfile, dir);
1395 strcat (debugfile, basename);
1397 if (separate_debug_file_exists (debugfile, crc32, objfile))
1398 goto cleanup_return_debugfile;
1400 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1401 strcpy (debugfile, dir);
1402 strcat (debugfile, DEBUG_SUBDIRECTORY);
1403 strcat (debugfile, "/");
1404 strcat (debugfile, basename);
1406 if (separate_debug_file_exists (debugfile, crc32, objfile))
1407 goto cleanup_return_debugfile;
1409 /* Then try in the global debugfile directories.
1411 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1412 cause "/..." lookups. */
1414 debugdir = debug_file_directory;
1419 while (*debugdir == DIRNAME_SEPARATOR)
1422 debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
1423 if (debugdir_end == NULL)
1424 debugdir_end = &debugdir[strlen (debugdir)];
1426 memcpy (debugfile, debugdir, debugdir_end - debugdir);
1427 debugfile[debugdir_end - debugdir] = 0;
1428 strcat (debugfile, "/");
1429 strcat (debugfile, dir);
1430 strcat (debugfile, basename);
1432 if (separate_debug_file_exists (debugfile, crc32, objfile))
1433 goto cleanup_return_debugfile;
1435 /* If the file is in the sysroot, try using its base path in the
1436 global debugfile directory. */
1438 && strncmp (canon_name, gdb_sysroot, strlen (gdb_sysroot)) == 0
1439 && IS_DIR_SEPARATOR (canon_name[strlen (gdb_sysroot)]))
1441 memcpy (debugfile, debugdir, debugdir_end - debugdir);
1442 debugfile[debugdir_end - debugdir] = 0;
1443 strcat (debugfile, canon_name + strlen (gdb_sysroot));
1444 strcat (debugfile, "/");
1445 strcat (debugfile, basename);
1447 if (separate_debug_file_exists (debugfile, crc32, objfile))
1448 goto cleanup_return_debugfile;
1451 debugdir = debugdir_end;
1453 while (*debugdir != 0);
1458 cleanup_return_debugfile:
1466 /* This is the symbol-file command. Read the file, analyze its
1467 symbols, and add a struct symtab to a symtab list. The syntax of
1468 the command is rather bizarre:
1470 1. The function buildargv implements various quoting conventions
1471 which are undocumented and have little or nothing in common with
1472 the way things are quoted (or not quoted) elsewhere in GDB.
1474 2. Options are used, which are not generally used in GDB (perhaps
1475 "set mapped on", "set readnow on" would be better)
1477 3. The order of options matters, which is contrary to GNU
1478 conventions (because it is confusing and inconvenient). */
1481 symbol_file_command (char *args, int from_tty)
1487 symbol_file_clear (from_tty);
1491 char **argv = gdb_buildargv (args);
1492 int flags = OBJF_USERLOADED;
1493 struct cleanup *cleanups;
1496 cleanups = make_cleanup_freeargv (argv);
1497 while (*argv != NULL)
1499 if (strcmp (*argv, "-readnow") == 0)
1500 flags |= OBJF_READNOW;
1501 else if (**argv == '-')
1502 error (_("unknown option `%s'"), *argv);
1505 symbol_file_add_main_1 (*argv, from_tty, flags);
1513 error (_("no symbol file name was specified"));
1515 do_cleanups (cleanups);
1519 /* Set the initial language.
1521 FIXME: A better solution would be to record the language in the
1522 psymtab when reading partial symbols, and then use it (if known) to
1523 set the language. This would be a win for formats that encode the
1524 language in an easily discoverable place, such as DWARF. For
1525 stabs, we can jump through hoops looking for specially named
1526 symbols or try to intuit the language from the specific type of
1527 stabs we find, but we can't do that until later when we read in
1531 set_initial_language (void)
1534 enum language lang = language_unknown;
1536 filename = find_main_filename ();
1537 if (filename != NULL)
1538 lang = deduce_language_from_filename (filename);
1540 if (lang == language_unknown)
1542 /* Make C the default language */
1546 set_language (lang);
1547 expected_language = current_language; /* Don't warn the user. */
1550 /* If NAME is a remote name open the file using remote protocol, otherwise
1551 open it normally. */
1554 bfd_open_maybe_remote (const char *name)
1556 if (remote_filename_p (name))
1557 return remote_bfd_open (name, gnutarget);
1559 return bfd_openr (name, gnutarget);
1563 /* Open the file specified by NAME and hand it off to BFD for
1564 preliminary analysis. Return a newly initialized bfd *, which
1565 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1566 absolute). In case of trouble, error() is called. */
1569 symfile_bfd_open (char *name)
1573 char *absolute_name;
1575 if (remote_filename_p (name))
1577 name = xstrdup (name);
1578 sym_bfd = remote_bfd_open (name, gnutarget);
1581 make_cleanup (xfree, name);
1582 error (_("`%s': can't open to read symbols: %s."), name,
1583 bfd_errmsg (bfd_get_error ()));
1586 if (!bfd_check_format (sym_bfd, bfd_object))
1588 bfd_close (sym_bfd);
1589 make_cleanup (xfree, name);
1590 error (_("`%s': can't read symbols: %s."), name,
1591 bfd_errmsg (bfd_get_error ()));
1597 name = tilde_expand (name); /* Returns 1st new malloc'd copy. */
1599 /* Look down path for it, allocate 2nd new malloc'd copy. */
1600 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, name,
1601 O_RDONLY | O_BINARY, &absolute_name);
1602 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1605 char *exename = alloca (strlen (name) + 5);
1606 strcat (strcpy (exename, name), ".exe");
1607 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
1608 O_RDONLY | O_BINARY, &absolute_name);
1613 make_cleanup (xfree, name);
1614 perror_with_name (name);
1617 /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
1618 bfd. It'll be freed in free_objfile(). */
1620 name = absolute_name;
1622 sym_bfd = bfd_fopen (name, gnutarget, FOPEN_RB, desc);
1626 make_cleanup (xfree, name);
1627 error (_("`%s': can't open to read symbols: %s."), name,
1628 bfd_errmsg (bfd_get_error ()));
1630 bfd_set_cacheable (sym_bfd, 1);
1632 if (!bfd_check_format (sym_bfd, bfd_object))
1634 /* FIXME: should be checking for errors from bfd_close (for one
1635 thing, on error it does not free all the storage associated
1637 bfd_close (sym_bfd); /* This also closes desc. */
1638 make_cleanup (xfree, name);
1639 error (_("`%s': can't read symbols: %s."), name,
1640 bfd_errmsg (bfd_get_error ()));
1643 /* bfd_usrdata exists for applications and libbfd must not touch it. */
1644 gdb_assert (bfd_usrdata (sym_bfd) == NULL);
1649 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1650 the section was not found. */
1653 get_section_index (struct objfile *objfile, char *section_name)
1655 asection *sect = bfd_get_section_by_name (objfile->obfd, section_name);
1663 /* Link SF into the global symtab_fns list. Called on startup by the
1664 _initialize routine in each object file format reader, to register
1665 information about each format the the reader is prepared to
1669 add_symtab_fns (struct sym_fns *sf)
1671 sf->next = symtab_fns;
1675 /* Initialize OBJFILE to read symbols from its associated BFD. It
1676 either returns or calls error(). The result is an initialized
1677 struct sym_fns in the objfile structure, that contains cached
1678 information about the symbol file. */
1680 static struct sym_fns *
1681 find_sym_fns (bfd *abfd)
1684 enum bfd_flavour our_flavour = bfd_get_flavour (abfd);
1686 if (our_flavour == bfd_target_srec_flavour
1687 || our_flavour == bfd_target_ihex_flavour
1688 || our_flavour == bfd_target_tekhex_flavour)
1689 return NULL; /* No symbols. */
1691 for (sf = symtab_fns; sf != NULL; sf = sf->next)
1692 if (our_flavour == sf->sym_flavour)
1695 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1696 bfd_get_target (abfd));
1700 /* This function runs the load command of our current target. */
1703 load_command (char *arg, int from_tty)
1705 /* The user might be reloading because the binary has changed. Take
1706 this opportunity to check. */
1707 reopen_exec_file ();
1715 parg = arg = get_exec_file (1);
1717 /* Count how many \ " ' tab space there are in the name. */
1718 while ((parg = strpbrk (parg, "\\\"'\t ")))
1726 /* We need to quote this string so buildargv can pull it apart. */
1727 char *temp = xmalloc (strlen (arg) + count + 1 );
1731 make_cleanup (xfree, temp);
1734 while ((parg = strpbrk (parg, "\\\"'\t ")))
1736 strncpy (ptemp, prev, parg - prev);
1737 ptemp += parg - prev;
1741 strcpy (ptemp, prev);
1747 target_load (arg, from_tty);
1749 /* After re-loading the executable, we don't really know which
1750 overlays are mapped any more. */
1751 overlay_cache_invalid = 1;
1754 /* This version of "load" should be usable for any target. Currently
1755 it is just used for remote targets, not inftarg.c or core files,
1756 on the theory that only in that case is it useful.
1758 Avoiding xmodem and the like seems like a win (a) because we don't have
1759 to worry about finding it, and (b) On VMS, fork() is very slow and so
1760 we don't want to run a subprocess. On the other hand, I'm not sure how
1761 performance compares. */
1763 static int validate_download = 0;
1765 /* Callback service function for generic_load (bfd_map_over_sections). */
1768 add_section_size_callback (bfd *abfd, asection *asec, void *data)
1770 bfd_size_type *sum = data;
1772 *sum += bfd_get_section_size (asec);
1775 /* Opaque data for load_section_callback. */
1776 struct load_section_data {
1777 unsigned long load_offset;
1778 struct load_progress_data *progress_data;
1779 VEC(memory_write_request_s) *requests;
1782 /* Opaque data for load_progress. */
1783 struct load_progress_data {
1784 /* Cumulative data. */
1785 unsigned long write_count;
1786 unsigned long data_count;
1787 bfd_size_type total_size;
1790 /* Opaque data for load_progress for a single section. */
1791 struct load_progress_section_data {
1792 struct load_progress_data *cumulative;
1794 /* Per-section data. */
1795 const char *section_name;
1796 ULONGEST section_sent;
1797 ULONGEST section_size;
1802 /* Target write callback routine for progress reporting. */
1805 load_progress (ULONGEST bytes, void *untyped_arg)
1807 struct load_progress_section_data *args = untyped_arg;
1808 struct load_progress_data *totals;
1811 /* Writing padding data. No easy way to get at the cumulative
1812 stats, so just ignore this. */
1815 totals = args->cumulative;
1817 if (bytes == 0 && args->section_sent == 0)
1819 /* The write is just starting. Let the user know we've started
1821 ui_out_message (uiout, 0, "Loading section %s, size %s lma %s\n",
1822 args->section_name, hex_string (args->section_size),
1823 paddress (target_gdbarch, args->lma));
1827 if (validate_download)
1829 /* Broken memories and broken monitors manifest themselves here
1830 when bring new computers to life. This doubles already slow
1832 /* NOTE: cagney/1999-10-18: A more efficient implementation
1833 might add a verify_memory() method to the target vector and
1834 then use that. remote.c could implement that method using
1835 the ``qCRC'' packet. */
1836 gdb_byte *check = xmalloc (bytes);
1837 struct cleanup *verify_cleanups = make_cleanup (xfree, check);
1839 if (target_read_memory (args->lma, check, bytes) != 0)
1840 error (_("Download verify read failed at %s"),
1841 paddress (target_gdbarch, args->lma));
1842 if (memcmp (args->buffer, check, bytes) != 0)
1843 error (_("Download verify compare failed at %s"),
1844 paddress (target_gdbarch, args->lma));
1845 do_cleanups (verify_cleanups);
1847 totals->data_count += bytes;
1849 args->buffer += bytes;
1850 totals->write_count += 1;
1851 args->section_sent += bytes;
1853 || (deprecated_ui_load_progress_hook != NULL
1854 && deprecated_ui_load_progress_hook (args->section_name,
1855 args->section_sent)))
1856 error (_("Canceled the download"));
1858 if (deprecated_show_load_progress != NULL)
1859 deprecated_show_load_progress (args->section_name,
1863 totals->total_size);
1866 /* Callback service function for generic_load (bfd_map_over_sections). */
1869 load_section_callback (bfd *abfd, asection *asec, void *data)
1871 struct memory_write_request *new_request;
1872 struct load_section_data *args = data;
1873 struct load_progress_section_data *section_data;
1874 bfd_size_type size = bfd_get_section_size (asec);
1876 const char *sect_name = bfd_get_section_name (abfd, asec);
1878 if ((bfd_get_section_flags (abfd, asec) & SEC_LOAD) == 0)
1884 new_request = VEC_safe_push (memory_write_request_s,
1885 args->requests, NULL);
1886 memset (new_request, 0, sizeof (struct memory_write_request));
1887 section_data = xcalloc (1, sizeof (struct load_progress_section_data));
1888 new_request->begin = bfd_section_lma (abfd, asec) + args->load_offset;
1889 new_request->end = new_request->begin + size; /* FIXME Should size be in instead? */
1890 new_request->data = xmalloc (size);
1891 new_request->baton = section_data;
1893 buffer = new_request->data;
1895 section_data->cumulative = args->progress_data;
1896 section_data->section_name = sect_name;
1897 section_data->section_size = size;
1898 section_data->lma = new_request->begin;
1899 section_data->buffer = buffer;
1901 bfd_get_section_contents (abfd, asec, buffer, 0, size);
1904 /* Clean up an entire memory request vector, including load
1905 data and progress records. */
1908 clear_memory_write_data (void *arg)
1910 VEC(memory_write_request_s) **vec_p = arg;
1911 VEC(memory_write_request_s) *vec = *vec_p;
1913 struct memory_write_request *mr;
1915 for (i = 0; VEC_iterate (memory_write_request_s, vec, i, mr); ++i)
1920 VEC_free (memory_write_request_s, vec);
1924 generic_load (char *args, int from_tty)
1927 struct timeval start_time, end_time;
1929 struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
1930 struct load_section_data cbdata;
1931 struct load_progress_data total_progress;
1936 memset (&cbdata, 0, sizeof (cbdata));
1937 memset (&total_progress, 0, sizeof (total_progress));
1938 cbdata.progress_data = &total_progress;
1940 make_cleanup (clear_memory_write_data, &cbdata.requests);
1943 error_no_arg (_("file to load"));
1945 argv = gdb_buildargv (args);
1946 make_cleanup_freeargv (argv);
1948 filename = tilde_expand (argv[0]);
1949 make_cleanup (xfree, filename);
1951 if (argv[1] != NULL)
1955 cbdata.load_offset = strtoul (argv[1], &endptr, 0);
1957 /* If the last word was not a valid number then
1958 treat it as a file name with spaces in. */
1959 if (argv[1] == endptr)
1960 error (_("Invalid download offset:%s."), argv[1]);
1962 if (argv[2] != NULL)
1963 error (_("Too many parameters."));
1966 /* Open the file for loading. */
1967 loadfile_bfd = bfd_openr (filename, gnutarget);
1968 if (loadfile_bfd == NULL)
1970 perror_with_name (filename);
1974 /* FIXME: should be checking for errors from bfd_close (for one thing,
1975 on error it does not free all the storage associated with the
1977 make_cleanup_bfd_close (loadfile_bfd);
1979 if (!bfd_check_format (loadfile_bfd, bfd_object))
1981 error (_("\"%s\" is not an object file: %s"), filename,
1982 bfd_errmsg (bfd_get_error ()));
1985 bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
1986 (void *) &total_progress.total_size);
1988 bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
1990 gettimeofday (&start_time, NULL);
1992 if (target_write_memory_blocks (cbdata.requests, flash_discard,
1993 load_progress) != 0)
1994 error (_("Load failed"));
1996 gettimeofday (&end_time, NULL);
1998 entry = bfd_get_start_address (loadfile_bfd);
1999 ui_out_text (uiout, "Start address ");
2000 ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch, entry));
2001 ui_out_text (uiout, ", load size ");
2002 ui_out_field_fmt (uiout, "load-size", "%lu", total_progress.data_count);
2003 ui_out_text (uiout, "\n");
2004 /* We were doing this in remote-mips.c, I suspect it is right
2005 for other targets too. */
2006 regcache_write_pc (get_current_regcache (), entry);
2008 /* Reset breakpoints, now that we have changed the load image. For
2009 instance, breakpoints may have been set (or reset, by
2010 post_create_inferior) while connected to the target but before we
2011 loaded the program. In that case, the prologue analyzer could
2012 have read instructions from the target to find the right
2013 breakpoint locations. Loading has changed the contents of that
2016 breakpoint_re_set ();
2018 /* FIXME: are we supposed to call symbol_file_add or not? According
2019 to a comment from remote-mips.c (where a call to symbol_file_add
2020 was commented out), making the call confuses GDB if more than one
2021 file is loaded in. Some targets do (e.g., remote-vx.c) but
2022 others don't (or didn't - perhaps they have all been deleted). */
2024 print_transfer_performance (gdb_stdout, total_progress.data_count,
2025 total_progress.write_count,
2026 &start_time, &end_time);
2028 do_cleanups (old_cleanups);
2031 /* Report how fast the transfer went. */
2033 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
2034 replaced by print_transfer_performance (with a very different
2035 function signature). */
2038 report_transfer_performance (unsigned long data_count, time_t start_time,
2041 struct timeval start, end;
2043 start.tv_sec = start_time;
2045 end.tv_sec = end_time;
2048 print_transfer_performance (gdb_stdout, data_count, 0, &start, &end);
2052 print_transfer_performance (struct ui_file *stream,
2053 unsigned long data_count,
2054 unsigned long write_count,
2055 const struct timeval *start_time,
2056 const struct timeval *end_time)
2058 ULONGEST time_count;
2060 /* Compute the elapsed time in milliseconds, as a tradeoff between
2061 accuracy and overflow. */
2062 time_count = (end_time->tv_sec - start_time->tv_sec) * 1000;
2063 time_count += (end_time->tv_usec - start_time->tv_usec) / 1000;
2065 ui_out_text (uiout, "Transfer rate: ");
2068 unsigned long rate = ((ULONGEST) data_count * 1000) / time_count;
2070 if (ui_out_is_mi_like_p (uiout))
2072 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate * 8);
2073 ui_out_text (uiout, " bits/sec");
2075 else if (rate < 1024)
2077 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate);
2078 ui_out_text (uiout, " bytes/sec");
2082 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate / 1024);
2083 ui_out_text (uiout, " KB/sec");
2088 ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8));
2089 ui_out_text (uiout, " bits in <1 sec");
2091 if (write_count > 0)
2093 ui_out_text (uiout, ", ");
2094 ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count);
2095 ui_out_text (uiout, " bytes/write");
2097 ui_out_text (uiout, ".\n");
2100 /* This function allows the addition of incrementally linked object files.
2101 It does not modify any state in the target, only in the debugger. */
2102 /* Note: ezannoni 2000-04-13 This function/command used to have a
2103 special case syntax for the rombug target (Rombug is the boot
2104 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2105 rombug case, the user doesn't need to supply a text address,
2106 instead a call to target_link() (in target.c) would supply the
2107 value to use. We are now discontinuing this type of ad hoc syntax. */
2110 add_symbol_file_command (char *args, int from_tty)
2112 struct gdbarch *gdbarch = get_current_arch ();
2113 char *filename = NULL;
2114 int flags = OBJF_USERLOADED;
2116 int expecting_option = 0;
2117 int section_index = 0;
2121 int expecting_sec_name = 0;
2122 int expecting_sec_addr = 0;
2131 struct section_addr_info *section_addrs;
2132 struct sect_opt *sect_opts = NULL;
2133 size_t num_sect_opts = 0;
2134 struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL);
2137 sect_opts = (struct sect_opt *) xmalloc (num_sect_opts
2138 * sizeof (struct sect_opt));
2143 error (_("add-symbol-file takes a file name and an address"));
2145 argv = gdb_buildargv (args);
2146 make_cleanup_freeargv (argv);
2148 for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt])
2150 /* Process the argument. */
2153 /* The first argument is the file name. */
2154 filename = tilde_expand (arg);
2155 make_cleanup (xfree, filename);
2160 /* The second argument is always the text address at which
2161 to load the program. */
2162 sect_opts[section_index].name = ".text";
2163 sect_opts[section_index].value = arg;
2164 if (++section_index >= num_sect_opts)
2167 sect_opts = ((struct sect_opt *)
2168 xrealloc (sect_opts,
2170 * sizeof (struct sect_opt)));
2175 /* It's an option (starting with '-') or it's an argument
2180 if (strcmp (arg, "-readnow") == 0)
2181 flags |= OBJF_READNOW;
2182 else if (strcmp (arg, "-s") == 0)
2184 expecting_sec_name = 1;
2185 expecting_sec_addr = 1;
2190 if (expecting_sec_name)
2192 sect_opts[section_index].name = arg;
2193 expecting_sec_name = 0;
2196 if (expecting_sec_addr)
2198 sect_opts[section_index].value = arg;
2199 expecting_sec_addr = 0;
2200 if (++section_index >= num_sect_opts)
2203 sect_opts = ((struct sect_opt *)
2204 xrealloc (sect_opts,
2206 * sizeof (struct sect_opt)));
2210 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
2215 /* This command takes at least two arguments. The first one is a
2216 filename, and the second is the address where this file has been
2217 loaded. Abort now if this address hasn't been provided by the
2219 if (section_index < 1)
2220 error (_("The address where %s has been loaded is missing"), filename);
2222 /* Print the prompt for the query below. And save the arguments into
2223 a sect_addr_info structure to be passed around to other
2224 functions. We have to split this up into separate print
2225 statements because hex_string returns a local static
2228 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename);
2229 section_addrs = alloc_section_addr_info (section_index);
2230 make_cleanup (xfree, section_addrs);
2231 for (i = 0; i < section_index; i++)
2234 char *val = sect_opts[i].value;
2235 char *sec = sect_opts[i].name;
2237 addr = parse_and_eval_address (val);
2239 /* Here we store the section offsets in the order they were
2240 entered on the command line. */
2241 section_addrs->other[sec_num].name = sec;
2242 section_addrs->other[sec_num].addr = addr;
2243 printf_unfiltered ("\t%s_addr = %s\n", sec,
2244 paddress (gdbarch, addr));
2247 /* The object's sections are initialized when a
2248 call is made to build_objfile_section_table (objfile).
2249 This happens in reread_symbols.
2250 At this point, we don't know what file type this is,
2251 so we can't determine what section names are valid. */
2254 if (from_tty && (!query ("%s", "")))
2255 error (_("Not confirmed."));
2257 symbol_file_add (filename, from_tty ? SYMFILE_VERBOSE : 0,
2258 section_addrs, flags);
2260 /* Getting new symbols may change our opinion about what is
2262 reinit_frame_cache ();
2263 do_cleanups (my_cleanups);
2267 /* Re-read symbols if a symbol-file has changed. */
2269 reread_symbols (void)
2271 struct objfile *objfile;
2274 struct stat new_statbuf;
2277 /* With the addition of shared libraries, this should be modified,
2278 the load time should be saved in the partial symbol tables, since
2279 different tables may come from different source files. FIXME.
2280 This routine should then walk down each partial symbol table
2281 and see if the symbol table that it originates from has been changed */
2283 for (objfile = object_files; objfile; objfile = objfile->next)
2285 /* solib-sunos.c creates one objfile with obfd. */
2286 if (objfile->obfd == NULL)
2289 /* Separate debug objfiles are handled in the main objfile. */
2290 if (objfile->separate_debug_objfile_backlink)
2293 /* If this object is from an archive (what you usually create with
2294 `ar', often called a `static library' on most systems, though
2295 a `shared library' on AIX is also an archive), then you should
2296 stat on the archive name, not member name. */
2297 if (objfile->obfd->my_archive)
2298 res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
2300 res = stat (objfile->name, &new_statbuf);
2303 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2304 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2308 new_modtime = new_statbuf.st_mtime;
2309 if (new_modtime != objfile->mtime)
2311 struct cleanup *old_cleanups;
2312 struct section_offsets *offsets;
2314 char *obfd_filename;
2316 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2319 /* There are various functions like symbol_file_add,
2320 symfile_bfd_open, syms_from_objfile, etc., which might
2321 appear to do what we want. But they have various other
2322 effects which we *don't* want. So we just do stuff
2323 ourselves. We don't worry about mapped files (for one thing,
2324 any mapped file will be out of date). */
2326 /* If we get an error, blow away this objfile (not sure if
2327 that is the correct response for things like shared
2329 old_cleanups = make_cleanup_free_objfile (objfile);
2330 /* We need to do this whenever any symbols go away. */
2331 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
2333 if (exec_bfd != NULL && strcmp (bfd_get_filename (objfile->obfd),
2334 bfd_get_filename (exec_bfd)) == 0)
2336 /* Reload EXEC_BFD without asking anything. */
2338 exec_file_attach (bfd_get_filename (objfile->obfd), 0);
2341 /* Clean up any state BFD has sitting around. We don't need
2342 to close the descriptor but BFD lacks a way of closing the
2343 BFD without closing the descriptor. */
2344 obfd_filename = bfd_get_filename (objfile->obfd);
2345 if (!bfd_close (objfile->obfd))
2346 error (_("Can't close BFD for %s: %s"), objfile->name,
2347 bfd_errmsg (bfd_get_error ()));
2348 objfile->obfd = bfd_open_maybe_remote (obfd_filename);
2349 if (objfile->obfd == NULL)
2350 error (_("Can't open %s to read symbols."), objfile->name);
2352 objfile->obfd = gdb_bfd_ref (objfile->obfd);
2353 /* bfd_openr sets cacheable to true, which is what we want. */
2354 if (!bfd_check_format (objfile->obfd, bfd_object))
2355 error (_("Can't read symbols from %s: %s."), objfile->name,
2356 bfd_errmsg (bfd_get_error ()));
2358 /* Save the offsets, we will nuke them with the rest of the
2360 num_offsets = objfile->num_sections;
2361 offsets = ((struct section_offsets *)
2362 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets)));
2363 memcpy (offsets, objfile->section_offsets,
2364 SIZEOF_N_SECTION_OFFSETS (num_offsets));
2366 /* Remove any references to this objfile in the global
2368 preserve_values (objfile);
2370 /* Nuke all the state that we will re-read. Much of the following
2371 code which sets things to NULL really is necessary to tell
2372 other parts of GDB that there is nothing currently there.
2374 Try to keep the freeing order compatible with free_objfile. */
2376 if (objfile->sf != NULL)
2378 (*objfile->sf->sym_finish) (objfile);
2381 clear_objfile_data (objfile);
2383 /* Free the separate debug objfiles. It will be
2384 automatically recreated by sym_read. */
2385 free_objfile_separate_debug (objfile);
2387 /* FIXME: Do we have to free a whole linked list, or is this
2389 if (objfile->global_psymbols.list)
2390 xfree (objfile->global_psymbols.list);
2391 memset (&objfile->global_psymbols, 0,
2392 sizeof (objfile->global_psymbols));
2393 if (objfile->static_psymbols.list)
2394 xfree (objfile->static_psymbols.list);
2395 memset (&objfile->static_psymbols, 0,
2396 sizeof (objfile->static_psymbols));
2398 /* Free the obstacks for non-reusable objfiles */
2399 bcache_xfree (objfile->psymbol_cache);
2400 objfile->psymbol_cache = bcache_xmalloc ();
2401 bcache_xfree (objfile->macro_cache);
2402 objfile->macro_cache = bcache_xmalloc ();
2403 bcache_xfree (objfile->filename_cache);
2404 objfile->filename_cache = bcache_xmalloc ();
2405 if (objfile->demangled_names_hash != NULL)
2407 htab_delete (objfile->demangled_names_hash);
2408 objfile->demangled_names_hash = NULL;
2410 obstack_free (&objfile->objfile_obstack, 0);
2411 objfile->sections = NULL;
2412 objfile->symtabs = NULL;
2413 objfile->psymtabs = NULL;
2414 objfile->psymtabs_addrmap = NULL;
2415 objfile->free_psymtabs = NULL;
2416 objfile->cp_namespace_symtab = NULL;
2417 objfile->msymbols = NULL;
2418 objfile->deprecated_sym_private = NULL;
2419 objfile->minimal_symbol_count = 0;
2420 memset (&objfile->msymbol_hash, 0,
2421 sizeof (objfile->msymbol_hash));
2422 memset (&objfile->msymbol_demangled_hash, 0,
2423 sizeof (objfile->msymbol_demangled_hash));
2425 objfile->psymbol_cache = bcache_xmalloc ();
2426 objfile->macro_cache = bcache_xmalloc ();
2427 objfile->filename_cache = bcache_xmalloc ();
2428 /* obstack_init also initializes the obstack so it is
2429 empty. We could use obstack_specify_allocation but
2430 gdb_obstack.h specifies the alloc/dealloc
2432 obstack_init (&objfile->objfile_obstack);
2433 if (build_objfile_section_table (objfile))
2435 error (_("Can't find the file sections in `%s': %s"),
2436 objfile->name, bfd_errmsg (bfd_get_error ()));
2438 terminate_minimal_symbol_table (objfile);
2440 /* We use the same section offsets as from last time. I'm not
2441 sure whether that is always correct for shared libraries. */
2442 objfile->section_offsets = (struct section_offsets *)
2443 obstack_alloc (&objfile->objfile_obstack,
2444 SIZEOF_N_SECTION_OFFSETS (num_offsets));
2445 memcpy (objfile->section_offsets, offsets,
2446 SIZEOF_N_SECTION_OFFSETS (num_offsets));
2447 objfile->num_sections = num_offsets;
2449 /* What the hell is sym_new_init for, anyway? The concept of
2450 distinguishing between the main file and additional files
2451 in this way seems rather dubious. */
2452 if (objfile == symfile_objfile)
2454 (*objfile->sf->sym_new_init) (objfile);
2457 (*objfile->sf->sym_init) (objfile);
2458 clear_complaints (&symfile_complaints, 1, 1);
2459 /* Do not set flags as this is safe and we don't want to be
2461 (*objfile->sf->sym_read) (objfile, 0);
2462 if (!objfile_has_symbols (objfile))
2465 printf_unfiltered (_("(no debugging symbols found)\n"));
2469 /* We're done reading the symbol file; finish off complaints. */
2470 clear_complaints (&symfile_complaints, 0, 1);
2472 /* Getting new symbols may change our opinion about what is
2475 reinit_frame_cache ();
2477 /* Discard cleanups as symbol reading was successful. */
2478 discard_cleanups (old_cleanups);
2480 /* If the mtime has changed between the time we set new_modtime
2481 and now, we *want* this to be out of date, so don't call stat
2483 objfile->mtime = new_modtime;
2485 init_entry_point_info (objfile);
2491 /* Notify objfiles that we've modified objfile sections. */
2492 objfiles_changed ();
2494 clear_symtab_users ();
2495 /* At least one objfile has changed, so we can consider that
2496 the executable we're debugging has changed too. */
2497 observer_notify_executable_changed ();
2510 static filename_language *filename_language_table;
2511 static int fl_table_size, fl_table_next;
2514 add_filename_language (char *ext, enum language lang)
2516 if (fl_table_next >= fl_table_size)
2518 fl_table_size += 10;
2519 filename_language_table =
2520 xrealloc (filename_language_table,
2521 fl_table_size * sizeof (*filename_language_table));
2524 filename_language_table[fl_table_next].ext = xstrdup (ext);
2525 filename_language_table[fl_table_next].lang = lang;
2529 static char *ext_args;
2531 show_ext_args (struct ui_file *file, int from_tty,
2532 struct cmd_list_element *c, const char *value)
2534 fprintf_filtered (file, _("\
2535 Mapping between filename extension and source language is \"%s\".\n"),
2540 set_ext_lang_command (char *args, int from_tty, struct cmd_list_element *e)
2543 char *cp = ext_args;
2546 /* First arg is filename extension, starting with '.' */
2548 error (_("'%s': Filename extension must begin with '.'"), ext_args);
2550 /* Find end of first arg. */
2551 while (*cp && !isspace (*cp))
2555 error (_("'%s': two arguments required -- filename extension and language"),
2558 /* Null-terminate first arg */
2561 /* Find beginning of second arg, which should be a source language. */
2562 while (*cp && isspace (*cp))
2566 error (_("'%s': two arguments required -- filename extension and language"),
2569 /* Lookup the language from among those we know. */
2570 lang = language_enum (cp);
2572 /* Now lookup the filename extension: do we already know it? */
2573 for (i = 0; i < fl_table_next; i++)
2574 if (0 == strcmp (ext_args, filename_language_table[i].ext))
2577 if (i >= fl_table_next)
2579 /* new file extension */
2580 add_filename_language (ext_args, lang);
2584 /* redefining a previously known filename extension */
2587 /* query ("Really make files of type %s '%s'?", */
2588 /* ext_args, language_str (lang)); */
2590 xfree (filename_language_table[i].ext);
2591 filename_language_table[i].ext = xstrdup (ext_args);
2592 filename_language_table[i].lang = lang;
2597 info_ext_lang_command (char *args, int from_tty)
2601 printf_filtered (_("Filename extensions and the languages they represent:"));
2602 printf_filtered ("\n\n");
2603 for (i = 0; i < fl_table_next; i++)
2604 printf_filtered ("\t%s\t- %s\n",
2605 filename_language_table[i].ext,
2606 language_str (filename_language_table[i].lang));
2610 init_filename_language_table (void)
2612 if (fl_table_size == 0) /* protect against repetition */
2616 filename_language_table =
2617 xmalloc (fl_table_size * sizeof (*filename_language_table));
2618 add_filename_language (".c", language_c);
2619 add_filename_language (".C", language_cplus);
2620 add_filename_language (".cc", language_cplus);
2621 add_filename_language (".cp", language_cplus);
2622 add_filename_language (".cpp", language_cplus);
2623 add_filename_language (".cxx", language_cplus);
2624 add_filename_language (".c++", language_cplus);
2625 add_filename_language (".java", language_java);
2626 add_filename_language (".class", language_java);
2627 add_filename_language (".m", language_objc);
2628 add_filename_language (".f", language_fortran);
2629 add_filename_language (".F", language_fortran);
2630 add_filename_language (".s", language_asm);
2631 add_filename_language (".sx", language_asm);
2632 add_filename_language (".S", language_asm);
2633 add_filename_language (".pas", language_pascal);
2634 add_filename_language (".p", language_pascal);
2635 add_filename_language (".pp", language_pascal);
2636 add_filename_language (".adb", language_ada);
2637 add_filename_language (".ads", language_ada);
2638 add_filename_language (".a", language_ada);
2639 add_filename_language (".ada", language_ada);
2640 add_filename_language (".dg", language_ada);
2645 deduce_language_from_filename (char *filename)
2650 if (filename != NULL)
2651 if ((cp = strrchr (filename, '.')) != NULL)
2652 for (i = 0; i < fl_table_next; i++)
2653 if (strcmp (cp, filename_language_table[i].ext) == 0)
2654 return filename_language_table[i].lang;
2656 return language_unknown;
2661 Allocate and partly initialize a new symbol table. Return a pointer
2662 to it. error() if no space.
2664 Caller must set these fields:
2673 allocate_symtab (char *filename, struct objfile *objfile)
2675 struct symtab *symtab;
2677 symtab = (struct symtab *)
2678 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symtab));
2679 memset (symtab, 0, sizeof (*symtab));
2680 symtab->filename = (char *) bcache (filename, strlen (filename) + 1,
2681 objfile->filename_cache);
2682 symtab->fullname = NULL;
2683 symtab->language = deduce_language_from_filename (filename);
2684 symtab->debugformat = "unknown";
2686 /* Hook it to the objfile it comes from */
2688 symtab->objfile = objfile;
2689 symtab->next = objfile->symtabs;
2690 objfile->symtabs = symtab;
2696 /* Reset all data structures in gdb which may contain references to symbol
2700 clear_symtab_users (void)
2702 /* Someday, we should do better than this, by only blowing away
2703 the things that really need to be blown. */
2705 /* Clear the "current" symtab first, because it is no longer valid.
2706 breakpoint_re_set may try to access the current symtab. */
2707 clear_current_source_symtab_and_line ();
2710 breakpoint_re_set ();
2711 set_default_breakpoint (0, NULL, 0, 0, 0);
2712 clear_pc_function_cache ();
2713 observer_notify_new_objfile (NULL);
2715 /* Clear globals which might have pointed into a removed objfile.
2716 FIXME: It's not clear which of these are supposed to persist
2717 between expressions and which ought to be reset each time. */
2718 expression_context_block = NULL;
2719 innermost_block = NULL;
2721 /* Varobj may refer to old symbols, perform a cleanup. */
2722 varobj_invalidate ();
2727 clear_symtab_users_cleanup (void *ignore)
2729 clear_symtab_users ();
2733 The following code implements an abstraction for debugging overlay sections.
2735 The target model is as follows:
2736 1) The gnu linker will permit multiple sections to be mapped into the
2737 same VMA, each with its own unique LMA (or load address).
2738 2) It is assumed that some runtime mechanism exists for mapping the
2739 sections, one by one, from the load address into the VMA address.
2740 3) This code provides a mechanism for gdb to keep track of which
2741 sections should be considered to be mapped from the VMA to the LMA.
2742 This information is used for symbol lookup, and memory read/write.
2743 For instance, if a section has been mapped then its contents
2744 should be read from the VMA, otherwise from the LMA.
2746 Two levels of debugger support for overlays are available. One is
2747 "manual", in which the debugger relies on the user to tell it which
2748 overlays are currently mapped. This level of support is
2749 implemented entirely in the core debugger, and the information about
2750 whether a section is mapped is kept in the objfile->obj_section table.
2752 The second level of support is "automatic", and is only available if
2753 the target-specific code provides functionality to read the target's
2754 overlay mapping table, and translate its contents for the debugger
2755 (by updating the mapped state information in the obj_section tables).
2757 The interface is as follows:
2759 overlay map <name> -- tell gdb to consider this section mapped
2760 overlay unmap <name> -- tell gdb to consider this section unmapped
2761 overlay list -- list the sections that GDB thinks are mapped
2762 overlay read-target -- get the target's state of what's mapped
2763 overlay off/manual/auto -- set overlay debugging state
2764 Functional interface:
2765 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2766 section, return that section.
2767 find_pc_overlay(pc): find any overlay section that contains
2768 the pc, either in its VMA or its LMA
2769 section_is_mapped(sect): true if overlay is marked as mapped
2770 section_is_overlay(sect): true if section's VMA != LMA
2771 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2772 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2773 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2774 overlay_mapped_address(...): map an address from section's LMA to VMA
2775 overlay_unmapped_address(...): map an address from section's VMA to LMA
2776 symbol_overlayed_address(...): Return a "current" address for symbol:
2777 either in VMA or LMA depending on whether
2778 the symbol's section is currently mapped
2781 /* Overlay debugging state: */
2783 enum overlay_debugging_state overlay_debugging = ovly_off;
2784 int overlay_cache_invalid = 0; /* True if need to refresh mapped state */
2786 /* Function: section_is_overlay (SECTION)
2787 Returns true if SECTION has VMA not equal to LMA, ie.
2788 SECTION is loaded at an address different from where it will "run". */
2791 section_is_overlay (struct obj_section *section)
2793 if (overlay_debugging && section)
2795 bfd *abfd = section->objfile->obfd;
2796 asection *bfd_section = section->the_bfd_section;
2798 if (bfd_section_lma (abfd, bfd_section) != 0
2799 && bfd_section_lma (abfd, bfd_section)
2800 != bfd_section_vma (abfd, bfd_section))
2807 /* Function: overlay_invalidate_all (void)
2808 Invalidate the mapped state of all overlay sections (mark it as stale). */
2811 overlay_invalidate_all (void)
2813 struct objfile *objfile;
2814 struct obj_section *sect;
2816 ALL_OBJSECTIONS (objfile, sect)
2817 if (section_is_overlay (sect))
2818 sect->ovly_mapped = -1;
2821 /* Function: section_is_mapped (SECTION)
2822 Returns true if section is an overlay, and is currently mapped.
2824 Access to the ovly_mapped flag is restricted to this function, so
2825 that we can do automatic update. If the global flag
2826 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2827 overlay_invalidate_all. If the mapped state of the particular
2828 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2831 section_is_mapped (struct obj_section *osect)
2833 struct gdbarch *gdbarch;
2835 if (osect == 0 || !section_is_overlay (osect))
2838 switch (overlay_debugging)
2842 return 0; /* overlay debugging off */
2843 case ovly_auto: /* overlay debugging automatic */
2844 /* Unles there is a gdbarch_overlay_update function,
2845 there's really nothing useful to do here (can't really go auto) */
2846 gdbarch = get_objfile_arch (osect->objfile);
2847 if (gdbarch_overlay_update_p (gdbarch))
2849 if (overlay_cache_invalid)
2851 overlay_invalidate_all ();
2852 overlay_cache_invalid = 0;
2854 if (osect->ovly_mapped == -1)
2855 gdbarch_overlay_update (gdbarch, osect);
2857 /* fall thru to manual case */
2858 case ovly_on: /* overlay debugging manual */
2859 return osect->ovly_mapped == 1;
2863 /* Function: pc_in_unmapped_range
2864 If PC falls into the lma range of SECTION, return true, else false. */
2867 pc_in_unmapped_range (CORE_ADDR pc, struct obj_section *section)
2869 if (section_is_overlay (section))
2871 bfd *abfd = section->objfile->obfd;
2872 asection *bfd_section = section->the_bfd_section;
2874 /* We assume the LMA is relocated by the same offset as the VMA. */
2875 bfd_vma size = bfd_get_section_size (bfd_section);
2876 CORE_ADDR offset = obj_section_offset (section);
2878 if (bfd_get_section_lma (abfd, bfd_section) + offset <= pc
2879 && pc < bfd_get_section_lma (abfd, bfd_section) + offset + size)
2886 /* Function: pc_in_mapped_range
2887 If PC falls into the vma range of SECTION, return true, else false. */
2890 pc_in_mapped_range (CORE_ADDR pc, struct obj_section *section)
2892 if (section_is_overlay (section))
2894 if (obj_section_addr (section) <= pc
2895 && pc < obj_section_endaddr (section))
2903 /* Return true if the mapped ranges of sections A and B overlap, false
2906 sections_overlap (struct obj_section *a, struct obj_section *b)
2908 CORE_ADDR a_start = obj_section_addr (a);
2909 CORE_ADDR a_end = obj_section_endaddr (a);
2910 CORE_ADDR b_start = obj_section_addr (b);
2911 CORE_ADDR b_end = obj_section_endaddr (b);
2913 return (a_start < b_end && b_start < a_end);
2916 /* Function: overlay_unmapped_address (PC, SECTION)
2917 Returns the address corresponding to PC in the unmapped (load) range.
2918 May be the same as PC. */
2921 overlay_unmapped_address (CORE_ADDR pc, struct obj_section *section)
2923 if (section_is_overlay (section) && pc_in_mapped_range (pc, section))
2925 bfd *abfd = section->objfile->obfd;
2926 asection *bfd_section = section->the_bfd_section;
2928 return pc + bfd_section_lma (abfd, bfd_section)
2929 - bfd_section_vma (abfd, bfd_section);
2935 /* Function: overlay_mapped_address (PC, SECTION)
2936 Returns the address corresponding to PC in the mapped (runtime) range.
2937 May be the same as PC. */
2940 overlay_mapped_address (CORE_ADDR pc, struct obj_section *section)
2942 if (section_is_overlay (section) && pc_in_unmapped_range (pc, section))
2944 bfd *abfd = section->objfile->obfd;
2945 asection *bfd_section = section->the_bfd_section;
2947 return pc + bfd_section_vma (abfd, bfd_section)
2948 - bfd_section_lma (abfd, bfd_section);
2955 /* Function: symbol_overlayed_address
2956 Return one of two addresses (relative to the VMA or to the LMA),
2957 depending on whether the section is mapped or not. */
2960 symbol_overlayed_address (CORE_ADDR address, struct obj_section *section)
2962 if (overlay_debugging)
2964 /* If the symbol has no section, just return its regular address. */
2967 /* If the symbol's section is not an overlay, just return its address */
2968 if (!section_is_overlay (section))
2970 /* If the symbol's section is mapped, just return its address */
2971 if (section_is_mapped (section))
2974 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
2975 * then return its LOADED address rather than its vma address!!
2977 return overlay_unmapped_address (address, section);
2982 /* Function: find_pc_overlay (PC)
2983 Return the best-match overlay section for PC:
2984 If PC matches a mapped overlay section's VMA, return that section.
2985 Else if PC matches an unmapped section's VMA, return that section.
2986 Else if PC matches an unmapped section's LMA, return that section. */
2988 struct obj_section *
2989 find_pc_overlay (CORE_ADDR pc)
2991 struct objfile *objfile;
2992 struct obj_section *osect, *best_match = NULL;
2994 if (overlay_debugging)
2995 ALL_OBJSECTIONS (objfile, osect)
2996 if (section_is_overlay (osect))
2998 if (pc_in_mapped_range (pc, osect))
3000 if (section_is_mapped (osect))
3005 else if (pc_in_unmapped_range (pc, osect))
3011 /* Function: find_pc_mapped_section (PC)
3012 If PC falls into the VMA address range of an overlay section that is
3013 currently marked as MAPPED, return that section. Else return NULL. */
3015 struct obj_section *
3016 find_pc_mapped_section (CORE_ADDR pc)
3018 struct objfile *objfile;
3019 struct obj_section *osect;
3021 if (overlay_debugging)
3022 ALL_OBJSECTIONS (objfile, osect)
3023 if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
3029 /* Function: list_overlays_command
3030 Print a list of mapped sections and their PC ranges */
3033 list_overlays_command (char *args, int from_tty)
3036 struct objfile *objfile;
3037 struct obj_section *osect;
3039 if (overlay_debugging)
3040 ALL_OBJSECTIONS (objfile, osect)
3041 if (section_is_mapped (osect))
3043 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3048 vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
3049 lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
3050 size = bfd_get_section_size (osect->the_bfd_section);
3051 name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
3053 printf_filtered ("Section %s, loaded at ", name);
3054 fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
3055 puts_filtered (" - ");
3056 fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
3057 printf_filtered (", mapped at ");
3058 fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
3059 puts_filtered (" - ");
3060 fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
3061 puts_filtered ("\n");
3066 printf_filtered (_("No sections are mapped.\n"));
3069 /* Function: map_overlay_command
3070 Mark the named section as mapped (ie. residing at its VMA address). */
3073 map_overlay_command (char *args, int from_tty)
3075 struct objfile *objfile, *objfile2;
3076 struct obj_section *sec, *sec2;
3078 if (!overlay_debugging)
3080 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3081 the 'overlay manual' command."));
3083 if (args == 0 || *args == 0)
3084 error (_("Argument required: name of an overlay section"));
3086 /* First, find a section matching the user supplied argument */
3087 ALL_OBJSECTIONS (objfile, sec)
3088 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
3090 /* Now, check to see if the section is an overlay. */
3091 if (!section_is_overlay (sec))
3092 continue; /* not an overlay section */
3094 /* Mark the overlay as "mapped" */
3095 sec->ovly_mapped = 1;
3097 /* Next, make a pass and unmap any sections that are
3098 overlapped by this new section: */
3099 ALL_OBJSECTIONS (objfile2, sec2)
3100 if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec, sec2))
3103 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3104 bfd_section_name (objfile->obfd,
3105 sec2->the_bfd_section));
3106 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2 */
3110 error (_("No overlay section called %s"), args);
3113 /* Function: unmap_overlay_command
3114 Mark the overlay section as unmapped
3115 (ie. resident in its LMA address range, rather than the VMA range). */
3118 unmap_overlay_command (char *args, int from_tty)
3120 struct objfile *objfile;
3121 struct obj_section *sec;
3123 if (!overlay_debugging)
3125 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3126 the 'overlay manual' command."));
3128 if (args == 0 || *args == 0)
3129 error (_("Argument required: name of an overlay section"));
3131 /* First, find a section matching the user supplied argument */
3132 ALL_OBJSECTIONS (objfile, sec)
3133 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
3135 if (!sec->ovly_mapped)
3136 error (_("Section %s is not mapped"), args);
3137 sec->ovly_mapped = 0;
3140 error (_("No overlay section called %s"), args);
3143 /* Function: overlay_auto_command
3144 A utility command to turn on overlay debugging.
3145 Possibly this should be done via a set/show command. */
3148 overlay_auto_command (char *args, int from_tty)
3150 overlay_debugging = ovly_auto;
3151 enable_overlay_breakpoints ();
3153 printf_unfiltered (_("Automatic overlay debugging enabled."));
3156 /* Function: overlay_manual_command
3157 A utility command to turn on overlay debugging.
3158 Possibly this should be done via a set/show command. */
3161 overlay_manual_command (char *args, int from_tty)
3163 overlay_debugging = ovly_on;
3164 disable_overlay_breakpoints ();
3166 printf_unfiltered (_("Overlay debugging enabled."));
3169 /* Function: overlay_off_command
3170 A utility command to turn on overlay debugging.
3171 Possibly this should be done via a set/show command. */
3174 overlay_off_command (char *args, int from_tty)
3176 overlay_debugging = ovly_off;
3177 disable_overlay_breakpoints ();
3179 printf_unfiltered (_("Overlay debugging disabled."));
3183 overlay_load_command (char *args, int from_tty)
3185 struct gdbarch *gdbarch = get_current_arch ();
3187 if (gdbarch_overlay_update_p (gdbarch))
3188 gdbarch_overlay_update (gdbarch, NULL);
3190 error (_("This target does not know how to read its overlay state."));
3193 /* Function: overlay_command
3194 A place-holder for a mis-typed command */
3196 /* Command list chain containing all defined "overlay" subcommands. */
3197 struct cmd_list_element *overlaylist;
3200 overlay_command (char *args, int from_tty)
3203 ("\"overlay\" must be followed by the name of an overlay command.\n");
3204 help_list (overlaylist, "overlay ", -1, gdb_stdout);
3208 /* Target Overlays for the "Simplest" overlay manager:
3210 This is GDB's default target overlay layer. It works with the
3211 minimal overlay manager supplied as an example by Cygnus. The
3212 entry point is via a function pointer "gdbarch_overlay_update",
3213 so targets that use a different runtime overlay manager can
3214 substitute their own overlay_update function and take over the
3217 The overlay_update function pokes around in the target's data structures
3218 to see what overlays are mapped, and updates GDB's overlay mapping with
3221 In this simple implementation, the target data structures are as follows:
3222 unsigned _novlys; /# number of overlay sections #/
3223 unsigned _ovly_table[_novlys][4] = {
3224 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3225 {..., ..., ..., ...},
3227 unsigned _novly_regions; /# number of overlay regions #/
3228 unsigned _ovly_region_table[_novly_regions][3] = {
3229 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3232 These functions will attempt to update GDB's mappedness state in the
3233 symbol section table, based on the target's mappedness state.
3235 To do this, we keep a cached copy of the target's _ovly_table, and
3236 attempt to detect when the cached copy is invalidated. The main
3237 entry point is "simple_overlay_update(SECT), which looks up SECT in
3238 the cached table and re-reads only the entry for that section from
3239 the target (whenever possible).
3242 /* Cached, dynamically allocated copies of the target data structures: */
3243 static unsigned (*cache_ovly_table)[4] = 0;
3245 static unsigned (*cache_ovly_region_table)[3] = 0;
3247 static unsigned cache_novlys = 0;
3249 static unsigned cache_novly_regions = 0;
3251 static CORE_ADDR cache_ovly_table_base = 0;
3253 static CORE_ADDR cache_ovly_region_table_base = 0;
3257 VMA, SIZE, LMA, MAPPED
3260 /* Throw away the cached copy of _ovly_table */
3262 simple_free_overlay_table (void)
3264 if (cache_ovly_table)
3265 xfree (cache_ovly_table);
3267 cache_ovly_table = NULL;
3268 cache_ovly_table_base = 0;
3272 /* Throw away the cached copy of _ovly_region_table */
3274 simple_free_overlay_region_table (void)
3276 if (cache_ovly_region_table)
3277 xfree (cache_ovly_region_table);
3278 cache_novly_regions = 0;
3279 cache_ovly_region_table = NULL;
3280 cache_ovly_region_table_base = 0;
3284 /* Read an array of ints of size SIZE from the target into a local buffer.
3285 Convert to host order. int LEN is number of ints */
3287 read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr,
3288 int len, int size, enum bfd_endian byte_order)
3290 /* FIXME (alloca): Not safe if array is very large. */
3291 gdb_byte *buf = alloca (len * size);
3294 read_memory (memaddr, buf, len * size);
3295 for (i = 0; i < len; i++)
3296 myaddr[i] = extract_unsigned_integer (size * i + buf, size, byte_order);
3299 /* Find and grab a copy of the target _ovly_table
3300 (and _novlys, which is needed for the table's size) */
3302 simple_read_overlay_table (void)
3304 struct minimal_symbol *novlys_msym, *ovly_table_msym;
3305 struct gdbarch *gdbarch;
3307 enum bfd_endian byte_order;
3309 simple_free_overlay_table ();
3310 novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
3313 error (_("Error reading inferior's overlay table: "
3314 "couldn't find `_novlys' variable\n"
3315 "in inferior. Use `overlay manual' mode."));
3319 ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
3320 if (! ovly_table_msym)
3322 error (_("Error reading inferior's overlay table: couldn't find "
3323 "`_ovly_table' array\n"
3324 "in inferior. Use `overlay manual' mode."));
3328 gdbarch = get_objfile_arch (msymbol_objfile (ovly_table_msym));
3329 word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3330 byte_order = gdbarch_byte_order (gdbarch);
3332 cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym),
3335 = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
3336 cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
3337 read_target_long_array (cache_ovly_table_base,
3338 (unsigned int *) cache_ovly_table,
3339 cache_novlys * 4, word_size, byte_order);
3341 return 1; /* SUCCESS */
3345 /* Find and grab a copy of the target _ovly_region_table
3346 (and _novly_regions, which is needed for the table's size) */
3348 simple_read_overlay_region_table (void)
3350 struct minimal_symbol *msym;
3351 struct gdbarch *gdbarch;
3353 enum bfd_endian byte_order;
3355 simple_free_overlay_region_table ();
3356 msym = lookup_minimal_symbol ("_novly_regions", NULL, NULL);
3358 return 0; /* failure */
3360 gdbarch = get_objfile_arch (msymbol_objfile (msym));
3361 word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3362 byte_order = gdbarch_byte_order (gdbarch);
3364 cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym),
3367 cache_ovly_region_table = (void *) xmalloc (cache_novly_regions * 12);
3368 if (cache_ovly_region_table != NULL)
3370 msym = lookup_minimal_symbol ("_ovly_region_table", NULL, NULL);
3373 cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym);
3374 read_target_long_array (cache_ovly_region_table_base,
3375 (unsigned int *) cache_ovly_region_table,
3376 cache_novly_regions * 3,
3377 word_size, byte_order);
3380 return 0; /* failure */
3383 return 0; /* failure */
3384 return 1; /* SUCCESS */
3388 /* Function: simple_overlay_update_1
3389 A helper function for simple_overlay_update. Assuming a cached copy
3390 of _ovly_table exists, look through it to find an entry whose vma,
3391 lma and size match those of OSECT. Re-read the entry and make sure
3392 it still matches OSECT (else the table may no longer be valid).
3393 Set OSECT's mapped state to match the entry. Return: 1 for
3394 success, 0 for failure. */
3397 simple_overlay_update_1 (struct obj_section *osect)
3400 bfd *obfd = osect->objfile->obfd;
3401 asection *bsect = osect->the_bfd_section;
3402 struct gdbarch *gdbarch = get_objfile_arch (osect->objfile);
3403 int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3404 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3406 size = bfd_get_section_size (osect->the_bfd_section);
3407 for (i = 0; i < cache_novlys; i++)
3408 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3409 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3410 /* && cache_ovly_table[i][SIZE] == size */ )
3412 read_target_long_array (cache_ovly_table_base + i * word_size,
3413 (unsigned int *) cache_ovly_table[i],
3414 4, word_size, byte_order);
3415 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3416 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3417 /* && cache_ovly_table[i][SIZE] == size */ )
3419 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3422 else /* Warning! Warning! Target's ovly table has changed! */
3428 /* Function: simple_overlay_update
3429 If OSECT is NULL, then update all sections' mapped state
3430 (after re-reading the entire target _ovly_table).
3431 If OSECT is non-NULL, then try to find a matching entry in the
3432 cached ovly_table and update only OSECT's mapped state.
3433 If a cached entry can't be found or the cache isn't valid, then
3434 re-read the entire cache, and go ahead and update all sections. */
3437 simple_overlay_update (struct obj_section *osect)
3439 struct objfile *objfile;
3441 /* Were we given an osect to look up? NULL means do all of them. */
3443 /* Have we got a cached copy of the target's overlay table? */
3444 if (cache_ovly_table != NULL)
3445 /* Does its cached location match what's currently in the symtab? */
3446 if (cache_ovly_table_base ==
3447 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL, NULL)))
3448 /* Then go ahead and try to look up this single section in the cache */
3449 if (simple_overlay_update_1 (osect))
3450 /* Found it! We're done. */
3453 /* Cached table no good: need to read the entire table anew.
3454 Or else we want all the sections, in which case it's actually
3455 more efficient to read the whole table in one block anyway. */
3457 if (! simple_read_overlay_table ())
3460 /* Now may as well update all sections, even if only one was requested. */
3461 ALL_OBJSECTIONS (objfile, osect)
3462 if (section_is_overlay (osect))
3465 bfd *obfd = osect->objfile->obfd;
3466 asection *bsect = osect->the_bfd_section;
3468 size = bfd_get_section_size (bsect);
3469 for (i = 0; i < cache_novlys; i++)
3470 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3471 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3472 /* && cache_ovly_table[i][SIZE] == size */ )
3473 { /* obj_section matches i'th entry in ovly_table */
3474 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3475 break; /* finished with inner for loop: break out */
3480 /* Set the output sections and output offsets for section SECTP in
3481 ABFD. The relocation code in BFD will read these offsets, so we
3482 need to be sure they're initialized. We map each section to itself,
3483 with no offset; this means that SECTP->vma will be honored. */
3486 symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy)
3488 sectp->output_section = sectp;
3489 sectp->output_offset = 0;
3492 /* Default implementation for sym_relocate. */
3496 default_symfile_relocate (struct objfile *objfile, asection *sectp,
3499 bfd *abfd = objfile->obfd;
3501 /* We're only interested in sections with relocation
3503 if ((sectp->flags & SEC_RELOC) == 0)
3506 /* We will handle section offsets properly elsewhere, so relocate as if
3507 all sections begin at 0. */
3508 bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL);
3510 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
3513 /* Relocate the contents of a debug section SECTP in ABFD. The
3514 contents are stored in BUF if it is non-NULL, or returned in a
3515 malloc'd buffer otherwise.
3517 For some platforms and debug info formats, shared libraries contain
3518 relocations against the debug sections (particularly for DWARF-2;
3519 one affected platform is PowerPC GNU/Linux, although it depends on
3520 the version of the linker in use). Also, ELF object files naturally
3521 have unresolved relocations for their debug sections. We need to apply
3522 the relocations in order to get the locations of symbols correct.
3523 Another example that may require relocation processing, is the
3524 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3528 symfile_relocate_debug_section (struct objfile *objfile,
3529 asection *sectp, bfd_byte *buf)
3531 gdb_assert (objfile->sf->sym_relocate);
3533 return (*objfile->sf->sym_relocate) (objfile, sectp, buf);
3536 struct symfile_segment_data *
3537 get_symfile_segment_data (bfd *abfd)
3539 struct sym_fns *sf = find_sym_fns (abfd);
3544 return sf->sym_segments (abfd);
3548 free_symfile_segment_data (struct symfile_segment_data *data)
3550 xfree (data->segment_bases);
3551 xfree (data->segment_sizes);
3552 xfree (data->segment_info);
3558 - DATA, containing segment addresses from the object file ABFD, and
3559 the mapping from ABFD's sections onto the segments that own them,
3561 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3562 segment addresses reported by the target,
3563 store the appropriate offsets for each section in OFFSETS.
3565 If there are fewer entries in SEGMENT_BASES than there are segments
3566 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3568 If there are more entries, then ignore the extra. The target may
3569 not be able to distinguish between an empty data segment and a
3570 missing data segment; a missing text segment is less plausible. */
3572 symfile_map_offsets_to_segments (bfd *abfd, struct symfile_segment_data *data,
3573 struct section_offsets *offsets,
3574 int num_segment_bases,
3575 const CORE_ADDR *segment_bases)
3580 /* It doesn't make sense to call this function unless you have some
3581 segment base addresses. */
3582 gdb_assert (num_segment_bases > 0);
3584 /* If we do not have segment mappings for the object file, we
3585 can not relocate it by segments. */
3586 gdb_assert (data != NULL);
3587 gdb_assert (data->num_segments > 0);
3589 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3591 int which = data->segment_info[i];
3593 gdb_assert (0 <= which && which <= data->num_segments);
3595 /* Don't bother computing offsets for sections that aren't
3596 loaded as part of any segment. */
3600 /* Use the last SEGMENT_BASES entry as the address of any extra
3601 segments mentioned in DATA->segment_info. */
3602 if (which > num_segment_bases)
3603 which = num_segment_bases;
3605 offsets->offsets[i] = (segment_bases[which - 1]
3606 - data->segment_bases[which - 1]);
3613 symfile_find_segment_sections (struct objfile *objfile)
3615 bfd *abfd = objfile->obfd;
3618 struct symfile_segment_data *data;
3620 data = get_symfile_segment_data (objfile->obfd);
3624 if (data->num_segments != 1 && data->num_segments != 2)
3626 free_symfile_segment_data (data);
3630 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3633 int which = data->segment_info[i];
3637 if (objfile->sect_index_text == -1)
3638 objfile->sect_index_text = sect->index;
3640 if (objfile->sect_index_rodata == -1)
3641 objfile->sect_index_rodata = sect->index;
3643 else if (which == 2)
3645 if (objfile->sect_index_data == -1)
3646 objfile->sect_index_data = sect->index;
3648 if (objfile->sect_index_bss == -1)
3649 objfile->sect_index_bss = sect->index;
3653 free_symfile_segment_data (data);
3657 _initialize_symfile (void)
3659 struct cmd_list_element *c;
3661 c = add_cmd ("symbol-file", class_files, symbol_file_command, _("\
3662 Load symbol table from executable file FILE.\n\
3663 The `file' command can also load symbol tables, as well as setting the file\n\
3664 to execute."), &cmdlist);
3665 set_cmd_completer (c, filename_completer);
3667 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\
3668 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3669 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3670 ADDR is the starting address of the file's text.\n\
3671 The optional arguments are section-name section-address pairs and\n\
3672 should be specified if the data and bss segments are not contiguous\n\
3673 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3675 set_cmd_completer (c, filename_completer);
3677 c = add_cmd ("load", class_files, load_command, _("\
3678 Dynamically load FILE into the running program, and record its symbols\n\
3679 for access from GDB.\n\
3680 A load OFFSET may also be given."), &cmdlist);
3681 set_cmd_completer (c, filename_completer);
3683 add_setshow_boolean_cmd ("symbol-reloading", class_support,
3684 &symbol_reloading, _("\
3685 Set dynamic symbol table reloading multiple times in one run."), _("\
3686 Show dynamic symbol table reloading multiple times in one run."), NULL,
3688 show_symbol_reloading,
3689 &setlist, &showlist);
3691 add_prefix_cmd ("overlay", class_support, overlay_command,
3692 _("Commands for debugging overlays."), &overlaylist,
3693 "overlay ", 0, &cmdlist);
3695 add_com_alias ("ovly", "overlay", class_alias, 1);
3696 add_com_alias ("ov", "overlay", class_alias, 1);
3698 add_cmd ("map-overlay", class_support, map_overlay_command,
3699 _("Assert that an overlay section is mapped."), &overlaylist);
3701 add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
3702 _("Assert that an overlay section is unmapped."), &overlaylist);
3704 add_cmd ("list-overlays", class_support, list_overlays_command,
3705 _("List mappings of overlay sections."), &overlaylist);
3707 add_cmd ("manual", class_support, overlay_manual_command,
3708 _("Enable overlay debugging."), &overlaylist);
3709 add_cmd ("off", class_support, overlay_off_command,
3710 _("Disable overlay debugging."), &overlaylist);
3711 add_cmd ("auto", class_support, overlay_auto_command,
3712 _("Enable automatic overlay debugging."), &overlaylist);
3713 add_cmd ("load-target", class_support, overlay_load_command,
3714 _("Read the overlay mapping state from the target."), &overlaylist);
3716 /* Filename extension to source language lookup table: */
3717 init_filename_language_table ();
3718 add_setshow_string_noescape_cmd ("extension-language", class_files,
3720 Set mapping between filename extension and source language."), _("\
3721 Show mapping between filename extension and source language."), _("\
3722 Usage: set extension-language .foo bar"),
3723 set_ext_lang_command,
3725 &setlist, &showlist);
3727 add_info ("extensions", info_ext_lang_command,
3728 _("All filename extensions associated with a source language."));
3730 add_setshow_optional_filename_cmd ("debug-file-directory", class_support,
3731 &debug_file_directory, _("\
3732 Set the directories where separate debug symbols are searched for."), _("\
3733 Show the directories where separate debug symbols are searched for."), _("\
3734 Separate debug symbols are first searched for in the same\n\
3735 directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\
3736 and lastly at the path of the directory of the binary with\n\
3737 each global debug-file-directory component prepended."),
3739 show_debug_file_directory,
3740 &setlist, &showlist);