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/readline.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 continguous 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 correspondig 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 wether
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 breakpoins.
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
);
1110 puts_filtered (_("Reading symbols from "));
1111 fputs_styled (name
, file_name_style
.style (), gdb_stdout
);
1112 puts_filtered ("...\n");
1115 syms_from_objfile (objfile
, addrs
, add_flags
);
1117 /* We now have at least a partial symbol table. Check to see if the
1118 user requested that all symbols be read on initial access via either
1119 the gdb startup command line or on a per symbol file basis. Expand
1120 all partial symbol tables for this objfile if so. */
1122 if ((flags
& OBJF_READNOW
))
1125 printf_filtered (_("Expanding full symbols from %s...\n"), name
);
1128 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1131 /* Note that we only print a message if we have no symbols and have
1132 no separate debug file. If there is a separate debug file which
1133 does not have symbols, we'll have emitted this message for that
1134 file, and so printing it twice is just redundant. */
1135 if (should_print
&& !objfile_has_symbols (objfile
)
1136 && objfile
->separate_debug_objfile
== nullptr)
1137 printf_filtered (_("(No debugging symbols found in %s)\n"), name
);
1141 if (deprecated_post_add_symbol_hook
)
1142 deprecated_post_add_symbol_hook ();
1145 /* We print some messages regardless of whether 'from_tty ||
1146 info_verbose' is true, so make sure they go out at the right
1148 gdb_flush (gdb_stdout
);
1150 if (objfile
->sf
== NULL
)
1152 gdb::observers::new_objfile
.notify (objfile
);
1153 return objfile
; /* No symbols. */
1156 finish_new_objfile (objfile
, add_flags
);
1158 gdb::observers::new_objfile
.notify (objfile
);
1160 bfd_cache_close_all ();
1164 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1165 see the objfile constructor. */
1168 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1169 symfile_add_flags symfile_flags
,
1170 struct objfile
*objfile
)
1172 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1173 because sections of BFD may not match sections of OBJFILE and because
1174 vma may have been modified by tools such as prelink. */
1175 section_addr_info sap
= build_section_addr_info_from_objfile (objfile
);
1177 symbol_file_add_with_addrs
1178 (bfd
, name
, symfile_flags
, &sap
,
1179 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1184 /* Process the symbol file ABFD, as either the main file or as a
1185 dynamically loaded file.
1186 See symbol_file_add_with_addrs's comments for details. */
1189 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1190 symfile_add_flags add_flags
,
1191 section_addr_info
*addrs
,
1192 objfile_flags flags
, struct objfile
*parent
)
1194 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1198 /* Process a symbol file, as either the main file or as a dynamically
1199 loaded file. See symbol_file_add_with_addrs's comments for details. */
1202 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1203 section_addr_info
*addrs
, objfile_flags flags
)
1205 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1207 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1211 /* Call symbol_file_add() with default values and update whatever is
1212 affected by the loading of a new main().
1213 Used when the file is supplied in the gdb command line
1214 and by some targets with special loading requirements.
1215 The auxiliary function, symbol_file_add_main_1(), has the flags
1216 argument for the switches that can only be specified in the symbol_file
1220 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1222 symbol_file_add_main_1 (args
, add_flags
, 0, 0);
1226 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1227 objfile_flags flags
, CORE_ADDR reloff
)
1229 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1231 struct objfile
*objfile
= symbol_file_add (args
, add_flags
, NULL
, flags
);
1233 objfile_rebase (objfile
, reloff
);
1235 /* Getting new symbols may change our opinion about
1236 what is frameless. */
1237 reinit_frame_cache ();
1239 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1240 set_initial_language ();
1244 symbol_file_clear (int from_tty
)
1246 if ((have_full_symbols () || have_partial_symbols ())
1249 ? !query (_("Discard symbol table from `%s'? "),
1250 objfile_name (symfile_objfile
))
1251 : !query (_("Discard symbol table? "))))
1252 error (_("Not confirmed."));
1254 /* solib descriptors may have handles to objfiles. Wipe them before their
1255 objfiles get stale by free_all_objfiles. */
1256 no_shared_libraries (NULL
, from_tty
);
1258 free_all_objfiles ();
1260 gdb_assert (symfile_objfile
== NULL
);
1262 printf_filtered (_("No symbol file now.\n"));
1265 /* See symfile.h. */
1267 bool separate_debug_file_debug
= false;
1270 separate_debug_file_exists (const std::string
&name
, unsigned long crc
,
1271 struct objfile
*parent_objfile
)
1273 unsigned long file_crc
;
1275 struct stat parent_stat
, abfd_stat
;
1276 int verified_as_different
;
1278 /* Find a separate debug info file as if symbols would be present in
1279 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1280 section can contain just the basename of PARENT_OBJFILE without any
1281 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1282 the separate debug infos with the same basename can exist. */
1284 if (filename_cmp (name
.c_str (), objfile_name (parent_objfile
)) == 0)
1287 if (separate_debug_file_debug
)
1289 printf_filtered (_(" Trying %s..."), name
.c_str ());
1290 gdb_flush (gdb_stdout
);
1293 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
.c_str (), gnutarget
, -1));
1297 if (separate_debug_file_debug
)
1298 printf_filtered (_(" no, unable to open.\n"));
1303 /* Verify symlinks were not the cause of filename_cmp name difference above.
1305 Some operating systems, e.g. Windows, do not provide a meaningful
1306 st_ino; they always set it to zero. (Windows does provide a
1307 meaningful st_dev.) Files accessed from gdbservers that do not
1308 support the vFile:fstat packet will also have st_ino set to zero.
1309 Do not indicate a duplicate library in either case. While there
1310 is no guarantee that a system that provides meaningful inode
1311 numbers will never set st_ino to zero, this is merely an
1312 optimization, so we do not need to worry about false negatives. */
1314 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1315 && abfd_stat
.st_ino
!= 0
1316 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1318 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1319 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1321 if (separate_debug_file_debug
)
1322 printf_filtered (_(" no, same file as the objfile.\n"));
1326 verified_as_different
= 1;
1329 verified_as_different
= 0;
1331 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1335 if (separate_debug_file_debug
)
1336 printf_filtered (_(" no, error computing CRC.\n"));
1341 if (crc
!= file_crc
)
1343 unsigned long parent_crc
;
1345 /* If the files could not be verified as different with
1346 bfd_stat then we need to calculate the parent's CRC
1347 to verify whether the files are different or not. */
1349 if (!verified_as_different
)
1351 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1353 if (separate_debug_file_debug
)
1354 printf_filtered (_(" no, error computing CRC.\n"));
1360 if (verified_as_different
|| parent_crc
!= file_crc
)
1361 warning (_("the debug information found in \"%s\""
1362 " does not match \"%s\" (CRC mismatch).\n"),
1363 name
.c_str (), objfile_name (parent_objfile
));
1365 if (separate_debug_file_debug
)
1366 printf_filtered (_(" no, CRC doesn't match.\n"));
1371 if (separate_debug_file_debug
)
1372 printf_filtered (_(" yes!\n"));
1377 char *debug_file_directory
= NULL
;
1379 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1380 struct cmd_list_element
*c
, const char *value
)
1382 fprintf_filtered (file
,
1383 _("The directory where separate debug "
1384 "symbols are searched for is \"%s\".\n"),
1388 #if ! defined (DEBUG_SUBDIRECTORY)
1389 #define DEBUG_SUBDIRECTORY ".debug"
1392 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1393 where the original file resides (may not be the same as
1394 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1395 looking for. CANON_DIR is the "realpath" form of DIR.
1396 DIR must contain a trailing '/'.
1397 Returns the path of the file with separate debug info, or an empty
1401 find_separate_debug_file (const char *dir
,
1402 const char *canon_dir
,
1403 const char *debuglink
,
1404 unsigned long crc32
, struct objfile
*objfile
)
1406 if (separate_debug_file_debug
)
1407 printf_filtered (_("\nLooking for separate debug info (debug link) for "
1408 "%s\n"), objfile_name (objfile
));
1410 /* First try in the same directory as the original file. */
1411 std::string debugfile
= dir
;
1412 debugfile
+= debuglink
;
1414 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1417 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1419 debugfile
+= DEBUG_SUBDIRECTORY
;
1421 debugfile
+= debuglink
;
1423 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1426 /* Then try in the global debugfile directories.
1428 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1429 cause "/..." lookups. */
1431 bool target_prefix
= startswith (dir
, "target:");
1432 const char *dir_notarget
= target_prefix
? dir
+ strlen ("target:") : dir
;
1433 std::vector
<gdb::unique_xmalloc_ptr
<char>> debugdir_vec
1434 = dirnames_to_char_ptr_vec (debug_file_directory
);
1435 gdb::unique_xmalloc_ptr
<char> canon_sysroot
= gdb_realpath (gdb_sysroot
);
1437 /* MS-Windows/MS-DOS don't allow colons in file names; we must
1438 convert the drive letter into a one-letter directory, so that the
1439 file name resulting from splicing below will be valid.
1441 FIXME: The below only works when GDB runs on MS-Windows/MS-DOS.
1442 There are various remote-debugging scenarios where such a
1443 transformation of the drive letter might be required when GDB runs
1444 on a Posix host, see
1446 https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
1448 If some of those scenarions need to be supported, we will need to
1449 use a different condition for HAS_DRIVE_SPEC and a different macro
1450 instead of STRIP_DRIVE_SPEC, which work on Posix systems as well. */
1452 if (HAS_DRIVE_SPEC (dir_notarget
))
1454 drive
= dir_notarget
[0];
1455 dir_notarget
= STRIP_DRIVE_SPEC (dir_notarget
);
1458 for (const gdb::unique_xmalloc_ptr
<char> &debugdir
: debugdir_vec
)
1460 debugfile
= target_prefix
? "target:" : "";
1461 debugfile
+= debugdir
.get ();
1464 debugfile
+= dir_notarget
;
1465 debugfile
+= debuglink
;
1467 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1470 const char *base_path
= NULL
;
1471 if (canon_dir
!= NULL
)
1473 if (canon_sysroot
.get () != NULL
)
1474 base_path
= child_path (canon_sysroot
.get (), canon_dir
);
1476 base_path
= child_path (gdb_sysroot
, canon_dir
);
1478 if (base_path
!= NULL
)
1480 /* If the file is in the sysroot, try using its base path in
1481 the global debugfile directory. */
1482 debugfile
= target_prefix
? "target:" : "";
1483 debugfile
+= debugdir
.get ();
1485 debugfile
+= base_path
;
1487 debugfile
+= debuglink
;
1489 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1492 /* If the file is in the sysroot, try using its base path in
1493 the sysroot's global debugfile directory. */
1494 debugfile
= target_prefix
? "target:" : "";
1495 debugfile
+= gdb_sysroot
;
1496 debugfile
+= debugdir
.get ();
1498 debugfile
+= base_path
;
1500 debugfile
+= debuglink
;
1502 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1508 return std::string ();
1511 /* Modify PATH to contain only "[/]directory/" part of PATH.
1512 If there were no directory separators in PATH, PATH will be empty
1513 string on return. */
1516 terminate_after_last_dir_separator (char *path
)
1520 /* Strip off the final filename part, leaving the directory name,
1521 followed by a slash. The directory can be relative or absolute. */
1522 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1523 if (IS_DIR_SEPARATOR (path
[i
]))
1526 /* If I is -1 then no directory is present there and DIR will be "". */
1530 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1531 Returns pathname, or an empty string. */
1534 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1536 unsigned long crc32
;
1538 gdb::unique_xmalloc_ptr
<char> debuglink
1539 (bfd_get_debug_link_info (objfile
->obfd
, &crc32
));
1541 if (debuglink
== NULL
)
1543 /* There's no separate debug info, hence there's no way we could
1544 load it => no warning. */
1545 return std::string ();
1548 std::string dir
= objfile_name (objfile
);
1549 terminate_after_last_dir_separator (&dir
[0]);
1550 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1552 std::string debugfile
1553 = find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1554 debuglink
.get (), crc32
, objfile
);
1556 if (debugfile
.empty ())
1558 /* For PR gdb/9538, try again with realpath (if different from the
1563 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1564 && S_ISLNK (st_buf
.st_mode
))
1566 gdb::unique_xmalloc_ptr
<char> symlink_dir
1567 (lrealpath (objfile_name (objfile
)));
1568 if (symlink_dir
!= NULL
)
1570 terminate_after_last_dir_separator (symlink_dir
.get ());
1571 if (dir
!= symlink_dir
.get ())
1573 /* Different directory, so try using it. */
1574 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1587 /* Make sure that OBJF_{READNOW,READNEVER} are not set
1591 validate_readnow_readnever (objfile_flags flags
)
1593 if ((flags
& OBJF_READNOW
) && (flags
& OBJF_READNEVER
))
1594 error (_("-readnow and -readnever cannot be used simultaneously"));
1597 /* This is the symbol-file command. Read the file, analyze its
1598 symbols, and add a struct symtab to a symtab list. The syntax of
1599 the command is rather bizarre:
1601 1. The function buildargv implements various quoting conventions
1602 which are undocumented and have little or nothing in common with
1603 the way things are quoted (or not quoted) elsewhere in GDB.
1605 2. Options are used, which are not generally used in GDB (perhaps
1606 "set mapped on", "set readnow on" would be better)
1608 3. The order of options matters, which is contrary to GNU
1609 conventions (because it is confusing and inconvenient). */
1612 symbol_file_command (const char *args
, int from_tty
)
1618 symbol_file_clear (from_tty
);
1622 objfile_flags flags
= OBJF_USERLOADED
;
1623 symfile_add_flags add_flags
= 0;
1625 bool stop_processing_options
= false;
1626 CORE_ADDR offset
= 0;
1631 add_flags
|= SYMFILE_VERBOSE
;
1633 gdb_argv
built_argv (args
);
1634 for (arg
= built_argv
[0], idx
= 0; arg
!= NULL
; arg
= built_argv
[++idx
])
1636 if (stop_processing_options
|| *arg
!= '-')
1641 error (_("Unrecognized argument \"%s\""), arg
);
1643 else if (strcmp (arg
, "-readnow") == 0)
1644 flags
|= OBJF_READNOW
;
1645 else if (strcmp (arg
, "-readnever") == 0)
1646 flags
|= OBJF_READNEVER
;
1647 else if (strcmp (arg
, "-o") == 0)
1649 arg
= built_argv
[++idx
];
1651 error (_("Missing argument to -o"));
1653 offset
= parse_and_eval_address (arg
);
1655 else if (strcmp (arg
, "--") == 0)
1656 stop_processing_options
= true;
1658 error (_("Unrecognized argument \"%s\""), arg
);
1662 error (_("no symbol file name was specified"));
1664 validate_readnow_readnever (flags
);
1666 /* Set SYMFILE_DEFER_BP_RESET because the proper displacement for a PIE
1667 (Position Independent Executable) main symbol file will only be
1668 computed by the solib_create_inferior_hook below. Without it,
1669 breakpoint_re_set would fail to insert the breakpoints with the zero
1671 add_flags
|= SYMFILE_DEFER_BP_RESET
;
1673 symbol_file_add_main_1 (name
, add_flags
, flags
, offset
);
1675 solib_create_inferior_hook (from_tty
);
1677 /* Now it's safe to re-add the breakpoints. */
1678 breakpoint_re_set ();
1682 /* Set the initial language.
1684 FIXME: A better solution would be to record the language in the
1685 psymtab when reading partial symbols, and then use it (if known) to
1686 set the language. This would be a win for formats that encode the
1687 language in an easily discoverable place, such as DWARF. For
1688 stabs, we can jump through hoops looking for specially named
1689 symbols or try to intuit the language from the specific type of
1690 stabs we find, but we can't do that until later when we read in
1694 set_initial_language (void)
1696 enum language lang
= main_language ();
1698 if (lang
== language_unknown
)
1700 const char *name
= main_name ();
1701 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1704 lang
= SYMBOL_LANGUAGE (sym
);
1707 if (lang
== language_unknown
)
1709 /* Make C the default language */
1713 set_language (lang
);
1714 expected_language
= current_language
; /* Don't warn the user. */
1717 /* Open the file specified by NAME and hand it off to BFD for
1718 preliminary analysis. Return a newly initialized bfd *, which
1719 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1720 absolute). In case of trouble, error() is called. */
1723 symfile_bfd_open (const char *name
)
1727 gdb::unique_xmalloc_ptr
<char> absolute_name
;
1728 if (!is_target_filename (name
))
1730 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1732 /* Look down path for it, allocate 2nd new malloc'd copy. */
1733 desc
= openp (getenv ("PATH"),
1734 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1735 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1736 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1739 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1741 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1742 desc
= openp (getenv ("PATH"),
1743 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1744 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1748 perror_with_name (expanded_name
.get ());
1750 name
= absolute_name
.get ();
1753 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1754 if (sym_bfd
== NULL
)
1755 error (_("`%s': can't open to read symbols: %s."), name
,
1756 bfd_errmsg (bfd_get_error ()));
1758 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1759 bfd_set_cacheable (sym_bfd
.get (), 1);
1761 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1762 error (_("`%s': can't read symbols: %s."), name
,
1763 bfd_errmsg (bfd_get_error ()));
1768 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1769 the section was not found. */
1772 get_section_index (struct objfile
*objfile
, const char *section_name
)
1774 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1782 /* Link SF into the global symtab_fns list.
1783 FLAVOUR is the file format that SF handles.
1784 Called on startup by the _initialize routine in each object file format
1785 reader, to register information about each format the reader is prepared
1789 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1791 symtab_fns
.emplace_back (flavour
, sf
);
1794 /* Initialize OBJFILE to read symbols from its associated BFD. It
1795 either returns or calls error(). The result is an initialized
1796 struct sym_fns in the objfile structure, that contains cached
1797 information about the symbol file. */
1799 static const struct sym_fns
*
1800 find_sym_fns (bfd
*abfd
)
1802 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1804 if (our_flavour
== bfd_target_srec_flavour
1805 || our_flavour
== bfd_target_ihex_flavour
1806 || our_flavour
== bfd_target_tekhex_flavour
)
1807 return NULL
; /* No symbols. */
1809 for (const registered_sym_fns
&rsf
: symtab_fns
)
1810 if (our_flavour
== rsf
.sym_flavour
)
1813 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1814 bfd_get_target (abfd
));
1818 /* This function runs the load command of our current target. */
1821 load_command (const char *arg
, int from_tty
)
1825 /* The user might be reloading because the binary has changed. Take
1826 this opportunity to check. */
1827 reopen_exec_file ();
1833 const char *parg
, *prev
;
1835 arg
= get_exec_file (1);
1837 /* We may need to quote this string so buildargv can pull it
1840 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1842 temp
.append (prev
, parg
- prev
);
1844 temp
.push_back ('\\');
1846 /* If we have not copied anything yet, then we didn't see a
1847 character to quote, and we can just leave ARG unchanged. */
1851 arg
= temp
.c_str ();
1855 target_load (arg
, from_tty
);
1857 /* After re-loading the executable, we don't really know which
1858 overlays are mapped any more. */
1859 overlay_cache_invalid
= 1;
1862 /* This version of "load" should be usable for any target. Currently
1863 it is just used for remote targets, not inftarg.c or core files,
1864 on the theory that only in that case is it useful.
1866 Avoiding xmodem and the like seems like a win (a) because we don't have
1867 to worry about finding it, and (b) On VMS, fork() is very slow and so
1868 we don't want to run a subprocess. On the other hand, I'm not sure how
1869 performance compares. */
1871 static int validate_download
= 0;
1873 /* Callback service function for generic_load (bfd_map_over_sections). */
1876 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1878 bfd_size_type
*sum
= (bfd_size_type
*) data
;
1880 *sum
+= bfd_section_size (asec
);
1883 /* Opaque data for load_progress. */
1884 struct load_progress_data
1886 /* Cumulative data. */
1887 unsigned long write_count
= 0;
1888 unsigned long data_count
= 0;
1889 bfd_size_type total_size
= 0;
1892 /* Opaque data for load_progress for a single section. */
1893 struct load_progress_section_data
1895 load_progress_section_data (load_progress_data
*cumulative_
,
1896 const char *section_name_
, ULONGEST section_size_
,
1897 CORE_ADDR lma_
, gdb_byte
*buffer_
)
1898 : cumulative (cumulative_
), section_name (section_name_
),
1899 section_size (section_size_
), lma (lma_
), buffer (buffer_
)
1902 struct load_progress_data
*cumulative
;
1904 /* Per-section data. */
1905 const char *section_name
;
1906 ULONGEST section_sent
= 0;
1907 ULONGEST section_size
;
1912 /* Opaque data for load_section_callback. */
1913 struct load_section_data
1915 load_section_data (load_progress_data
*progress_data_
)
1916 : progress_data (progress_data_
)
1919 ~load_section_data ()
1921 for (auto &&request
: requests
)
1923 xfree (request
.data
);
1924 delete ((load_progress_section_data
*) request
.baton
);
1928 CORE_ADDR load_offset
= 0;
1929 struct load_progress_data
*progress_data
;
1930 std::vector
<struct memory_write_request
> requests
;
1933 /* Target write callback routine for progress reporting. */
1936 load_progress (ULONGEST bytes
, void *untyped_arg
)
1938 struct load_progress_section_data
*args
1939 = (struct load_progress_section_data
*) untyped_arg
;
1940 struct load_progress_data
*totals
;
1943 /* Writing padding data. No easy way to get at the cumulative
1944 stats, so just ignore this. */
1947 totals
= args
->cumulative
;
1949 if (bytes
== 0 && args
->section_sent
== 0)
1951 /* The write is just starting. Let the user know we've started
1953 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1955 hex_string (args
->section_size
),
1956 paddress (target_gdbarch (), args
->lma
));
1960 if (validate_download
)
1962 /* Broken memories and broken monitors manifest themselves here
1963 when bring new computers to life. This doubles already slow
1965 /* NOTE: cagney/1999-10-18: A more efficient implementation
1966 might add a verify_memory() method to the target vector and
1967 then use that. remote.c could implement that method using
1968 the ``qCRC'' packet. */
1969 gdb::byte_vector
check (bytes
);
1971 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1972 error (_("Download verify read failed at %s"),
1973 paddress (target_gdbarch (), args
->lma
));
1974 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1975 error (_("Download verify compare failed at %s"),
1976 paddress (target_gdbarch (), args
->lma
));
1978 totals
->data_count
+= bytes
;
1980 args
->buffer
+= bytes
;
1981 totals
->write_count
+= 1;
1982 args
->section_sent
+= bytes
;
1983 if (check_quit_flag ()
1984 || (deprecated_ui_load_progress_hook
!= NULL
1985 && deprecated_ui_load_progress_hook (args
->section_name
,
1986 args
->section_sent
)))
1987 error (_("Canceled the download"));
1989 if (deprecated_show_load_progress
!= NULL
)
1990 deprecated_show_load_progress (args
->section_name
,
1994 totals
->total_size
);
1997 /* Callback service function for generic_load (bfd_map_over_sections). */
2000 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
2002 struct load_section_data
*args
= (struct load_section_data
*) data
;
2003 bfd_size_type size
= bfd_section_size (asec
);
2004 const char *sect_name
= bfd_section_name (asec
);
2006 if ((bfd_section_flags (asec
) & SEC_LOAD
) == 0)
2012 ULONGEST begin
= bfd_section_lma (asec
) + args
->load_offset
;
2013 ULONGEST end
= begin
+ size
;
2014 gdb_byte
*buffer
= (gdb_byte
*) xmalloc (size
);
2015 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2017 load_progress_section_data
*section_data
2018 = new load_progress_section_data (args
->progress_data
, sect_name
, size
,
2021 args
->requests
.emplace_back (begin
, end
, buffer
, section_data
);
2024 static void print_transfer_performance (struct ui_file
*stream
,
2025 unsigned long data_count
,
2026 unsigned long write_count
,
2027 std::chrono::steady_clock::duration d
);
2029 /* See symfile.h. */
2032 generic_load (const char *args
, int from_tty
)
2034 struct load_progress_data total_progress
;
2035 struct load_section_data
cbdata (&total_progress
);
2036 struct ui_out
*uiout
= current_uiout
;
2039 error_no_arg (_("file to load"));
2041 gdb_argv
argv (args
);
2043 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2045 if (argv
[1] != NULL
)
2049 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2051 /* If the last word was not a valid number then
2052 treat it as a file name with spaces in. */
2053 if (argv
[1] == endptr
)
2054 error (_("Invalid download offset:%s."), argv
[1]);
2056 if (argv
[2] != NULL
)
2057 error (_("Too many parameters."));
2060 /* Open the file for loading. */
2061 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
2062 if (loadfile_bfd
== NULL
)
2063 perror_with_name (filename
.get ());
2065 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2067 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2068 bfd_errmsg (bfd_get_error ()));
2071 bfd_map_over_sections (loadfile_bfd
.get (), add_section_size_callback
,
2072 (void *) &total_progress
.total_size
);
2074 bfd_map_over_sections (loadfile_bfd
.get (), load_section_callback
, &cbdata
);
2076 using namespace std::chrono
;
2078 steady_clock::time_point start_time
= steady_clock::now ();
2080 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2081 load_progress
) != 0)
2082 error (_("Load failed"));
2084 steady_clock::time_point end_time
= steady_clock::now ();
2086 CORE_ADDR entry
= bfd_get_start_address (loadfile_bfd
.get ());
2087 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2088 uiout
->text ("Start address ");
2089 uiout
->field_core_addr ("address", target_gdbarch (), entry
);
2090 uiout
->text (", load size ");
2091 uiout
->field_unsigned ("load-size", total_progress
.data_count
);
2093 regcache_write_pc (get_current_regcache (), entry
);
2095 /* Reset breakpoints, now that we have changed the load image. For
2096 instance, breakpoints may have been set (or reset, by
2097 post_create_inferior) while connected to the target but before we
2098 loaded the program. In that case, the prologue analyzer could
2099 have read instructions from the target to find the right
2100 breakpoint locations. Loading has changed the contents of that
2103 breakpoint_re_set ();
2105 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2106 total_progress
.write_count
,
2107 end_time
- start_time
);
2110 /* Report on STREAM the performance of a memory transfer operation,
2111 such as 'load'. DATA_COUNT is the number of bytes transferred.
2112 WRITE_COUNT is the number of separate write operations, or 0, if
2113 that information is not available. TIME is how long the operation
2117 print_transfer_performance (struct ui_file
*stream
,
2118 unsigned long data_count
,
2119 unsigned long write_count
,
2120 std::chrono::steady_clock::duration time
)
2122 using namespace std::chrono
;
2123 struct ui_out
*uiout
= current_uiout
;
2125 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2127 uiout
->text ("Transfer rate: ");
2128 if (ms
.count () > 0)
2130 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2132 if (uiout
->is_mi_like_p ())
2134 uiout
->field_unsigned ("transfer-rate", rate
* 8);
2135 uiout
->text (" bits/sec");
2137 else if (rate
< 1024)
2139 uiout
->field_unsigned ("transfer-rate", rate
);
2140 uiout
->text (" bytes/sec");
2144 uiout
->field_unsigned ("transfer-rate", rate
/ 1024);
2145 uiout
->text (" KB/sec");
2150 uiout
->field_unsigned ("transferred-bits", (data_count
* 8));
2151 uiout
->text (" bits in <1 sec");
2153 if (write_count
> 0)
2156 uiout
->field_unsigned ("write-rate", data_count
/ write_count
);
2157 uiout
->text (" bytes/write");
2159 uiout
->text (".\n");
2162 /* Add an OFFSET to the start address of each section in OBJF, except
2163 sections that were specified in ADDRS. */
2166 set_objfile_default_section_offset (struct objfile
*objf
,
2167 const section_addr_info
&addrs
,
2170 /* Add OFFSET to all sections by default. */
2171 std::vector
<struct section_offsets
> offsets (objf
->num_sections
,
2174 /* Create sorted lists of all sections in ADDRS as well as all
2175 sections in OBJF. */
2177 std::vector
<const struct other_sections
*> addrs_sorted
2178 = addrs_section_sort (addrs
);
2180 section_addr_info objf_addrs
2181 = build_section_addr_info_from_objfile (objf
);
2182 std::vector
<const struct other_sections
*> objf_addrs_sorted
2183 = addrs_section_sort (objf_addrs
);
2185 /* Walk the BFD section list, and if a matching section is found in
2186 ADDRS_SORTED_LIST, set its offset to zero to keep its address
2189 Note that both lists may contain multiple sections with the same
2190 name, and then the sections from ADDRS are matched in BFD order
2191 (thanks to sectindex). */
2193 std::vector
<const struct other_sections
*>::iterator addrs_sorted_iter
2194 = addrs_sorted
.begin ();
2195 for (const other_sections
*objf_sect
: objf_addrs_sorted
)
2197 const char *objf_name
= addr_section_name (objf_sect
->name
.c_str ());
2200 while (cmp
< 0 && addrs_sorted_iter
!= addrs_sorted
.end ())
2202 const struct other_sections
*sect
= *addrs_sorted_iter
;
2203 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
2204 cmp
= strcmp (sect_name
, objf_name
);
2206 ++addrs_sorted_iter
;
2210 offsets
[objf_sect
->sectindex
].offsets
[0] = 0;
2213 /* Apply the new section offsets. */
2214 objfile_relocate (objf
, offsets
.data ());
2217 /* This function allows the addition of incrementally linked object files.
2218 It does not modify any state in the target, only in the debugger. */
2221 add_symbol_file_command (const char *args
, int from_tty
)
2223 struct gdbarch
*gdbarch
= get_current_arch ();
2224 gdb::unique_xmalloc_ptr
<char> filename
;
2227 struct objfile
*objf
;
2228 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2229 symfile_add_flags add_flags
= 0;
2232 add_flags
|= SYMFILE_VERBOSE
;
2240 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2241 bool stop_processing_options
= false;
2242 CORE_ADDR offset
= 0;
2247 error (_("add-symbol-file takes a file name and an address"));
2249 bool seen_addr
= false;
2250 bool seen_offset
= false;
2251 gdb_argv
argv (args
);
2253 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2255 if (stop_processing_options
|| *arg
!= '-')
2257 if (filename
== NULL
)
2259 /* First non-option argument is always the filename. */
2260 filename
.reset (tilde_expand (arg
));
2262 else if (!seen_addr
)
2264 /* The second non-option argument is always the text
2265 address at which to load the program. */
2266 sect_opts
[0].value
= arg
;
2270 error (_("Unrecognized argument \"%s\""), arg
);
2272 else if (strcmp (arg
, "-readnow") == 0)
2273 flags
|= OBJF_READNOW
;
2274 else if (strcmp (arg
, "-readnever") == 0)
2275 flags
|= OBJF_READNEVER
;
2276 else if (strcmp (arg
, "-s") == 0)
2278 if (argv
[argcnt
+ 1] == NULL
)
2279 error (_("Missing section name after \"-s\""));
2280 else if (argv
[argcnt
+ 2] == NULL
)
2281 error (_("Missing section address after \"-s\""));
2283 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2285 sect_opts
.push_back (sect
);
2288 else if (strcmp (arg
, "-o") == 0)
2290 arg
= argv
[++argcnt
];
2292 error (_("Missing argument to -o"));
2294 offset
= parse_and_eval_address (arg
);
2297 else if (strcmp (arg
, "--") == 0)
2298 stop_processing_options
= true;
2300 error (_("Unrecognized argument \"%s\""), arg
);
2303 if (filename
== NULL
)
2304 error (_("You must provide a filename to be loaded."));
2306 validate_readnow_readnever (flags
);
2308 /* Print the prompt for the query below. And save the arguments into
2309 a sect_addr_info structure to be passed around to other
2310 functions. We have to split this up into separate print
2311 statements because hex_string returns a local static
2314 printf_unfiltered (_("add symbol table from file \"%s\""),
2316 section_addr_info section_addrs
;
2317 std::vector
<sect_opt
>::const_iterator it
= sect_opts
.begin ();
2320 for (; it
!= sect_opts
.end (); ++it
)
2323 const char *val
= it
->value
;
2324 const char *sec
= it
->name
;
2326 if (section_addrs
.empty ())
2327 printf_unfiltered (_(" at\n"));
2328 addr
= parse_and_eval_address (val
);
2330 /* Here we store the section offsets in the order they were
2331 entered on the command line. Every array element is
2332 assigned an ascending section index to preserve the above
2333 order over an unstable sorting algorithm. This dummy
2334 index is not used for any other purpose.
2336 section_addrs
.emplace_back (addr
, sec
, section_addrs
.size ());
2337 printf_filtered ("\t%s_addr = %s\n", sec
,
2338 paddress (gdbarch
, addr
));
2340 /* The object's sections are initialized when a
2341 call is made to build_objfile_section_table (objfile).
2342 This happens in reread_symbols.
2343 At this point, we don't know what file type this is,
2344 so we can't determine what section names are valid. */
2347 printf_unfiltered (_("%s offset by %s\n"),
2348 (section_addrs
.empty ()
2349 ? _(" with all sections")
2350 : _("with other sections")),
2351 paddress (gdbarch
, offset
));
2352 else if (section_addrs
.empty ())
2353 printf_unfiltered ("\n");
2355 if (from_tty
&& (!query ("%s", "")))
2356 error (_("Not confirmed."));
2358 objf
= symbol_file_add (filename
.get (), add_flags
, §ion_addrs
,
2360 if (!objfile_has_symbols (objf
) && objf
->per_bfd
->minimal_symbol_count
<= 0)
2361 warning (_("newly-added symbol file \"%s\" does not provide any symbols"),
2365 set_objfile_default_section_offset (objf
, section_addrs
, offset
);
2367 add_target_sections_of_objfile (objf
);
2369 /* Getting new symbols may change our opinion about what is
2371 reinit_frame_cache ();
2375 /* This function removes a symbol file that was added via add-symbol-file. */
2378 remove_symbol_file_command (const char *args
, int from_tty
)
2380 struct objfile
*objf
= NULL
;
2381 struct program_space
*pspace
= current_program_space
;
2386 error (_("remove-symbol-file: no symbol file provided"));
2388 gdb_argv
argv (args
);
2390 if (strcmp (argv
[0], "-a") == 0)
2392 /* Interpret the next argument as an address. */
2395 if (argv
[1] == NULL
)
2396 error (_("Missing address argument"));
2398 if (argv
[2] != NULL
)
2399 error (_("Junk after %s"), argv
[1]);
2401 addr
= parse_and_eval_address (argv
[1]);
2403 for (objfile
*objfile
: current_program_space
->objfiles ())
2405 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2406 && (objfile
->flags
& OBJF_SHARED
) != 0
2407 && objfile
->pspace
== pspace
2408 && is_addr_in_objfile (addr
, objfile
))
2415 else if (argv
[0] != NULL
)
2417 /* Interpret the current argument as a file name. */
2419 if (argv
[1] != NULL
)
2420 error (_("Junk after %s"), argv
[0]);
2422 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2424 for (objfile
*objfile
: current_program_space
->objfiles ())
2426 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2427 && (objfile
->flags
& OBJF_SHARED
) != 0
2428 && objfile
->pspace
== pspace
2429 && filename_cmp (filename
.get (), objfile_name (objfile
)) == 0)
2438 error (_("No symbol file found"));
2441 && !query (_("Remove symbol table from file \"%s\"? "),
2442 objfile_name (objf
)))
2443 error (_("Not confirmed."));
2446 clear_symtab_users (0);
2449 /* Re-read symbols if a symbol-file has changed. */
2452 reread_symbols (void)
2455 struct stat new_statbuf
;
2457 std::vector
<struct objfile
*> new_objfiles
;
2459 for (objfile
*objfile
: current_program_space
->objfiles ())
2461 if (objfile
->obfd
== NULL
)
2464 /* Separate debug objfiles are handled in the main objfile. */
2465 if (objfile
->separate_debug_objfile_backlink
)
2468 /* If this object is from an archive (what you usually create with
2469 `ar', often called a `static library' on most systems, though
2470 a `shared library' on AIX is also an archive), then you should
2471 stat on the archive name, not member name. */
2472 if (objfile
->obfd
->my_archive
)
2473 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2475 res
= stat (objfile_name (objfile
), &new_statbuf
);
2478 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2479 printf_filtered (_("`%s' has disappeared; keeping its symbols.\n"),
2480 objfile_name (objfile
));
2483 new_modtime
= new_statbuf
.st_mtime
;
2484 if (new_modtime
!= objfile
->mtime
)
2486 struct section_offsets
*offsets
;
2489 printf_filtered (_("`%s' has changed; re-reading symbols.\n"),
2490 objfile_name (objfile
));
2492 /* There are various functions like symbol_file_add,
2493 symfile_bfd_open, syms_from_objfile, etc., which might
2494 appear to do what we want. But they have various other
2495 effects which we *don't* want. So we just do stuff
2496 ourselves. We don't worry about mapped files (for one thing,
2497 any mapped file will be out of date). */
2499 /* If we get an error, blow away this objfile (not sure if
2500 that is the correct response for things like shared
2502 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
2504 /* We need to do this whenever any symbols go away. */
2505 clear_symtab_users_cleanup
defer_clear_users (0);
2507 if (exec_bfd
!= NULL
2508 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2509 bfd_get_filename (exec_bfd
)) == 0)
2511 /* Reload EXEC_BFD without asking anything. */
2513 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2516 /* Keep the calls order approx. the same as in free_objfile. */
2518 /* Free the separate debug objfiles. It will be
2519 automatically recreated by sym_read. */
2520 free_objfile_separate_debug (objfile
);
2522 /* Remove any references to this objfile in the global
2524 preserve_values (objfile
);
2526 /* Nuke all the state that we will re-read. Much of the following
2527 code which sets things to NULL really is necessary to tell
2528 other parts of GDB that there is nothing currently there.
2530 Try to keep the freeing order compatible with free_objfile. */
2532 if (objfile
->sf
!= NULL
)
2534 (*objfile
->sf
->sym_finish
) (objfile
);
2537 clear_objfile_data (objfile
);
2539 /* Clean up any state BFD has sitting around. */
2541 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2542 const char *obfd_filename
;
2544 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2545 /* Open the new BFD before freeing the old one, so that
2546 the filename remains live. */
2547 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
, -1));
2548 objfile
->obfd
= temp
.release ();
2549 if (objfile
->obfd
== NULL
)
2550 error (_("Can't open %s to read symbols."), obfd_filename
);
2553 std::string original_name
= objfile
->original_name
;
2555 /* bfd_openr sets cacheable to true, which is what we want. */
2556 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2557 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2558 bfd_errmsg (bfd_get_error ()));
2560 /* Save the offsets, we will nuke them with the rest of the
2562 num_offsets
= objfile
->num_sections
;
2563 offsets
= ((struct section_offsets
*)
2564 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2565 memcpy (offsets
, objfile
->section_offsets
,
2566 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2568 objfile
->reset_psymtabs ();
2570 /* NB: after this call to obstack_free, objfiles_changed
2571 will need to be called (see discussion below). */
2572 obstack_free (&objfile
->objfile_obstack
, 0);
2573 objfile
->sections
= NULL
;
2574 objfile
->compunit_symtabs
= NULL
;
2575 objfile
->template_symbols
= NULL
;
2576 objfile
->static_links
.reset (nullptr);
2578 /* obstack_init also initializes the obstack so it is
2579 empty. We could use obstack_specify_allocation but
2580 gdb_obstack.h specifies the alloc/dealloc functions. */
2581 obstack_init (&objfile
->objfile_obstack
);
2583 /* set_objfile_per_bfd potentially allocates the per-bfd
2584 data on the objfile's obstack (if sharing data across
2585 multiple users is not possible), so it's important to
2586 do it *after* the obstack has been initialized. */
2587 set_objfile_per_bfd (objfile
);
2589 objfile
->original_name
2590 = obstack_strdup (&objfile
->objfile_obstack
, original_name
);
2592 /* Reset the sym_fns pointer. The ELF reader can change it
2593 based on whether .gdb_index is present, and we need it to
2594 start over. PR symtab/15885 */
2595 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2597 build_objfile_section_table (objfile
);
2599 /* We use the same section offsets as from last time. I'm not
2600 sure whether that is always correct for shared libraries. */
2601 objfile
->section_offsets
= (struct section_offsets
*)
2602 obstack_alloc (&objfile
->objfile_obstack
,
2603 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2604 memcpy (objfile
->section_offsets
, offsets
,
2605 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2606 objfile
->num_sections
= num_offsets
;
2608 /* What the hell is sym_new_init for, anyway? The concept of
2609 distinguishing between the main file and additional files
2610 in this way seems rather dubious. */
2611 if (objfile
== symfile_objfile
)
2613 (*objfile
->sf
->sym_new_init
) (objfile
);
2616 (*objfile
->sf
->sym_init
) (objfile
);
2617 clear_complaints ();
2619 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2621 /* We are about to read new symbols and potentially also
2622 DWARF information. Some targets may want to pass addresses
2623 read from DWARF DIE's through an adjustment function before
2624 saving them, like MIPS, which may call into
2625 "find_pc_section". When called, that function will make
2626 use of per-objfile program space data.
2628 Since we discarded our section information above, we have
2629 dangling pointers in the per-objfile program space data
2630 structure. Force GDB to update the section mapping
2631 information by letting it know the objfile has changed,
2632 making the dangling pointers point to correct data
2635 objfiles_changed ();
2637 read_symbols (objfile
, 0);
2639 if (!objfile_has_symbols (objfile
))
2642 printf_filtered (_("(no debugging symbols found)\n"));
2646 /* We're done reading the symbol file; finish off complaints. */
2647 clear_complaints ();
2649 /* Getting new symbols may change our opinion about what is
2652 reinit_frame_cache ();
2654 /* Discard cleanups as symbol reading was successful. */
2655 objfile_holder
.release ();
2656 defer_clear_users
.release ();
2658 /* If the mtime has changed between the time we set new_modtime
2659 and now, we *want* this to be out of date, so don't call stat
2661 objfile
->mtime
= new_modtime
;
2662 init_entry_point_info (objfile
);
2664 new_objfiles
.push_back (objfile
);
2668 if (!new_objfiles
.empty ())
2670 clear_symtab_users (0);
2672 /* clear_objfile_data for each objfile was called before freeing it and
2673 gdb::observers::new_objfile.notify (NULL) has been called by
2674 clear_symtab_users above. Notify the new files now. */
2675 for (auto iter
: new_objfiles
)
2676 gdb::observers::new_objfile
.notify (iter
);
2678 /* At least one objfile has changed, so we can consider that
2679 the executable we're debugging has changed too. */
2680 gdb::observers::executable_changed
.notify ();
2685 struct filename_language
2687 filename_language (const std::string
&ext_
, enum language lang_
)
2688 : ext (ext_
), lang (lang_
)
2695 static std::vector
<filename_language
> filename_language_table
;
2697 /* See symfile.h. */
2700 add_filename_language (const char *ext
, enum language lang
)
2702 filename_language_table
.emplace_back (ext
, lang
);
2705 static char *ext_args
;
2707 show_ext_args (struct ui_file
*file
, int from_tty
,
2708 struct cmd_list_element
*c
, const char *value
)
2710 fprintf_filtered (file
,
2711 _("Mapping between filename extension "
2712 "and source language is \"%s\".\n"),
2717 set_ext_lang_command (const char *args
,
2718 int from_tty
, struct cmd_list_element
*e
)
2720 char *cp
= ext_args
;
2723 /* First arg is filename extension, starting with '.' */
2725 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2727 /* Find end of first arg. */
2728 while (*cp
&& !isspace (*cp
))
2732 error (_("'%s': two arguments required -- "
2733 "filename extension and language"),
2736 /* Null-terminate first arg. */
2739 /* Find beginning of second arg, which should be a source language. */
2740 cp
= skip_spaces (cp
);
2743 error (_("'%s': two arguments required -- "
2744 "filename extension and language"),
2747 /* Lookup the language from among those we know. */
2748 lang
= language_enum (cp
);
2750 auto it
= filename_language_table
.begin ();
2751 /* Now lookup the filename extension: do we already know it? */
2752 for (; it
!= filename_language_table
.end (); it
++)
2754 if (it
->ext
== ext_args
)
2758 if (it
== filename_language_table
.end ())
2760 /* New file extension. */
2761 add_filename_language (ext_args
, lang
);
2765 /* Redefining a previously known filename extension. */
2768 /* query ("Really make files of type %s '%s'?", */
2769 /* ext_args, language_str (lang)); */
2776 info_ext_lang_command (const char *args
, int from_tty
)
2778 printf_filtered (_("Filename extensions and the languages they represent:"));
2779 printf_filtered ("\n\n");
2780 for (const filename_language
&entry
: filename_language_table
)
2781 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2782 language_str (entry
.lang
));
2786 deduce_language_from_filename (const char *filename
)
2790 if (filename
!= NULL
)
2791 if ((cp
= strrchr (filename
, '.')) != NULL
)
2793 for (const filename_language
&entry
: filename_language_table
)
2794 if (entry
.ext
== cp
)
2798 return language_unknown
;
2801 /* Allocate and initialize a new symbol table.
2802 CUST is from the result of allocate_compunit_symtab. */
2805 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2807 struct objfile
*objfile
= cust
->objfile
;
2808 struct symtab
*symtab
2809 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2812 = ((const char *) objfile
->per_bfd
->filename_cache
.insert
2813 (filename
, strlen (filename
) + 1));
2814 symtab
->fullname
= NULL
;
2815 symtab
->language
= deduce_language_from_filename (filename
);
2817 /* This can be very verbose with lots of headers.
2818 Only print at higher debug levels. */
2819 if (symtab_create_debug
>= 2)
2821 /* Be a bit clever with debugging messages, and don't print objfile
2822 every time, only when it changes. */
2823 static char *last_objfile_name
= NULL
;
2825 if (last_objfile_name
== NULL
2826 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2828 xfree (last_objfile_name
);
2829 last_objfile_name
= xstrdup (objfile_name (objfile
));
2830 fprintf_filtered (gdb_stdlog
,
2831 "Creating one or more symtabs for objfile %s ...\n",
2834 fprintf_filtered (gdb_stdlog
,
2835 "Created symtab %s for module %s.\n",
2836 host_address_to_string (symtab
), filename
);
2839 /* Add it to CUST's list of symtabs. */
2840 if (cust
->filetabs
== NULL
)
2842 cust
->filetabs
= symtab
;
2843 cust
->last_filetab
= symtab
;
2847 cust
->last_filetab
->next
= symtab
;
2848 cust
->last_filetab
= symtab
;
2851 /* Backlink to the containing compunit symtab. */
2852 symtab
->compunit_symtab
= cust
;
2857 /* Allocate and initialize a new compunit.
2858 NAME is the name of the main source file, if there is one, or some
2859 descriptive text if there are no source files. */
2861 struct compunit_symtab
*
2862 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2864 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2865 struct compunit_symtab
);
2866 const char *saved_name
;
2868 cu
->objfile
= objfile
;
2870 /* The name we record here is only for display/debugging purposes.
2871 Just save the basename to avoid path issues (too long for display,
2872 relative vs absolute, etc.). */
2873 saved_name
= lbasename (name
);
2874 cu
->name
= obstack_strdup (&objfile
->objfile_obstack
, saved_name
);
2876 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2878 if (symtab_create_debug
)
2880 fprintf_filtered (gdb_stdlog
,
2881 "Created compunit symtab %s for %s.\n",
2882 host_address_to_string (cu
),
2889 /* Hook CU to the objfile it comes from. */
2892 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2894 cu
->next
= cu
->objfile
->compunit_symtabs
;
2895 cu
->objfile
->compunit_symtabs
= cu
;
2899 /* Reset all data structures in gdb which may contain references to
2900 symbol table data. */
2903 clear_symtab_users (symfile_add_flags add_flags
)
2905 /* Someday, we should do better than this, by only blowing away
2906 the things that really need to be blown. */
2908 /* Clear the "current" symtab first, because it is no longer valid.
2909 breakpoint_re_set may try to access the current symtab. */
2910 clear_current_source_symtab_and_line ();
2913 clear_last_displayed_sal ();
2914 clear_pc_function_cache ();
2915 gdb::observers::new_objfile
.notify (NULL
);
2917 /* Varobj may refer to old symbols, perform a cleanup. */
2918 varobj_invalidate ();
2920 /* Now that the various caches have been cleared, we can re_set
2921 our breakpoints without risking it using stale data. */
2922 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2923 breakpoint_re_set ();
2927 The following code implements an abstraction for debugging overlay sections.
2929 The target model is as follows:
2930 1) The gnu linker will permit multiple sections to be mapped into the
2931 same VMA, each with its own unique LMA (or load address).
2932 2) It is assumed that some runtime mechanism exists for mapping the
2933 sections, one by one, from the load address into the VMA address.
2934 3) This code provides a mechanism for gdb to keep track of which
2935 sections should be considered to be mapped from the VMA to the LMA.
2936 This information is used for symbol lookup, and memory read/write.
2937 For instance, if a section has been mapped then its contents
2938 should be read from the VMA, otherwise from the LMA.
2940 Two levels of debugger support for overlays are available. One is
2941 "manual", in which the debugger relies on the user to tell it which
2942 overlays are currently mapped. This level of support is
2943 implemented entirely in the core debugger, and the information about
2944 whether a section is mapped is kept in the objfile->obj_section table.
2946 The second level of support is "automatic", and is only available if
2947 the target-specific code provides functionality to read the target's
2948 overlay mapping table, and translate its contents for the debugger
2949 (by updating the mapped state information in the obj_section tables).
2951 The interface is as follows:
2953 overlay map <name> -- tell gdb to consider this section mapped
2954 overlay unmap <name> -- tell gdb to consider this section unmapped
2955 overlay list -- list the sections that GDB thinks are mapped
2956 overlay read-target -- get the target's state of what's mapped
2957 overlay off/manual/auto -- set overlay debugging state
2958 Functional interface:
2959 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2960 section, return that section.
2961 find_pc_overlay(pc): find any overlay section that contains
2962 the pc, either in its VMA or its LMA
2963 section_is_mapped(sect): true if overlay is marked as mapped
2964 section_is_overlay(sect): true if section's VMA != LMA
2965 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2966 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2967 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2968 overlay_mapped_address(...): map an address from section's LMA to VMA
2969 overlay_unmapped_address(...): map an address from section's VMA to LMA
2970 symbol_overlayed_address(...): Return a "current" address for symbol:
2971 either in VMA or LMA depending on whether
2972 the symbol's section is currently mapped. */
2974 /* Overlay debugging state: */
2976 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2977 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2979 /* Function: section_is_overlay (SECTION)
2980 Returns true if SECTION has VMA not equal to LMA, ie.
2981 SECTION is loaded at an address different from where it will "run". */
2984 section_is_overlay (struct obj_section
*section
)
2986 if (overlay_debugging
&& section
)
2988 asection
*bfd_section
= section
->the_bfd_section
;
2990 if (bfd_section_lma (bfd_section
) != 0
2991 && bfd_section_lma (bfd_section
) != bfd_section_vma (bfd_section
))
2998 /* Function: overlay_invalidate_all (void)
2999 Invalidate the mapped state of all overlay sections (mark it as stale). */
3002 overlay_invalidate_all (void)
3004 struct obj_section
*sect
;
3006 for (objfile
*objfile
: current_program_space
->objfiles ())
3007 ALL_OBJFILE_OSECTIONS (objfile
, sect
)
3008 if (section_is_overlay (sect
))
3009 sect
->ovly_mapped
= -1;
3012 /* Function: section_is_mapped (SECTION)
3013 Returns true if section is an overlay, and is currently mapped.
3015 Access to the ovly_mapped flag is restricted to this function, so
3016 that we can do automatic update. If the global flag
3017 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3018 overlay_invalidate_all. If the mapped state of the particular
3019 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3022 section_is_mapped (struct obj_section
*osect
)
3024 struct gdbarch
*gdbarch
;
3026 if (osect
== 0 || !section_is_overlay (osect
))
3029 switch (overlay_debugging
)
3033 return 0; /* overlay debugging off */
3034 case ovly_auto
: /* overlay debugging automatic */
3035 /* Unles there is a gdbarch_overlay_update function,
3036 there's really nothing useful to do here (can't really go auto). */
3037 gdbarch
= get_objfile_arch (osect
->objfile
);
3038 if (gdbarch_overlay_update_p (gdbarch
))
3040 if (overlay_cache_invalid
)
3042 overlay_invalidate_all ();
3043 overlay_cache_invalid
= 0;
3045 if (osect
->ovly_mapped
== -1)
3046 gdbarch_overlay_update (gdbarch
, osect
);
3049 case ovly_on
: /* overlay debugging manual */
3050 return osect
->ovly_mapped
== 1;
3054 /* Function: pc_in_unmapped_range
3055 If PC falls into the lma range of SECTION, return true, else false. */
3058 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3060 if (section_is_overlay (section
))
3062 asection
*bfd_section
= section
->the_bfd_section
;
3064 /* We assume the LMA is relocated by the same offset as the VMA. */
3065 bfd_vma size
= bfd_section_size (bfd_section
);
3066 CORE_ADDR offset
= obj_section_offset (section
);
3068 if (bfd_section_lma (bfd_section
) + offset
<= pc
3069 && pc
< bfd_section_lma (bfd_section
) + offset
+ size
)
3076 /* Function: pc_in_mapped_range
3077 If PC falls into the vma range of SECTION, return true, else false. */
3080 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3082 if (section_is_overlay (section
))
3084 if (obj_section_addr (section
) <= pc
3085 && pc
< obj_section_endaddr (section
))
3092 /* Return true if the mapped ranges of sections A and B overlap, false
3096 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3098 CORE_ADDR a_start
= obj_section_addr (a
);
3099 CORE_ADDR a_end
= obj_section_endaddr (a
);
3100 CORE_ADDR b_start
= obj_section_addr (b
);
3101 CORE_ADDR b_end
= obj_section_endaddr (b
);
3103 return (a_start
< b_end
&& b_start
< a_end
);
3106 /* Function: overlay_unmapped_address (PC, SECTION)
3107 Returns the address corresponding to PC in the unmapped (load) range.
3108 May be the same as PC. */
3111 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3113 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3115 asection
*bfd_section
= section
->the_bfd_section
;
3117 return (pc
+ bfd_section_lma (bfd_section
)
3118 - bfd_section_vma (bfd_section
));
3124 /* Function: overlay_mapped_address (PC, SECTION)
3125 Returns the address corresponding to PC in the mapped (runtime) range.
3126 May be the same as PC. */
3129 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3131 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3133 asection
*bfd_section
= section
->the_bfd_section
;
3135 return (pc
+ bfd_section_vma (bfd_section
)
3136 - bfd_section_lma (bfd_section
));
3142 /* Function: symbol_overlayed_address
3143 Return one of two addresses (relative to the VMA or to the LMA),
3144 depending on whether the section is mapped or not. */
3147 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3149 if (overlay_debugging
)
3151 /* If the symbol has no section, just return its regular address. */
3154 /* If the symbol's section is not an overlay, just return its
3156 if (!section_is_overlay (section
))
3158 /* If the symbol's section is mapped, just return its address. */
3159 if (section_is_mapped (section
))
3162 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3163 * then return its LOADED address rather than its vma address!!
3165 return overlay_unmapped_address (address
, section
);
3170 /* Function: find_pc_overlay (PC)
3171 Return the best-match overlay section for PC:
3172 If PC matches a mapped overlay section's VMA, return that section.
3173 Else if PC matches an unmapped section's VMA, return that section.
3174 Else if PC matches an unmapped section's LMA, return that section. */
3176 struct obj_section
*
3177 find_pc_overlay (CORE_ADDR pc
)
3179 struct obj_section
*osect
, *best_match
= NULL
;
3181 if (overlay_debugging
)
3183 for (objfile
*objfile
: current_program_space
->objfiles ())
3184 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3185 if (section_is_overlay (osect
))
3187 if (pc_in_mapped_range (pc
, osect
))
3189 if (section_is_mapped (osect
))
3194 else if (pc_in_unmapped_range (pc
, osect
))
3201 /* Function: find_pc_mapped_section (PC)
3202 If PC falls into the VMA address range of an overlay section that is
3203 currently marked as MAPPED, return that section. Else return NULL. */
3205 struct obj_section
*
3206 find_pc_mapped_section (CORE_ADDR pc
)
3208 struct obj_section
*osect
;
3210 if (overlay_debugging
)
3212 for (objfile
*objfile
: current_program_space
->objfiles ())
3213 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3214 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3221 /* Function: list_overlays_command
3222 Print a list of mapped sections and their PC ranges. */
3225 list_overlays_command (const char *args
, int from_tty
)
3228 struct obj_section
*osect
;
3230 if (overlay_debugging
)
3232 for (objfile
*objfile
: current_program_space
->objfiles ())
3233 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3234 if (section_is_mapped (osect
))
3236 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3241 vma
= bfd_section_vma (osect
->the_bfd_section
);
3242 lma
= bfd_section_lma (osect
->the_bfd_section
);
3243 size
= bfd_section_size (osect
->the_bfd_section
);
3244 name
= bfd_section_name (osect
->the_bfd_section
);
3246 printf_filtered ("Section %s, loaded at ", name
);
3247 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3248 puts_filtered (" - ");
3249 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3250 printf_filtered (", mapped at ");
3251 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3252 puts_filtered (" - ");
3253 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3254 puts_filtered ("\n");
3260 printf_filtered (_("No sections are mapped.\n"));
3263 /* Function: map_overlay_command
3264 Mark the named section as mapped (ie. residing at its VMA address). */
3267 map_overlay_command (const char *args
, int from_tty
)
3269 struct obj_section
*sec
, *sec2
;
3271 if (!overlay_debugging
)
3272 error (_("Overlay debugging not enabled. Use "
3273 "either the 'overlay auto' or\n"
3274 "the 'overlay manual' command."));
3276 if (args
== 0 || *args
== 0)
3277 error (_("Argument required: name of an overlay section"));
3279 /* First, find a section matching the user supplied argument. */
3280 for (objfile
*obj_file
: current_program_space
->objfiles ())
3281 ALL_OBJFILE_OSECTIONS (obj_file
, sec
)
3282 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3284 /* Now, check to see if the section is an overlay. */
3285 if (!section_is_overlay (sec
))
3286 continue; /* not an overlay section */
3288 /* Mark the overlay as "mapped". */
3289 sec
->ovly_mapped
= 1;
3291 /* Next, make a pass and unmap any sections that are
3292 overlapped by this new section: */
3293 for (objfile
*objfile2
: current_program_space
->objfiles ())
3294 ALL_OBJFILE_OSECTIONS (objfile2
, sec2
)
3295 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
,
3299 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3300 bfd_section_name (sec2
->the_bfd_section
));
3301 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3305 error (_("No overlay section called %s"), args
);
3308 /* Function: unmap_overlay_command
3309 Mark the overlay section as unmapped
3310 (ie. resident in its LMA address range, rather than the VMA range). */
3313 unmap_overlay_command (const char *args
, int from_tty
)
3315 struct obj_section
*sec
= NULL
;
3317 if (!overlay_debugging
)
3318 error (_("Overlay debugging not enabled. "
3319 "Use either the 'overlay auto' or\n"
3320 "the 'overlay manual' command."));
3322 if (args
== 0 || *args
== 0)
3323 error (_("Argument required: name of an overlay section"));
3325 /* First, find a section matching the user supplied argument. */
3326 for (objfile
*objfile
: current_program_space
->objfiles ())
3327 ALL_OBJFILE_OSECTIONS (objfile
, sec
)
3328 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3330 if (!sec
->ovly_mapped
)
3331 error (_("Section %s is not mapped"), args
);
3332 sec
->ovly_mapped
= 0;
3335 error (_("No overlay section called %s"), args
);
3338 /* Function: overlay_auto_command
3339 A utility command to turn on overlay debugging.
3340 Possibly this should be done via a set/show command. */
3343 overlay_auto_command (const char *args
, int from_tty
)
3345 overlay_debugging
= ovly_auto
;
3346 enable_overlay_breakpoints ();
3348 printf_unfiltered (_("Automatic overlay debugging enabled."));
3351 /* Function: overlay_manual_command
3352 A utility command to turn on overlay debugging.
3353 Possibly this should be done via a set/show command. */
3356 overlay_manual_command (const char *args
, int from_tty
)
3358 overlay_debugging
= ovly_on
;
3359 disable_overlay_breakpoints ();
3361 printf_unfiltered (_("Overlay debugging enabled."));
3364 /* Function: overlay_off_command
3365 A utility command to turn on overlay debugging.
3366 Possibly this should be done via a set/show command. */
3369 overlay_off_command (const char *args
, int from_tty
)
3371 overlay_debugging
= ovly_off
;
3372 disable_overlay_breakpoints ();
3374 printf_unfiltered (_("Overlay debugging disabled."));
3378 overlay_load_command (const char *args
, int from_tty
)
3380 struct gdbarch
*gdbarch
= get_current_arch ();
3382 if (gdbarch_overlay_update_p (gdbarch
))
3383 gdbarch_overlay_update (gdbarch
, NULL
);
3385 error (_("This target does not know how to read its overlay state."));
3388 /* Function: overlay_command
3389 A place-holder for a mis-typed command. */
3391 /* Command list chain containing all defined "overlay" subcommands. */
3392 static struct cmd_list_element
*overlaylist
;
3395 overlay_command (const char *args
, int from_tty
)
3398 ("\"overlay\" must be followed by the name of an overlay command.\n");
3399 help_list (overlaylist
, "overlay ", all_commands
, gdb_stdout
);
3402 /* Target Overlays for the "Simplest" overlay manager:
3404 This is GDB's default target overlay layer. It works with the
3405 minimal overlay manager supplied as an example by Cygnus. The
3406 entry point is via a function pointer "gdbarch_overlay_update",
3407 so targets that use a different runtime overlay manager can
3408 substitute their own overlay_update function and take over the
3411 The overlay_update function pokes around in the target's data structures
3412 to see what overlays are mapped, and updates GDB's overlay mapping with
3415 In this simple implementation, the target data structures are as follows:
3416 unsigned _novlys; /# number of overlay sections #/
3417 unsigned _ovly_table[_novlys][4] = {
3418 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3419 {..., ..., ..., ...},
3421 unsigned _novly_regions; /# number of overlay regions #/
3422 unsigned _ovly_region_table[_novly_regions][3] = {
3423 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3426 These functions will attempt to update GDB's mappedness state in the
3427 symbol section table, based on the target's mappedness state.
3429 To do this, we keep a cached copy of the target's _ovly_table, and
3430 attempt to detect when the cached copy is invalidated. The main
3431 entry point is "simple_overlay_update(SECT), which looks up SECT in
3432 the cached table and re-reads only the entry for that section from
3433 the target (whenever possible). */
3435 /* Cached, dynamically allocated copies of the target data structures: */
3436 static unsigned (*cache_ovly_table
)[4] = 0;
3437 static unsigned cache_novlys
= 0;
3438 static CORE_ADDR cache_ovly_table_base
= 0;
3441 VMA
, OSIZE
, LMA
, MAPPED
3444 /* Throw away the cached copy of _ovly_table. */
3447 simple_free_overlay_table (void)
3449 if (cache_ovly_table
)
3450 xfree (cache_ovly_table
);
3452 cache_ovly_table
= NULL
;
3453 cache_ovly_table_base
= 0;
3456 /* Read an array of ints of size SIZE from the target into a local buffer.
3457 Convert to host order. int LEN is number of ints. */
3460 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3461 int len
, int size
, enum bfd_endian byte_order
)
3463 /* FIXME (alloca): Not safe if array is very large. */
3464 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3467 read_memory (memaddr
, buf
, len
* size
);
3468 for (i
= 0; i
< len
; i
++)
3469 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3472 /* Find and grab a copy of the target _ovly_table
3473 (and _novlys, which is needed for the table's size). */
3476 simple_read_overlay_table (void)
3478 struct bound_minimal_symbol novlys_msym
;
3479 struct bound_minimal_symbol ovly_table_msym
;
3480 struct gdbarch
*gdbarch
;
3482 enum bfd_endian byte_order
;
3484 simple_free_overlay_table ();
3485 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3486 if (! novlys_msym
.minsym
)
3488 error (_("Error reading inferior's overlay table: "
3489 "couldn't find `_novlys' variable\n"
3490 "in inferior. Use `overlay manual' mode."));
3494 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3495 if (! ovly_table_msym
.minsym
)
3497 error (_("Error reading inferior's overlay table: couldn't find "
3498 "`_ovly_table' array\n"
3499 "in inferior. Use `overlay manual' mode."));
3503 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3504 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3505 byte_order
= gdbarch_byte_order (gdbarch
);
3507 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3510 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3511 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3512 read_target_long_array (cache_ovly_table_base
,
3513 (unsigned int *) cache_ovly_table
,
3514 cache_novlys
* 4, word_size
, byte_order
);
3516 return 1; /* SUCCESS */
3519 /* Function: simple_overlay_update_1
3520 A helper function for simple_overlay_update. Assuming a cached copy
3521 of _ovly_table exists, look through it to find an entry whose vma,
3522 lma and size match those of OSECT. Re-read the entry and make sure
3523 it still matches OSECT (else the table may no longer be valid).
3524 Set OSECT's mapped state to match the entry. Return: 1 for
3525 success, 0 for failure. */
3528 simple_overlay_update_1 (struct obj_section
*osect
)
3531 asection
*bsect
= osect
->the_bfd_section
;
3532 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3533 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3534 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3536 for (i
= 0; i
< cache_novlys
; i
++)
3537 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3538 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3540 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3541 (unsigned int *) cache_ovly_table
[i
],
3542 4, word_size
, byte_order
);
3543 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3544 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3546 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3549 else /* Warning! Warning! Target's ovly table has changed! */
3555 /* Function: simple_overlay_update
3556 If OSECT is NULL, then update all sections' mapped state
3557 (after re-reading the entire target _ovly_table).
3558 If OSECT is non-NULL, then try to find a matching entry in the
3559 cached ovly_table and update only OSECT's mapped state.
3560 If a cached entry can't be found or the cache isn't valid, then
3561 re-read the entire cache, and go ahead and update all sections. */
3564 simple_overlay_update (struct obj_section
*osect
)
3566 /* Were we given an osect to look up? NULL means do all of them. */
3568 /* Have we got a cached copy of the target's overlay table? */
3569 if (cache_ovly_table
!= NULL
)
3571 /* Does its cached location match what's currently in the
3573 struct bound_minimal_symbol minsym
3574 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3576 if (minsym
.minsym
== NULL
)
3577 error (_("Error reading inferior's overlay table: couldn't "
3578 "find `_ovly_table' array\n"
3579 "in inferior. Use `overlay manual' mode."));
3581 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3582 /* Then go ahead and try to look up this single section in
3584 if (simple_overlay_update_1 (osect
))
3585 /* Found it! We're done. */
3589 /* Cached table no good: need to read the entire table anew.
3590 Or else we want all the sections, in which case it's actually
3591 more efficient to read the whole table in one block anyway. */
3593 if (! simple_read_overlay_table ())
3596 /* Now may as well update all sections, even if only one was requested. */
3597 for (objfile
*objfile
: current_program_space
->objfiles ())
3598 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3599 if (section_is_overlay (osect
))
3602 asection
*bsect
= osect
->the_bfd_section
;
3604 for (i
= 0; i
< cache_novlys
; i
++)
3605 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3606 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3607 { /* obj_section matches i'th entry in ovly_table. */
3608 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3609 break; /* finished with inner for loop: break out. */
3614 /* Set the output sections and output offsets for section SECTP in
3615 ABFD. The relocation code in BFD will read these offsets, so we
3616 need to be sure they're initialized. We map each section to itself,
3617 with no offset; this means that SECTP->vma will be honored. */
3620 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3622 sectp
->output_section
= sectp
;
3623 sectp
->output_offset
= 0;
3626 /* Default implementation for sym_relocate. */
3629 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3632 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3634 bfd
*abfd
= sectp
->owner
;
3636 /* We're only interested in sections with relocation
3638 if ((sectp
->flags
& SEC_RELOC
) == 0)
3641 /* We will handle section offsets properly elsewhere, so relocate as if
3642 all sections begin at 0. */
3643 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3645 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3648 /* Relocate the contents of a debug section SECTP in ABFD. The
3649 contents are stored in BUF if it is non-NULL, or returned in a
3650 malloc'd buffer otherwise.
3652 For some platforms and debug info formats, shared libraries contain
3653 relocations against the debug sections (particularly for DWARF-2;
3654 one affected platform is PowerPC GNU/Linux, although it depends on
3655 the version of the linker in use). Also, ELF object files naturally
3656 have unresolved relocations for their debug sections. We need to apply
3657 the relocations in order to get the locations of symbols correct.
3658 Another example that may require relocation processing, is the
3659 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3663 symfile_relocate_debug_section (struct objfile
*objfile
,
3664 asection
*sectp
, bfd_byte
*buf
)
3666 gdb_assert (objfile
->sf
->sym_relocate
);
3668 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3671 struct symfile_segment_data
*
3672 get_symfile_segment_data (bfd
*abfd
)
3674 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3679 return sf
->sym_segments (abfd
);
3683 free_symfile_segment_data (struct symfile_segment_data
*data
)
3685 xfree (data
->segment_bases
);
3686 xfree (data
->segment_sizes
);
3687 xfree (data
->segment_info
);
3692 - DATA, containing segment addresses from the object file ABFD, and
3693 the mapping from ABFD's sections onto the segments that own them,
3695 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3696 segment addresses reported by the target,
3697 store the appropriate offsets for each section in OFFSETS.
3699 If there are fewer entries in SEGMENT_BASES than there are segments
3700 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3702 If there are more entries, then ignore the extra. The target may
3703 not be able to distinguish between an empty data segment and a
3704 missing data segment; a missing text segment is less plausible. */
3707 symfile_map_offsets_to_segments (bfd
*abfd
,
3708 const struct symfile_segment_data
*data
,
3709 struct section_offsets
*offsets
,
3710 int num_segment_bases
,
3711 const CORE_ADDR
*segment_bases
)
3716 /* It doesn't make sense to call this function unless you have some
3717 segment base addresses. */
3718 gdb_assert (num_segment_bases
> 0);
3720 /* If we do not have segment mappings for the object file, we
3721 can not relocate it by segments. */
3722 gdb_assert (data
!= NULL
);
3723 gdb_assert (data
->num_segments
> 0);
3725 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3727 int which
= data
->segment_info
[i
];
3729 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3731 /* Don't bother computing offsets for sections that aren't
3732 loaded as part of any segment. */
3736 /* Use the last SEGMENT_BASES entry as the address of any extra
3737 segments mentioned in DATA->segment_info. */
3738 if (which
> num_segment_bases
)
3739 which
= num_segment_bases
;
3741 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3742 - data
->segment_bases
[which
- 1]);
3749 symfile_find_segment_sections (struct objfile
*objfile
)
3751 bfd
*abfd
= objfile
->obfd
;
3754 struct symfile_segment_data
*data
;
3756 data
= get_symfile_segment_data (objfile
->obfd
);
3760 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3762 free_symfile_segment_data (data
);
3766 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3768 int which
= data
->segment_info
[i
];
3772 if (objfile
->sect_index_text
== -1)
3773 objfile
->sect_index_text
= sect
->index
;
3775 if (objfile
->sect_index_rodata
== -1)
3776 objfile
->sect_index_rodata
= sect
->index
;
3778 else if (which
== 2)
3780 if (objfile
->sect_index_data
== -1)
3781 objfile
->sect_index_data
= sect
->index
;
3783 if (objfile
->sect_index_bss
== -1)
3784 objfile
->sect_index_bss
= sect
->index
;
3788 free_symfile_segment_data (data
);
3791 /* Listen for free_objfile events. */
3794 symfile_free_objfile (struct objfile
*objfile
)
3796 /* Remove the target sections owned by this objfile. */
3797 if (objfile
!= NULL
)
3798 remove_target_sections ((void *) objfile
);
3801 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3802 Expand all symtabs that match the specified criteria.
3803 See quick_symbol_functions.expand_symtabs_matching for details. */
3806 expand_symtabs_matching
3807 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3808 const lookup_name_info
&lookup_name
,
3809 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3810 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3811 enum search_domain kind
)
3813 for (objfile
*objfile
: current_program_space
->objfiles ())
3816 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3819 expansion_notify
, kind
);
3823 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3824 Map function FUN over every file.
3825 See quick_symbol_functions.map_symbol_filenames for details. */
3828 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3831 for (objfile
*objfile
: current_program_space
->objfiles ())
3834 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3841 namespace selftests
{
3842 namespace filename_language
{
3844 static void test_filename_language ()
3846 /* This test messes up the filename_language_table global. */
3847 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3849 /* Test deducing an unknown extension. */
3850 language lang
= deduce_language_from_filename ("myfile.blah");
3851 SELF_CHECK (lang
== language_unknown
);
3853 /* Test deducing a known extension. */
3854 lang
= deduce_language_from_filename ("myfile.c");
3855 SELF_CHECK (lang
== language_c
);
3857 /* Test adding a new extension using the internal API. */
3858 add_filename_language (".blah", language_pascal
);
3859 lang
= deduce_language_from_filename ("myfile.blah");
3860 SELF_CHECK (lang
== language_pascal
);
3864 test_set_ext_lang_command ()
3866 /* This test messes up the filename_language_table global. */
3867 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3869 /* Confirm that the .hello extension is not known. */
3870 language lang
= deduce_language_from_filename ("cake.hello");
3871 SELF_CHECK (lang
== language_unknown
);
3873 /* Test adding a new extension using the CLI command. */
3874 auto args_holder
= make_unique_xstrdup (".hello rust");
3875 ext_args
= args_holder
.get ();
3876 set_ext_lang_command (NULL
, 1, NULL
);
3878 lang
= deduce_language_from_filename ("cake.hello");
3879 SELF_CHECK (lang
== language_rust
);
3881 /* Test overriding an existing extension using the CLI command. */
3882 int size_before
= filename_language_table
.size ();
3883 args_holder
.reset (xstrdup (".hello pascal"));
3884 ext_args
= args_holder
.get ();
3885 set_ext_lang_command (NULL
, 1, NULL
);
3886 int size_after
= filename_language_table
.size ();
3888 lang
= deduce_language_from_filename ("cake.hello");
3889 SELF_CHECK (lang
== language_pascal
);
3890 SELF_CHECK (size_before
== size_after
);
3893 } /* namespace filename_language */
3894 } /* namespace selftests */
3896 #endif /* GDB_SELF_TEST */
3899 _initialize_symfile (void)
3901 struct cmd_list_element
*c
;
3903 gdb::observers::free_objfile
.attach (symfile_free_objfile
);
3905 #define READNOW_READNEVER_HELP \
3906 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3907 immediately. This makes the command slower, but may make future operations\n\
3909 The '-readnever' option will prevent GDB from reading the symbol file's\n\
3910 symbolic debug information."
3912 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3913 Load symbol table from executable file FILE.\n\
3914 Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3915 OFF is an optional offset which is added to each section address.\n\
3916 The `file' command can also load symbol tables, as well as setting the file\n\
3917 to execute.\n" READNOW_READNEVER_HELP
), &cmdlist
);
3918 set_cmd_completer (c
, filename_completer
);
3920 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3921 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3922 Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3923 [-s SECT-NAME SECT-ADDR]...\n\
3924 ADDR is the starting address of the file's text.\n\
3925 Each '-s' argument provides a section name and address, and\n\
3926 should be specified if the data and bss segments are not contiguous\n\
3927 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3928 OFF is an optional offset which is added to the default load addresses\n\
3929 of all sections for which no other address was specified.\n"
3930 READNOW_READNEVER_HELP
),
3932 set_cmd_completer (c
, filename_completer
);
3934 c
= add_cmd ("remove-symbol-file", class_files
,
3935 remove_symbol_file_command
, _("\
3936 Remove a symbol file added via the add-symbol-file command.\n\
3937 Usage: remove-symbol-file FILENAME\n\
3938 remove-symbol-file -a ADDRESS\n\
3939 The file to remove can be identified by its filename or by an address\n\
3940 that lies within the boundaries of this symbol file in memory."),
3943 c
= add_cmd ("load", class_files
, load_command
, _("\
3944 Dynamically load FILE into the running program.\n\
3945 FILE symbols are recorded for access from GDB.\n\
3946 Usage: load [FILE] [OFFSET]\n\
3947 An optional load OFFSET may also be given as a literal address.\n\
3948 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3949 on its own."), &cmdlist
);
3950 set_cmd_completer (c
, filename_completer
);
3952 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3953 _("Commands for debugging overlays."), &overlaylist
,
3954 "overlay ", 0, &cmdlist
);
3956 add_com_alias ("ovly", "overlay", class_alias
, 1);
3957 add_com_alias ("ov", "overlay", class_alias
, 1);
3959 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3960 _("Assert that an overlay section is mapped."), &overlaylist
);
3962 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3963 _("Assert that an overlay section is unmapped."), &overlaylist
);
3965 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3966 _("List mappings of overlay sections."), &overlaylist
);
3968 add_cmd ("manual", class_support
, overlay_manual_command
,
3969 _("Enable overlay debugging."), &overlaylist
);
3970 add_cmd ("off", class_support
, overlay_off_command
,
3971 _("Disable overlay debugging."), &overlaylist
);
3972 add_cmd ("auto", class_support
, overlay_auto_command
,
3973 _("Enable automatic overlay debugging."), &overlaylist
);
3974 add_cmd ("load-target", class_support
, overlay_load_command
,
3975 _("Read the overlay mapping state from the target."), &overlaylist
);
3977 /* Filename extension to source language lookup table: */
3978 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3980 Set mapping between filename extension and source language."), _("\
3981 Show mapping between filename extension and source language."), _("\
3982 Usage: set extension-language .foo bar"),
3983 set_ext_lang_command
,
3985 &setlist
, &showlist
);
3987 add_info ("extensions", info_ext_lang_command
,
3988 _("All filename extensions associated with a source language."));
3990 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3991 &debug_file_directory
, _("\
3992 Set the directories where separate debug symbols are searched for."), _("\
3993 Show the directories where separate debug symbols are searched for."), _("\
3994 Separate debug symbols are first searched for in the same\n\
3995 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3996 and lastly at the path of the directory of the binary with\n\
3997 each global debug-file-directory component prepended."),
3999 show_debug_file_directory
,
4000 &setlist
, &showlist
);
4002 add_setshow_enum_cmd ("symbol-loading", no_class
,
4003 print_symbol_loading_enums
, &print_symbol_loading
,
4005 Set printing of symbol loading messages."), _("\
4006 Show printing of symbol loading messages."), _("\
4007 off == turn all messages off\n\
4008 brief == print messages for the executable,\n\
4009 and brief messages for shared libraries\n\
4010 full == print messages for the executable,\n\
4011 and messages for each shared library."),
4014 &setprintlist
, &showprintlist
);
4016 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
4017 &separate_debug_file_debug
, _("\
4018 Set printing of separate debug info file search debug."), _("\
4019 Show printing of separate debug info file search debug."), _("\
4020 When on, GDB prints the searched locations while looking for separate debug \
4021 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
4024 selftests::register_test
4025 ("filename_language", selftests::filename_language::test_filename_language
);
4026 selftests::register_test
4027 ("set_ext_lang_command",
4028 selftests::filename_language::test_set_ext_lang_command
);