1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
35 #include "breakpoint.h"
37 #include "complaints.h"
41 #include "filenames.h" /* for DOSish file names */
42 #include "gdb-stabs.h"
43 #include "gdb_obstack.h"
44 #include "completer.h"
47 #include "readline/readline.h"
48 #include "gdb_assert.h"
52 #include "parser-defs.h"
59 #include "cli/cli-utils.h"
61 #include <sys/types.h>
71 int (*deprecated_ui_load_progress_hook
) (const char *section
,
73 void (*deprecated_show_load_progress
) (const char *section
,
74 unsigned long section_sent
,
75 unsigned long section_size
,
76 unsigned long total_sent
,
77 unsigned long total_size
);
78 void (*deprecated_pre_add_symbol_hook
) (const char *);
79 void (*deprecated_post_add_symbol_hook
) (void);
81 static void clear_symtab_users_cleanup (void *ignore
);
83 /* Global variables owned by this file. */
84 int readnow_symbol_files
; /* Read full symbols immediately. */
86 /* Functions this file defines. */
88 static void load_command (char *, int);
90 static void symbol_file_add_main_1 (const char *args
, int from_tty
, int flags
);
92 static void add_symbol_file_command (char *, int);
94 static const struct sym_fns
*find_sym_fns (bfd
*);
96 static void decrement_reading_symtab (void *);
98 static void overlay_invalidate_all (void);
100 static void overlay_auto_command (char *, int);
102 static void overlay_manual_command (char *, int);
104 static void overlay_off_command (char *, int);
106 static void overlay_load_command (char *, int);
108 static void overlay_command (char *, int);
110 static void simple_free_overlay_table (void);
112 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
115 static int simple_read_overlay_table (void);
117 static int simple_overlay_update_1 (struct obj_section
*);
119 static void add_filename_language (char *ext
, enum language lang
);
121 static void info_ext_lang_command (char *args
, int from_tty
);
123 static void init_filename_language_table (void);
125 static void symfile_find_segment_sections (struct objfile
*objfile
);
127 void _initialize_symfile (void);
129 /* List of all available sym_fns. On gdb startup, each object file reader
130 calls add_symtab_fns() to register information on each format it is
135 /* BFD flavour that we handle. */
136 enum bfd_flavour sym_flavour
;
138 /* The "vtable" of symbol functions. */
139 const struct sym_fns
*sym_fns
;
140 } registered_sym_fns
;
142 DEF_VEC_O (registered_sym_fns
);
144 static VEC (registered_sym_fns
) *symtab_fns
= NULL
;
146 /* If non-zero, shared library symbols will be added automatically
147 when the inferior is created, new libraries are loaded, or when
148 attaching to the inferior. This is almost always what users will
149 want to have happen; but for very large programs, the startup time
150 will be excessive, and so if this is a problem, the user can clear
151 this flag and then add the shared library symbols as needed. Note
152 that there is a potential for confusion, since if the shared
153 library symbols are not loaded, commands like "info fun" will *not*
154 report all the functions that are actually present. */
156 int auto_solib_add
= 1;
159 /* True if we are reading a symbol table. */
161 int currently_reading_symtab
= 0;
164 decrement_reading_symtab (void *dummy
)
166 currently_reading_symtab
--;
167 gdb_assert (currently_reading_symtab
>= 0);
170 /* Increment currently_reading_symtab and return a cleanup that can be
171 used to decrement it. */
174 increment_reading_symtab (void)
176 ++currently_reading_symtab
;
177 gdb_assert (currently_reading_symtab
> 0);
178 return make_cleanup (decrement_reading_symtab
, NULL
);
181 /* Remember the lowest-addressed loadable section we've seen.
182 This function is called via bfd_map_over_sections.
184 In case of equal vmas, the section with the largest size becomes the
185 lowest-addressed loadable section.
187 If the vmas and sizes are equal, the last section is considered the
188 lowest-addressed loadable section. */
191 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
193 asection
**lowest
= (asection
**) obj
;
195 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
198 *lowest
= sect
; /* First loadable section */
199 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
200 *lowest
= sect
; /* A lower loadable section */
201 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
202 && (bfd_section_size (abfd
, (*lowest
))
203 <= bfd_section_size (abfd
, sect
)))
207 /* Create a new section_addr_info, with room for NUM_SECTIONS. The
208 new object's 'num_sections' field is set to 0; it must be updated
211 struct section_addr_info
*
212 alloc_section_addr_info (size_t num_sections
)
214 struct section_addr_info
*sap
;
217 size
= (sizeof (struct section_addr_info
)
218 + sizeof (struct other_sections
) * (num_sections
- 1));
219 sap
= (struct section_addr_info
*) xmalloc (size
);
220 memset (sap
, 0, size
);
225 /* Build (allocate and populate) a section_addr_info struct from
226 an existing section table. */
228 extern struct section_addr_info
*
229 build_section_addr_info_from_section_table (const struct target_section
*start
,
230 const struct target_section
*end
)
232 struct section_addr_info
*sap
;
233 const struct target_section
*stp
;
236 sap
= alloc_section_addr_info (end
- start
);
238 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
240 struct bfd_section
*asect
= stp
->the_bfd_section
;
241 bfd
*abfd
= asect
->owner
;
243 if (bfd_get_section_flags (abfd
, asect
) & (SEC_ALLOC
| SEC_LOAD
)
244 && oidx
< end
- start
)
246 sap
->other
[oidx
].addr
= stp
->addr
;
247 sap
->other
[oidx
].name
= xstrdup (bfd_section_name (abfd
, asect
));
248 sap
->other
[oidx
].sectindex
= gdb_bfd_section_index (abfd
, asect
);
253 sap
->num_sections
= oidx
;
258 /* Create a section_addr_info from section offsets in ABFD. */
260 static struct section_addr_info
*
261 build_section_addr_info_from_bfd (bfd
*abfd
)
263 struct section_addr_info
*sap
;
265 struct bfd_section
*sec
;
267 sap
= alloc_section_addr_info (bfd_count_sections (abfd
));
268 for (i
= 0, sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
269 if (bfd_get_section_flags (abfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
271 sap
->other
[i
].addr
= bfd_get_section_vma (abfd
, sec
);
272 sap
->other
[i
].name
= xstrdup (bfd_get_section_name (abfd
, sec
));
273 sap
->other
[i
].sectindex
= gdb_bfd_section_index (abfd
, sec
);
277 sap
->num_sections
= i
;
282 /* Create a section_addr_info from section offsets in OBJFILE. */
284 struct section_addr_info
*
285 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
287 struct section_addr_info
*sap
;
290 /* Before reread_symbols gets rewritten it is not safe to call:
291 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
293 sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
294 for (i
= 0; i
< sap
->num_sections
; i
++)
296 int sectindex
= sap
->other
[i
].sectindex
;
298 sap
->other
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
303 /* Free all memory allocated by build_section_addr_info_from_section_table. */
306 free_section_addr_info (struct section_addr_info
*sap
)
310 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
311 xfree (sap
->other
[idx
].name
);
315 /* Initialize OBJFILE's sect_index_* members. */
318 init_objfile_sect_indices (struct objfile
*objfile
)
323 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
325 objfile
->sect_index_text
= sect
->index
;
327 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
329 objfile
->sect_index_data
= sect
->index
;
331 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
333 objfile
->sect_index_bss
= sect
->index
;
335 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
337 objfile
->sect_index_rodata
= sect
->index
;
339 /* This is where things get really weird... We MUST have valid
340 indices for the various sect_index_* members or gdb will abort.
341 So if for example, there is no ".text" section, we have to
342 accomodate that. First, check for a file with the standard
343 one or two segments. */
345 symfile_find_segment_sections (objfile
);
347 /* Except when explicitly adding symbol files at some address,
348 section_offsets contains nothing but zeros, so it doesn't matter
349 which slot in section_offsets the individual sect_index_* members
350 index into. So if they are all zero, it is safe to just point
351 all the currently uninitialized indices to the first slot. But
352 beware: if this is the main executable, it may be relocated
353 later, e.g. by the remote qOffsets packet, and then this will
354 be wrong! That's why we try segments first. */
356 for (i
= 0; i
< objfile
->num_sections
; i
++)
358 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
363 if (i
== objfile
->num_sections
)
365 if (objfile
->sect_index_text
== -1)
366 objfile
->sect_index_text
= 0;
367 if (objfile
->sect_index_data
== -1)
368 objfile
->sect_index_data
= 0;
369 if (objfile
->sect_index_bss
== -1)
370 objfile
->sect_index_bss
= 0;
371 if (objfile
->sect_index_rodata
== -1)
372 objfile
->sect_index_rodata
= 0;
376 /* The arguments to place_section. */
378 struct place_section_arg
380 struct section_offsets
*offsets
;
384 /* Find a unique offset to use for loadable section SECT if
385 the user did not provide an offset. */
388 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
390 struct place_section_arg
*arg
= obj
;
391 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
393 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
395 /* We are only interested in allocated sections. */
396 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
399 /* If the user specified an offset, honor it. */
400 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
403 /* Otherwise, let's try to find a place for the section. */
404 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
411 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
413 int indx
= cur_sec
->index
;
415 /* We don't need to compare against ourself. */
419 /* We can only conflict with allocated sections. */
420 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
423 /* If the section offset is 0, either the section has not been placed
424 yet, or it was the lowest section placed (in which case LOWEST
425 will be past its end). */
426 if (offsets
[indx
] == 0)
429 /* If this section would overlap us, then we must move up. */
430 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
431 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
433 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
434 start_addr
= (start_addr
+ align
- 1) & -align
;
439 /* Otherwise, we appear to be OK. So far. */
444 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
445 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
448 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
449 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
453 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
455 const struct section_addr_info
*addrs
)
459 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
461 /* Now calculate offsets for section that were specified by the caller. */
462 for (i
= 0; i
< addrs
->num_sections
; i
++)
464 const struct other_sections
*osp
;
466 osp
= &addrs
->other
[i
];
467 if (osp
->sectindex
== -1)
470 /* Record all sections in offsets. */
471 /* The section_offsets in the objfile are here filled in using
473 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
477 /* Transform section name S for a name comparison. prelink can split section
478 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
479 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
480 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
481 (`.sbss') section has invalid (increased) virtual address. */
484 addr_section_name (const char *s
)
486 if (strcmp (s
, ".dynbss") == 0)
488 if (strcmp (s
, ".sdynbss") == 0)
494 /* qsort comparator for addrs_section_sort. Sort entries in ascending order by
495 their (name, sectindex) pair. sectindex makes the sort by name stable. */
498 addrs_section_compar (const void *ap
, const void *bp
)
500 const struct other_sections
*a
= *((struct other_sections
**) ap
);
501 const struct other_sections
*b
= *((struct other_sections
**) bp
);
504 retval
= strcmp (addr_section_name (a
->name
), addr_section_name (b
->name
));
508 return a
->sectindex
- b
->sectindex
;
511 /* Provide sorted array of pointers to sections of ADDRS. The array is
512 terminated by NULL. Caller is responsible to call xfree for it. */
514 static struct other_sections
**
515 addrs_section_sort (struct section_addr_info
*addrs
)
517 struct other_sections
**array
;
520 /* `+ 1' for the NULL terminator. */
521 array
= xmalloc (sizeof (*array
) * (addrs
->num_sections
+ 1));
522 for (i
= 0; i
< addrs
->num_sections
; i
++)
523 array
[i
] = &addrs
->other
[i
];
526 qsort (array
, i
, sizeof (*array
), addrs_section_compar
);
531 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
532 also SECTINDEXes specific to ABFD there. This function can be used to
533 rebase ADDRS to start referencing different BFD than before. */
536 addr_info_make_relative (struct section_addr_info
*addrs
, bfd
*abfd
)
538 asection
*lower_sect
;
539 CORE_ADDR lower_offset
;
541 struct cleanup
*my_cleanup
;
542 struct section_addr_info
*abfd_addrs
;
543 struct other_sections
**addrs_sorted
, **abfd_addrs_sorted
;
544 struct other_sections
**addrs_to_abfd_addrs
;
546 /* Find lowest loadable section to be used as starting point for
547 continguous sections. */
549 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
550 if (lower_sect
== NULL
)
552 warning (_("no loadable sections found in added symbol-file %s"),
553 bfd_get_filename (abfd
));
557 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
559 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
560 in ABFD. Section names are not unique - there can be multiple sections of
561 the same name. Also the sections of the same name do not have to be
562 adjacent to each other. Some sections may be present only in one of the
563 files. Even sections present in both files do not have to be in the same
566 Use stable sort by name for the sections in both files. Then linearly
567 scan both lists matching as most of the entries as possible. */
569 addrs_sorted
= addrs_section_sort (addrs
);
570 my_cleanup
= make_cleanup (xfree
, addrs_sorted
);
572 abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
573 make_cleanup_free_section_addr_info (abfd_addrs
);
574 abfd_addrs_sorted
= addrs_section_sort (abfd_addrs
);
575 make_cleanup (xfree
, abfd_addrs_sorted
);
577 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
578 ABFD_ADDRS_SORTED. */
580 addrs_to_abfd_addrs
= xzalloc (sizeof (*addrs_to_abfd_addrs
)
581 * addrs
->num_sections
);
582 make_cleanup (xfree
, addrs_to_abfd_addrs
);
584 while (*addrs_sorted
)
586 const char *sect_name
= addr_section_name ((*addrs_sorted
)->name
);
588 while (*abfd_addrs_sorted
589 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
593 if (*abfd_addrs_sorted
594 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
599 /* Make the found item directly addressable from ADDRS. */
600 index_in_addrs
= *addrs_sorted
- addrs
->other
;
601 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
602 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_addrs_sorted
;
604 /* Never use the same ABFD entry twice. */
611 /* Calculate offsets for the loadable sections.
612 FIXME! Sections must be in order of increasing loadable section
613 so that contiguous sections can use the lower-offset!!!
615 Adjust offsets if the segments are not contiguous.
616 If the section is contiguous, its offset should be set to
617 the offset of the highest loadable section lower than it
618 (the loadable section directly below it in memory).
619 this_offset = lower_offset = lower_addr - lower_orig_addr */
621 for (i
= 0; i
< addrs
->num_sections
; i
++)
623 struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
627 /* This is the index used by BFD. */
628 addrs
->other
[i
].sectindex
= sect
->sectindex
;
630 if (addrs
->other
[i
].addr
!= 0)
632 addrs
->other
[i
].addr
-= sect
->addr
;
633 lower_offset
= addrs
->other
[i
].addr
;
636 addrs
->other
[i
].addr
= lower_offset
;
640 /* addr_section_name transformation is not used for SECT_NAME. */
641 const char *sect_name
= addrs
->other
[i
].name
;
643 /* This section does not exist in ABFD, which is normally
644 unexpected and we want to issue a warning.
646 However, the ELF prelinker does create a few sections which are
647 marked in the main executable as loadable (they are loaded in
648 memory from the DYNAMIC segment) and yet are not present in
649 separate debug info files. This is fine, and should not cause
650 a warning. Shared libraries contain just the section
651 ".gnu.liblist" but it is not marked as loadable there. There is
652 no other way to identify them than by their name as the sections
653 created by prelink have no special flags.
655 For the sections `.bss' and `.sbss' see addr_section_name. */
657 if (!(strcmp (sect_name
, ".gnu.liblist") == 0
658 || strcmp (sect_name
, ".gnu.conflict") == 0
659 || (strcmp (sect_name
, ".bss") == 0
661 && strcmp (addrs
->other
[i
- 1].name
, ".dynbss") == 0
662 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
663 || (strcmp (sect_name
, ".sbss") == 0
665 && strcmp (addrs
->other
[i
- 1].name
, ".sdynbss") == 0
666 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
667 warning (_("section %s not found in %s"), sect_name
,
668 bfd_get_filename (abfd
));
670 addrs
->other
[i
].addr
= 0;
671 addrs
->other
[i
].sectindex
= -1;
675 do_cleanups (my_cleanup
);
678 /* Parse the user's idea of an offset for dynamic linking, into our idea
679 of how to represent it for fast symbol reading. This is the default
680 version of the sym_fns.sym_offsets function for symbol readers that
681 don't need to do anything special. It allocates a section_offsets table
682 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
685 default_symfile_offsets (struct objfile
*objfile
,
686 const struct section_addr_info
*addrs
)
688 objfile
->num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
689 objfile
->section_offsets
= (struct section_offsets
*)
690 obstack_alloc (&objfile
->objfile_obstack
,
691 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
692 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
693 objfile
->num_sections
, addrs
);
695 /* For relocatable files, all loadable sections will start at zero.
696 The zero is meaningless, so try to pick arbitrary addresses such
697 that no loadable sections overlap. This algorithm is quadratic,
698 but the number of sections in a single object file is generally
700 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
702 struct place_section_arg arg
;
703 bfd
*abfd
= objfile
->obfd
;
706 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
707 /* We do not expect this to happen; just skip this step if the
708 relocatable file has a section with an assigned VMA. */
709 if (bfd_section_vma (abfd
, cur_sec
) != 0)
714 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
716 /* Pick non-overlapping offsets for sections the user did not
718 arg
.offsets
= objfile
->section_offsets
;
720 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
722 /* Correctly filling in the section offsets is not quite
723 enough. Relocatable files have two properties that
724 (most) shared objects do not:
726 - Their debug information will contain relocations. Some
727 shared libraries do also, but many do not, so this can not
730 - If there are multiple code sections they will be loaded
731 at different relative addresses in memory than they are
732 in the objfile, since all sections in the file will start
735 Because GDB has very limited ability to map from an
736 address in debug info to the correct code section,
737 it relies on adding SECT_OFF_TEXT to things which might be
738 code. If we clear all the section offsets, and set the
739 section VMAs instead, then symfile_relocate_debug_section
740 will return meaningful debug information pointing at the
743 GDB has too many different data structures for section
744 addresses - a bfd, objfile, and so_list all have section
745 tables, as does exec_ops. Some of these could probably
748 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
749 cur_sec
= cur_sec
->next
)
751 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
754 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
755 exec_set_section_address (bfd_get_filename (abfd
),
757 offsets
[cur_sec
->index
]);
758 offsets
[cur_sec
->index
] = 0;
763 /* Remember the bfd indexes for the .text, .data, .bss and
765 init_objfile_sect_indices (objfile
);
768 /* Divide the file into segments, which are individual relocatable units.
769 This is the default version of the sym_fns.sym_segments function for
770 symbol readers that do not have an explicit representation of segments.
771 It assumes that object files do not have segments, and fully linked
772 files have a single segment. */
774 struct symfile_segment_data
*
775 default_symfile_segments (bfd
*abfd
)
779 struct symfile_segment_data
*data
;
782 /* Relocatable files contain enough information to position each
783 loadable section independently; they should not be relocated
785 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
788 /* Make sure there is at least one loadable section in the file. */
789 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
791 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
799 low
= bfd_get_section_vma (abfd
, sect
);
800 high
= low
+ bfd_get_section_size (sect
);
802 data
= XCNEW (struct symfile_segment_data
);
803 data
->num_segments
= 1;
804 data
->segment_bases
= XCNEW (CORE_ADDR
);
805 data
->segment_sizes
= XCNEW (CORE_ADDR
);
807 num_sections
= bfd_count_sections (abfd
);
808 data
->segment_info
= XCNEWVEC (int, num_sections
);
810 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
814 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
817 vma
= bfd_get_section_vma (abfd
, sect
);
820 if (vma
+ bfd_get_section_size (sect
) > high
)
821 high
= vma
+ bfd_get_section_size (sect
);
823 data
->segment_info
[i
] = 1;
826 data
->segment_bases
[0] = low
;
827 data
->segment_sizes
[0] = high
- low
;
832 /* This is a convenience function to call sym_read for OBJFILE and
833 possibly force the partial symbols to be read. */
836 read_symbols (struct objfile
*objfile
, int add_flags
)
838 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
840 /* find_separate_debug_file_in_section should be called only if there is
841 single binary with no existing separate debug info file. */
842 if (!objfile_has_partial_symbols (objfile
)
843 && objfile
->separate_debug_objfile
== NULL
844 && objfile
->separate_debug_objfile_backlink
== NULL
)
846 bfd
*abfd
= find_separate_debug_file_in_section (objfile
);
847 struct cleanup
*cleanup
= make_cleanup_bfd_unref (abfd
);
851 /* find_separate_debug_file_in_section uses the same filename for the
852 virtual section-as-bfd like the bfd filename containing the
853 section. Therefore use also non-canonical name form for the same
854 file containing the section. */
855 symbol_file_add_separate (abfd
, objfile
->original_name
, add_flags
,
859 do_cleanups (cleanup
);
861 if ((add_flags
& SYMFILE_NO_READ
) == 0)
862 require_partial_symbols (objfile
, 0);
865 /* Initialize entry point information for this objfile. */
868 init_entry_point_info (struct objfile
*objfile
)
870 /* Save startup file's range of PC addresses to help blockframe.c
871 decide where the bottom of the stack is. */
873 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
875 /* Executable file -- record its entry point so we'll recognize
876 the startup file because it contains the entry point. */
877 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
878 objfile
->ei
.entry_point_p
= 1;
880 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
881 && bfd_get_start_address (objfile
->obfd
) != 0)
883 /* Some shared libraries may have entry points set and be
884 runnable. There's no clear way to indicate this, so just check
885 for values other than zero. */
886 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
887 objfile
->ei
.entry_point_p
= 1;
891 /* Examination of non-executable.o files. Short-circuit this stuff. */
892 objfile
->ei
.entry_point_p
= 0;
895 if (objfile
->ei
.entry_point_p
)
897 struct obj_section
*osect
;
898 CORE_ADDR entry_point
= objfile
->ei
.entry_point
;
901 /* Make certain that the address points at real code, and not a
902 function descriptor. */
904 = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile
),
908 /* Remove any ISA markers, so that this matches entries in the
910 objfile
->ei
.entry_point
911 = gdbarch_addr_bits_remove (get_objfile_arch (objfile
), entry_point
);
914 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
916 struct bfd_section
*sect
= osect
->the_bfd_section
;
918 if (entry_point
>= bfd_get_section_vma (objfile
->obfd
, sect
)
919 && entry_point
< (bfd_get_section_vma (objfile
->obfd
, sect
)
920 + bfd_get_section_size (sect
)))
922 objfile
->ei
.the_bfd_section_index
923 = gdb_bfd_section_index (objfile
->obfd
, sect
);
930 objfile
->ei
.the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
934 /* Process a symbol file, as either the main file or as a dynamically
937 This function does not set the OBJFILE's entry-point info.
939 OBJFILE is where the symbols are to be read from.
941 ADDRS is the list of section load addresses. If the user has given
942 an 'add-symbol-file' command, then this is the list of offsets and
943 addresses he or she provided as arguments to the command; or, if
944 we're handling a shared library, these are the actual addresses the
945 sections are loaded at, according to the inferior's dynamic linker
946 (as gleaned by GDB's shared library code). We convert each address
947 into an offset from the section VMA's as it appears in the object
948 file, and then call the file's sym_offsets function to convert this
949 into a format-specific offset table --- a `struct section_offsets'.
951 ADD_FLAGS encodes verbosity level, whether this is main symbol or
952 an extra symbol file such as dynamically loaded code, and wether
953 breakpoint reset should be deferred. */
956 syms_from_objfile_1 (struct objfile
*objfile
,
957 struct section_addr_info
*addrs
,
960 struct section_addr_info
*local_addr
= NULL
;
961 struct cleanup
*old_chain
;
962 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
964 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
966 if (objfile
->sf
== NULL
)
968 /* No symbols to load, but we still need to make sure
969 that the section_offsets table is allocated. */
970 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
971 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_sections
);
973 objfile
->num_sections
= num_sections
;
974 objfile
->section_offsets
975 = obstack_alloc (&objfile
->objfile_obstack
, size
);
976 memset (objfile
->section_offsets
, 0, size
);
980 /* Make sure that partially constructed symbol tables will be cleaned up
981 if an error occurs during symbol reading. */
982 old_chain
= make_cleanup_free_objfile (objfile
);
984 /* If ADDRS is NULL, put together a dummy address list.
985 We now establish the convention that an addr of zero means
986 no load address was specified. */
989 local_addr
= alloc_section_addr_info (1);
990 make_cleanup (xfree
, local_addr
);
996 /* We will modify the main symbol table, make sure that all its users
997 will be cleaned up if an error occurs during symbol reading. */
998 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1000 /* Since no error yet, throw away the old symbol table. */
1002 if (symfile_objfile
!= NULL
)
1004 free_objfile (symfile_objfile
);
1005 gdb_assert (symfile_objfile
== NULL
);
1008 /* Currently we keep symbols from the add-symbol-file command.
1009 If the user wants to get rid of them, they should do "symbol-file"
1010 without arguments first. Not sure this is the best behavior
1013 (*objfile
->sf
->sym_new_init
) (objfile
);
1016 /* Convert addr into an offset rather than an absolute address.
1017 We find the lowest address of a loaded segment in the objfile,
1018 and assume that <addr> is where that got loaded.
1020 We no longer warn if the lowest section is not a text segment (as
1021 happens for the PA64 port. */
1022 if (addrs
->num_sections
> 0)
1023 addr_info_make_relative (addrs
, objfile
->obfd
);
1025 /* Initialize symbol reading routines for this objfile, allow complaints to
1026 appear for this new file, and record how verbose to be, then do the
1027 initial symbol reading for this file. */
1029 (*objfile
->sf
->sym_init
) (objfile
);
1030 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
1032 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
1034 read_symbols (objfile
, add_flags
);
1036 /* Discard cleanups as symbol reading was successful. */
1038 discard_cleanups (old_chain
);
1042 /* Same as syms_from_objfile_1, but also initializes the objfile
1043 entry-point info. */
1046 syms_from_objfile (struct objfile
*objfile
,
1047 struct section_addr_info
*addrs
,
1050 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
1051 init_entry_point_info (objfile
);
1054 /* Perform required actions after either reading in the initial
1055 symbols for a new objfile, or mapping in the symbols from a reusable
1056 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1059 new_symfile_objfile (struct objfile
*objfile
, int add_flags
)
1061 /* If this is the main symbol file we have to clean up all users of the
1062 old main symbol file. Otherwise it is sufficient to fixup all the
1063 breakpoints that may have been redefined by this symbol file. */
1064 if (add_flags
& SYMFILE_MAINLINE
)
1066 /* OK, make it the "real" symbol file. */
1067 symfile_objfile
= objfile
;
1069 clear_symtab_users (add_flags
);
1071 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1073 breakpoint_re_set ();
1076 /* We're done reading the symbol file; finish off complaints. */
1077 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
1080 /* Process a symbol file, as either the main file or as a dynamically
1083 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1084 A new reference is acquired by this function.
1086 For NAME description see allocate_objfile's definition.
1088 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1089 extra, such as dynamically loaded code, and what to do with breakpoins.
1091 ADDRS is as described for syms_from_objfile_1, above.
1092 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1094 PARENT is the original objfile if ABFD is a separate debug info file.
1095 Otherwise PARENT is NULL.
1097 Upon success, returns a pointer to the objfile that was added.
1098 Upon failure, jumps back to command level (never returns). */
1100 static struct objfile
*
1101 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
, int add_flags
,
1102 struct section_addr_info
*addrs
,
1103 int flags
, struct objfile
*parent
)
1105 struct objfile
*objfile
;
1106 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1107 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1108 const int should_print
= ((from_tty
|| info_verbose
)
1109 && (readnow_symbol_files
1110 || (add_flags
& SYMFILE_NO_READ
) == 0));
1112 if (readnow_symbol_files
)
1114 flags
|= OBJF_READNOW
;
1115 add_flags
&= ~SYMFILE_NO_READ
;
1118 /* Give user a chance to burp if we'd be
1119 interactively wiping out any existing symbols. */
1121 if ((have_full_symbols () || have_partial_symbols ())
1124 && !query (_("Load new symbol table from \"%s\"? "), name
))
1125 error (_("Not confirmed."));
1127 objfile
= allocate_objfile (abfd
, name
,
1128 flags
| (mainline
? OBJF_MAINLINE
: 0));
1131 add_separate_debug_objfile (objfile
, parent
);
1133 /* We either created a new mapped symbol table, mapped an existing
1134 symbol table file which has not had initial symbol reading
1135 performed, or need to read an unmapped symbol table. */
1138 if (deprecated_pre_add_symbol_hook
)
1139 deprecated_pre_add_symbol_hook (name
);
1142 printf_unfiltered (_("Reading symbols from %s..."), name
);
1144 gdb_flush (gdb_stdout
);
1147 syms_from_objfile (objfile
, addrs
, add_flags
);
1149 /* We now have at least a partial symbol table. Check to see if the
1150 user requested that all symbols be read on initial access via either
1151 the gdb startup command line or on a per symbol file basis. Expand
1152 all partial symbol tables for this objfile if so. */
1154 if ((flags
& OBJF_READNOW
))
1158 printf_unfiltered (_("expanding to full symbols..."));
1160 gdb_flush (gdb_stdout
);
1164 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1167 if (should_print
&& !objfile_has_symbols (objfile
))
1170 printf_unfiltered (_("(no debugging symbols found)..."));
1176 if (deprecated_post_add_symbol_hook
)
1177 deprecated_post_add_symbol_hook ();
1179 printf_unfiltered (_("done.\n"));
1182 /* We print some messages regardless of whether 'from_tty ||
1183 info_verbose' is true, so make sure they go out at the right
1185 gdb_flush (gdb_stdout
);
1187 if (objfile
->sf
== NULL
)
1189 observer_notify_new_objfile (objfile
);
1190 return objfile
; /* No symbols. */
1193 new_symfile_objfile (objfile
, add_flags
);
1195 observer_notify_new_objfile (objfile
);
1197 bfd_cache_close_all ();
1201 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1202 see allocate_objfile's definition. */
1205 symbol_file_add_separate (bfd
*bfd
, const char *name
, int symfile_flags
,
1206 struct objfile
*objfile
)
1208 struct objfile
*new_objfile
;
1209 struct section_addr_info
*sap
;
1210 struct cleanup
*my_cleanup
;
1212 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1213 because sections of BFD may not match sections of OBJFILE and because
1214 vma may have been modified by tools such as prelink. */
1215 sap
= build_section_addr_info_from_objfile (objfile
);
1216 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1218 new_objfile
= symbol_file_add_with_addrs
1219 (bfd
, name
, symfile_flags
, sap
,
1220 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1224 do_cleanups (my_cleanup
);
1227 /* Process the symbol file ABFD, as either the main file or as a
1228 dynamically loaded file.
1229 See symbol_file_add_with_addrs's comments for details. */
1232 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
, int add_flags
,
1233 struct section_addr_info
*addrs
,
1234 int flags
, struct objfile
*parent
)
1236 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1240 /* Process a symbol file, as either the main file or as a dynamically
1241 loaded file. See symbol_file_add_with_addrs's comments for details. */
1244 symbol_file_add (const char *name
, int add_flags
,
1245 struct section_addr_info
*addrs
, int flags
)
1247 bfd
*bfd
= symfile_bfd_open (name
);
1248 struct cleanup
*cleanup
= make_cleanup_bfd_unref (bfd
);
1249 struct objfile
*objf
;
1251 objf
= symbol_file_add_from_bfd (bfd
, name
, add_flags
, addrs
, flags
, NULL
);
1252 do_cleanups (cleanup
);
1256 /* Call symbol_file_add() with default values and update whatever is
1257 affected by the loading of a new main().
1258 Used when the file is supplied in the gdb command line
1259 and by some targets with special loading requirements.
1260 The auxiliary function, symbol_file_add_main_1(), has the flags
1261 argument for the switches that can only be specified in the symbol_file
1265 symbol_file_add_main (const char *args
, int from_tty
)
1267 symbol_file_add_main_1 (args
, from_tty
, 0);
1271 symbol_file_add_main_1 (const char *args
, int from_tty
, int flags
)
1273 const int add_flags
= (current_inferior ()->symfile_flags
1274 | SYMFILE_MAINLINE
| (from_tty
? SYMFILE_VERBOSE
: 0));
1276 symbol_file_add (args
, add_flags
, NULL
, flags
);
1278 /* Getting new symbols may change our opinion about
1279 what is frameless. */
1280 reinit_frame_cache ();
1282 if ((flags
& SYMFILE_NO_READ
) == 0)
1283 set_initial_language ();
1287 symbol_file_clear (int from_tty
)
1289 if ((have_full_symbols () || have_partial_symbols ())
1292 ? !query (_("Discard symbol table from `%s'? "),
1293 objfile_name (symfile_objfile
))
1294 : !query (_("Discard symbol table? "))))
1295 error (_("Not confirmed."));
1297 /* solib descriptors may have handles to objfiles. Wipe them before their
1298 objfiles get stale by free_all_objfiles. */
1299 no_shared_libraries (NULL
, from_tty
);
1301 free_all_objfiles ();
1303 gdb_assert (symfile_objfile
== NULL
);
1305 printf_unfiltered (_("No symbol file now.\n"));
1309 separate_debug_file_exists (const char *name
, unsigned long crc
,
1310 struct objfile
*parent_objfile
)
1312 unsigned long file_crc
;
1315 struct stat parent_stat
, abfd_stat
;
1316 int verified_as_different
;
1318 /* Find a separate debug info file as if symbols would be present in
1319 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1320 section can contain just the basename of PARENT_OBJFILE without any
1321 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1322 the separate debug infos with the same basename can exist. */
1324 if (filename_cmp (name
, objfile_name (parent_objfile
)) == 0)
1327 abfd
= gdb_bfd_open_maybe_remote (name
);
1332 /* Verify symlinks were not the cause of filename_cmp name difference above.
1334 Some operating systems, e.g. Windows, do not provide a meaningful
1335 st_ino; they always set it to zero. (Windows does provide a
1336 meaningful st_dev.) Do not indicate a duplicate library in that
1337 case. While there is no guarantee that a system that provides
1338 meaningful inode numbers will never set st_ino to zero, this is
1339 merely an optimization, so we do not need to worry about false
1342 if (bfd_stat (abfd
, &abfd_stat
) == 0
1343 && abfd_stat
.st_ino
!= 0
1344 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1346 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1347 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1349 gdb_bfd_unref (abfd
);
1352 verified_as_different
= 1;
1355 verified_as_different
= 0;
1357 file_crc_p
= gdb_bfd_crc (abfd
, &file_crc
);
1359 gdb_bfd_unref (abfd
);
1364 if (crc
!= file_crc
)
1366 unsigned long parent_crc
;
1368 /* If one (or both) the files are accessed for example the via "remote:"
1369 gdbserver way it does not support the bfd_stat operation. Verify
1370 whether those two files are not the same manually. */
1372 if (!verified_as_different
)
1374 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1378 if (verified_as_different
|| parent_crc
!= file_crc
)
1379 warning (_("the debug information found in \"%s\""
1380 " does not match \"%s\" (CRC mismatch).\n"),
1381 name
, objfile_name (parent_objfile
));
1389 char *debug_file_directory
= NULL
;
1391 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1392 struct cmd_list_element
*c
, const char *value
)
1394 fprintf_filtered (file
,
1395 _("The directory where separate debug "
1396 "symbols are searched for is \"%s\".\n"),
1400 #if ! defined (DEBUG_SUBDIRECTORY)
1401 #define DEBUG_SUBDIRECTORY ".debug"
1404 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1405 where the original file resides (may not be the same as
1406 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1407 looking for. CANON_DIR is the "realpath" form of DIR.
1408 DIR must contain a trailing '/'.
1409 Returns the path of the file with separate debug info, of NULL. */
1412 find_separate_debug_file (const char *dir
,
1413 const char *canon_dir
,
1414 const char *debuglink
,
1415 unsigned long crc32
, struct objfile
*objfile
)
1420 VEC (char_ptr
) *debugdir_vec
;
1421 struct cleanup
*back_to
;
1424 /* Set I to max (strlen (canon_dir), strlen (dir)). */
1426 if (canon_dir
!= NULL
&& strlen (canon_dir
) > i
)
1427 i
= strlen (canon_dir
);
1429 debugfile
= xmalloc (strlen (debug_file_directory
) + 1
1431 + strlen (DEBUG_SUBDIRECTORY
)
1433 + strlen (debuglink
)
1436 /* First try in the same directory as the original file. */
1437 strcpy (debugfile
, dir
);
1438 strcat (debugfile
, debuglink
);
1440 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1443 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1444 strcpy (debugfile
, dir
);
1445 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1446 strcat (debugfile
, "/");
1447 strcat (debugfile
, debuglink
);
1449 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1452 /* Then try in the global debugfile directories.
1454 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1455 cause "/..." lookups. */
1457 debugdir_vec
= dirnames_to_char_ptr_vec (debug_file_directory
);
1458 back_to
= make_cleanup_free_char_ptr_vec (debugdir_vec
);
1460 for (ix
= 0; VEC_iterate (char_ptr
, debugdir_vec
, ix
, debugdir
); ++ix
)
1462 strcpy (debugfile
, debugdir
);
1463 strcat (debugfile
, "/");
1464 strcat (debugfile
, dir
);
1465 strcat (debugfile
, debuglink
);
1467 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1469 do_cleanups (back_to
);
1473 /* If the file is in the sysroot, try using its base path in the
1474 global debugfile directory. */
1475 if (canon_dir
!= NULL
1476 && filename_ncmp (canon_dir
, gdb_sysroot
,
1477 strlen (gdb_sysroot
)) == 0
1478 && IS_DIR_SEPARATOR (canon_dir
[strlen (gdb_sysroot
)]))
1480 strcpy (debugfile
, debugdir
);
1481 strcat (debugfile
, canon_dir
+ strlen (gdb_sysroot
));
1482 strcat (debugfile
, "/");
1483 strcat (debugfile
, debuglink
);
1485 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1487 do_cleanups (back_to
);
1493 do_cleanups (back_to
);
1498 /* Modify PATH to contain only "[/]directory/" part of PATH.
1499 If there were no directory separators in PATH, PATH will be empty
1500 string on return. */
1503 terminate_after_last_dir_separator (char *path
)
1507 /* Strip off the final filename part, leaving the directory name,
1508 followed by a slash. The directory can be relative or absolute. */
1509 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1510 if (IS_DIR_SEPARATOR (path
[i
]))
1513 /* If I is -1 then no directory is present there and DIR will be "". */
1517 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1518 Returns pathname, or NULL. */
1521 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1524 char *dir
, *canon_dir
;
1526 unsigned long crc32
;
1527 struct cleanup
*cleanups
;
1529 debuglink
= bfd_get_debug_link_info (objfile
->obfd
, &crc32
);
1531 if (debuglink
== NULL
)
1533 /* There's no separate debug info, hence there's no way we could
1534 load it => no warning. */
1538 cleanups
= make_cleanup (xfree
, debuglink
);
1539 dir
= xstrdup (objfile_name (objfile
));
1540 make_cleanup (xfree
, dir
);
1541 terminate_after_last_dir_separator (dir
);
1542 canon_dir
= lrealpath (dir
);
1544 debugfile
= find_separate_debug_file (dir
, canon_dir
, debuglink
,
1548 if (debugfile
== NULL
)
1551 /* For PR gdb/9538, try again with realpath (if different from the
1556 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1557 && S_ISLNK (st_buf
.st_mode
))
1561 symlink_dir
= lrealpath (objfile_name (objfile
));
1562 if (symlink_dir
!= NULL
)
1564 make_cleanup (xfree
, symlink_dir
);
1565 terminate_after_last_dir_separator (symlink_dir
);
1566 if (strcmp (dir
, symlink_dir
) != 0)
1568 /* Different directory, so try using it. */
1569 debugfile
= find_separate_debug_file (symlink_dir
,
1577 #endif /* HAVE_LSTAT */
1580 do_cleanups (cleanups
);
1584 /* This is the symbol-file command. Read the file, analyze its
1585 symbols, and add a struct symtab to a symtab list. The syntax of
1586 the command is rather bizarre:
1588 1. The function buildargv implements various quoting conventions
1589 which are undocumented and have little or nothing in common with
1590 the way things are quoted (or not quoted) elsewhere in GDB.
1592 2. Options are used, which are not generally used in GDB (perhaps
1593 "set mapped on", "set readnow on" would be better)
1595 3. The order of options matters, which is contrary to GNU
1596 conventions (because it is confusing and inconvenient). */
1599 symbol_file_command (char *args
, int from_tty
)
1605 symbol_file_clear (from_tty
);
1609 char **argv
= gdb_buildargv (args
);
1610 int flags
= OBJF_USERLOADED
;
1611 struct cleanup
*cleanups
;
1614 cleanups
= make_cleanup_freeargv (argv
);
1615 while (*argv
!= NULL
)
1617 if (strcmp (*argv
, "-readnow") == 0)
1618 flags
|= OBJF_READNOW
;
1619 else if (**argv
== '-')
1620 error (_("unknown option `%s'"), *argv
);
1623 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1631 error (_("no symbol file name was specified"));
1633 do_cleanups (cleanups
);
1637 /* Set the initial language.
1639 FIXME: A better solution would be to record the language in the
1640 psymtab when reading partial symbols, and then use it (if known) to
1641 set the language. This would be a win for formats that encode the
1642 language in an easily discoverable place, such as DWARF. For
1643 stabs, we can jump through hoops looking for specially named
1644 symbols or try to intuit the language from the specific type of
1645 stabs we find, but we can't do that until later when we read in
1649 set_initial_language (void)
1651 enum language lang
= language_unknown
;
1653 if (language_of_main
!= language_unknown
)
1654 lang
= language_of_main
;
1657 char *name
= main_name ();
1658 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
);
1661 lang
= SYMBOL_LANGUAGE (sym
);
1664 if (lang
== language_unknown
)
1666 /* Make C the default language */
1670 set_language (lang
);
1671 expected_language
= current_language
; /* Don't warn the user. */
1674 /* If NAME is a remote name open the file using remote protocol, otherwise
1675 open it normally. Returns a new reference to the BFD. On error,
1676 returns NULL with the BFD error set. */
1679 gdb_bfd_open_maybe_remote (const char *name
)
1683 if (remote_filename_p (name
))
1684 result
= remote_bfd_open (name
, gnutarget
);
1686 result
= gdb_bfd_open (name
, gnutarget
, -1);
1691 /* Open the file specified by NAME and hand it off to BFD for
1692 preliminary analysis. Return a newly initialized bfd *, which
1693 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1694 absolute). In case of trouble, error() is called. */
1697 symfile_bfd_open (const char *cname
)
1701 char *name
, *absolute_name
;
1702 struct cleanup
*back_to
;
1704 if (remote_filename_p (cname
))
1706 sym_bfd
= remote_bfd_open (cname
, gnutarget
);
1708 error (_("`%s': can't open to read symbols: %s."), cname
,
1709 bfd_errmsg (bfd_get_error ()));
1711 if (!bfd_check_format (sym_bfd
, bfd_object
))
1713 make_cleanup_bfd_unref (sym_bfd
);
1714 error (_("`%s': can't read symbols: %s."), cname
,
1715 bfd_errmsg (bfd_get_error ()));
1721 name
= tilde_expand (cname
); /* Returns 1st new malloc'd copy. */
1723 /* Look down path for it, allocate 2nd new malloc'd copy. */
1724 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, name
,
1725 O_RDONLY
| O_BINARY
, &absolute_name
);
1726 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1729 char *exename
= alloca (strlen (name
) + 5);
1731 strcat (strcpy (exename
, name
), ".exe");
1732 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1733 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1738 make_cleanup (xfree
, name
);
1739 perror_with_name (name
);
1743 name
= absolute_name
;
1744 back_to
= make_cleanup (xfree
, name
);
1746 sym_bfd
= gdb_bfd_open (name
, gnutarget
, desc
);
1748 error (_("`%s': can't open to read symbols: %s."), name
,
1749 bfd_errmsg (bfd_get_error ()));
1750 bfd_set_cacheable (sym_bfd
, 1);
1752 if (!bfd_check_format (sym_bfd
, bfd_object
))
1754 make_cleanup_bfd_unref (sym_bfd
);
1755 error (_("`%s': can't read symbols: %s."), name
,
1756 bfd_errmsg (bfd_get_error ()));
1759 do_cleanups (back_to
);
1764 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1765 the section was not found. */
1768 get_section_index (struct objfile
*objfile
, char *section_name
)
1770 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1778 /* Link SF into the global symtab_fns list.
1779 FLAVOUR is the file format that SF handles.
1780 Called on startup by the _initialize routine in each object file format
1781 reader, to register information about each format the reader is prepared
1785 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1787 registered_sym_fns fns
= { flavour
, sf
};
1789 VEC_safe_push (registered_sym_fns
, symtab_fns
, &fns
);
1792 /* Initialize OBJFILE to read symbols from its associated BFD. It
1793 either returns or calls error(). The result is an initialized
1794 struct sym_fns in the objfile structure, that contains cached
1795 information about the symbol file. */
1797 static const struct sym_fns
*
1798 find_sym_fns (bfd
*abfd
)
1800 registered_sym_fns
*rsf
;
1801 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1804 if (our_flavour
== bfd_target_srec_flavour
1805 || our_flavour
== bfd_target_ihex_flavour
1806 || our_flavour
== bfd_target_tekhex_flavour
)
1807 return NULL
; /* No symbols. */
1809 for (i
= 0; VEC_iterate (registered_sym_fns
, symtab_fns
, i
, rsf
); ++i
)
1810 if (our_flavour
== rsf
->sym_flavour
)
1811 return rsf
->sym_fns
;
1813 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1814 bfd_get_target (abfd
));
1818 /* This function runs the load command of our current target. */
1821 load_command (char *arg
, int from_tty
)
1823 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1827 /* The user might be reloading because the binary has changed. Take
1828 this opportunity to check. */
1829 reopen_exec_file ();
1837 parg
= arg
= get_exec_file (1);
1839 /* Count how many \ " ' tab space there are in the name. */
1840 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1848 /* We need to quote this string so buildargv can pull it apart. */
1849 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1853 make_cleanup (xfree
, temp
);
1856 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1858 strncpy (ptemp
, prev
, parg
- prev
);
1859 ptemp
+= parg
- prev
;
1863 strcpy (ptemp
, prev
);
1869 target_load (arg
, from_tty
);
1871 /* After re-loading the executable, we don't really know which
1872 overlays are mapped any more. */
1873 overlay_cache_invalid
= 1;
1875 do_cleanups (cleanup
);
1878 /* This version of "load" should be usable for any target. Currently
1879 it is just used for remote targets, not inftarg.c or core files,
1880 on the theory that only in that case is it useful.
1882 Avoiding xmodem and the like seems like a win (a) because we don't have
1883 to worry about finding it, and (b) On VMS, fork() is very slow and so
1884 we don't want to run a subprocess. On the other hand, I'm not sure how
1885 performance compares. */
1887 static int validate_download
= 0;
1889 /* Callback service function for generic_load (bfd_map_over_sections). */
1892 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1894 bfd_size_type
*sum
= data
;
1896 *sum
+= bfd_get_section_size (asec
);
1899 /* Opaque data for load_section_callback. */
1900 struct load_section_data
{
1901 CORE_ADDR load_offset
;
1902 struct load_progress_data
*progress_data
;
1903 VEC(memory_write_request_s
) *requests
;
1906 /* Opaque data for load_progress. */
1907 struct load_progress_data
{
1908 /* Cumulative data. */
1909 unsigned long write_count
;
1910 unsigned long data_count
;
1911 bfd_size_type total_size
;
1914 /* Opaque data for load_progress for a single section. */
1915 struct load_progress_section_data
{
1916 struct load_progress_data
*cumulative
;
1918 /* Per-section data. */
1919 const char *section_name
;
1920 ULONGEST section_sent
;
1921 ULONGEST section_size
;
1926 /* Target write callback routine for progress reporting. */
1929 load_progress (ULONGEST bytes
, void *untyped_arg
)
1931 struct load_progress_section_data
*args
= untyped_arg
;
1932 struct load_progress_data
*totals
;
1935 /* Writing padding data. No easy way to get at the cumulative
1936 stats, so just ignore this. */
1939 totals
= args
->cumulative
;
1941 if (bytes
== 0 && args
->section_sent
== 0)
1943 /* The write is just starting. Let the user know we've started
1945 ui_out_message (current_uiout
, 0, "Loading section %s, size %s lma %s\n",
1946 args
->section_name
, hex_string (args
->section_size
),
1947 paddress (target_gdbarch (), args
->lma
));
1951 if (validate_download
)
1953 /* Broken memories and broken monitors manifest themselves here
1954 when bring new computers to life. This doubles already slow
1956 /* NOTE: cagney/1999-10-18: A more efficient implementation
1957 might add a verify_memory() method to the target vector and
1958 then use that. remote.c could implement that method using
1959 the ``qCRC'' packet. */
1960 gdb_byte
*check
= xmalloc (bytes
);
1961 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1963 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
1964 error (_("Download verify read failed at %s"),
1965 paddress (target_gdbarch (), args
->lma
));
1966 if (memcmp (args
->buffer
, check
, bytes
) != 0)
1967 error (_("Download verify compare failed at %s"),
1968 paddress (target_gdbarch (), args
->lma
));
1969 do_cleanups (verify_cleanups
);
1971 totals
->data_count
+= bytes
;
1973 args
->buffer
+= bytes
;
1974 totals
->write_count
+= 1;
1975 args
->section_sent
+= bytes
;
1976 if (check_quit_flag ()
1977 || (deprecated_ui_load_progress_hook
!= NULL
1978 && deprecated_ui_load_progress_hook (args
->section_name
,
1979 args
->section_sent
)))
1980 error (_("Canceled the download"));
1982 if (deprecated_show_load_progress
!= NULL
)
1983 deprecated_show_load_progress (args
->section_name
,
1987 totals
->total_size
);
1990 /* Callback service function for generic_load (bfd_map_over_sections). */
1993 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1995 struct memory_write_request
*new_request
;
1996 struct load_section_data
*args
= data
;
1997 struct load_progress_section_data
*section_data
;
1998 bfd_size_type size
= bfd_get_section_size (asec
);
2000 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
2002 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
2008 new_request
= VEC_safe_push (memory_write_request_s
,
2009 args
->requests
, NULL
);
2010 memset (new_request
, 0, sizeof (struct memory_write_request
));
2011 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
2012 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
2013 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size
2015 new_request
->data
= xmalloc (size
);
2016 new_request
->baton
= section_data
;
2018 buffer
= new_request
->data
;
2020 section_data
->cumulative
= args
->progress_data
;
2021 section_data
->section_name
= sect_name
;
2022 section_data
->section_size
= size
;
2023 section_data
->lma
= new_request
->begin
;
2024 section_data
->buffer
= buffer
;
2026 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2029 /* Clean up an entire memory request vector, including load
2030 data and progress records. */
2033 clear_memory_write_data (void *arg
)
2035 VEC(memory_write_request_s
) **vec_p
= arg
;
2036 VEC(memory_write_request_s
) *vec
= *vec_p
;
2038 struct memory_write_request
*mr
;
2040 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
2045 VEC_free (memory_write_request_s
, vec
);
2049 generic_load (char *args
, int from_tty
)
2052 struct timeval start_time
, end_time
;
2054 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
2055 struct load_section_data cbdata
;
2056 struct load_progress_data total_progress
;
2057 struct ui_out
*uiout
= current_uiout
;
2062 memset (&cbdata
, 0, sizeof (cbdata
));
2063 memset (&total_progress
, 0, sizeof (total_progress
));
2064 cbdata
.progress_data
= &total_progress
;
2066 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
2069 error_no_arg (_("file to load"));
2071 argv
= gdb_buildargv (args
);
2072 make_cleanup_freeargv (argv
);
2074 filename
= tilde_expand (argv
[0]);
2075 make_cleanup (xfree
, filename
);
2077 if (argv
[1] != NULL
)
2081 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2083 /* If the last word was not a valid number then
2084 treat it as a file name with spaces in. */
2085 if (argv
[1] == endptr
)
2086 error (_("Invalid download offset:%s."), argv
[1]);
2088 if (argv
[2] != NULL
)
2089 error (_("Too many parameters."));
2092 /* Open the file for loading. */
2093 loadfile_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2094 if (loadfile_bfd
== NULL
)
2096 perror_with_name (filename
);
2100 make_cleanup_bfd_unref (loadfile_bfd
);
2102 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
2104 error (_("\"%s\" is not an object file: %s"), filename
,
2105 bfd_errmsg (bfd_get_error ()));
2108 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
2109 (void *) &total_progress
.total_size
);
2111 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
2113 gettimeofday (&start_time
, NULL
);
2115 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2116 load_progress
) != 0)
2117 error (_("Load failed"));
2119 gettimeofday (&end_time
, NULL
);
2121 entry
= bfd_get_start_address (loadfile_bfd
);
2122 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2123 ui_out_text (uiout
, "Start address ");
2124 ui_out_field_fmt (uiout
, "address", "%s", paddress (target_gdbarch (), entry
));
2125 ui_out_text (uiout
, ", load size ");
2126 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
2127 ui_out_text (uiout
, "\n");
2128 /* We were doing this in remote-mips.c, I suspect it is right
2129 for other targets too. */
2130 regcache_write_pc (get_current_regcache (), entry
);
2132 /* Reset breakpoints, now that we have changed the load image. For
2133 instance, breakpoints may have been set (or reset, by
2134 post_create_inferior) while connected to the target but before we
2135 loaded the program. In that case, the prologue analyzer could
2136 have read instructions from the target to find the right
2137 breakpoint locations. Loading has changed the contents of that
2140 breakpoint_re_set ();
2142 /* FIXME: are we supposed to call symbol_file_add or not? According
2143 to a comment from remote-mips.c (where a call to symbol_file_add
2144 was commented out), making the call confuses GDB if more than one
2145 file is loaded in. Some targets do (e.g., remote-vx.c) but
2146 others don't (or didn't - perhaps they have all been deleted). */
2148 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2149 total_progress
.write_count
,
2150 &start_time
, &end_time
);
2152 do_cleanups (old_cleanups
);
2155 /* Report how fast the transfer went. */
2158 print_transfer_performance (struct ui_file
*stream
,
2159 unsigned long data_count
,
2160 unsigned long write_count
,
2161 const struct timeval
*start_time
,
2162 const struct timeval
*end_time
)
2164 ULONGEST time_count
;
2165 struct ui_out
*uiout
= current_uiout
;
2167 /* Compute the elapsed time in milliseconds, as a tradeoff between
2168 accuracy and overflow. */
2169 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
2170 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
2172 ui_out_text (uiout
, "Transfer rate: ");
2175 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
2177 if (ui_out_is_mi_like_p (uiout
))
2179 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
2180 ui_out_text (uiout
, " bits/sec");
2182 else if (rate
< 1024)
2184 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
2185 ui_out_text (uiout
, " bytes/sec");
2189 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
2190 ui_out_text (uiout
, " KB/sec");
2195 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
2196 ui_out_text (uiout
, " bits in <1 sec");
2198 if (write_count
> 0)
2200 ui_out_text (uiout
, ", ");
2201 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
2202 ui_out_text (uiout
, " bytes/write");
2204 ui_out_text (uiout
, ".\n");
2207 /* This function allows the addition of incrementally linked object files.
2208 It does not modify any state in the target, only in the debugger. */
2209 /* Note: ezannoni 2000-04-13 This function/command used to have a
2210 special case syntax for the rombug target (Rombug is the boot
2211 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2212 rombug case, the user doesn't need to supply a text address,
2213 instead a call to target_link() (in target.c) would supply the
2214 value to use. We are now discontinuing this type of ad hoc syntax. */
2217 add_symbol_file_command (char *args
, int from_tty
)
2219 struct gdbarch
*gdbarch
= get_current_arch ();
2220 char *filename
= NULL
;
2221 int flags
= OBJF_USERLOADED
;
2223 int section_index
= 0;
2227 int expecting_sec_name
= 0;
2228 int expecting_sec_addr
= 0;
2230 struct objfile
*objf
;
2238 struct section_addr_info
*section_addrs
;
2239 struct sect_opt
*sect_opts
= NULL
;
2240 size_t num_sect_opts
= 0;
2241 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2244 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2245 * sizeof (struct sect_opt
));
2250 error (_("add-symbol-file takes a file name and an address"));
2252 argv
= gdb_buildargv (args
);
2253 make_cleanup_freeargv (argv
);
2255 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2257 /* Process the argument. */
2260 /* The first argument is the file name. */
2261 filename
= tilde_expand (arg
);
2262 make_cleanup (xfree
, filename
);
2264 else if (argcnt
== 1)
2266 /* The second argument is always the text address at which
2267 to load the program. */
2268 sect_opts
[section_index
].name
= ".text";
2269 sect_opts
[section_index
].value
= arg
;
2270 if (++section_index
>= num_sect_opts
)
2273 sect_opts
= ((struct sect_opt
*)
2274 xrealloc (sect_opts
,
2276 * sizeof (struct sect_opt
)));
2281 /* It's an option (starting with '-') or it's an argument
2283 if (expecting_sec_name
)
2285 sect_opts
[section_index
].name
= arg
;
2286 expecting_sec_name
= 0;
2288 else if (expecting_sec_addr
)
2290 sect_opts
[section_index
].value
= arg
;
2291 expecting_sec_addr
= 0;
2292 if (++section_index
>= num_sect_opts
)
2295 sect_opts
= ((struct sect_opt
*)
2296 xrealloc (sect_opts
,
2298 * sizeof (struct sect_opt
)));
2301 else if (strcmp (arg
, "-readnow") == 0)
2302 flags
|= OBJF_READNOW
;
2303 else if (strcmp (arg
, "-s") == 0)
2305 expecting_sec_name
= 1;
2306 expecting_sec_addr
= 1;
2309 error (_("USAGE: add-symbol-file <filename> <textaddress>"
2310 " [-readnow] [-s <secname> <addr>]*"));
2314 /* This command takes at least two arguments. The first one is a
2315 filename, and the second is the address where this file has been
2316 loaded. Abort now if this address hasn't been provided by the
2318 if (section_index
< 1)
2319 error (_("The address where %s has been loaded is missing"), filename
);
2321 /* Print the prompt for the query below. And save the arguments into
2322 a sect_addr_info structure to be passed around to other
2323 functions. We have to split this up into separate print
2324 statements because hex_string returns a local static
2327 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2328 section_addrs
= alloc_section_addr_info (section_index
);
2329 make_cleanup (xfree
, section_addrs
);
2330 for (i
= 0; i
< section_index
; i
++)
2333 char *val
= sect_opts
[i
].value
;
2334 char *sec
= sect_opts
[i
].name
;
2336 addr
= parse_and_eval_address (val
);
2338 /* Here we store the section offsets in the order they were
2339 entered on the command line. */
2340 section_addrs
->other
[sec_num
].name
= sec
;
2341 section_addrs
->other
[sec_num
].addr
= addr
;
2342 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2343 paddress (gdbarch
, addr
));
2346 /* The object's sections are initialized when a
2347 call is made to build_objfile_section_table (objfile).
2348 This happens in reread_symbols.
2349 At this point, we don't know what file type this is,
2350 so we can't determine what section names are valid. */
2352 section_addrs
->num_sections
= sec_num
;
2354 if (from_tty
&& (!query ("%s", "")))
2355 error (_("Not confirmed."));
2357 objf
= symbol_file_add (filename
, from_tty
? SYMFILE_VERBOSE
: 0,
2358 section_addrs
, flags
);
2360 add_target_sections_of_objfile (objf
);
2362 /* Getting new symbols may change our opinion about what is
2364 reinit_frame_cache ();
2365 do_cleanups (my_cleanups
);
2369 /* This function removes a symbol file that was added via add-symbol-file. */
2372 remove_symbol_file_command (char *args
, int from_tty
)
2375 struct objfile
*objf
= NULL
;
2376 struct cleanup
*my_cleanups
;
2377 struct program_space
*pspace
= current_program_space
;
2378 struct gdbarch
*gdbarch
= get_current_arch ();
2383 error (_("remove-symbol-file: no symbol file provided"));
2385 my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2387 argv
= gdb_buildargv (args
);
2389 if (strcmp (argv
[0], "-a") == 0)
2391 /* Interpret the next argument as an address. */
2394 if (argv
[1] == NULL
)
2395 error (_("Missing address argument"));
2397 if (argv
[2] != NULL
)
2398 error (_("Junk after %s"), argv
[1]);
2400 addr
= parse_and_eval_address (argv
[1]);
2405 && objf
->flags
& OBJF_USERLOADED
2406 && objf
->pspace
== pspace
&& is_addr_in_objfile (addr
, objf
))
2410 else if (argv
[0] != NULL
)
2412 /* Interpret the current argument as a file name. */
2415 if (argv
[1] != NULL
)
2416 error (_("Junk after %s"), argv
[0]);
2418 filename
= tilde_expand (argv
[0]);
2419 make_cleanup (xfree
, filename
);
2424 && objf
->flags
& OBJF_USERLOADED
2425 && objf
->pspace
== pspace
2426 && filename_cmp (filename
, objfile_name (objf
)) == 0)
2432 error (_("No symbol file found"));
2435 && !query (_("Remove symbol table from file \"%s\"? "),
2436 objfile_name (objf
)))
2437 error (_("Not confirmed."));
2439 free_objfile (objf
);
2440 clear_symtab_users (0);
2442 do_cleanups (my_cleanups
);
2445 typedef struct objfile
*objfilep
;
2447 DEF_VEC_P (objfilep
);
2449 /* Re-read symbols if a symbol-file has changed. */
2452 reread_symbols (void)
2454 struct objfile
*objfile
;
2456 struct stat new_statbuf
;
2458 VEC (objfilep
) *new_objfiles
= NULL
;
2459 struct cleanup
*all_cleanups
;
2461 all_cleanups
= make_cleanup (VEC_cleanup (objfilep
), &new_objfiles
);
2463 /* With the addition of shared libraries, this should be modified,
2464 the load time should be saved in the partial symbol tables, since
2465 different tables may come from different source files. FIXME.
2466 This routine should then walk down each partial symbol table
2467 and see if the symbol table that it originates from has been changed. */
2469 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2471 if (objfile
->obfd
== NULL
)
2474 /* Separate debug objfiles are handled in the main objfile. */
2475 if (objfile
->separate_debug_objfile_backlink
)
2478 /* If this object is from an archive (what you usually create with
2479 `ar', often called a `static library' on most systems, though
2480 a `shared library' on AIX is also an archive), then you should
2481 stat on the archive name, not member name. */
2482 if (objfile
->obfd
->my_archive
)
2483 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2485 res
= stat (objfile_name (objfile
), &new_statbuf
);
2488 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2489 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2490 objfile_name (objfile
));
2493 new_modtime
= new_statbuf
.st_mtime
;
2494 if (new_modtime
!= objfile
->mtime
)
2496 struct cleanup
*old_cleanups
;
2497 struct section_offsets
*offsets
;
2499 char *original_name
;
2501 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2502 objfile_name (objfile
));
2504 /* There are various functions like symbol_file_add,
2505 symfile_bfd_open, syms_from_objfile, etc., which might
2506 appear to do what we want. But they have various other
2507 effects which we *don't* want. So we just do stuff
2508 ourselves. We don't worry about mapped files (for one thing,
2509 any mapped file will be out of date). */
2511 /* If we get an error, blow away this objfile (not sure if
2512 that is the correct response for things like shared
2514 old_cleanups
= make_cleanup_free_objfile (objfile
);
2515 /* We need to do this whenever any symbols go away. */
2516 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2518 if (exec_bfd
!= NULL
2519 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2520 bfd_get_filename (exec_bfd
)) == 0)
2522 /* Reload EXEC_BFD without asking anything. */
2524 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2527 /* Keep the calls order approx. the same as in free_objfile. */
2529 /* Free the separate debug objfiles. It will be
2530 automatically recreated by sym_read. */
2531 free_objfile_separate_debug (objfile
);
2533 /* Remove any references to this objfile in the global
2535 preserve_values (objfile
);
2537 /* Nuke all the state that we will re-read. Much of the following
2538 code which sets things to NULL really is necessary to tell
2539 other parts of GDB that there is nothing currently there.
2541 Try to keep the freeing order compatible with free_objfile. */
2543 if (objfile
->sf
!= NULL
)
2545 (*objfile
->sf
->sym_finish
) (objfile
);
2548 clear_objfile_data (objfile
);
2550 /* Clean up any state BFD has sitting around. */
2552 struct bfd
*obfd
= objfile
->obfd
;
2553 char *obfd_filename
;
2555 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2556 /* Open the new BFD before freeing the old one, so that
2557 the filename remains live. */
2558 objfile
->obfd
= gdb_bfd_open_maybe_remote (obfd_filename
);
2559 if (objfile
->obfd
== NULL
)
2561 /* We have to make a cleanup and error here, rather
2562 than erroring later, because once we unref OBFD,
2563 OBFD_FILENAME will be freed. */
2564 make_cleanup_bfd_unref (obfd
);
2565 error (_("Can't open %s to read symbols."), obfd_filename
);
2567 gdb_bfd_unref (obfd
);
2570 original_name
= xstrdup (objfile
->original_name
);
2571 make_cleanup (xfree
, original_name
);
2573 /* bfd_openr sets cacheable to true, which is what we want. */
2574 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2575 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2576 bfd_errmsg (bfd_get_error ()));
2578 /* Save the offsets, we will nuke them with the rest of the
2580 num_offsets
= objfile
->num_sections
;
2581 offsets
= ((struct section_offsets
*)
2582 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2583 memcpy (offsets
, objfile
->section_offsets
,
2584 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2586 /* FIXME: Do we have to free a whole linked list, or is this
2588 if (objfile
->global_psymbols
.list
)
2589 xfree (objfile
->global_psymbols
.list
);
2590 memset (&objfile
->global_psymbols
, 0,
2591 sizeof (objfile
->global_psymbols
));
2592 if (objfile
->static_psymbols
.list
)
2593 xfree (objfile
->static_psymbols
.list
);
2594 memset (&objfile
->static_psymbols
, 0,
2595 sizeof (objfile
->static_psymbols
));
2597 /* Free the obstacks for non-reusable objfiles. */
2598 psymbol_bcache_free (objfile
->psymbol_cache
);
2599 objfile
->psymbol_cache
= psymbol_bcache_init ();
2600 obstack_free (&objfile
->objfile_obstack
, 0);
2601 objfile
->sections
= NULL
;
2602 objfile
->symtabs
= NULL
;
2603 objfile
->psymtabs
= NULL
;
2604 objfile
->psymtabs_addrmap
= NULL
;
2605 objfile
->free_psymtabs
= NULL
;
2606 objfile
->template_symbols
= NULL
;
2607 objfile
->msymbols
= NULL
;
2608 objfile
->minimal_symbol_count
= 0;
2609 memset (&objfile
->msymbol_hash
, 0,
2610 sizeof (objfile
->msymbol_hash
));
2611 memset (&objfile
->msymbol_demangled_hash
, 0,
2612 sizeof (objfile
->msymbol_demangled_hash
));
2614 /* obstack_init also initializes the obstack so it is
2615 empty. We could use obstack_specify_allocation but
2616 gdb_obstack.h specifies the alloc/dealloc functions. */
2617 obstack_init (&objfile
->objfile_obstack
);
2619 /* set_objfile_per_bfd potentially allocates the per-bfd
2620 data on the objfile's obstack (if sharing data across
2621 multiple users is not possible), so it's important to
2622 do it *after* the obstack has been initialized. */
2623 set_objfile_per_bfd (objfile
);
2625 objfile
->original_name
= obstack_copy0 (&objfile
->objfile_obstack
,
2627 strlen (original_name
));
2629 /* Reset the sym_fns pointer. The ELF reader can change it
2630 based on whether .gdb_index is present, and we need it to
2631 start over. PR symtab/15885 */
2632 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2634 build_objfile_section_table (objfile
);
2635 terminate_minimal_symbol_table (objfile
);
2637 /* We use the same section offsets as from last time. I'm not
2638 sure whether that is always correct for shared libraries. */
2639 objfile
->section_offsets
= (struct section_offsets
*)
2640 obstack_alloc (&objfile
->objfile_obstack
,
2641 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2642 memcpy (objfile
->section_offsets
, offsets
,
2643 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2644 objfile
->num_sections
= num_offsets
;
2646 /* What the hell is sym_new_init for, anyway? The concept of
2647 distinguishing between the main file and additional files
2648 in this way seems rather dubious. */
2649 if (objfile
== symfile_objfile
)
2651 (*objfile
->sf
->sym_new_init
) (objfile
);
2654 (*objfile
->sf
->sym_init
) (objfile
);
2655 clear_complaints (&symfile_complaints
, 1, 1);
2657 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2658 read_symbols (objfile
, 0);
2660 if (!objfile_has_symbols (objfile
))
2663 printf_unfiltered (_("(no debugging symbols found)\n"));
2667 /* We're done reading the symbol file; finish off complaints. */
2668 clear_complaints (&symfile_complaints
, 0, 1);
2670 /* Getting new symbols may change our opinion about what is
2673 reinit_frame_cache ();
2675 /* Discard cleanups as symbol reading was successful. */
2676 discard_cleanups (old_cleanups
);
2678 /* If the mtime has changed between the time we set new_modtime
2679 and now, we *want* this to be out of date, so don't call stat
2681 objfile
->mtime
= new_modtime
;
2682 init_entry_point_info (objfile
);
2684 VEC_safe_push (objfilep
, new_objfiles
, objfile
);
2692 /* Notify objfiles that we've modified objfile sections. */
2693 objfiles_changed ();
2695 clear_symtab_users (0);
2697 /* clear_objfile_data for each objfile was called before freeing it and
2698 observer_notify_new_objfile (NULL) has been called by
2699 clear_symtab_users above. Notify the new files now. */
2700 for (ix
= 0; VEC_iterate (objfilep
, new_objfiles
, ix
, objfile
); ix
++)
2701 observer_notify_new_objfile (objfile
);
2703 /* At least one objfile has changed, so we can consider that
2704 the executable we're debugging has changed too. */
2705 observer_notify_executable_changed ();
2708 do_cleanups (all_cleanups
);
2719 static filename_language
*filename_language_table
;
2720 static int fl_table_size
, fl_table_next
;
2723 add_filename_language (char *ext
, enum language lang
)
2725 if (fl_table_next
>= fl_table_size
)
2727 fl_table_size
+= 10;
2728 filename_language_table
=
2729 xrealloc (filename_language_table
,
2730 fl_table_size
* sizeof (*filename_language_table
));
2733 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2734 filename_language_table
[fl_table_next
].lang
= lang
;
2738 static char *ext_args
;
2740 show_ext_args (struct ui_file
*file
, int from_tty
,
2741 struct cmd_list_element
*c
, const char *value
)
2743 fprintf_filtered (file
,
2744 _("Mapping between filename extension "
2745 "and source language is \"%s\".\n"),
2750 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2753 char *cp
= ext_args
;
2756 /* First arg is filename extension, starting with '.' */
2758 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2760 /* Find end of first arg. */
2761 while (*cp
&& !isspace (*cp
))
2765 error (_("'%s': two arguments required -- "
2766 "filename extension and language"),
2769 /* Null-terminate first arg. */
2772 /* Find beginning of second arg, which should be a source language. */
2773 cp
= skip_spaces (cp
);
2776 error (_("'%s': two arguments required -- "
2777 "filename extension and language"),
2780 /* Lookup the language from among those we know. */
2781 lang
= language_enum (cp
);
2783 /* Now lookup the filename extension: do we already know it? */
2784 for (i
= 0; i
< fl_table_next
; i
++)
2785 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2788 if (i
>= fl_table_next
)
2790 /* New file extension. */
2791 add_filename_language (ext_args
, lang
);
2795 /* Redefining a previously known filename extension. */
2798 /* query ("Really make files of type %s '%s'?", */
2799 /* ext_args, language_str (lang)); */
2801 xfree (filename_language_table
[i
].ext
);
2802 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2803 filename_language_table
[i
].lang
= lang
;
2808 info_ext_lang_command (char *args
, int from_tty
)
2812 printf_filtered (_("Filename extensions and the languages they represent:"));
2813 printf_filtered ("\n\n");
2814 for (i
= 0; i
< fl_table_next
; i
++)
2815 printf_filtered ("\t%s\t- %s\n",
2816 filename_language_table
[i
].ext
,
2817 language_str (filename_language_table
[i
].lang
));
2821 init_filename_language_table (void)
2823 if (fl_table_size
== 0) /* Protect against repetition. */
2827 filename_language_table
=
2828 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2829 add_filename_language (".c", language_c
);
2830 add_filename_language (".d", language_d
);
2831 add_filename_language (".C", language_cplus
);
2832 add_filename_language (".cc", language_cplus
);
2833 add_filename_language (".cp", language_cplus
);
2834 add_filename_language (".cpp", language_cplus
);
2835 add_filename_language (".cxx", language_cplus
);
2836 add_filename_language (".c++", language_cplus
);
2837 add_filename_language (".java", language_java
);
2838 add_filename_language (".class", language_java
);
2839 add_filename_language (".m", language_objc
);
2840 add_filename_language (".f", language_fortran
);
2841 add_filename_language (".F", language_fortran
);
2842 add_filename_language (".for", language_fortran
);
2843 add_filename_language (".FOR", language_fortran
);
2844 add_filename_language (".ftn", language_fortran
);
2845 add_filename_language (".FTN", language_fortran
);
2846 add_filename_language (".fpp", language_fortran
);
2847 add_filename_language (".FPP", language_fortran
);
2848 add_filename_language (".f90", language_fortran
);
2849 add_filename_language (".F90", language_fortran
);
2850 add_filename_language (".f95", language_fortran
);
2851 add_filename_language (".F95", language_fortran
);
2852 add_filename_language (".f03", language_fortran
);
2853 add_filename_language (".F03", language_fortran
);
2854 add_filename_language (".f08", language_fortran
);
2855 add_filename_language (".F08", language_fortran
);
2856 add_filename_language (".s", language_asm
);
2857 add_filename_language (".sx", language_asm
);
2858 add_filename_language (".S", language_asm
);
2859 add_filename_language (".pas", language_pascal
);
2860 add_filename_language (".p", language_pascal
);
2861 add_filename_language (".pp", language_pascal
);
2862 add_filename_language (".adb", language_ada
);
2863 add_filename_language (".ads", language_ada
);
2864 add_filename_language (".a", language_ada
);
2865 add_filename_language (".ada", language_ada
);
2866 add_filename_language (".dg", language_ada
);
2871 deduce_language_from_filename (const char *filename
)
2876 if (filename
!= NULL
)
2877 if ((cp
= strrchr (filename
, '.')) != NULL
)
2878 for (i
= 0; i
< fl_table_next
; i
++)
2879 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2880 return filename_language_table
[i
].lang
;
2882 return language_unknown
;
2887 Allocate and partly initialize a new symbol table. Return a pointer
2888 to it. error() if no space.
2890 Caller must set these fields:
2899 allocate_symtab (const char *filename
, struct objfile
*objfile
)
2901 struct symtab
*symtab
;
2903 symtab
= (struct symtab
*)
2904 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2905 memset (symtab
, 0, sizeof (*symtab
));
2906 symtab
->filename
= bcache (filename
, strlen (filename
) + 1,
2907 objfile
->per_bfd
->filename_cache
);
2908 symtab
->fullname
= NULL
;
2909 symtab
->language
= deduce_language_from_filename (filename
);
2910 symtab
->debugformat
= "unknown";
2912 /* Hook it to the objfile it comes from. */
2914 symtab
->objfile
= objfile
;
2915 symtab
->next
= objfile
->symtabs
;
2916 objfile
->symtabs
= symtab
;
2918 /* This can be very verbose with lots of headers.
2919 Only print at higher debug levels. */
2920 if (symtab_create_debug
>= 2)
2922 /* Be a bit clever with debugging messages, and don't print objfile
2923 every time, only when it changes. */
2924 static char *last_objfile_name
= NULL
;
2926 if (last_objfile_name
== NULL
2927 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2929 xfree (last_objfile_name
);
2930 last_objfile_name
= xstrdup (objfile_name (objfile
));
2931 fprintf_unfiltered (gdb_stdlog
,
2932 "Creating one or more symtabs for objfile %s ...\n",
2935 fprintf_unfiltered (gdb_stdlog
,
2936 "Created symtab %s for module %s.\n",
2937 host_address_to_string (symtab
), filename
);
2944 /* Reset all data structures in gdb which may contain references to symbol
2945 table data. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
2948 clear_symtab_users (int add_flags
)
2950 /* Someday, we should do better than this, by only blowing away
2951 the things that really need to be blown. */
2953 /* Clear the "current" symtab first, because it is no longer valid.
2954 breakpoint_re_set may try to access the current symtab. */
2955 clear_current_source_symtab_and_line ();
2958 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2959 breakpoint_re_set ();
2960 clear_last_displayed_sal ();
2961 clear_pc_function_cache ();
2962 observer_notify_new_objfile (NULL
);
2964 /* Clear globals which might have pointed into a removed objfile.
2965 FIXME: It's not clear which of these are supposed to persist
2966 between expressions and which ought to be reset each time. */
2967 expression_context_block
= NULL
;
2968 innermost_block
= NULL
;
2970 /* Varobj may refer to old symbols, perform a cleanup. */
2971 varobj_invalidate ();
2976 clear_symtab_users_cleanup (void *ignore
)
2978 clear_symtab_users (0);
2982 The following code implements an abstraction for debugging overlay sections.
2984 The target model is as follows:
2985 1) The gnu linker will permit multiple sections to be mapped into the
2986 same VMA, each with its own unique LMA (or load address).
2987 2) It is assumed that some runtime mechanism exists for mapping the
2988 sections, one by one, from the load address into the VMA address.
2989 3) This code provides a mechanism for gdb to keep track of which
2990 sections should be considered to be mapped from the VMA to the LMA.
2991 This information is used for symbol lookup, and memory read/write.
2992 For instance, if a section has been mapped then its contents
2993 should be read from the VMA, otherwise from the LMA.
2995 Two levels of debugger support for overlays are available. One is
2996 "manual", in which the debugger relies on the user to tell it which
2997 overlays are currently mapped. This level of support is
2998 implemented entirely in the core debugger, and the information about
2999 whether a section is mapped is kept in the objfile->obj_section table.
3001 The second level of support is "automatic", and is only available if
3002 the target-specific code provides functionality to read the target's
3003 overlay mapping table, and translate its contents for the debugger
3004 (by updating the mapped state information in the obj_section tables).
3006 The interface is as follows:
3008 overlay map <name> -- tell gdb to consider this section mapped
3009 overlay unmap <name> -- tell gdb to consider this section unmapped
3010 overlay list -- list the sections that GDB thinks are mapped
3011 overlay read-target -- get the target's state of what's mapped
3012 overlay off/manual/auto -- set overlay debugging state
3013 Functional interface:
3014 find_pc_mapped_section(pc): if the pc is in the range of a mapped
3015 section, return that section.
3016 find_pc_overlay(pc): find any overlay section that contains
3017 the pc, either in its VMA or its LMA
3018 section_is_mapped(sect): true if overlay is marked as mapped
3019 section_is_overlay(sect): true if section's VMA != LMA
3020 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
3021 pc_in_unmapped_range(...): true if pc belongs to section's LMA
3022 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
3023 overlay_mapped_address(...): map an address from section's LMA to VMA
3024 overlay_unmapped_address(...): map an address from section's VMA to LMA
3025 symbol_overlayed_address(...): Return a "current" address for symbol:
3026 either in VMA or LMA depending on whether
3027 the symbol's section is currently mapped. */
3029 /* Overlay debugging state: */
3031 enum overlay_debugging_state overlay_debugging
= ovly_off
;
3032 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
3034 /* Function: section_is_overlay (SECTION)
3035 Returns true if SECTION has VMA not equal to LMA, ie.
3036 SECTION is loaded at an address different from where it will "run". */
3039 section_is_overlay (struct obj_section
*section
)
3041 if (overlay_debugging
&& section
)
3043 bfd
*abfd
= section
->objfile
->obfd
;
3044 asection
*bfd_section
= section
->the_bfd_section
;
3046 if (bfd_section_lma (abfd
, bfd_section
) != 0
3047 && bfd_section_lma (abfd
, bfd_section
)
3048 != bfd_section_vma (abfd
, bfd_section
))
3055 /* Function: overlay_invalidate_all (void)
3056 Invalidate the mapped state of all overlay sections (mark it as stale). */
3059 overlay_invalidate_all (void)
3061 struct objfile
*objfile
;
3062 struct obj_section
*sect
;
3064 ALL_OBJSECTIONS (objfile
, sect
)
3065 if (section_is_overlay (sect
))
3066 sect
->ovly_mapped
= -1;
3069 /* Function: section_is_mapped (SECTION)
3070 Returns true if section is an overlay, and is currently mapped.
3072 Access to the ovly_mapped flag is restricted to this function, so
3073 that we can do automatic update. If the global flag
3074 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3075 overlay_invalidate_all. If the mapped state of the particular
3076 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3079 section_is_mapped (struct obj_section
*osect
)
3081 struct gdbarch
*gdbarch
;
3083 if (osect
== 0 || !section_is_overlay (osect
))
3086 switch (overlay_debugging
)
3090 return 0; /* overlay debugging off */
3091 case ovly_auto
: /* overlay debugging automatic */
3092 /* Unles there is a gdbarch_overlay_update function,
3093 there's really nothing useful to do here (can't really go auto). */
3094 gdbarch
= get_objfile_arch (osect
->objfile
);
3095 if (gdbarch_overlay_update_p (gdbarch
))
3097 if (overlay_cache_invalid
)
3099 overlay_invalidate_all ();
3100 overlay_cache_invalid
= 0;
3102 if (osect
->ovly_mapped
== -1)
3103 gdbarch_overlay_update (gdbarch
, osect
);
3105 /* fall thru to manual case */
3106 case ovly_on
: /* overlay debugging manual */
3107 return osect
->ovly_mapped
== 1;
3111 /* Function: pc_in_unmapped_range
3112 If PC falls into the lma range of SECTION, return true, else false. */
3115 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3117 if (section_is_overlay (section
))
3119 bfd
*abfd
= section
->objfile
->obfd
;
3120 asection
*bfd_section
= section
->the_bfd_section
;
3122 /* We assume the LMA is relocated by the same offset as the VMA. */
3123 bfd_vma size
= bfd_get_section_size (bfd_section
);
3124 CORE_ADDR offset
= obj_section_offset (section
);
3126 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3127 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3134 /* Function: pc_in_mapped_range
3135 If PC falls into the vma range of SECTION, return true, else false. */
3138 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3140 if (section_is_overlay (section
))
3142 if (obj_section_addr (section
) <= pc
3143 && pc
< obj_section_endaddr (section
))
3150 /* Return true if the mapped ranges of sections A and B overlap, false
3154 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3156 CORE_ADDR a_start
= obj_section_addr (a
);
3157 CORE_ADDR a_end
= obj_section_endaddr (a
);
3158 CORE_ADDR b_start
= obj_section_addr (b
);
3159 CORE_ADDR b_end
= obj_section_endaddr (b
);
3161 return (a_start
< b_end
&& b_start
< a_end
);
3164 /* Function: overlay_unmapped_address (PC, SECTION)
3165 Returns the address corresponding to PC in the unmapped (load) range.
3166 May be the same as PC. */
3169 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3171 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3173 bfd
*abfd
= section
->objfile
->obfd
;
3174 asection
*bfd_section
= section
->the_bfd_section
;
3176 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3177 - bfd_section_vma (abfd
, bfd_section
);
3183 /* Function: overlay_mapped_address (PC, SECTION)
3184 Returns the address corresponding to PC in the mapped (runtime) range.
3185 May be the same as PC. */
3188 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3190 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3192 bfd
*abfd
= section
->objfile
->obfd
;
3193 asection
*bfd_section
= section
->the_bfd_section
;
3195 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3196 - bfd_section_lma (abfd
, bfd_section
);
3202 /* Function: symbol_overlayed_address
3203 Return one of two addresses (relative to the VMA or to the LMA),
3204 depending on whether the section is mapped or not. */
3207 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3209 if (overlay_debugging
)
3211 /* If the symbol has no section, just return its regular address. */
3214 /* If the symbol's section is not an overlay, just return its
3216 if (!section_is_overlay (section
))
3218 /* If the symbol's section is mapped, just return its address. */
3219 if (section_is_mapped (section
))
3222 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3223 * then return its LOADED address rather than its vma address!!
3225 return overlay_unmapped_address (address
, section
);
3230 /* Function: find_pc_overlay (PC)
3231 Return the best-match overlay section for PC:
3232 If PC matches a mapped overlay section's VMA, return that section.
3233 Else if PC matches an unmapped section's VMA, return that section.
3234 Else if PC matches an unmapped section's LMA, return that section. */
3236 struct obj_section
*
3237 find_pc_overlay (CORE_ADDR pc
)
3239 struct objfile
*objfile
;
3240 struct obj_section
*osect
, *best_match
= NULL
;
3242 if (overlay_debugging
)
3243 ALL_OBJSECTIONS (objfile
, osect
)
3244 if (section_is_overlay (osect
))
3246 if (pc_in_mapped_range (pc
, osect
))
3248 if (section_is_mapped (osect
))
3253 else if (pc_in_unmapped_range (pc
, osect
))
3259 /* Function: find_pc_mapped_section (PC)
3260 If PC falls into the VMA address range of an overlay section that is
3261 currently marked as MAPPED, return that section. Else return NULL. */
3263 struct obj_section
*
3264 find_pc_mapped_section (CORE_ADDR pc
)
3266 struct objfile
*objfile
;
3267 struct obj_section
*osect
;
3269 if (overlay_debugging
)
3270 ALL_OBJSECTIONS (objfile
, osect
)
3271 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3277 /* Function: list_overlays_command
3278 Print a list of mapped sections and their PC ranges. */
3281 list_overlays_command (char *args
, int from_tty
)
3284 struct objfile
*objfile
;
3285 struct obj_section
*osect
;
3287 if (overlay_debugging
)
3288 ALL_OBJSECTIONS (objfile
, osect
)
3289 if (section_is_mapped (osect
))
3291 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3296 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3297 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3298 size
= bfd_get_section_size (osect
->the_bfd_section
);
3299 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3301 printf_filtered ("Section %s, loaded at ", name
);
3302 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3303 puts_filtered (" - ");
3304 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3305 printf_filtered (", mapped at ");
3306 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3307 puts_filtered (" - ");
3308 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3309 puts_filtered ("\n");
3314 printf_filtered (_("No sections are mapped.\n"));
3317 /* Function: map_overlay_command
3318 Mark the named section as mapped (ie. residing at its VMA address). */
3321 map_overlay_command (char *args
, int from_tty
)
3323 struct objfile
*objfile
, *objfile2
;
3324 struct obj_section
*sec
, *sec2
;
3326 if (!overlay_debugging
)
3327 error (_("Overlay debugging not enabled. Use "
3328 "either the 'overlay auto' or\n"
3329 "the 'overlay manual' command."));
3331 if (args
== 0 || *args
== 0)
3332 error (_("Argument required: name of an overlay section"));
3334 /* First, find a section matching the user supplied argument. */
3335 ALL_OBJSECTIONS (objfile
, sec
)
3336 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3338 /* Now, check to see if the section is an overlay. */
3339 if (!section_is_overlay (sec
))
3340 continue; /* not an overlay section */
3342 /* Mark the overlay as "mapped". */
3343 sec
->ovly_mapped
= 1;
3345 /* Next, make a pass and unmap any sections that are
3346 overlapped by this new section: */
3347 ALL_OBJSECTIONS (objfile2
, sec2
)
3348 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3351 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3352 bfd_section_name (objfile
->obfd
,
3353 sec2
->the_bfd_section
));
3354 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3358 error (_("No overlay section called %s"), args
);
3361 /* Function: unmap_overlay_command
3362 Mark the overlay section as unmapped
3363 (ie. resident in its LMA address range, rather than the VMA range). */
3366 unmap_overlay_command (char *args
, int from_tty
)
3368 struct objfile
*objfile
;
3369 struct obj_section
*sec
;
3371 if (!overlay_debugging
)
3372 error (_("Overlay debugging not enabled. "
3373 "Use either the 'overlay auto' or\n"
3374 "the 'overlay manual' command."));
3376 if (args
== 0 || *args
== 0)
3377 error (_("Argument required: name of an overlay section"));
3379 /* First, find a section matching the user supplied argument. */
3380 ALL_OBJSECTIONS (objfile
, sec
)
3381 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3383 if (!sec
->ovly_mapped
)
3384 error (_("Section %s is not mapped"), args
);
3385 sec
->ovly_mapped
= 0;
3388 error (_("No overlay section called %s"), args
);
3391 /* Function: overlay_auto_command
3392 A utility command to turn on overlay debugging.
3393 Possibly this should be done via a set/show command. */
3396 overlay_auto_command (char *args
, int from_tty
)
3398 overlay_debugging
= ovly_auto
;
3399 enable_overlay_breakpoints ();
3401 printf_unfiltered (_("Automatic overlay debugging enabled."));
3404 /* Function: overlay_manual_command
3405 A utility command to turn on overlay debugging.
3406 Possibly this should be done via a set/show command. */
3409 overlay_manual_command (char *args
, int from_tty
)
3411 overlay_debugging
= ovly_on
;
3412 disable_overlay_breakpoints ();
3414 printf_unfiltered (_("Overlay debugging enabled."));
3417 /* Function: overlay_off_command
3418 A utility command to turn on overlay debugging.
3419 Possibly this should be done via a set/show command. */
3422 overlay_off_command (char *args
, int from_tty
)
3424 overlay_debugging
= ovly_off
;
3425 disable_overlay_breakpoints ();
3427 printf_unfiltered (_("Overlay debugging disabled."));
3431 overlay_load_command (char *args
, int from_tty
)
3433 struct gdbarch
*gdbarch
= get_current_arch ();
3435 if (gdbarch_overlay_update_p (gdbarch
))
3436 gdbarch_overlay_update (gdbarch
, NULL
);
3438 error (_("This target does not know how to read its overlay state."));
3441 /* Function: overlay_command
3442 A place-holder for a mis-typed command. */
3444 /* Command list chain containing all defined "overlay" subcommands. */
3445 static struct cmd_list_element
*overlaylist
;
3448 overlay_command (char *args
, int from_tty
)
3451 ("\"overlay\" must be followed by the name of an overlay command.\n");
3452 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3455 /* Target Overlays for the "Simplest" overlay manager:
3457 This is GDB's default target overlay layer. It works with the
3458 minimal overlay manager supplied as an example by Cygnus. The
3459 entry point is via a function pointer "gdbarch_overlay_update",
3460 so targets that use a different runtime overlay manager can
3461 substitute their own overlay_update function and take over the
3464 The overlay_update function pokes around in the target's data structures
3465 to see what overlays are mapped, and updates GDB's overlay mapping with
3468 In this simple implementation, the target data structures are as follows:
3469 unsigned _novlys; /# number of overlay sections #/
3470 unsigned _ovly_table[_novlys][4] = {
3471 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3472 {..., ..., ..., ...},
3474 unsigned _novly_regions; /# number of overlay regions #/
3475 unsigned _ovly_region_table[_novly_regions][3] = {
3476 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3479 These functions will attempt to update GDB's mappedness state in the
3480 symbol section table, based on the target's mappedness state.
3482 To do this, we keep a cached copy of the target's _ovly_table, and
3483 attempt to detect when the cached copy is invalidated. The main
3484 entry point is "simple_overlay_update(SECT), which looks up SECT in
3485 the cached table and re-reads only the entry for that section from
3486 the target (whenever possible). */
3488 /* Cached, dynamically allocated copies of the target data structures: */
3489 static unsigned (*cache_ovly_table
)[4] = 0;
3490 static unsigned cache_novlys
= 0;
3491 static CORE_ADDR cache_ovly_table_base
= 0;
3494 VMA
, SIZE
, LMA
, MAPPED
3497 /* Throw away the cached copy of _ovly_table. */
3500 simple_free_overlay_table (void)
3502 if (cache_ovly_table
)
3503 xfree (cache_ovly_table
);
3505 cache_ovly_table
= NULL
;
3506 cache_ovly_table_base
= 0;
3509 /* Read an array of ints of size SIZE from the target into a local buffer.
3510 Convert to host order. int LEN is number of ints. */
3513 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3514 int len
, int size
, enum bfd_endian byte_order
)
3516 /* FIXME (alloca): Not safe if array is very large. */
3517 gdb_byte
*buf
= alloca (len
* size
);
3520 read_memory (memaddr
, buf
, len
* size
);
3521 for (i
= 0; i
< len
; i
++)
3522 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3525 /* Find and grab a copy of the target _ovly_table
3526 (and _novlys, which is needed for the table's size). */
3529 simple_read_overlay_table (void)
3531 struct minimal_symbol
*novlys_msym
;
3532 struct bound_minimal_symbol ovly_table_msym
;
3533 struct gdbarch
*gdbarch
;
3535 enum bfd_endian byte_order
;
3537 simple_free_overlay_table ();
3538 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3541 error (_("Error reading inferior's overlay table: "
3542 "couldn't find `_novlys' variable\n"
3543 "in inferior. Use `overlay manual' mode."));
3547 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3548 if (! ovly_table_msym
.minsym
)
3550 error (_("Error reading inferior's overlay table: couldn't find "
3551 "`_ovly_table' array\n"
3552 "in inferior. Use `overlay manual' mode."));
3556 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3557 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3558 byte_order
= gdbarch_byte_order (gdbarch
);
3560 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
),
3563 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3564 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
.minsym
);
3565 read_target_long_array (cache_ovly_table_base
,
3566 (unsigned int *) cache_ovly_table
,
3567 cache_novlys
* 4, word_size
, byte_order
);
3569 return 1; /* SUCCESS */
3572 /* Function: simple_overlay_update_1
3573 A helper function for simple_overlay_update. Assuming a cached copy
3574 of _ovly_table exists, look through it to find an entry whose vma,
3575 lma and size match those of OSECT. Re-read the entry and make sure
3576 it still matches OSECT (else the table may no longer be valid).
3577 Set OSECT's mapped state to match the entry. Return: 1 for
3578 success, 0 for failure. */
3581 simple_overlay_update_1 (struct obj_section
*osect
)
3584 bfd
*obfd
= osect
->objfile
->obfd
;
3585 asection
*bsect
= osect
->the_bfd_section
;
3586 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3587 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3588 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3590 size
= bfd_get_section_size (osect
->the_bfd_section
);
3591 for (i
= 0; i
< cache_novlys
; i
++)
3592 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3593 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3594 /* && cache_ovly_table[i][SIZE] == size */ )
3596 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3597 (unsigned int *) cache_ovly_table
[i
],
3598 4, word_size
, byte_order
);
3599 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3600 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3601 /* && cache_ovly_table[i][SIZE] == size */ )
3603 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3606 else /* Warning! Warning! Target's ovly table has changed! */
3612 /* Function: simple_overlay_update
3613 If OSECT is NULL, then update all sections' mapped state
3614 (after re-reading the entire target _ovly_table).
3615 If OSECT is non-NULL, then try to find a matching entry in the
3616 cached ovly_table and update only OSECT's mapped state.
3617 If a cached entry can't be found or the cache isn't valid, then
3618 re-read the entire cache, and go ahead and update all sections. */
3621 simple_overlay_update (struct obj_section
*osect
)
3623 struct objfile
*objfile
;
3625 /* Were we given an osect to look up? NULL means do all of them. */
3627 /* Have we got a cached copy of the target's overlay table? */
3628 if (cache_ovly_table
!= NULL
)
3630 /* Does its cached location match what's currently in the
3632 struct minimal_symbol
*minsym
3633 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3636 error (_("Error reading inferior's overlay table: couldn't "
3637 "find `_ovly_table' array\n"
3638 "in inferior. Use `overlay manual' mode."));
3640 if (cache_ovly_table_base
== SYMBOL_VALUE_ADDRESS (minsym
))
3641 /* Then go ahead and try to look up this single section in
3643 if (simple_overlay_update_1 (osect
))
3644 /* Found it! We're done. */
3648 /* Cached table no good: need to read the entire table anew.
3649 Or else we want all the sections, in which case it's actually
3650 more efficient to read the whole table in one block anyway. */
3652 if (! simple_read_overlay_table ())
3655 /* Now may as well update all sections, even if only one was requested. */
3656 ALL_OBJSECTIONS (objfile
, osect
)
3657 if (section_is_overlay (osect
))
3660 bfd
*obfd
= osect
->objfile
->obfd
;
3661 asection
*bsect
= osect
->the_bfd_section
;
3663 size
= bfd_get_section_size (bsect
);
3664 for (i
= 0; i
< cache_novlys
; i
++)
3665 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3666 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3667 /* && cache_ovly_table[i][SIZE] == size */ )
3668 { /* obj_section matches i'th entry in ovly_table. */
3669 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3670 break; /* finished with inner for loop: break out. */
3675 /* Set the output sections and output offsets for section SECTP in
3676 ABFD. The relocation code in BFD will read these offsets, so we
3677 need to be sure they're initialized. We map each section to itself,
3678 with no offset; this means that SECTP->vma will be honored. */
3681 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3683 sectp
->output_section
= sectp
;
3684 sectp
->output_offset
= 0;
3687 /* Default implementation for sym_relocate. */
3690 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3693 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3695 bfd
*abfd
= sectp
->owner
;
3697 /* We're only interested in sections with relocation
3699 if ((sectp
->flags
& SEC_RELOC
) == 0)
3702 /* We will handle section offsets properly elsewhere, so relocate as if
3703 all sections begin at 0. */
3704 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3706 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3709 /* Relocate the contents of a debug section SECTP in ABFD. The
3710 contents are stored in BUF if it is non-NULL, or returned in a
3711 malloc'd buffer otherwise.
3713 For some platforms and debug info formats, shared libraries contain
3714 relocations against the debug sections (particularly for DWARF-2;
3715 one affected platform is PowerPC GNU/Linux, although it depends on
3716 the version of the linker in use). Also, ELF object files naturally
3717 have unresolved relocations for their debug sections. We need to apply
3718 the relocations in order to get the locations of symbols correct.
3719 Another example that may require relocation processing, is the
3720 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3724 symfile_relocate_debug_section (struct objfile
*objfile
,
3725 asection
*sectp
, bfd_byte
*buf
)
3727 gdb_assert (objfile
->sf
->sym_relocate
);
3729 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3732 struct symfile_segment_data
*
3733 get_symfile_segment_data (bfd
*abfd
)
3735 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3740 return sf
->sym_segments (abfd
);
3744 free_symfile_segment_data (struct symfile_segment_data
*data
)
3746 xfree (data
->segment_bases
);
3747 xfree (data
->segment_sizes
);
3748 xfree (data
->segment_info
);
3753 - DATA, containing segment addresses from the object file ABFD, and
3754 the mapping from ABFD's sections onto the segments that own them,
3756 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3757 segment addresses reported by the target,
3758 store the appropriate offsets for each section in OFFSETS.
3760 If there are fewer entries in SEGMENT_BASES than there are segments
3761 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3763 If there are more entries, then ignore the extra. The target may
3764 not be able to distinguish between an empty data segment and a
3765 missing data segment; a missing text segment is less plausible. */
3768 symfile_map_offsets_to_segments (bfd
*abfd
,
3769 const struct symfile_segment_data
*data
,
3770 struct section_offsets
*offsets
,
3771 int num_segment_bases
,
3772 const CORE_ADDR
*segment_bases
)
3777 /* It doesn't make sense to call this function unless you have some
3778 segment base addresses. */
3779 gdb_assert (num_segment_bases
> 0);
3781 /* If we do not have segment mappings for the object file, we
3782 can not relocate it by segments. */
3783 gdb_assert (data
!= NULL
);
3784 gdb_assert (data
->num_segments
> 0);
3786 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3788 int which
= data
->segment_info
[i
];
3790 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3792 /* Don't bother computing offsets for sections that aren't
3793 loaded as part of any segment. */
3797 /* Use the last SEGMENT_BASES entry as the address of any extra
3798 segments mentioned in DATA->segment_info. */
3799 if (which
> num_segment_bases
)
3800 which
= num_segment_bases
;
3802 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3803 - data
->segment_bases
[which
- 1]);
3810 symfile_find_segment_sections (struct objfile
*objfile
)
3812 bfd
*abfd
= objfile
->obfd
;
3815 struct symfile_segment_data
*data
;
3817 data
= get_symfile_segment_data (objfile
->obfd
);
3821 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3823 free_symfile_segment_data (data
);
3827 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3829 int which
= data
->segment_info
[i
];
3833 if (objfile
->sect_index_text
== -1)
3834 objfile
->sect_index_text
= sect
->index
;
3836 if (objfile
->sect_index_rodata
== -1)
3837 objfile
->sect_index_rodata
= sect
->index
;
3839 else if (which
== 2)
3841 if (objfile
->sect_index_data
== -1)
3842 objfile
->sect_index_data
= sect
->index
;
3844 if (objfile
->sect_index_bss
== -1)
3845 objfile
->sect_index_bss
= sect
->index
;
3849 free_symfile_segment_data (data
);
3852 /* Listen for free_objfile events. */
3855 symfile_free_objfile (struct objfile
*objfile
)
3857 /* Remove the target sections of user-added objfiles. */
3858 if (objfile
!= 0 && objfile
->flags
& OBJF_USERLOADED
)
3859 remove_target_sections ((void *) objfile
);
3862 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3863 Expand all symtabs that match the specified criteria.
3864 See quick_symbol_functions.expand_symtabs_matching for details. */
3867 expand_symtabs_matching (expand_symtabs_file_matcher_ftype
*file_matcher
,
3868 expand_symtabs_symbol_matcher_ftype
*symbol_matcher
,
3869 enum search_domain kind
,
3872 struct objfile
*objfile
;
3874 ALL_OBJFILES (objfile
)
3877 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3878 symbol_matcher
, kind
,
3883 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3884 Map function FUN over every file.
3885 See quick_symbol_functions.map_symbol_filenames for details. */
3888 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3891 struct objfile
*objfile
;
3893 ALL_OBJFILES (objfile
)
3896 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3902 _initialize_symfile (void)
3904 struct cmd_list_element
*c
;
3906 observer_attach_free_objfile (symfile_free_objfile
);
3908 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3909 Load symbol table from executable file FILE.\n\
3910 The `file' command can also load symbol tables, as well as setting the file\n\
3911 to execute."), &cmdlist
);
3912 set_cmd_completer (c
, filename_completer
);
3914 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3915 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3916 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\
3917 ...]\nADDR is the starting address of the file's text.\n\
3918 The optional arguments are section-name section-address pairs and\n\
3919 should be specified if the data and bss segments are not contiguous\n\
3920 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3922 set_cmd_completer (c
, filename_completer
);
3924 c
= add_cmd ("remove-symbol-file", class_files
,
3925 remove_symbol_file_command
, _("\
3926 Remove a symbol file added via the add-symbol-file command.\n\
3927 Usage: remove-symbol-file FILENAME\n\
3928 remove-symbol-file -a ADDRESS\n\
3929 The file to remove can be identified by its filename or by an address\n\
3930 that lies within the boundaries of this symbol file in memory."),
3933 c
= add_cmd ("load", class_files
, load_command
, _("\
3934 Dynamically load FILE into the running program, and record its symbols\n\
3935 for access from GDB.\n\
3936 A load OFFSET may also be given."), &cmdlist
);
3937 set_cmd_completer (c
, filename_completer
);
3939 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3940 _("Commands for debugging overlays."), &overlaylist
,
3941 "overlay ", 0, &cmdlist
);
3943 add_com_alias ("ovly", "overlay", class_alias
, 1);
3944 add_com_alias ("ov", "overlay", class_alias
, 1);
3946 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3947 _("Assert that an overlay section is mapped."), &overlaylist
);
3949 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3950 _("Assert that an overlay section is unmapped."), &overlaylist
);
3952 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3953 _("List mappings of overlay sections."), &overlaylist
);
3955 add_cmd ("manual", class_support
, overlay_manual_command
,
3956 _("Enable overlay debugging."), &overlaylist
);
3957 add_cmd ("off", class_support
, overlay_off_command
,
3958 _("Disable overlay debugging."), &overlaylist
);
3959 add_cmd ("auto", class_support
, overlay_auto_command
,
3960 _("Enable automatic overlay debugging."), &overlaylist
);
3961 add_cmd ("load-target", class_support
, overlay_load_command
,
3962 _("Read the overlay mapping state from the target."), &overlaylist
);
3964 /* Filename extension to source language lookup table: */
3965 init_filename_language_table ();
3966 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3968 Set mapping between filename extension and source language."), _("\
3969 Show mapping between filename extension and source language."), _("\
3970 Usage: set extension-language .foo bar"),
3971 set_ext_lang_command
,
3973 &setlist
, &showlist
);
3975 add_info ("extensions", info_ext_lang_command
,
3976 _("All filename extensions associated with a source language."));
3978 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3979 &debug_file_directory
, _("\
3980 Set the directories where separate debug symbols are searched for."), _("\
3981 Show the directories where separate debug symbols are searched for."), _("\
3982 Separate debug symbols are first searched for in the same\n\
3983 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3984 and lastly at the path of the directory of the binary with\n\
3985 each global debug-file-directory component prepended."),
3987 show_debug_file_directory
,
3988 &setlist
, &showlist
);