1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2019 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/tilde.h"
49 #include "observable.h"
51 #include "parser-defs.h"
58 #include "cli/cli-utils.h"
59 #include "gdbsupport/byte-vector.h"
60 #include "gdbsupport/pathstuff.h"
61 #include "gdbsupport/selftest.h"
62 #include "cli/cli-style.h"
63 #include "gdbsupport/forward-scope-exit.h"
65 #include <sys/types.h>
74 int (*deprecated_ui_load_progress_hook
) (const char *section
,
76 void (*deprecated_show_load_progress
) (const char *section
,
77 unsigned long section_sent
,
78 unsigned long section_size
,
79 unsigned long total_sent
,
80 unsigned long total_size
);
81 void (*deprecated_pre_add_symbol_hook
) (const char *);
82 void (*deprecated_post_add_symbol_hook
) (void);
84 using clear_symtab_users_cleanup
85 = FORWARD_SCOPE_EXIT (clear_symtab_users
);
87 /* Global variables owned by this file. */
88 int readnow_symbol_files
; /* Read full symbols immediately. */
89 int readnever_symbol_files
; /* Never read full symbols. */
91 /* Functions this file defines. */
93 static void symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
94 objfile_flags flags
, CORE_ADDR reloff
);
96 static const struct sym_fns
*find_sym_fns (bfd
*);
98 static void overlay_invalidate_all (void);
100 static void simple_free_overlay_table (void);
102 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
105 static int simple_read_overlay_table (void);
107 static int simple_overlay_update_1 (struct obj_section
*);
109 static void symfile_find_segment_sections (struct objfile
*objfile
);
111 /* List of all available sym_fns. On gdb startup, each object file reader
112 calls add_symtab_fns() to register information on each format it is
115 struct registered_sym_fns
117 registered_sym_fns (bfd_flavour sym_flavour_
, const struct sym_fns
*sym_fns_
)
118 : sym_flavour (sym_flavour_
), sym_fns (sym_fns_
)
121 /* BFD flavour that we handle. */
122 enum bfd_flavour sym_flavour
;
124 /* The "vtable" of symbol functions. */
125 const struct sym_fns
*sym_fns
;
128 static std::vector
<registered_sym_fns
> symtab_fns
;
130 /* Values for "set print symbol-loading". */
132 const char print_symbol_loading_off
[] = "off";
133 const char print_symbol_loading_brief
[] = "brief";
134 const char print_symbol_loading_full
[] = "full";
135 static const char *print_symbol_loading_enums
[] =
137 print_symbol_loading_off
,
138 print_symbol_loading_brief
,
139 print_symbol_loading_full
,
142 static const char *print_symbol_loading
= print_symbol_loading_full
;
146 bool auto_solib_add
= true;
149 /* Return non-zero if symbol-loading messages should be printed.
150 FROM_TTY is the standard from_tty argument to gdb commands.
151 If EXEC is non-zero the messages are for the executable.
152 Otherwise, messages are for shared libraries.
153 If FULL is non-zero then the caller is printing a detailed message.
154 E.g., the message includes the shared library name.
155 Otherwise, the caller is printing a brief "summary" message. */
158 print_symbol_loading_p (int from_tty
, int exec
, int full
)
160 if (!from_tty
&& !info_verbose
)
165 /* We don't check FULL for executables, there are few such
166 messages, therefore brief == full. */
167 return print_symbol_loading
!= print_symbol_loading_off
;
170 return print_symbol_loading
== print_symbol_loading_full
;
171 return print_symbol_loading
== print_symbol_loading_brief
;
174 /* True if we are reading a symbol table. */
176 int currently_reading_symtab
= 0;
178 /* Increment currently_reading_symtab and return a cleanup that can be
179 used to decrement it. */
181 scoped_restore_tmpl
<int>
182 increment_reading_symtab (void)
184 gdb_assert (currently_reading_symtab
>= 0);
185 return make_scoped_restore (¤tly_reading_symtab
,
186 currently_reading_symtab
+ 1);
189 /* Remember the lowest-addressed loadable section we've seen.
190 This function is called via bfd_map_over_sections.
192 In case of equal vmas, the section with the largest size becomes the
193 lowest-addressed loadable section.
195 If the vmas and sizes are equal, the last section is considered the
196 lowest-addressed loadable section. */
199 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
201 asection
**lowest
= (asection
**) obj
;
203 if (0 == (bfd_section_flags (sect
) & (SEC_ALLOC
| SEC_LOAD
)))
206 *lowest
= sect
; /* First loadable section */
207 else if (bfd_section_vma (*lowest
) > bfd_section_vma (sect
))
208 *lowest
= sect
; /* A lower loadable section */
209 else if (bfd_section_vma (*lowest
) == bfd_section_vma (sect
)
210 && (bfd_section_size (*lowest
) <= bfd_section_size (sect
)))
214 /* Build (allocate and populate) a section_addr_info struct from
215 an existing section table. */
218 build_section_addr_info_from_section_table (const struct target_section
*start
,
219 const struct target_section
*end
)
221 const struct target_section
*stp
;
223 section_addr_info sap
;
225 for (stp
= start
; stp
!= end
; stp
++)
227 struct bfd_section
*asect
= stp
->the_bfd_section
;
228 bfd
*abfd
= asect
->owner
;
230 if (bfd_section_flags (asect
) & (SEC_ALLOC
| SEC_LOAD
)
231 && sap
.size () < end
- start
)
232 sap
.emplace_back (stp
->addr
,
233 bfd_section_name (asect
),
234 gdb_bfd_section_index (abfd
, asect
));
240 /* Create a section_addr_info from section offsets in ABFD. */
242 static section_addr_info
243 build_section_addr_info_from_bfd (bfd
*abfd
)
245 struct bfd_section
*sec
;
247 section_addr_info sap
;
248 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
249 if (bfd_section_flags (sec
) & (SEC_ALLOC
| SEC_LOAD
))
250 sap
.emplace_back (bfd_section_vma (sec
),
251 bfd_section_name (sec
),
252 gdb_bfd_section_index (abfd
, sec
));
257 /* Create a section_addr_info from section offsets in OBJFILE. */
260 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
264 /* Before reread_symbols gets rewritten it is not safe to call:
265 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
267 section_addr_info sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
268 for (i
= 0; i
< sap
.size (); i
++)
270 int sectindex
= sap
[i
].sectindex
;
272 sap
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
277 /* Initialize OBJFILE's sect_index_* members. */
280 init_objfile_sect_indices (struct objfile
*objfile
)
285 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
287 objfile
->sect_index_text
= sect
->index
;
289 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
291 objfile
->sect_index_data
= sect
->index
;
293 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
295 objfile
->sect_index_bss
= sect
->index
;
297 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
299 objfile
->sect_index_rodata
= sect
->index
;
301 /* This is where things get really weird... We MUST have valid
302 indices for the various sect_index_* members or gdb will abort.
303 So if for example, there is no ".text" section, we have to
304 accomodate that. First, check for a file with the standard
305 one or two segments. */
307 symfile_find_segment_sections (objfile
);
309 /* Except when explicitly adding symbol files at some address,
310 section_offsets contains nothing but zeros, so it doesn't matter
311 which slot in section_offsets the individual sect_index_* members
312 index into. So if they are all zero, it is safe to just point
313 all the currently uninitialized indices to the first slot. But
314 beware: if this is the main executable, it may be relocated
315 later, e.g. by the remote qOffsets packet, and then this will
316 be wrong! That's why we try segments first. */
318 for (i
= 0; i
< objfile
->num_sections
; i
++)
320 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
325 if (i
== objfile
->num_sections
)
327 if (objfile
->sect_index_text
== -1)
328 objfile
->sect_index_text
= 0;
329 if (objfile
->sect_index_data
== -1)
330 objfile
->sect_index_data
= 0;
331 if (objfile
->sect_index_bss
== -1)
332 objfile
->sect_index_bss
= 0;
333 if (objfile
->sect_index_rodata
== -1)
334 objfile
->sect_index_rodata
= 0;
338 /* The arguments to place_section. */
340 struct place_section_arg
342 struct section_offsets
*offsets
;
346 /* Find a unique offset to use for loadable section SECT if
347 the user did not provide an offset. */
350 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
352 struct place_section_arg
*arg
= (struct place_section_arg
*) obj
;
353 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
355 ULONGEST align
= ((ULONGEST
) 1) << bfd_section_alignment (sect
);
357 /* We are only interested in allocated sections. */
358 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
361 /* If the user specified an offset, honor it. */
362 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
365 /* Otherwise, let's try to find a place for the section. */
366 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
373 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
375 int indx
= cur_sec
->index
;
377 /* We don't need to compare against ourself. */
381 /* We can only conflict with allocated sections. */
382 if ((bfd_section_flags (cur_sec
) & SEC_ALLOC
) == 0)
385 /* If the section offset is 0, either the section has not been placed
386 yet, or it was the lowest section placed (in which case LOWEST
387 will be past its end). */
388 if (offsets
[indx
] == 0)
391 /* If this section would overlap us, then we must move up. */
392 if (start_addr
+ bfd_section_size (sect
) > offsets
[indx
]
393 && start_addr
< offsets
[indx
] + bfd_section_size (cur_sec
))
395 start_addr
= offsets
[indx
] + bfd_section_size (cur_sec
);
396 start_addr
= (start_addr
+ align
- 1) & -align
;
401 /* Otherwise, we appear to be OK. So far. */
406 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
407 arg
->lowest
= start_addr
+ bfd_section_size (sect
);
410 /* Store section_addr_info as prepared (made relative and with SECTINDEX
411 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
415 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
417 const section_addr_info
&addrs
)
421 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
423 /* Now calculate offsets for section that were specified by the caller. */
424 for (i
= 0; i
< addrs
.size (); i
++)
426 const struct other_sections
*osp
;
429 if (osp
->sectindex
== -1)
432 /* Record all sections in offsets. */
433 /* The section_offsets in the objfile are here filled in using
435 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
439 /* Transform section name S for a name comparison. prelink can split section
440 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
441 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
442 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
443 (`.sbss') section has invalid (increased) virtual address. */
446 addr_section_name (const char *s
)
448 if (strcmp (s
, ".dynbss") == 0)
450 if (strcmp (s
, ".sdynbss") == 0)
456 /* std::sort comparator for addrs_section_sort. Sort entries in
457 ascending order by their (name, sectindex) pair. sectindex makes
458 the sort by name stable. */
461 addrs_section_compar (const struct other_sections
*a
,
462 const struct other_sections
*b
)
466 retval
= strcmp (addr_section_name (a
->name
.c_str ()),
467 addr_section_name (b
->name
.c_str ()));
471 return a
->sectindex
< b
->sectindex
;
474 /* Provide sorted array of pointers to sections of ADDRS. */
476 static std::vector
<const struct other_sections
*>
477 addrs_section_sort (const section_addr_info
&addrs
)
481 std::vector
<const struct other_sections
*> array (addrs
.size ());
482 for (i
= 0; i
< addrs
.size (); i
++)
483 array
[i
] = &addrs
[i
];
485 std::sort (array
.begin (), array
.end (), addrs_section_compar
);
490 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
491 also SECTINDEXes specific to ABFD there. This function can be used to
492 rebase ADDRS to start referencing different BFD than before. */
495 addr_info_make_relative (section_addr_info
*addrs
, bfd
*abfd
)
497 asection
*lower_sect
;
498 CORE_ADDR lower_offset
;
501 /* Find lowest loadable section to be used as starting point for
502 contiguous sections. */
504 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
505 if (lower_sect
== NULL
)
507 warning (_("no loadable sections found in added symbol-file %s"),
508 bfd_get_filename (abfd
));
512 lower_offset
= bfd_section_vma (lower_sect
);
514 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
515 in ABFD. Section names are not unique - there can be multiple sections of
516 the same name. Also the sections of the same name do not have to be
517 adjacent to each other. Some sections may be present only in one of the
518 files. Even sections present in both files do not have to be in the same
521 Use stable sort by name for the sections in both files. Then linearly
522 scan both lists matching as most of the entries as possible. */
524 std::vector
<const struct other_sections
*> addrs_sorted
525 = addrs_section_sort (*addrs
);
527 section_addr_info abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
528 std::vector
<const struct other_sections
*> abfd_addrs_sorted
529 = addrs_section_sort (abfd_addrs
);
531 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
532 ABFD_ADDRS_SORTED. */
534 std::vector
<const struct other_sections
*>
535 addrs_to_abfd_addrs (addrs
->size (), nullptr);
537 std::vector
<const struct other_sections
*>::iterator abfd_sorted_iter
538 = abfd_addrs_sorted
.begin ();
539 for (const other_sections
*sect
: addrs_sorted
)
541 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
543 while (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
544 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
548 if (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
549 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
554 /* Make the found item directly addressable from ADDRS. */
555 index_in_addrs
= sect
- addrs
->data ();
556 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
557 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_sorted_iter
;
559 /* Never use the same ABFD entry twice. */
564 /* Calculate offsets for the loadable sections.
565 FIXME! Sections must be in order of increasing loadable section
566 so that contiguous sections can use the lower-offset!!!
568 Adjust offsets if the segments are not contiguous.
569 If the section is contiguous, its offset should be set to
570 the offset of the highest loadable section lower than it
571 (the loadable section directly below it in memory).
572 this_offset = lower_offset = lower_addr - lower_orig_addr */
574 for (i
= 0; i
< addrs
->size (); i
++)
576 const struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
580 /* This is the index used by BFD. */
581 (*addrs
)[i
].sectindex
= sect
->sectindex
;
583 if ((*addrs
)[i
].addr
!= 0)
585 (*addrs
)[i
].addr
-= sect
->addr
;
586 lower_offset
= (*addrs
)[i
].addr
;
589 (*addrs
)[i
].addr
= lower_offset
;
593 /* addr_section_name transformation is not used for SECT_NAME. */
594 const std::string
§_name
= (*addrs
)[i
].name
;
596 /* This section does not exist in ABFD, which is normally
597 unexpected and we want to issue a warning.
599 However, the ELF prelinker does create a few sections which are
600 marked in the main executable as loadable (they are loaded in
601 memory from the DYNAMIC segment) and yet are not present in
602 separate debug info files. This is fine, and should not cause
603 a warning. Shared libraries contain just the section
604 ".gnu.liblist" but it is not marked as loadable there. There is
605 no other way to identify them than by their name as the sections
606 created by prelink have no special flags.
608 For the sections `.bss' and `.sbss' see addr_section_name. */
610 if (!(sect_name
== ".gnu.liblist"
611 || sect_name
== ".gnu.conflict"
612 || (sect_name
== ".bss"
614 && (*addrs
)[i
- 1].name
== ".dynbss"
615 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
616 || (sect_name
== ".sbss"
618 && (*addrs
)[i
- 1].name
== ".sdynbss"
619 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
620 warning (_("section %s not found in %s"), sect_name
.c_str (),
621 bfd_get_filename (abfd
));
623 (*addrs
)[i
].addr
= 0;
624 (*addrs
)[i
].sectindex
= -1;
629 /* Parse the user's idea of an offset for dynamic linking, into our idea
630 of how to represent it for fast symbol reading. This is the default
631 version of the sym_fns.sym_offsets function for symbol readers that
632 don't need to do anything special. It allocates a section_offsets table
633 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
636 default_symfile_offsets (struct objfile
*objfile
,
637 const section_addr_info
&addrs
)
639 objfile
->num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
640 objfile
->section_offsets
= (struct section_offsets
*)
641 obstack_alloc (&objfile
->objfile_obstack
,
642 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
643 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
644 objfile
->num_sections
, addrs
);
646 /* For relocatable files, all loadable sections will start at zero.
647 The zero is meaningless, so try to pick arbitrary addresses such
648 that no loadable sections overlap. This algorithm is quadratic,
649 but the number of sections in a single object file is generally
651 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
653 struct place_section_arg arg
;
654 bfd
*abfd
= objfile
->obfd
;
657 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
658 /* We do not expect this to happen; just skip this step if the
659 relocatable file has a section with an assigned VMA. */
660 if (bfd_section_vma (cur_sec
) != 0)
665 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
667 /* Pick non-overlapping offsets for sections the user did not
669 arg
.offsets
= objfile
->section_offsets
;
671 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
673 /* Correctly filling in the section offsets is not quite
674 enough. Relocatable files have two properties that
675 (most) shared objects do not:
677 - Their debug information will contain relocations. Some
678 shared libraries do also, but many do not, so this can not
681 - If there are multiple code sections they will be loaded
682 at different relative addresses in memory than they are
683 in the objfile, since all sections in the file will start
686 Because GDB has very limited ability to map from an
687 address in debug info to the correct code section,
688 it relies on adding SECT_OFF_TEXT to things which might be
689 code. If we clear all the section offsets, and set the
690 section VMAs instead, then symfile_relocate_debug_section
691 will return meaningful debug information pointing at the
694 GDB has too many different data structures for section
695 addresses - a bfd, objfile, and so_list all have section
696 tables, as does exec_ops. Some of these could probably
699 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
700 cur_sec
= cur_sec
->next
)
702 if ((bfd_section_flags (cur_sec
) & SEC_ALLOC
) == 0)
705 bfd_set_section_vma (cur_sec
, offsets
[cur_sec
->index
]);
706 exec_set_section_address (bfd_get_filename (abfd
),
708 offsets
[cur_sec
->index
]);
709 offsets
[cur_sec
->index
] = 0;
714 /* Remember the bfd indexes for the .text, .data, .bss and
716 init_objfile_sect_indices (objfile
);
719 /* Divide the file into segments, which are individual relocatable units.
720 This is the default version of the sym_fns.sym_segments function for
721 symbol readers that do not have an explicit representation of segments.
722 It assumes that object files do not have segments, and fully linked
723 files have a single segment. */
725 struct symfile_segment_data
*
726 default_symfile_segments (bfd
*abfd
)
730 struct symfile_segment_data
*data
;
733 /* Relocatable files contain enough information to position each
734 loadable section independently; they should not be relocated
736 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
739 /* Make sure there is at least one loadable section in the file. */
740 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
742 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
750 low
= bfd_section_vma (sect
);
751 high
= low
+ bfd_section_size (sect
);
753 data
= XCNEW (struct symfile_segment_data
);
754 data
->num_segments
= 1;
755 data
->segment_bases
= XCNEW (CORE_ADDR
);
756 data
->segment_sizes
= XCNEW (CORE_ADDR
);
758 num_sections
= bfd_count_sections (abfd
);
759 data
->segment_info
= XCNEWVEC (int, num_sections
);
761 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
765 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
768 vma
= bfd_section_vma (sect
);
771 if (vma
+ bfd_section_size (sect
) > high
)
772 high
= vma
+ bfd_section_size (sect
);
774 data
->segment_info
[i
] = 1;
777 data
->segment_bases
[0] = low
;
778 data
->segment_sizes
[0] = high
- low
;
783 /* This is a convenience function to call sym_read for OBJFILE and
784 possibly force the partial symbols to be read. */
787 read_symbols (struct objfile
*objfile
, symfile_add_flags add_flags
)
789 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
790 objfile
->per_bfd
->minsyms_read
= true;
792 /* find_separate_debug_file_in_section should be called only if there is
793 single binary with no existing separate debug info file. */
794 if (!objfile_has_partial_symbols (objfile
)
795 && objfile
->separate_debug_objfile
== NULL
796 && objfile
->separate_debug_objfile_backlink
== NULL
)
798 gdb_bfd_ref_ptr
abfd (find_separate_debug_file_in_section (objfile
));
802 /* find_separate_debug_file_in_section uses the same filename for the
803 virtual section-as-bfd like the bfd filename containing the
804 section. Therefore use also non-canonical name form for the same
805 file containing the section. */
806 symbol_file_add_separate (abfd
.get (),
807 bfd_get_filename (abfd
.get ()),
808 add_flags
| SYMFILE_NOT_FILENAME
, objfile
);
811 if ((add_flags
& SYMFILE_NO_READ
) == 0)
812 require_partial_symbols (objfile
, 0);
815 /* Initialize entry point information for this objfile. */
818 init_entry_point_info (struct objfile
*objfile
)
820 struct entry_info
*ei
= &objfile
->per_bfd
->ei
;
826 /* Save startup file's range of PC addresses to help blockframe.c
827 decide where the bottom of the stack is. */
829 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
831 /* Executable file -- record its entry point so we'll recognize
832 the startup file because it contains the entry point. */
833 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
834 ei
->entry_point_p
= 1;
836 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
837 && bfd_get_start_address (objfile
->obfd
) != 0)
839 /* Some shared libraries may have entry points set and be
840 runnable. There's no clear way to indicate this, so just check
841 for values other than zero. */
842 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
843 ei
->entry_point_p
= 1;
847 /* Examination of non-executable.o files. Short-circuit this stuff. */
848 ei
->entry_point_p
= 0;
851 if (ei
->entry_point_p
)
853 struct obj_section
*osect
;
854 CORE_ADDR entry_point
= ei
->entry_point
;
857 /* Make certain that the address points at real code, and not a
858 function descriptor. */
860 = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile
),
862 current_top_target ());
864 /* Remove any ISA markers, so that this matches entries in the
867 = gdbarch_addr_bits_remove (get_objfile_arch (objfile
), entry_point
);
870 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
872 struct bfd_section
*sect
= osect
->the_bfd_section
;
874 if (entry_point
>= bfd_section_vma (sect
)
875 && entry_point
< (bfd_section_vma (sect
)
876 + bfd_section_size (sect
)))
878 ei
->the_bfd_section_index
879 = gdb_bfd_section_index (objfile
->obfd
, sect
);
886 ei
->the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
890 /* Process a symbol file, as either the main file or as a dynamically
893 This function does not set the OBJFILE's entry-point info.
895 OBJFILE is where the symbols are to be read from.
897 ADDRS is the list of section load addresses. If the user has given
898 an 'add-symbol-file' command, then this is the list of offsets and
899 addresses he or she provided as arguments to the command; or, if
900 we're handling a shared library, these are the actual addresses the
901 sections are loaded at, according to the inferior's dynamic linker
902 (as gleaned by GDB's shared library code). We convert each address
903 into an offset from the section VMA's as it appears in the object
904 file, and then call the file's sym_offsets function to convert this
905 into a format-specific offset table --- a `struct section_offsets'.
906 The sectindex field is used to control the ordering of sections
907 with the same name. Upon return, it is updated to contain the
908 corresponding BFD section index, or -1 if the section was not found.
910 ADD_FLAGS encodes verbosity level, whether this is main symbol or
911 an extra symbol file such as dynamically loaded code, and whether
912 breakpoint reset should be deferred. */
915 syms_from_objfile_1 (struct objfile
*objfile
,
916 section_addr_info
*addrs
,
917 symfile_add_flags add_flags
)
919 section_addr_info local_addr
;
920 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
922 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
924 if (objfile
->sf
== NULL
)
926 /* No symbols to load, but we still need to make sure
927 that the section_offsets table is allocated. */
928 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
929 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_sections
);
931 objfile
->num_sections
= num_sections
;
932 objfile
->section_offsets
933 = (struct section_offsets
*) obstack_alloc (&objfile
->objfile_obstack
,
935 memset (objfile
->section_offsets
, 0, size
);
939 /* Make sure that partially constructed symbol tables will be cleaned up
940 if an error occurs during symbol reading. */
941 gdb::optional
<clear_symtab_users_cleanup
> defer_clear_users
;
943 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
945 /* If ADDRS is NULL, put together a dummy address list.
946 We now establish the convention that an addr of zero means
947 no load address was specified. */
953 /* We will modify the main symbol table, make sure that all its users
954 will be cleaned up if an error occurs during symbol reading. */
955 defer_clear_users
.emplace ((symfile_add_flag
) 0);
957 /* Since no error yet, throw away the old symbol table. */
959 if (symfile_objfile
!= NULL
)
961 delete symfile_objfile
;
962 gdb_assert (symfile_objfile
== NULL
);
965 /* Currently we keep symbols from the add-symbol-file command.
966 If the user wants to get rid of them, they should do "symbol-file"
967 without arguments first. Not sure this is the best behavior
970 (*objfile
->sf
->sym_new_init
) (objfile
);
973 /* Convert addr into an offset rather than an absolute address.
974 We find the lowest address of a loaded segment in the objfile,
975 and assume that <addr> is where that got loaded.
977 We no longer warn if the lowest section is not a text segment (as
978 happens for the PA64 port. */
979 if (addrs
->size () > 0)
980 addr_info_make_relative (addrs
, objfile
->obfd
);
982 /* Initialize symbol reading routines for this objfile, allow complaints to
983 appear for this new file, and record how verbose to be, then do the
984 initial symbol reading for this file. */
986 (*objfile
->sf
->sym_init
) (objfile
);
989 (*objfile
->sf
->sym_offsets
) (objfile
, *addrs
);
991 read_symbols (objfile
, add_flags
);
993 /* Discard cleanups as symbol reading was successful. */
995 objfile_holder
.release ();
996 if (defer_clear_users
)
997 defer_clear_users
->release ();
1000 /* Same as syms_from_objfile_1, but also initializes the objfile
1001 entry-point info. */
1004 syms_from_objfile (struct objfile
*objfile
,
1005 section_addr_info
*addrs
,
1006 symfile_add_flags add_flags
)
1008 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
1009 init_entry_point_info (objfile
);
1012 /* Perform required actions after either reading in the initial
1013 symbols for a new objfile, or mapping in the symbols from a reusable
1014 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1017 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
1019 /* If this is the main symbol file we have to clean up all users of the
1020 old main symbol file. Otherwise it is sufficient to fixup all the
1021 breakpoints that may have been redefined by this symbol file. */
1022 if (add_flags
& SYMFILE_MAINLINE
)
1024 /* OK, make it the "real" symbol file. */
1025 symfile_objfile
= objfile
;
1027 clear_symtab_users (add_flags
);
1029 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1031 breakpoint_re_set ();
1034 /* We're done reading the symbol file; finish off complaints. */
1035 clear_complaints ();
1038 /* Process a symbol file, as either the main file or as a dynamically
1041 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1042 A new reference is acquired by this function.
1044 For NAME description see the objfile constructor.
1046 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1047 extra, such as dynamically loaded code, and what to do with breakpoints.
1049 ADDRS is as described for syms_from_objfile_1, above.
1050 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1052 PARENT is the original objfile if ABFD is a separate debug info file.
1053 Otherwise PARENT is NULL.
1055 Upon success, returns a pointer to the objfile that was added.
1056 Upon failure, jumps back to command level (never returns). */
1058 static struct objfile
*
1059 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
,
1060 symfile_add_flags add_flags
,
1061 section_addr_info
*addrs
,
1062 objfile_flags flags
, struct objfile
*parent
)
1064 struct objfile
*objfile
;
1065 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1066 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1067 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1068 && (readnow_symbol_files
1069 || (add_flags
& SYMFILE_NO_READ
) == 0));
1071 if (readnow_symbol_files
)
1073 flags
|= OBJF_READNOW
;
1074 add_flags
&= ~SYMFILE_NO_READ
;
1076 else if (readnever_symbol_files
1077 || (parent
!= NULL
&& (parent
->flags
& OBJF_READNEVER
)))
1079 flags
|= OBJF_READNEVER
;
1080 add_flags
|= SYMFILE_NO_READ
;
1082 if ((add_flags
& SYMFILE_NOT_FILENAME
) != 0)
1083 flags
|= OBJF_NOT_FILENAME
;
1085 /* Give user a chance to burp if we'd be
1086 interactively wiping out any existing symbols. */
1088 if ((have_full_symbols () || have_partial_symbols ())
1091 && !query (_("Load new symbol table from \"%s\"? "), name
))
1092 error (_("Not confirmed."));
1095 flags
|= OBJF_MAINLINE
;
1096 objfile
= new struct objfile (abfd
, name
, flags
);
1099 add_separate_debug_objfile (objfile
, parent
);
1101 /* We either created a new mapped symbol table, mapped an existing
1102 symbol table file which has not had initial symbol reading
1103 performed, or need to read an unmapped symbol table. */
1106 if (deprecated_pre_add_symbol_hook
)
1107 deprecated_pre_add_symbol_hook (name
);
1109 printf_filtered (_("Reading symbols from %ps...\n"),
1110 styled_string (file_name_style
.style (), name
));
1112 syms_from_objfile (objfile
, addrs
, add_flags
);
1114 /* We now have at least a partial symbol table. Check to see if the
1115 user requested that all symbols be read on initial access via either
1116 the gdb startup command line or on a per symbol file basis. Expand
1117 all partial symbol tables for this objfile if so. */
1119 if ((flags
& OBJF_READNOW
))
1122 printf_filtered (_("Expanding full symbols from %ps...\n"),
1123 styled_string (file_name_style
.style (), name
));
1126 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1129 /* Note that we only print a message if we have no symbols and have
1130 no separate debug file. If there is a separate debug file which
1131 does not have symbols, we'll have emitted this message for that
1132 file, and so printing it twice is just redundant. */
1133 if (should_print
&& !objfile_has_symbols (objfile
)
1134 && objfile
->separate_debug_objfile
== nullptr)
1135 printf_filtered (_("(No debugging symbols found in %ps)\n"),
1136 styled_string (file_name_style
.style (), name
));
1140 if (deprecated_post_add_symbol_hook
)
1141 deprecated_post_add_symbol_hook ();
1144 /* We print some messages regardless of whether 'from_tty ||
1145 info_verbose' is true, so make sure they go out at the right
1147 gdb_flush (gdb_stdout
);
1149 if (objfile
->sf
== NULL
)
1151 gdb::observers::new_objfile
.notify (objfile
);
1152 return objfile
; /* No symbols. */
1155 finish_new_objfile (objfile
, add_flags
);
1157 gdb::observers::new_objfile
.notify (objfile
);
1159 bfd_cache_close_all ();
1163 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1164 see the objfile constructor. */
1167 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1168 symfile_add_flags symfile_flags
,
1169 struct objfile
*objfile
)
1171 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1172 because sections of BFD may not match sections of OBJFILE and because
1173 vma may have been modified by tools such as prelink. */
1174 section_addr_info sap
= build_section_addr_info_from_objfile (objfile
);
1176 symbol_file_add_with_addrs
1177 (bfd
, name
, symfile_flags
, &sap
,
1178 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1183 /* Process the symbol file ABFD, as either the main file or as a
1184 dynamically loaded file.
1185 See symbol_file_add_with_addrs's comments for details. */
1188 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1189 symfile_add_flags add_flags
,
1190 section_addr_info
*addrs
,
1191 objfile_flags flags
, struct objfile
*parent
)
1193 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1197 /* Process a symbol file, as either the main file or as a dynamically
1198 loaded file. See symbol_file_add_with_addrs's comments for details. */
1201 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1202 section_addr_info
*addrs
, objfile_flags flags
)
1204 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1206 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1210 /* Call symbol_file_add() with default values and update whatever is
1211 affected by the loading of a new main().
1212 Used when the file is supplied in the gdb command line
1213 and by some targets with special loading requirements.
1214 The auxiliary function, symbol_file_add_main_1(), has the flags
1215 argument for the switches that can only be specified in the symbol_file
1219 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1221 symbol_file_add_main_1 (args
, add_flags
, 0, 0);
1225 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1226 objfile_flags flags
, CORE_ADDR reloff
)
1228 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1230 struct objfile
*objfile
= symbol_file_add (args
, add_flags
, NULL
, flags
);
1232 objfile_rebase (objfile
, reloff
);
1234 /* Getting new symbols may change our opinion about
1235 what is frameless. */
1236 reinit_frame_cache ();
1238 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1239 set_initial_language ();
1243 symbol_file_clear (int from_tty
)
1245 if ((have_full_symbols () || have_partial_symbols ())
1248 ? !query (_("Discard symbol table from `%s'? "),
1249 objfile_name (symfile_objfile
))
1250 : !query (_("Discard symbol table? "))))
1251 error (_("Not confirmed."));
1253 /* solib descriptors may have handles to objfiles. Wipe them before their
1254 objfiles get stale by free_all_objfiles. */
1255 no_shared_libraries (NULL
, from_tty
);
1257 free_all_objfiles ();
1259 gdb_assert (symfile_objfile
== NULL
);
1261 printf_filtered (_("No symbol file now.\n"));
1264 /* See symfile.h. */
1266 bool separate_debug_file_debug
= false;
1269 separate_debug_file_exists (const std::string
&name
, unsigned long crc
,
1270 struct objfile
*parent_objfile
)
1272 unsigned long file_crc
;
1274 struct stat parent_stat
, abfd_stat
;
1275 int verified_as_different
;
1277 /* Find a separate debug info file as if symbols would be present in
1278 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1279 section can contain just the basename of PARENT_OBJFILE without any
1280 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1281 the separate debug infos with the same basename can exist. */
1283 if (filename_cmp (name
.c_str (), objfile_name (parent_objfile
)) == 0)
1286 if (separate_debug_file_debug
)
1288 printf_filtered (_(" Trying %s..."), name
.c_str ());
1289 gdb_flush (gdb_stdout
);
1292 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
.c_str (), gnutarget
, -1));
1296 if (separate_debug_file_debug
)
1297 printf_filtered (_(" no, unable to open.\n"));
1302 /* Verify symlinks were not the cause of filename_cmp name difference above.
1304 Some operating systems, e.g. Windows, do not provide a meaningful
1305 st_ino; they always set it to zero. (Windows does provide a
1306 meaningful st_dev.) Files accessed from gdbservers that do not
1307 support the vFile:fstat packet will also have st_ino set to zero.
1308 Do not indicate a duplicate library in either case. While there
1309 is no guarantee that a system that provides meaningful inode
1310 numbers will never set st_ino to zero, this is merely an
1311 optimization, so we do not need to worry about false negatives. */
1313 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1314 && abfd_stat
.st_ino
!= 0
1315 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1317 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1318 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1320 if (separate_debug_file_debug
)
1321 printf_filtered (_(" no, same file as the objfile.\n"));
1325 verified_as_different
= 1;
1328 verified_as_different
= 0;
1330 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1334 if (separate_debug_file_debug
)
1335 printf_filtered (_(" no, error computing CRC.\n"));
1340 if (crc
!= file_crc
)
1342 unsigned long parent_crc
;
1344 /* If the files could not be verified as different with
1345 bfd_stat then we need to calculate the parent's CRC
1346 to verify whether the files are different or not. */
1348 if (!verified_as_different
)
1350 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1352 if (separate_debug_file_debug
)
1353 printf_filtered (_(" no, error computing CRC.\n"));
1359 if (verified_as_different
|| parent_crc
!= file_crc
)
1360 warning (_("the debug information found in \"%s\""
1361 " does not match \"%s\" (CRC mismatch).\n"),
1362 name
.c_str (), objfile_name (parent_objfile
));
1364 if (separate_debug_file_debug
)
1365 printf_filtered (_(" no, CRC doesn't match.\n"));
1370 if (separate_debug_file_debug
)
1371 printf_filtered (_(" yes!\n"));
1376 char *debug_file_directory
= NULL
;
1378 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1379 struct cmd_list_element
*c
, const char *value
)
1381 fprintf_filtered (file
,
1382 _("The directory where separate debug "
1383 "symbols are searched for is \"%s\".\n"),
1387 #if ! defined (DEBUG_SUBDIRECTORY)
1388 #define DEBUG_SUBDIRECTORY ".debug"
1391 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1392 where the original file resides (may not be the same as
1393 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1394 looking for. CANON_DIR is the "realpath" form of DIR.
1395 DIR must contain a trailing '/'.
1396 Returns the path of the file with separate debug info, or an empty
1400 find_separate_debug_file (const char *dir
,
1401 const char *canon_dir
,
1402 const char *debuglink
,
1403 unsigned long crc32
, struct objfile
*objfile
)
1405 if (separate_debug_file_debug
)
1406 printf_filtered (_("\nLooking for separate debug info (debug link) for "
1407 "%s\n"), objfile_name (objfile
));
1409 /* First try in the same directory as the original file. */
1410 std::string debugfile
= dir
;
1411 debugfile
+= debuglink
;
1413 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1416 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1418 debugfile
+= DEBUG_SUBDIRECTORY
;
1420 debugfile
+= debuglink
;
1422 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1425 /* Then try in the global debugfile directories.
1427 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1428 cause "/..." lookups. */
1430 bool target_prefix
= startswith (dir
, "target:");
1431 const char *dir_notarget
= target_prefix
? dir
+ strlen ("target:") : dir
;
1432 std::vector
<gdb::unique_xmalloc_ptr
<char>> debugdir_vec
1433 = dirnames_to_char_ptr_vec (debug_file_directory
);
1434 gdb::unique_xmalloc_ptr
<char> canon_sysroot
= gdb_realpath (gdb_sysroot
);
1436 /* MS-Windows/MS-DOS don't allow colons in file names; we must
1437 convert the drive letter into a one-letter directory, so that the
1438 file name resulting from splicing below will be valid.
1440 FIXME: The below only works when GDB runs on MS-Windows/MS-DOS.
1441 There are various remote-debugging scenarios where such a
1442 transformation of the drive letter might be required when GDB runs
1443 on a Posix host, see
1445 https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
1447 If some of those scenarios need to be supported, we will need to
1448 use a different condition for HAS_DRIVE_SPEC and a different macro
1449 instead of STRIP_DRIVE_SPEC, which work on Posix systems as well. */
1451 if (HAS_DRIVE_SPEC (dir_notarget
))
1453 drive
= dir_notarget
[0];
1454 dir_notarget
= STRIP_DRIVE_SPEC (dir_notarget
);
1457 for (const gdb::unique_xmalloc_ptr
<char> &debugdir
: debugdir_vec
)
1459 debugfile
= target_prefix
? "target:" : "";
1460 debugfile
+= debugdir
.get ();
1463 debugfile
+= dir_notarget
;
1464 debugfile
+= debuglink
;
1466 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1469 const char *base_path
= NULL
;
1470 if (canon_dir
!= NULL
)
1472 if (canon_sysroot
.get () != NULL
)
1473 base_path
= child_path (canon_sysroot
.get (), canon_dir
);
1475 base_path
= child_path (gdb_sysroot
, canon_dir
);
1477 if (base_path
!= NULL
)
1479 /* If the file is in the sysroot, try using its base path in
1480 the global debugfile directory. */
1481 debugfile
= target_prefix
? "target:" : "";
1482 debugfile
+= debugdir
.get ();
1484 debugfile
+= base_path
;
1486 debugfile
+= debuglink
;
1488 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1491 /* If the file is in the sysroot, try using its base path in
1492 the sysroot's global debugfile directory. */
1493 debugfile
= target_prefix
? "target:" : "";
1494 debugfile
+= gdb_sysroot
;
1495 debugfile
+= debugdir
.get ();
1497 debugfile
+= base_path
;
1499 debugfile
+= debuglink
;
1501 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1507 return std::string ();
1510 /* Modify PATH to contain only "[/]directory/" part of PATH.
1511 If there were no directory separators in PATH, PATH will be empty
1512 string on return. */
1515 terminate_after_last_dir_separator (char *path
)
1519 /* Strip off the final filename part, leaving the directory name,
1520 followed by a slash. The directory can be relative or absolute. */
1521 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1522 if (IS_DIR_SEPARATOR (path
[i
]))
1525 /* If I is -1 then no directory is present there and DIR will be "". */
1529 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1530 Returns pathname, or an empty string. */
1533 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1535 unsigned long crc32
;
1537 gdb::unique_xmalloc_ptr
<char> debuglink
1538 (bfd_get_debug_link_info (objfile
->obfd
, &crc32
));
1540 if (debuglink
== NULL
)
1542 /* There's no separate debug info, hence there's no way we could
1543 load it => no warning. */
1544 return std::string ();
1547 std::string dir
= objfile_name (objfile
);
1548 terminate_after_last_dir_separator (&dir
[0]);
1549 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1551 std::string debugfile
1552 = find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1553 debuglink
.get (), crc32
, objfile
);
1555 if (debugfile
.empty ())
1557 /* For PR gdb/9538, try again with realpath (if different from the
1562 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1563 && S_ISLNK (st_buf
.st_mode
))
1565 gdb::unique_xmalloc_ptr
<char> symlink_dir
1566 (lrealpath (objfile_name (objfile
)));
1567 if (symlink_dir
!= NULL
)
1569 terminate_after_last_dir_separator (symlink_dir
.get ());
1570 if (dir
!= symlink_dir
.get ())
1572 /* Different directory, so try using it. */
1573 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1586 /* Make sure that OBJF_{READNOW,READNEVER} are not set
1590 validate_readnow_readnever (objfile_flags flags
)
1592 if ((flags
& OBJF_READNOW
) && (flags
& OBJF_READNEVER
))
1593 error (_("-readnow and -readnever cannot be used simultaneously"));
1596 /* This is the symbol-file command. Read the file, analyze its
1597 symbols, and add a struct symtab to a symtab list. The syntax of
1598 the command is rather bizarre:
1600 1. The function buildargv implements various quoting conventions
1601 which are undocumented and have little or nothing in common with
1602 the way things are quoted (or not quoted) elsewhere in GDB.
1604 2. Options are used, which are not generally used in GDB (perhaps
1605 "set mapped on", "set readnow on" would be better)
1607 3. The order of options matters, which is contrary to GNU
1608 conventions (because it is confusing and inconvenient). */
1611 symbol_file_command (const char *args
, int from_tty
)
1617 symbol_file_clear (from_tty
);
1621 objfile_flags flags
= OBJF_USERLOADED
;
1622 symfile_add_flags add_flags
= 0;
1624 bool stop_processing_options
= false;
1625 CORE_ADDR offset
= 0;
1630 add_flags
|= SYMFILE_VERBOSE
;
1632 gdb_argv
built_argv (args
);
1633 for (arg
= built_argv
[0], idx
= 0; arg
!= NULL
; arg
= built_argv
[++idx
])
1635 if (stop_processing_options
|| *arg
!= '-')
1640 error (_("Unrecognized argument \"%s\""), arg
);
1642 else if (strcmp (arg
, "-readnow") == 0)
1643 flags
|= OBJF_READNOW
;
1644 else if (strcmp (arg
, "-readnever") == 0)
1645 flags
|= OBJF_READNEVER
;
1646 else if (strcmp (arg
, "-o") == 0)
1648 arg
= built_argv
[++idx
];
1650 error (_("Missing argument to -o"));
1652 offset
= parse_and_eval_address (arg
);
1654 else if (strcmp (arg
, "--") == 0)
1655 stop_processing_options
= true;
1657 error (_("Unrecognized argument \"%s\""), arg
);
1661 error (_("no symbol file name was specified"));
1663 validate_readnow_readnever (flags
);
1665 /* Set SYMFILE_DEFER_BP_RESET because the proper displacement for a PIE
1666 (Position Independent Executable) main symbol file will only be
1667 computed by the solib_create_inferior_hook below. Without it,
1668 breakpoint_re_set would fail to insert the breakpoints with the zero
1670 add_flags
|= SYMFILE_DEFER_BP_RESET
;
1672 symbol_file_add_main_1 (name
, add_flags
, flags
, offset
);
1674 solib_create_inferior_hook (from_tty
);
1676 /* Now it's safe to re-add the breakpoints. */
1677 breakpoint_re_set ();
1681 /* Set the initial language.
1683 FIXME: A better solution would be to record the language in the
1684 psymtab when reading partial symbols, and then use it (if known) to
1685 set the language. This would be a win for formats that encode the
1686 language in an easily discoverable place, such as DWARF. For
1687 stabs, we can jump through hoops looking for specially named
1688 symbols or try to intuit the language from the specific type of
1689 stabs we find, but we can't do that until later when we read in
1693 set_initial_language (void)
1695 enum language lang
= main_language ();
1697 if (lang
== language_unknown
)
1699 const char *name
= main_name ();
1700 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1703 lang
= SYMBOL_LANGUAGE (sym
);
1706 if (lang
== language_unknown
)
1708 /* Make C the default language */
1712 set_language (lang
);
1713 expected_language
= current_language
; /* Don't warn the user. */
1716 /* Open the file specified by NAME and hand it off to BFD for
1717 preliminary analysis. Return a newly initialized bfd *, which
1718 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1719 absolute). In case of trouble, error() is called. */
1722 symfile_bfd_open (const char *name
)
1726 gdb::unique_xmalloc_ptr
<char> absolute_name
;
1727 if (!is_target_filename (name
))
1729 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1731 /* Look down path for it, allocate 2nd new malloc'd copy. */
1732 desc
= openp (getenv ("PATH"),
1733 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1734 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1735 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1738 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1740 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1741 desc
= openp (getenv ("PATH"),
1742 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1743 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1747 perror_with_name (expanded_name
.get ());
1749 name
= absolute_name
.get ();
1752 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1753 if (sym_bfd
== NULL
)
1754 error (_("`%s': can't open to read symbols: %s."), name
,
1755 bfd_errmsg (bfd_get_error ()));
1757 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1758 bfd_set_cacheable (sym_bfd
.get (), 1);
1760 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1761 error (_("`%s': can't read symbols: %s."), name
,
1762 bfd_errmsg (bfd_get_error ()));
1767 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1768 the section was not found. */
1771 get_section_index (struct objfile
*objfile
, const char *section_name
)
1773 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1781 /* Link SF into the global symtab_fns list.
1782 FLAVOUR is the file format that SF handles.
1783 Called on startup by the _initialize routine in each object file format
1784 reader, to register information about each format the reader is prepared
1788 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1790 symtab_fns
.emplace_back (flavour
, sf
);
1793 /* Initialize OBJFILE to read symbols from its associated BFD. It
1794 either returns or calls error(). The result is an initialized
1795 struct sym_fns in the objfile structure, that contains cached
1796 information about the symbol file. */
1798 static const struct sym_fns
*
1799 find_sym_fns (bfd
*abfd
)
1801 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1803 if (our_flavour
== bfd_target_srec_flavour
1804 || our_flavour
== bfd_target_ihex_flavour
1805 || our_flavour
== bfd_target_tekhex_flavour
)
1806 return NULL
; /* No symbols. */
1808 for (const registered_sym_fns
&rsf
: symtab_fns
)
1809 if (our_flavour
== rsf
.sym_flavour
)
1812 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1813 bfd_get_target (abfd
));
1817 /* This function runs the load command of our current target. */
1820 load_command (const char *arg
, int from_tty
)
1824 /* The user might be reloading because the binary has changed. Take
1825 this opportunity to check. */
1826 reopen_exec_file ();
1832 const char *parg
, *prev
;
1834 arg
= get_exec_file (1);
1836 /* We may need to quote this string so buildargv can pull it
1839 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1841 temp
.append (prev
, parg
- prev
);
1843 temp
.push_back ('\\');
1845 /* If we have not copied anything yet, then we didn't see a
1846 character to quote, and we can just leave ARG unchanged. */
1850 arg
= temp
.c_str ();
1854 target_load (arg
, from_tty
);
1856 /* After re-loading the executable, we don't really know which
1857 overlays are mapped any more. */
1858 overlay_cache_invalid
= 1;
1861 /* This version of "load" should be usable for any target. Currently
1862 it is just used for remote targets, not inftarg.c or core files,
1863 on the theory that only in that case is it useful.
1865 Avoiding xmodem and the like seems like a win (a) because we don't have
1866 to worry about finding it, and (b) On VMS, fork() is very slow and so
1867 we don't want to run a subprocess. On the other hand, I'm not sure how
1868 performance compares. */
1870 static int validate_download
= 0;
1872 /* Callback service function for generic_load (bfd_map_over_sections). */
1875 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1877 bfd_size_type
*sum
= (bfd_size_type
*) data
;
1879 *sum
+= bfd_section_size (asec
);
1882 /* Opaque data for load_progress. */
1883 struct load_progress_data
1885 /* Cumulative data. */
1886 unsigned long write_count
= 0;
1887 unsigned long data_count
= 0;
1888 bfd_size_type total_size
= 0;
1891 /* Opaque data for load_progress for a single section. */
1892 struct load_progress_section_data
1894 load_progress_section_data (load_progress_data
*cumulative_
,
1895 const char *section_name_
, ULONGEST section_size_
,
1896 CORE_ADDR lma_
, gdb_byte
*buffer_
)
1897 : cumulative (cumulative_
), section_name (section_name_
),
1898 section_size (section_size_
), lma (lma_
), buffer (buffer_
)
1901 struct load_progress_data
*cumulative
;
1903 /* Per-section data. */
1904 const char *section_name
;
1905 ULONGEST section_sent
= 0;
1906 ULONGEST section_size
;
1911 /* Opaque data for load_section_callback. */
1912 struct load_section_data
1914 load_section_data (load_progress_data
*progress_data_
)
1915 : progress_data (progress_data_
)
1918 ~load_section_data ()
1920 for (auto &&request
: requests
)
1922 xfree (request
.data
);
1923 delete ((load_progress_section_data
*) request
.baton
);
1927 CORE_ADDR load_offset
= 0;
1928 struct load_progress_data
*progress_data
;
1929 std::vector
<struct memory_write_request
> requests
;
1932 /* Target write callback routine for progress reporting. */
1935 load_progress (ULONGEST bytes
, void *untyped_arg
)
1937 struct load_progress_section_data
*args
1938 = (struct load_progress_section_data
*) untyped_arg
;
1939 struct load_progress_data
*totals
;
1942 /* Writing padding data. No easy way to get at the cumulative
1943 stats, so just ignore this. */
1946 totals
= args
->cumulative
;
1948 if (bytes
== 0 && args
->section_sent
== 0)
1950 /* The write is just starting. Let the user know we've started
1952 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1954 hex_string (args
->section_size
),
1955 paddress (target_gdbarch (), args
->lma
));
1959 if (validate_download
)
1961 /* Broken memories and broken monitors manifest themselves here
1962 when bring new computers to life. This doubles already slow
1964 /* NOTE: cagney/1999-10-18: A more efficient implementation
1965 might add a verify_memory() method to the target vector and
1966 then use that. remote.c could implement that method using
1967 the ``qCRC'' packet. */
1968 gdb::byte_vector
check (bytes
);
1970 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1971 error (_("Download verify read failed at %s"),
1972 paddress (target_gdbarch (), args
->lma
));
1973 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1974 error (_("Download verify compare failed at %s"),
1975 paddress (target_gdbarch (), args
->lma
));
1977 totals
->data_count
+= bytes
;
1979 args
->buffer
+= bytes
;
1980 totals
->write_count
+= 1;
1981 args
->section_sent
+= bytes
;
1982 if (check_quit_flag ()
1983 || (deprecated_ui_load_progress_hook
!= NULL
1984 && deprecated_ui_load_progress_hook (args
->section_name
,
1985 args
->section_sent
)))
1986 error (_("Canceled the download"));
1988 if (deprecated_show_load_progress
!= NULL
)
1989 deprecated_show_load_progress (args
->section_name
,
1993 totals
->total_size
);
1996 /* Callback service function for generic_load (bfd_map_over_sections). */
1999 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
2001 struct load_section_data
*args
= (struct load_section_data
*) data
;
2002 bfd_size_type size
= bfd_section_size (asec
);
2003 const char *sect_name
= bfd_section_name (asec
);
2005 if ((bfd_section_flags (asec
) & SEC_LOAD
) == 0)
2011 ULONGEST begin
= bfd_section_lma (asec
) + args
->load_offset
;
2012 ULONGEST end
= begin
+ size
;
2013 gdb_byte
*buffer
= (gdb_byte
*) xmalloc (size
);
2014 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2016 load_progress_section_data
*section_data
2017 = new load_progress_section_data (args
->progress_data
, sect_name
, size
,
2020 args
->requests
.emplace_back (begin
, end
, buffer
, section_data
);
2023 static void print_transfer_performance (struct ui_file
*stream
,
2024 unsigned long data_count
,
2025 unsigned long write_count
,
2026 std::chrono::steady_clock::duration d
);
2028 /* See symfile.h. */
2031 generic_load (const char *args
, int from_tty
)
2033 struct load_progress_data total_progress
;
2034 struct load_section_data
cbdata (&total_progress
);
2035 struct ui_out
*uiout
= current_uiout
;
2038 error_no_arg (_("file to load"));
2040 gdb_argv
argv (args
);
2042 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2044 if (argv
[1] != NULL
)
2048 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2050 /* If the last word was not a valid number then
2051 treat it as a file name with spaces in. */
2052 if (argv
[1] == endptr
)
2053 error (_("Invalid download offset:%s."), argv
[1]);
2055 if (argv
[2] != NULL
)
2056 error (_("Too many parameters."));
2059 /* Open the file for loading. */
2060 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
2061 if (loadfile_bfd
== NULL
)
2062 perror_with_name (filename
.get ());
2064 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2066 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2067 bfd_errmsg (bfd_get_error ()));
2070 bfd_map_over_sections (loadfile_bfd
.get (), add_section_size_callback
,
2071 (void *) &total_progress
.total_size
);
2073 bfd_map_over_sections (loadfile_bfd
.get (), load_section_callback
, &cbdata
);
2075 using namespace std::chrono
;
2077 steady_clock::time_point start_time
= steady_clock::now ();
2079 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2080 load_progress
) != 0)
2081 error (_("Load failed"));
2083 steady_clock::time_point end_time
= steady_clock::now ();
2085 CORE_ADDR entry
= bfd_get_start_address (loadfile_bfd
.get ());
2086 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2087 uiout
->text ("Start address ");
2088 uiout
->field_core_addr ("address", target_gdbarch (), entry
);
2089 uiout
->text (", load size ");
2090 uiout
->field_unsigned ("load-size", total_progress
.data_count
);
2092 regcache_write_pc (get_current_regcache (), entry
);
2094 /* Reset breakpoints, now that we have changed the load image. For
2095 instance, breakpoints may have been set (or reset, by
2096 post_create_inferior) while connected to the target but before we
2097 loaded the program. In that case, the prologue analyzer could
2098 have read instructions from the target to find the right
2099 breakpoint locations. Loading has changed the contents of that
2102 breakpoint_re_set ();
2104 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2105 total_progress
.write_count
,
2106 end_time
- start_time
);
2109 /* Report on STREAM the performance of a memory transfer operation,
2110 such as 'load'. DATA_COUNT is the number of bytes transferred.
2111 WRITE_COUNT is the number of separate write operations, or 0, if
2112 that information is not available. TIME is how long the operation
2116 print_transfer_performance (struct ui_file
*stream
,
2117 unsigned long data_count
,
2118 unsigned long write_count
,
2119 std::chrono::steady_clock::duration time
)
2121 using namespace std::chrono
;
2122 struct ui_out
*uiout
= current_uiout
;
2124 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2126 uiout
->text ("Transfer rate: ");
2127 if (ms
.count () > 0)
2129 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2131 if (uiout
->is_mi_like_p ())
2133 uiout
->field_unsigned ("transfer-rate", rate
* 8);
2134 uiout
->text (" bits/sec");
2136 else if (rate
< 1024)
2138 uiout
->field_unsigned ("transfer-rate", rate
);
2139 uiout
->text (" bytes/sec");
2143 uiout
->field_unsigned ("transfer-rate", rate
/ 1024);
2144 uiout
->text (" KB/sec");
2149 uiout
->field_unsigned ("transferred-bits", (data_count
* 8));
2150 uiout
->text (" bits in <1 sec");
2152 if (write_count
> 0)
2155 uiout
->field_unsigned ("write-rate", data_count
/ write_count
);
2156 uiout
->text (" bytes/write");
2158 uiout
->text (".\n");
2161 /* Add an OFFSET to the start address of each section in OBJF, except
2162 sections that were specified in ADDRS. */
2165 set_objfile_default_section_offset (struct objfile
*objf
,
2166 const section_addr_info
&addrs
,
2169 /* Add OFFSET to all sections by default. */
2170 std::vector
<struct section_offsets
> offsets (objf
->num_sections
,
2173 /* Create sorted lists of all sections in ADDRS as well as all
2174 sections in OBJF. */
2176 std::vector
<const struct other_sections
*> addrs_sorted
2177 = addrs_section_sort (addrs
);
2179 section_addr_info objf_addrs
2180 = build_section_addr_info_from_objfile (objf
);
2181 std::vector
<const struct other_sections
*> objf_addrs_sorted
2182 = addrs_section_sort (objf_addrs
);
2184 /* Walk the BFD section list, and if a matching section is found in
2185 ADDRS_SORTED_LIST, set its offset to zero to keep its address
2188 Note that both lists may contain multiple sections with the same
2189 name, and then the sections from ADDRS are matched in BFD order
2190 (thanks to sectindex). */
2192 std::vector
<const struct other_sections
*>::iterator addrs_sorted_iter
2193 = addrs_sorted
.begin ();
2194 for (const other_sections
*objf_sect
: objf_addrs_sorted
)
2196 const char *objf_name
= addr_section_name (objf_sect
->name
.c_str ());
2199 while (cmp
< 0 && addrs_sorted_iter
!= addrs_sorted
.end ())
2201 const struct other_sections
*sect
= *addrs_sorted_iter
;
2202 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
2203 cmp
= strcmp (sect_name
, objf_name
);
2205 ++addrs_sorted_iter
;
2209 offsets
[objf_sect
->sectindex
].offsets
[0] = 0;
2212 /* Apply the new section offsets. */
2213 objfile_relocate (objf
, offsets
.data ());
2216 /* This function allows the addition of incrementally linked object files.
2217 It does not modify any state in the target, only in the debugger. */
2220 add_symbol_file_command (const char *args
, int from_tty
)
2222 struct gdbarch
*gdbarch
= get_current_arch ();
2223 gdb::unique_xmalloc_ptr
<char> filename
;
2226 struct objfile
*objf
;
2227 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2228 symfile_add_flags add_flags
= 0;
2231 add_flags
|= SYMFILE_VERBOSE
;
2239 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2240 bool stop_processing_options
= false;
2241 CORE_ADDR offset
= 0;
2246 error (_("add-symbol-file takes a file name and an address"));
2248 bool seen_addr
= false;
2249 bool seen_offset
= false;
2250 gdb_argv
argv (args
);
2252 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2254 if (stop_processing_options
|| *arg
!= '-')
2256 if (filename
== NULL
)
2258 /* First non-option argument is always the filename. */
2259 filename
.reset (tilde_expand (arg
));
2261 else if (!seen_addr
)
2263 /* The second non-option argument is always the text
2264 address at which to load the program. */
2265 sect_opts
[0].value
= arg
;
2269 error (_("Unrecognized argument \"%s\""), arg
);
2271 else if (strcmp (arg
, "-readnow") == 0)
2272 flags
|= OBJF_READNOW
;
2273 else if (strcmp (arg
, "-readnever") == 0)
2274 flags
|= OBJF_READNEVER
;
2275 else if (strcmp (arg
, "-s") == 0)
2277 if (argv
[argcnt
+ 1] == NULL
)
2278 error (_("Missing section name after \"-s\""));
2279 else if (argv
[argcnt
+ 2] == NULL
)
2280 error (_("Missing section address after \"-s\""));
2282 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2284 sect_opts
.push_back (sect
);
2287 else if (strcmp (arg
, "-o") == 0)
2289 arg
= argv
[++argcnt
];
2291 error (_("Missing argument to -o"));
2293 offset
= parse_and_eval_address (arg
);
2296 else if (strcmp (arg
, "--") == 0)
2297 stop_processing_options
= true;
2299 error (_("Unrecognized argument \"%s\""), arg
);
2302 if (filename
== NULL
)
2303 error (_("You must provide a filename to be loaded."));
2305 validate_readnow_readnever (flags
);
2307 /* Print the prompt for the query below. And save the arguments into
2308 a sect_addr_info structure to be passed around to other
2309 functions. We have to split this up into separate print
2310 statements because hex_string returns a local static
2313 printf_unfiltered (_("add symbol table from file \"%s\""),
2315 section_addr_info section_addrs
;
2316 std::vector
<sect_opt
>::const_iterator it
= sect_opts
.begin ();
2319 for (; it
!= sect_opts
.end (); ++it
)
2322 const char *val
= it
->value
;
2323 const char *sec
= it
->name
;
2325 if (section_addrs
.empty ())
2326 printf_unfiltered (_(" at\n"));
2327 addr
= parse_and_eval_address (val
);
2329 /* Here we store the section offsets in the order they were
2330 entered on the command line. Every array element is
2331 assigned an ascending section index to preserve the above
2332 order over an unstable sorting algorithm. This dummy
2333 index is not used for any other purpose.
2335 section_addrs
.emplace_back (addr
, sec
, section_addrs
.size ());
2336 printf_filtered ("\t%s_addr = %s\n", sec
,
2337 paddress (gdbarch
, addr
));
2339 /* The object's sections are initialized when a
2340 call is made to build_objfile_section_table (objfile).
2341 This happens in reread_symbols.
2342 At this point, we don't know what file type this is,
2343 so we can't determine what section names are valid. */
2346 printf_unfiltered (_("%s offset by %s\n"),
2347 (section_addrs
.empty ()
2348 ? _(" with all sections")
2349 : _("with other sections")),
2350 paddress (gdbarch
, offset
));
2351 else if (section_addrs
.empty ())
2352 printf_unfiltered ("\n");
2354 if (from_tty
&& (!query ("%s", "")))
2355 error (_("Not confirmed."));
2357 objf
= symbol_file_add (filename
.get (), add_flags
, §ion_addrs
,
2359 if (!objfile_has_symbols (objf
) && objf
->per_bfd
->minimal_symbol_count
<= 0)
2360 warning (_("newly-added symbol file \"%s\" does not provide any symbols"),
2364 set_objfile_default_section_offset (objf
, section_addrs
, offset
);
2366 add_target_sections_of_objfile (objf
);
2368 /* Getting new symbols may change our opinion about what is
2370 reinit_frame_cache ();
2374 /* This function removes a symbol file that was added via add-symbol-file. */
2377 remove_symbol_file_command (const char *args
, int from_tty
)
2379 struct objfile
*objf
= NULL
;
2380 struct program_space
*pspace
= current_program_space
;
2385 error (_("remove-symbol-file: no symbol file provided"));
2387 gdb_argv
argv (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]);
2402 for (objfile
*objfile
: current_program_space
->objfiles ())
2404 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2405 && (objfile
->flags
& OBJF_SHARED
) != 0
2406 && objfile
->pspace
== pspace
2407 && is_addr_in_objfile (addr
, objfile
))
2414 else if (argv
[0] != NULL
)
2416 /* Interpret the current argument as a file name. */
2418 if (argv
[1] != NULL
)
2419 error (_("Junk after %s"), argv
[0]);
2421 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2423 for (objfile
*objfile
: current_program_space
->objfiles ())
2425 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2426 && (objfile
->flags
& OBJF_SHARED
) != 0
2427 && objfile
->pspace
== pspace
2428 && filename_cmp (filename
.get (), objfile_name (objfile
)) == 0)
2437 error (_("No symbol file found"));
2440 && !query (_("Remove symbol table from file \"%s\"? "),
2441 objfile_name (objf
)))
2442 error (_("Not confirmed."));
2445 clear_symtab_users (0);
2448 /* Re-read symbols if a symbol-file has changed. */
2451 reread_symbols (void)
2454 struct stat new_statbuf
;
2456 std::vector
<struct objfile
*> new_objfiles
;
2458 for (objfile
*objfile
: current_program_space
->objfiles ())
2460 if (objfile
->obfd
== NULL
)
2463 /* Separate debug objfiles are handled in the main objfile. */
2464 if (objfile
->separate_debug_objfile_backlink
)
2467 /* If this object is from an archive (what you usually create with
2468 `ar', often called a `static library' on most systems, though
2469 a `shared library' on AIX is also an archive), then you should
2470 stat on the archive name, not member name. */
2471 if (objfile
->obfd
->my_archive
)
2472 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2474 res
= stat (objfile_name (objfile
), &new_statbuf
);
2477 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2478 printf_filtered (_("`%s' has disappeared; keeping its symbols.\n"),
2479 objfile_name (objfile
));
2482 new_modtime
= new_statbuf
.st_mtime
;
2483 if (new_modtime
!= objfile
->mtime
)
2485 struct section_offsets
*offsets
;
2488 printf_filtered (_("`%s' has changed; re-reading symbols.\n"),
2489 objfile_name (objfile
));
2491 /* There are various functions like symbol_file_add,
2492 symfile_bfd_open, syms_from_objfile, etc., which might
2493 appear to do what we want. But they have various other
2494 effects which we *don't* want. So we just do stuff
2495 ourselves. We don't worry about mapped files (for one thing,
2496 any mapped file will be out of date). */
2498 /* If we get an error, blow away this objfile (not sure if
2499 that is the correct response for things like shared
2501 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
2503 /* We need to do this whenever any symbols go away. */
2504 clear_symtab_users_cleanup
defer_clear_users (0);
2506 if (exec_bfd
!= NULL
2507 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2508 bfd_get_filename (exec_bfd
)) == 0)
2510 /* Reload EXEC_BFD without asking anything. */
2512 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2515 /* Keep the calls order approx. the same as in free_objfile. */
2517 /* Free the separate debug objfiles. It will be
2518 automatically recreated by sym_read. */
2519 free_objfile_separate_debug (objfile
);
2521 /* Clear the stale source cache. */
2522 forget_cached_source_info ();
2524 /* Remove any references to this objfile in the global
2526 preserve_values (objfile
);
2528 /* Nuke all the state that we will re-read. Much of the following
2529 code which sets things to NULL really is necessary to tell
2530 other parts of GDB that there is nothing currently there.
2532 Try to keep the freeing order compatible with free_objfile. */
2534 if (objfile
->sf
!= NULL
)
2536 (*objfile
->sf
->sym_finish
) (objfile
);
2539 clear_objfile_data (objfile
);
2541 /* Clean up any state BFD has sitting around. */
2543 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2544 const char *obfd_filename
;
2546 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2547 /* Open the new BFD before freeing the old one, so that
2548 the filename remains live. */
2549 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
, -1));
2550 objfile
->obfd
= temp
.release ();
2551 if (objfile
->obfd
== NULL
)
2552 error (_("Can't open %s to read symbols."), obfd_filename
);
2555 std::string original_name
= objfile
->original_name
;
2557 /* bfd_openr sets cacheable to true, which is what we want. */
2558 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2559 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2560 bfd_errmsg (bfd_get_error ()));
2562 /* Save the offsets, we will nuke them with the rest of the
2564 num_offsets
= objfile
->num_sections
;
2565 offsets
= ((struct section_offsets
*)
2566 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2567 memcpy (offsets
, objfile
->section_offsets
,
2568 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2570 objfile
->reset_psymtabs ();
2572 /* NB: after this call to obstack_free, objfiles_changed
2573 will need to be called (see discussion below). */
2574 obstack_free (&objfile
->objfile_obstack
, 0);
2575 objfile
->sections
= NULL
;
2576 objfile
->compunit_symtabs
= NULL
;
2577 objfile
->template_symbols
= NULL
;
2578 objfile
->static_links
.reset (nullptr);
2580 /* obstack_init also initializes the obstack so it is
2581 empty. We could use obstack_specify_allocation but
2582 gdb_obstack.h specifies the alloc/dealloc functions. */
2583 obstack_init (&objfile
->objfile_obstack
);
2585 /* set_objfile_per_bfd potentially allocates the per-bfd
2586 data on the objfile's obstack (if sharing data across
2587 multiple users is not possible), so it's important to
2588 do it *after* the obstack has been initialized. */
2589 set_objfile_per_bfd (objfile
);
2591 objfile
->original_name
2592 = obstack_strdup (&objfile
->objfile_obstack
, original_name
);
2594 /* Reset the sym_fns pointer. The ELF reader can change it
2595 based on whether .gdb_index is present, and we need it to
2596 start over. PR symtab/15885 */
2597 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2599 build_objfile_section_table (objfile
);
2601 /* We use the same section offsets as from last time. I'm not
2602 sure whether that is always correct for shared libraries. */
2603 objfile
->section_offsets
= (struct section_offsets
*)
2604 obstack_alloc (&objfile
->objfile_obstack
,
2605 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2606 memcpy (objfile
->section_offsets
, offsets
,
2607 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2608 objfile
->num_sections
= num_offsets
;
2610 /* What the hell is sym_new_init for, anyway? The concept of
2611 distinguishing between the main file and additional files
2612 in this way seems rather dubious. */
2613 if (objfile
== symfile_objfile
)
2615 (*objfile
->sf
->sym_new_init
) (objfile
);
2618 (*objfile
->sf
->sym_init
) (objfile
);
2619 clear_complaints ();
2621 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2623 /* We are about to read new symbols and potentially also
2624 DWARF information. Some targets may want to pass addresses
2625 read from DWARF DIE's through an adjustment function before
2626 saving them, like MIPS, which may call into
2627 "find_pc_section". When called, that function will make
2628 use of per-objfile program space data.
2630 Since we discarded our section information above, we have
2631 dangling pointers in the per-objfile program space data
2632 structure. Force GDB to update the section mapping
2633 information by letting it know the objfile has changed,
2634 making the dangling pointers point to correct data
2637 objfiles_changed ();
2639 read_symbols (objfile
, 0);
2641 if (!objfile_has_symbols (objfile
))
2644 printf_filtered (_("(no debugging symbols found)\n"));
2648 /* We're done reading the symbol file; finish off complaints. */
2649 clear_complaints ();
2651 /* Getting new symbols may change our opinion about what is
2654 reinit_frame_cache ();
2656 /* Discard cleanups as symbol reading was successful. */
2657 objfile_holder
.release ();
2658 defer_clear_users
.release ();
2660 /* If the mtime has changed between the time we set new_modtime
2661 and now, we *want* this to be out of date, so don't call stat
2663 objfile
->mtime
= new_modtime
;
2664 init_entry_point_info (objfile
);
2666 new_objfiles
.push_back (objfile
);
2670 if (!new_objfiles
.empty ())
2672 clear_symtab_users (0);
2674 /* clear_objfile_data for each objfile was called before freeing it and
2675 gdb::observers::new_objfile.notify (NULL) has been called by
2676 clear_symtab_users above. Notify the new files now. */
2677 for (auto iter
: new_objfiles
)
2678 gdb::observers::new_objfile
.notify (iter
);
2680 /* At least one objfile has changed, so we can consider that
2681 the executable we're debugging has changed too. */
2682 gdb::observers::executable_changed
.notify ();
2687 struct filename_language
2689 filename_language (const std::string
&ext_
, enum language lang_
)
2690 : ext (ext_
), lang (lang_
)
2697 static std::vector
<filename_language
> filename_language_table
;
2699 /* See symfile.h. */
2702 add_filename_language (const char *ext
, enum language lang
)
2704 filename_language_table
.emplace_back (ext
, lang
);
2707 static char *ext_args
;
2709 show_ext_args (struct ui_file
*file
, int from_tty
,
2710 struct cmd_list_element
*c
, const char *value
)
2712 fprintf_filtered (file
,
2713 _("Mapping between filename extension "
2714 "and source language is \"%s\".\n"),
2719 set_ext_lang_command (const char *args
,
2720 int from_tty
, struct cmd_list_element
*e
)
2722 char *cp
= ext_args
;
2725 /* First arg is filename extension, starting with '.' */
2727 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2729 /* Find end of first arg. */
2730 while (*cp
&& !isspace (*cp
))
2734 error (_("'%s': two arguments required -- "
2735 "filename extension and language"),
2738 /* Null-terminate first arg. */
2741 /* Find beginning of second arg, which should be a source language. */
2742 cp
= skip_spaces (cp
);
2745 error (_("'%s': two arguments required -- "
2746 "filename extension and language"),
2749 /* Lookup the language from among those we know. */
2750 lang
= language_enum (cp
);
2752 auto it
= filename_language_table
.begin ();
2753 /* Now lookup the filename extension: do we already know it? */
2754 for (; it
!= filename_language_table
.end (); it
++)
2756 if (it
->ext
== ext_args
)
2760 if (it
== filename_language_table
.end ())
2762 /* New file extension. */
2763 add_filename_language (ext_args
, lang
);
2767 /* Redefining a previously known filename extension. */
2770 /* query ("Really make files of type %s '%s'?", */
2771 /* ext_args, language_str (lang)); */
2778 info_ext_lang_command (const char *args
, int from_tty
)
2780 printf_filtered (_("Filename extensions and the languages they represent:"));
2781 printf_filtered ("\n\n");
2782 for (const filename_language
&entry
: filename_language_table
)
2783 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2784 language_str (entry
.lang
));
2788 deduce_language_from_filename (const char *filename
)
2792 if (filename
!= NULL
)
2793 if ((cp
= strrchr (filename
, '.')) != NULL
)
2795 for (const filename_language
&entry
: filename_language_table
)
2796 if (entry
.ext
== cp
)
2800 return language_unknown
;
2803 /* Allocate and initialize a new symbol table.
2804 CUST is from the result of allocate_compunit_symtab. */
2807 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2809 struct objfile
*objfile
= cust
->objfile
;
2810 struct symtab
*symtab
2811 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2814 = ((const char *) objfile
->per_bfd
->filename_cache
.insert
2815 (filename
, strlen (filename
) + 1));
2816 symtab
->fullname
= NULL
;
2817 symtab
->language
= deduce_language_from_filename (filename
);
2819 /* This can be very verbose with lots of headers.
2820 Only print at higher debug levels. */
2821 if (symtab_create_debug
>= 2)
2823 /* Be a bit clever with debugging messages, and don't print objfile
2824 every time, only when it changes. */
2825 static char *last_objfile_name
= NULL
;
2827 if (last_objfile_name
== NULL
2828 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2830 xfree (last_objfile_name
);
2831 last_objfile_name
= xstrdup (objfile_name (objfile
));
2832 fprintf_filtered (gdb_stdlog
,
2833 "Creating one or more symtabs for objfile %s ...\n",
2836 fprintf_filtered (gdb_stdlog
,
2837 "Created symtab %s for module %s.\n",
2838 host_address_to_string (symtab
), filename
);
2841 /* Add it to CUST's list of symtabs. */
2842 if (cust
->filetabs
== NULL
)
2844 cust
->filetabs
= symtab
;
2845 cust
->last_filetab
= symtab
;
2849 cust
->last_filetab
->next
= symtab
;
2850 cust
->last_filetab
= symtab
;
2853 /* Backlink to the containing compunit symtab. */
2854 symtab
->compunit_symtab
= cust
;
2859 /* Allocate and initialize a new compunit.
2860 NAME is the name of the main source file, if there is one, or some
2861 descriptive text if there are no source files. */
2863 struct compunit_symtab
*
2864 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2866 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2867 struct compunit_symtab
);
2868 const char *saved_name
;
2870 cu
->objfile
= objfile
;
2872 /* The name we record here is only for display/debugging purposes.
2873 Just save the basename to avoid path issues (too long for display,
2874 relative vs absolute, etc.). */
2875 saved_name
= lbasename (name
);
2876 cu
->name
= obstack_strdup (&objfile
->objfile_obstack
, saved_name
);
2878 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2880 if (symtab_create_debug
)
2882 fprintf_filtered (gdb_stdlog
,
2883 "Created compunit symtab %s for %s.\n",
2884 host_address_to_string (cu
),
2891 /* Hook CU to the objfile it comes from. */
2894 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2896 cu
->next
= cu
->objfile
->compunit_symtabs
;
2897 cu
->objfile
->compunit_symtabs
= cu
;
2901 /* Reset all data structures in gdb which may contain references to
2902 symbol table data. */
2905 clear_symtab_users (symfile_add_flags add_flags
)
2907 /* Someday, we should do better than this, by only blowing away
2908 the things that really need to be blown. */
2910 /* Clear the "current" symtab first, because it is no longer valid.
2911 breakpoint_re_set may try to access the current symtab. */
2912 clear_current_source_symtab_and_line ();
2915 clear_last_displayed_sal ();
2916 clear_pc_function_cache ();
2917 gdb::observers::new_objfile
.notify (NULL
);
2919 /* Varobj may refer to old symbols, perform a cleanup. */
2920 varobj_invalidate ();
2922 /* Now that the various caches have been cleared, we can re_set
2923 our breakpoints without risking it using stale data. */
2924 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2925 breakpoint_re_set ();
2929 The following code implements an abstraction for debugging overlay sections.
2931 The target model is as follows:
2932 1) The gnu linker will permit multiple sections to be mapped into the
2933 same VMA, each with its own unique LMA (or load address).
2934 2) It is assumed that some runtime mechanism exists for mapping the
2935 sections, one by one, from the load address into the VMA address.
2936 3) This code provides a mechanism for gdb to keep track of which
2937 sections should be considered to be mapped from the VMA to the LMA.
2938 This information is used for symbol lookup, and memory read/write.
2939 For instance, if a section has been mapped then its contents
2940 should be read from the VMA, otherwise from the LMA.
2942 Two levels of debugger support for overlays are available. One is
2943 "manual", in which the debugger relies on the user to tell it which
2944 overlays are currently mapped. This level of support is
2945 implemented entirely in the core debugger, and the information about
2946 whether a section is mapped is kept in the objfile->obj_section table.
2948 The second level of support is "automatic", and is only available if
2949 the target-specific code provides functionality to read the target's
2950 overlay mapping table, and translate its contents for the debugger
2951 (by updating the mapped state information in the obj_section tables).
2953 The interface is as follows:
2955 overlay map <name> -- tell gdb to consider this section mapped
2956 overlay unmap <name> -- tell gdb to consider this section unmapped
2957 overlay list -- list the sections that GDB thinks are mapped
2958 overlay read-target -- get the target's state of what's mapped
2959 overlay off/manual/auto -- set overlay debugging state
2960 Functional interface:
2961 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2962 section, return that section.
2963 find_pc_overlay(pc): find any overlay section that contains
2964 the pc, either in its VMA or its LMA
2965 section_is_mapped(sect): true if overlay is marked as mapped
2966 section_is_overlay(sect): true if section's VMA != LMA
2967 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2968 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2969 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2970 overlay_mapped_address(...): map an address from section's LMA to VMA
2971 overlay_unmapped_address(...): map an address from section's VMA to LMA
2972 symbol_overlayed_address(...): Return a "current" address for symbol:
2973 either in VMA or LMA depending on whether
2974 the symbol's section is currently mapped. */
2976 /* Overlay debugging state: */
2978 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2979 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2981 /* Function: section_is_overlay (SECTION)
2982 Returns true if SECTION has VMA not equal to LMA, ie.
2983 SECTION is loaded at an address different from where it will "run". */
2986 section_is_overlay (struct obj_section
*section
)
2988 if (overlay_debugging
&& section
)
2990 asection
*bfd_section
= section
->the_bfd_section
;
2992 if (bfd_section_lma (bfd_section
) != 0
2993 && bfd_section_lma (bfd_section
) != bfd_section_vma (bfd_section
))
3000 /* Function: overlay_invalidate_all (void)
3001 Invalidate the mapped state of all overlay sections (mark it as stale). */
3004 overlay_invalidate_all (void)
3006 struct obj_section
*sect
;
3008 for (objfile
*objfile
: current_program_space
->objfiles ())
3009 ALL_OBJFILE_OSECTIONS (objfile
, sect
)
3010 if (section_is_overlay (sect
))
3011 sect
->ovly_mapped
= -1;
3014 /* Function: section_is_mapped (SECTION)
3015 Returns true if section is an overlay, and is currently mapped.
3017 Access to the ovly_mapped flag is restricted to this function, so
3018 that we can do automatic update. If the global flag
3019 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3020 overlay_invalidate_all. If the mapped state of the particular
3021 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3024 section_is_mapped (struct obj_section
*osect
)
3026 struct gdbarch
*gdbarch
;
3028 if (osect
== 0 || !section_is_overlay (osect
))
3031 switch (overlay_debugging
)
3035 return 0; /* overlay debugging off */
3036 case ovly_auto
: /* overlay debugging automatic */
3037 /* Unles there is a gdbarch_overlay_update function,
3038 there's really nothing useful to do here (can't really go auto). */
3039 gdbarch
= get_objfile_arch (osect
->objfile
);
3040 if (gdbarch_overlay_update_p (gdbarch
))
3042 if (overlay_cache_invalid
)
3044 overlay_invalidate_all ();
3045 overlay_cache_invalid
= 0;
3047 if (osect
->ovly_mapped
== -1)
3048 gdbarch_overlay_update (gdbarch
, osect
);
3051 case ovly_on
: /* overlay debugging manual */
3052 return osect
->ovly_mapped
== 1;
3056 /* Function: pc_in_unmapped_range
3057 If PC falls into the lma range of SECTION, return true, else false. */
3060 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3062 if (section_is_overlay (section
))
3064 asection
*bfd_section
= section
->the_bfd_section
;
3066 /* We assume the LMA is relocated by the same offset as the VMA. */
3067 bfd_vma size
= bfd_section_size (bfd_section
);
3068 CORE_ADDR offset
= obj_section_offset (section
);
3070 if (bfd_section_lma (bfd_section
) + offset
<= pc
3071 && pc
< bfd_section_lma (bfd_section
) + offset
+ size
)
3078 /* Function: pc_in_mapped_range
3079 If PC falls into the vma range of SECTION, return true, else false. */
3082 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3084 if (section_is_overlay (section
))
3086 if (obj_section_addr (section
) <= pc
3087 && pc
< obj_section_endaddr (section
))
3094 /* Return true if the mapped ranges of sections A and B overlap, false
3098 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3100 CORE_ADDR a_start
= obj_section_addr (a
);
3101 CORE_ADDR a_end
= obj_section_endaddr (a
);
3102 CORE_ADDR b_start
= obj_section_addr (b
);
3103 CORE_ADDR b_end
= obj_section_endaddr (b
);
3105 return (a_start
< b_end
&& b_start
< a_end
);
3108 /* Function: overlay_unmapped_address (PC, SECTION)
3109 Returns the address corresponding to PC in the unmapped (load) range.
3110 May be the same as PC. */
3113 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3115 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3117 asection
*bfd_section
= section
->the_bfd_section
;
3119 return (pc
+ bfd_section_lma (bfd_section
)
3120 - bfd_section_vma (bfd_section
));
3126 /* Function: overlay_mapped_address (PC, SECTION)
3127 Returns the address corresponding to PC in the mapped (runtime) range.
3128 May be the same as PC. */
3131 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3133 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3135 asection
*bfd_section
= section
->the_bfd_section
;
3137 return (pc
+ bfd_section_vma (bfd_section
)
3138 - bfd_section_lma (bfd_section
));
3144 /* Function: symbol_overlayed_address
3145 Return one of two addresses (relative to the VMA or to the LMA),
3146 depending on whether the section is mapped or not. */
3149 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3151 if (overlay_debugging
)
3153 /* If the symbol has no section, just return its regular address. */
3156 /* If the symbol's section is not an overlay, just return its
3158 if (!section_is_overlay (section
))
3160 /* If the symbol's section is mapped, just return its address. */
3161 if (section_is_mapped (section
))
3164 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3165 * then return its LOADED address rather than its vma address!!
3167 return overlay_unmapped_address (address
, section
);
3172 /* Function: find_pc_overlay (PC)
3173 Return the best-match overlay section for PC:
3174 If PC matches a mapped overlay section's VMA, return that section.
3175 Else if PC matches an unmapped section's VMA, return that section.
3176 Else if PC matches an unmapped section's LMA, return that section. */
3178 struct obj_section
*
3179 find_pc_overlay (CORE_ADDR pc
)
3181 struct obj_section
*osect
, *best_match
= NULL
;
3183 if (overlay_debugging
)
3185 for (objfile
*objfile
: current_program_space
->objfiles ())
3186 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3187 if (section_is_overlay (osect
))
3189 if (pc_in_mapped_range (pc
, osect
))
3191 if (section_is_mapped (osect
))
3196 else if (pc_in_unmapped_range (pc
, osect
))
3203 /* Function: find_pc_mapped_section (PC)
3204 If PC falls into the VMA address range of an overlay section that is
3205 currently marked as MAPPED, return that section. Else return NULL. */
3207 struct obj_section
*
3208 find_pc_mapped_section (CORE_ADDR pc
)
3210 struct obj_section
*osect
;
3212 if (overlay_debugging
)
3214 for (objfile
*objfile
: current_program_space
->objfiles ())
3215 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3216 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3223 /* Function: list_overlays_command
3224 Print a list of mapped sections and their PC ranges. */
3227 list_overlays_command (const char *args
, int from_tty
)
3230 struct obj_section
*osect
;
3232 if (overlay_debugging
)
3234 for (objfile
*objfile
: current_program_space
->objfiles ())
3235 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3236 if (section_is_mapped (osect
))
3238 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3243 vma
= bfd_section_vma (osect
->the_bfd_section
);
3244 lma
= bfd_section_lma (osect
->the_bfd_section
);
3245 size
= bfd_section_size (osect
->the_bfd_section
);
3246 name
= bfd_section_name (osect
->the_bfd_section
);
3248 printf_filtered ("Section %s, loaded at ", name
);
3249 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3250 puts_filtered (" - ");
3251 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3252 printf_filtered (", mapped at ");
3253 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3254 puts_filtered (" - ");
3255 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3256 puts_filtered ("\n");
3262 printf_filtered (_("No sections are mapped.\n"));
3265 /* Function: map_overlay_command
3266 Mark the named section as mapped (ie. residing at its VMA address). */
3269 map_overlay_command (const char *args
, int from_tty
)
3271 struct obj_section
*sec
, *sec2
;
3273 if (!overlay_debugging
)
3274 error (_("Overlay debugging not enabled. Use "
3275 "either the 'overlay auto' or\n"
3276 "the 'overlay manual' command."));
3278 if (args
== 0 || *args
== 0)
3279 error (_("Argument required: name of an overlay section"));
3281 /* First, find a section matching the user supplied argument. */
3282 for (objfile
*obj_file
: current_program_space
->objfiles ())
3283 ALL_OBJFILE_OSECTIONS (obj_file
, sec
)
3284 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3286 /* Now, check to see if the section is an overlay. */
3287 if (!section_is_overlay (sec
))
3288 continue; /* not an overlay section */
3290 /* Mark the overlay as "mapped". */
3291 sec
->ovly_mapped
= 1;
3293 /* Next, make a pass and unmap any sections that are
3294 overlapped by this new section: */
3295 for (objfile
*objfile2
: current_program_space
->objfiles ())
3296 ALL_OBJFILE_OSECTIONS (objfile2
, sec2
)
3297 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
,
3301 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3302 bfd_section_name (sec2
->the_bfd_section
));
3303 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3307 error (_("No overlay section called %s"), args
);
3310 /* Function: unmap_overlay_command
3311 Mark the overlay section as unmapped
3312 (ie. resident in its LMA address range, rather than the VMA range). */
3315 unmap_overlay_command (const char *args
, int from_tty
)
3317 struct obj_section
*sec
= NULL
;
3319 if (!overlay_debugging
)
3320 error (_("Overlay debugging not enabled. "
3321 "Use either the 'overlay auto' or\n"
3322 "the 'overlay manual' command."));
3324 if (args
== 0 || *args
== 0)
3325 error (_("Argument required: name of an overlay section"));
3327 /* First, find a section matching the user supplied argument. */
3328 for (objfile
*objfile
: current_program_space
->objfiles ())
3329 ALL_OBJFILE_OSECTIONS (objfile
, sec
)
3330 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3332 if (!sec
->ovly_mapped
)
3333 error (_("Section %s is not mapped"), args
);
3334 sec
->ovly_mapped
= 0;
3337 error (_("No overlay section called %s"), args
);
3340 /* Function: overlay_auto_command
3341 A utility command to turn on overlay debugging.
3342 Possibly this should be done via a set/show command. */
3345 overlay_auto_command (const char *args
, int from_tty
)
3347 overlay_debugging
= ovly_auto
;
3348 enable_overlay_breakpoints ();
3350 printf_unfiltered (_("Automatic overlay debugging enabled."));
3353 /* Function: overlay_manual_command
3354 A utility command to turn on overlay debugging.
3355 Possibly this should be done via a set/show command. */
3358 overlay_manual_command (const char *args
, int from_tty
)
3360 overlay_debugging
= ovly_on
;
3361 disable_overlay_breakpoints ();
3363 printf_unfiltered (_("Overlay debugging enabled."));
3366 /* Function: overlay_off_command
3367 A utility command to turn on overlay debugging.
3368 Possibly this should be done via a set/show command. */
3371 overlay_off_command (const char *args
, int from_tty
)
3373 overlay_debugging
= ovly_off
;
3374 disable_overlay_breakpoints ();
3376 printf_unfiltered (_("Overlay debugging disabled."));
3380 overlay_load_command (const char *args
, int from_tty
)
3382 struct gdbarch
*gdbarch
= get_current_arch ();
3384 if (gdbarch_overlay_update_p (gdbarch
))
3385 gdbarch_overlay_update (gdbarch
, NULL
);
3387 error (_("This target does not know how to read its overlay state."));
3390 /* Function: overlay_command
3391 A place-holder for a mis-typed command. */
3393 /* Command list chain containing all defined "overlay" subcommands. */
3394 static struct cmd_list_element
*overlaylist
;
3397 overlay_command (const char *args
, int from_tty
)
3400 ("\"overlay\" must be followed by the name of an overlay command.\n");
3401 help_list (overlaylist
, "overlay ", all_commands
, gdb_stdout
);
3404 /* Target Overlays for the "Simplest" overlay manager:
3406 This is GDB's default target overlay layer. It works with the
3407 minimal overlay manager supplied as an example by Cygnus. The
3408 entry point is via a function pointer "gdbarch_overlay_update",
3409 so targets that use a different runtime overlay manager can
3410 substitute their own overlay_update function and take over the
3413 The overlay_update function pokes around in the target's data structures
3414 to see what overlays are mapped, and updates GDB's overlay mapping with
3417 In this simple implementation, the target data structures are as follows:
3418 unsigned _novlys; /# number of overlay sections #/
3419 unsigned _ovly_table[_novlys][4] = {
3420 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3421 {..., ..., ..., ...},
3423 unsigned _novly_regions; /# number of overlay regions #/
3424 unsigned _ovly_region_table[_novly_regions][3] = {
3425 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3428 These functions will attempt to update GDB's mappedness state in the
3429 symbol section table, based on the target's mappedness state.
3431 To do this, we keep a cached copy of the target's _ovly_table, and
3432 attempt to detect when the cached copy is invalidated. The main
3433 entry point is "simple_overlay_update(SECT), which looks up SECT in
3434 the cached table and re-reads only the entry for that section from
3435 the target (whenever possible). */
3437 /* Cached, dynamically allocated copies of the target data structures: */
3438 static unsigned (*cache_ovly_table
)[4] = 0;
3439 static unsigned cache_novlys
= 0;
3440 static CORE_ADDR cache_ovly_table_base
= 0;
3443 VMA
, OSIZE
, LMA
, MAPPED
3446 /* Throw away the cached copy of _ovly_table. */
3449 simple_free_overlay_table (void)
3451 if (cache_ovly_table
)
3452 xfree (cache_ovly_table
);
3454 cache_ovly_table
= NULL
;
3455 cache_ovly_table_base
= 0;
3458 /* Read an array of ints of size SIZE from the target into a local buffer.
3459 Convert to host order. int LEN is number of ints. */
3462 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3463 int len
, int size
, enum bfd_endian byte_order
)
3465 /* FIXME (alloca): Not safe if array is very large. */
3466 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3469 read_memory (memaddr
, buf
, len
* size
);
3470 for (i
= 0; i
< len
; i
++)
3471 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3474 /* Find and grab a copy of the target _ovly_table
3475 (and _novlys, which is needed for the table's size). */
3478 simple_read_overlay_table (void)
3480 struct bound_minimal_symbol novlys_msym
;
3481 struct bound_minimal_symbol ovly_table_msym
;
3482 struct gdbarch
*gdbarch
;
3484 enum bfd_endian byte_order
;
3486 simple_free_overlay_table ();
3487 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3488 if (! novlys_msym
.minsym
)
3490 error (_("Error reading inferior's overlay table: "
3491 "couldn't find `_novlys' variable\n"
3492 "in inferior. Use `overlay manual' mode."));
3496 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3497 if (! ovly_table_msym
.minsym
)
3499 error (_("Error reading inferior's overlay table: couldn't find "
3500 "`_ovly_table' array\n"
3501 "in inferior. Use `overlay manual' mode."));
3505 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3506 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3507 byte_order
= gdbarch_byte_order (gdbarch
);
3509 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3512 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3513 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3514 read_target_long_array (cache_ovly_table_base
,
3515 (unsigned int *) cache_ovly_table
,
3516 cache_novlys
* 4, word_size
, byte_order
);
3518 return 1; /* SUCCESS */
3521 /* Function: simple_overlay_update_1
3522 A helper function for simple_overlay_update. Assuming a cached copy
3523 of _ovly_table exists, look through it to find an entry whose vma,
3524 lma and size match those of OSECT. Re-read the entry and make sure
3525 it still matches OSECT (else the table may no longer be valid).
3526 Set OSECT's mapped state to match the entry. Return: 1 for
3527 success, 0 for failure. */
3530 simple_overlay_update_1 (struct obj_section
*osect
)
3533 asection
*bsect
= osect
->the_bfd_section
;
3534 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3535 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3536 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3538 for (i
= 0; i
< cache_novlys
; i
++)
3539 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3540 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3542 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3543 (unsigned int *) cache_ovly_table
[i
],
3544 4, word_size
, byte_order
);
3545 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3546 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3548 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3551 else /* Warning! Warning! Target's ovly table has changed! */
3557 /* Function: simple_overlay_update
3558 If OSECT is NULL, then update all sections' mapped state
3559 (after re-reading the entire target _ovly_table).
3560 If OSECT is non-NULL, then try to find a matching entry in the
3561 cached ovly_table and update only OSECT's mapped state.
3562 If a cached entry can't be found or the cache isn't valid, then
3563 re-read the entire cache, and go ahead and update all sections. */
3566 simple_overlay_update (struct obj_section
*osect
)
3568 /* Were we given an osect to look up? NULL means do all of them. */
3570 /* Have we got a cached copy of the target's overlay table? */
3571 if (cache_ovly_table
!= NULL
)
3573 /* Does its cached location match what's currently in the
3575 struct bound_minimal_symbol minsym
3576 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3578 if (minsym
.minsym
== NULL
)
3579 error (_("Error reading inferior's overlay table: couldn't "
3580 "find `_ovly_table' array\n"
3581 "in inferior. Use `overlay manual' mode."));
3583 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3584 /* Then go ahead and try to look up this single section in
3586 if (simple_overlay_update_1 (osect
))
3587 /* Found it! We're done. */
3591 /* Cached table no good: need to read the entire table anew.
3592 Or else we want all the sections, in which case it's actually
3593 more efficient to read the whole table in one block anyway. */
3595 if (! simple_read_overlay_table ())
3598 /* Now may as well update all sections, even if only one was requested. */
3599 for (objfile
*objfile
: current_program_space
->objfiles ())
3600 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3601 if (section_is_overlay (osect
))
3604 asection
*bsect
= osect
->the_bfd_section
;
3606 for (i
= 0; i
< cache_novlys
; i
++)
3607 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3608 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3609 { /* obj_section matches i'th entry in ovly_table. */
3610 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3611 break; /* finished with inner for loop: break out. */
3616 /* Set the output sections and output offsets for section SECTP in
3617 ABFD. The relocation code in BFD will read these offsets, so we
3618 need to be sure they're initialized. We map each section to itself,
3619 with no offset; this means that SECTP->vma will be honored. */
3622 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3624 sectp
->output_section
= sectp
;
3625 sectp
->output_offset
= 0;
3628 /* Default implementation for sym_relocate. */
3631 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3634 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3636 bfd
*abfd
= sectp
->owner
;
3638 /* We're only interested in sections with relocation
3640 if ((sectp
->flags
& SEC_RELOC
) == 0)
3643 /* We will handle section offsets properly elsewhere, so relocate as if
3644 all sections begin at 0. */
3645 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3647 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3650 /* Relocate the contents of a debug section SECTP in ABFD. The
3651 contents are stored in BUF if it is non-NULL, or returned in a
3652 malloc'd buffer otherwise.
3654 For some platforms and debug info formats, shared libraries contain
3655 relocations against the debug sections (particularly for DWARF-2;
3656 one affected platform is PowerPC GNU/Linux, although it depends on
3657 the version of the linker in use). Also, ELF object files naturally
3658 have unresolved relocations for their debug sections. We need to apply
3659 the relocations in order to get the locations of symbols correct.
3660 Another example that may require relocation processing, is the
3661 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3665 symfile_relocate_debug_section (struct objfile
*objfile
,
3666 asection
*sectp
, bfd_byte
*buf
)
3668 gdb_assert (objfile
->sf
->sym_relocate
);
3670 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3673 struct symfile_segment_data
*
3674 get_symfile_segment_data (bfd
*abfd
)
3676 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3681 return sf
->sym_segments (abfd
);
3685 free_symfile_segment_data (struct symfile_segment_data
*data
)
3687 xfree (data
->segment_bases
);
3688 xfree (data
->segment_sizes
);
3689 xfree (data
->segment_info
);
3694 - DATA, containing segment addresses from the object file ABFD, and
3695 the mapping from ABFD's sections onto the segments that own them,
3697 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3698 segment addresses reported by the target,
3699 store the appropriate offsets for each section in OFFSETS.
3701 If there are fewer entries in SEGMENT_BASES than there are segments
3702 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3704 If there are more entries, then ignore the extra. The target may
3705 not be able to distinguish between an empty data segment and a
3706 missing data segment; a missing text segment is less plausible. */
3709 symfile_map_offsets_to_segments (bfd
*abfd
,
3710 const struct symfile_segment_data
*data
,
3711 struct section_offsets
*offsets
,
3712 int num_segment_bases
,
3713 const CORE_ADDR
*segment_bases
)
3718 /* It doesn't make sense to call this function unless you have some
3719 segment base addresses. */
3720 gdb_assert (num_segment_bases
> 0);
3722 /* If we do not have segment mappings for the object file, we
3723 can not relocate it by segments. */
3724 gdb_assert (data
!= NULL
);
3725 gdb_assert (data
->num_segments
> 0);
3727 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3729 int which
= data
->segment_info
[i
];
3731 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3733 /* Don't bother computing offsets for sections that aren't
3734 loaded as part of any segment. */
3738 /* Use the last SEGMENT_BASES entry as the address of any extra
3739 segments mentioned in DATA->segment_info. */
3740 if (which
> num_segment_bases
)
3741 which
= num_segment_bases
;
3743 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3744 - data
->segment_bases
[which
- 1]);
3751 symfile_find_segment_sections (struct objfile
*objfile
)
3753 bfd
*abfd
= objfile
->obfd
;
3756 struct symfile_segment_data
*data
;
3758 data
= get_symfile_segment_data (objfile
->obfd
);
3762 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3764 free_symfile_segment_data (data
);
3768 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3770 int which
= data
->segment_info
[i
];
3774 if (objfile
->sect_index_text
== -1)
3775 objfile
->sect_index_text
= sect
->index
;
3777 if (objfile
->sect_index_rodata
== -1)
3778 objfile
->sect_index_rodata
= sect
->index
;
3780 else if (which
== 2)
3782 if (objfile
->sect_index_data
== -1)
3783 objfile
->sect_index_data
= sect
->index
;
3785 if (objfile
->sect_index_bss
== -1)
3786 objfile
->sect_index_bss
= sect
->index
;
3790 free_symfile_segment_data (data
);
3793 /* Listen for free_objfile events. */
3796 symfile_free_objfile (struct objfile
*objfile
)
3798 /* Remove the target sections owned by this objfile. */
3799 if (objfile
!= NULL
)
3800 remove_target_sections ((void *) objfile
);
3803 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3804 Expand all symtabs that match the specified criteria.
3805 See quick_symbol_functions.expand_symtabs_matching for details. */
3808 expand_symtabs_matching
3809 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3810 const lookup_name_info
&lookup_name
,
3811 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3812 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3813 enum search_domain kind
)
3815 for (objfile
*objfile
: current_program_space
->objfiles ())
3818 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3821 expansion_notify
, kind
);
3825 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3826 Map function FUN over every file.
3827 See quick_symbol_functions.map_symbol_filenames for details. */
3830 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3833 for (objfile
*objfile
: current_program_space
->objfiles ())
3836 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3843 namespace selftests
{
3844 namespace filename_language
{
3846 static void test_filename_language ()
3848 /* This test messes up the filename_language_table global. */
3849 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3851 /* Test deducing an unknown extension. */
3852 language lang
= deduce_language_from_filename ("myfile.blah");
3853 SELF_CHECK (lang
== language_unknown
);
3855 /* Test deducing a known extension. */
3856 lang
= deduce_language_from_filename ("myfile.c");
3857 SELF_CHECK (lang
== language_c
);
3859 /* Test adding a new extension using the internal API. */
3860 add_filename_language (".blah", language_pascal
);
3861 lang
= deduce_language_from_filename ("myfile.blah");
3862 SELF_CHECK (lang
== language_pascal
);
3866 test_set_ext_lang_command ()
3868 /* This test messes up the filename_language_table global. */
3869 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3871 /* Confirm that the .hello extension is not known. */
3872 language lang
= deduce_language_from_filename ("cake.hello");
3873 SELF_CHECK (lang
== language_unknown
);
3875 /* Test adding a new extension using the CLI command. */
3876 auto args_holder
= make_unique_xstrdup (".hello rust");
3877 ext_args
= args_holder
.get ();
3878 set_ext_lang_command (NULL
, 1, NULL
);
3880 lang
= deduce_language_from_filename ("cake.hello");
3881 SELF_CHECK (lang
== language_rust
);
3883 /* Test overriding an existing extension using the CLI command. */
3884 int size_before
= filename_language_table
.size ();
3885 args_holder
.reset (xstrdup (".hello pascal"));
3886 ext_args
= args_holder
.get ();
3887 set_ext_lang_command (NULL
, 1, NULL
);
3888 int size_after
= filename_language_table
.size ();
3890 lang
= deduce_language_from_filename ("cake.hello");
3891 SELF_CHECK (lang
== language_pascal
);
3892 SELF_CHECK (size_before
== size_after
);
3895 } /* namespace filename_language */
3896 } /* namespace selftests */
3898 #endif /* GDB_SELF_TEST */
3901 _initialize_symfile (void)
3903 struct cmd_list_element
*c
;
3905 gdb::observers::free_objfile
.attach (symfile_free_objfile
);
3907 #define READNOW_READNEVER_HELP \
3908 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3909 immediately. This makes the command slower, but may make future operations\n\
3911 The '-readnever' option will prevent GDB from reading the symbol file's\n\
3912 symbolic debug information."
3914 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3915 Load symbol table from executable file FILE.\n\
3916 Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3917 OFF is an optional offset which is added to each section address.\n\
3918 The `file' command can also load symbol tables, as well as setting the file\n\
3919 to execute.\n" READNOW_READNEVER_HELP
), &cmdlist
);
3920 set_cmd_completer (c
, filename_completer
);
3922 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3923 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3924 Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3925 [-s SECT-NAME SECT-ADDR]...\n\
3926 ADDR is the starting address of the file's text.\n\
3927 Each '-s' argument provides a section name and address, and\n\
3928 should be specified if the data and bss segments are not contiguous\n\
3929 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3930 OFF is an optional offset which is added to the default load addresses\n\
3931 of all sections for which no other address was specified.\n"
3932 READNOW_READNEVER_HELP
),
3934 set_cmd_completer (c
, filename_completer
);
3936 c
= add_cmd ("remove-symbol-file", class_files
,
3937 remove_symbol_file_command
, _("\
3938 Remove a symbol file added via the add-symbol-file command.\n\
3939 Usage: remove-symbol-file FILENAME\n\
3940 remove-symbol-file -a ADDRESS\n\
3941 The file to remove can be identified by its filename or by an address\n\
3942 that lies within the boundaries of this symbol file in memory."),
3945 c
= add_cmd ("load", class_files
, load_command
, _("\
3946 Dynamically load FILE into the running program.\n\
3947 FILE symbols are recorded for access from GDB.\n\
3948 Usage: load [FILE] [OFFSET]\n\
3949 An optional load OFFSET may also be given as a literal address.\n\
3950 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3951 on its own."), &cmdlist
);
3952 set_cmd_completer (c
, filename_completer
);
3954 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3955 _("Commands for debugging overlays."), &overlaylist
,
3956 "overlay ", 0, &cmdlist
);
3958 add_com_alias ("ovly", "overlay", class_alias
, 1);
3959 add_com_alias ("ov", "overlay", class_alias
, 1);
3961 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3962 _("Assert that an overlay section is mapped."), &overlaylist
);
3964 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3965 _("Assert that an overlay section is unmapped."), &overlaylist
);
3967 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3968 _("List mappings of overlay sections."), &overlaylist
);
3970 add_cmd ("manual", class_support
, overlay_manual_command
,
3971 _("Enable overlay debugging."), &overlaylist
);
3972 add_cmd ("off", class_support
, overlay_off_command
,
3973 _("Disable overlay debugging."), &overlaylist
);
3974 add_cmd ("auto", class_support
, overlay_auto_command
,
3975 _("Enable automatic overlay debugging."), &overlaylist
);
3976 add_cmd ("load-target", class_support
, overlay_load_command
,
3977 _("Read the overlay mapping state from the target."), &overlaylist
);
3979 /* Filename extension to source language lookup table: */
3980 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3982 Set mapping between filename extension and source language."), _("\
3983 Show mapping between filename extension and source language."), _("\
3984 Usage: set extension-language .foo bar"),
3985 set_ext_lang_command
,
3987 &setlist
, &showlist
);
3989 add_info ("extensions", info_ext_lang_command
,
3990 _("All filename extensions associated with a source language."));
3992 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3993 &debug_file_directory
, _("\
3994 Set the directories where separate debug symbols are searched for."), _("\
3995 Show the directories where separate debug symbols are searched for."), _("\
3996 Separate debug symbols are first searched for in the same\n\
3997 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3998 and lastly at the path of the directory of the binary with\n\
3999 each global debug-file-directory component prepended."),
4001 show_debug_file_directory
,
4002 &setlist
, &showlist
);
4004 add_setshow_enum_cmd ("symbol-loading", no_class
,
4005 print_symbol_loading_enums
, &print_symbol_loading
,
4007 Set printing of symbol loading messages."), _("\
4008 Show printing of symbol loading messages."), _("\
4009 off == turn all messages off\n\
4010 brief == print messages for the executable,\n\
4011 and brief messages for shared libraries\n\
4012 full == print messages for the executable,\n\
4013 and messages for each shared library."),
4016 &setprintlist
, &showprintlist
);
4018 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
4019 &separate_debug_file_debug
, _("\
4020 Set printing of separate debug info file search debug."), _("\
4021 Show printing of separate debug info file search debug."), _("\
4022 When on, GDB prints the searched locations while looking for separate debug \
4023 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
4026 selftests::register_test
4027 ("filename_language", selftests::filename_language::test_filename_language
);
4028 selftests::register_test
4029 ("set_ext_lang_command",
4030 selftests::filename_language::test_set_ext_lang_command
);