1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2021 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
35 #include "breakpoint.h"
37 #include "complaints.h"
41 #include "filenames.h" /* for DOSish file names */
42 #include "gdb-stabs.h"
43 #include "gdb_obstack.h"
44 #include "completer.h"
47 #include "readline/tilde.h"
49 #include "observable.h"
51 #include "parser-defs.h"
58 #include "cli/cli-utils.h"
59 #include "gdbsupport/byte-vector.h"
60 #include "gdbsupport/pathstuff.h"
61 #include "gdbsupport/selftest.h"
62 #include "cli/cli-style.h"
63 #include "gdbsupport/forward-scope-exit.h"
65 #include <sys/types.h>
72 int (*deprecated_ui_load_progress_hook
) (const char *section
,
74 void (*deprecated_show_load_progress
) (const char *section
,
75 unsigned long section_sent
,
76 unsigned long section_size
,
77 unsigned long total_sent
,
78 unsigned long total_size
);
79 void (*deprecated_pre_add_symbol_hook
) (const char *);
80 void (*deprecated_post_add_symbol_hook
) (void);
82 using clear_symtab_users_cleanup
83 = FORWARD_SCOPE_EXIT (clear_symtab_users
);
85 /* Global variables owned by this file. */
89 int readnow_symbol_files
;
93 int readnever_symbol_files
;
95 /* Functions this file defines. */
97 static void symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
98 objfile_flags flags
, CORE_ADDR reloff
);
100 static const struct sym_fns
*find_sym_fns (bfd
*);
102 static void overlay_invalidate_all (void);
104 static void simple_free_overlay_table (void);
106 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
109 static int simple_read_overlay_table (void);
111 static int simple_overlay_update_1 (struct obj_section
*);
113 static void symfile_find_segment_sections (struct objfile
*objfile
);
115 /* List of all available sym_fns. On gdb startup, each object file reader
116 calls add_symtab_fns() to register information on each format it is
119 struct registered_sym_fns
121 registered_sym_fns (bfd_flavour sym_flavour_
, const struct sym_fns
*sym_fns_
)
122 : sym_flavour (sym_flavour_
), sym_fns (sym_fns_
)
125 /* BFD flavour that we handle. */
126 enum bfd_flavour sym_flavour
;
128 /* The "vtable" of symbol functions. */
129 const struct sym_fns
*sym_fns
;
132 static std::vector
<registered_sym_fns
> symtab_fns
;
134 /* Values for "set print symbol-loading". */
136 const char print_symbol_loading_off
[] = "off";
137 const char print_symbol_loading_brief
[] = "brief";
138 const char print_symbol_loading_full
[] = "full";
139 static const char *print_symbol_loading_enums
[] =
141 print_symbol_loading_off
,
142 print_symbol_loading_brief
,
143 print_symbol_loading_full
,
146 static const char *print_symbol_loading
= print_symbol_loading_full
;
150 bool auto_solib_add
= true;
153 /* Return non-zero if symbol-loading messages should be printed.
154 FROM_TTY is the standard from_tty argument to gdb commands.
155 If EXEC is non-zero the messages are for the executable.
156 Otherwise, messages are for shared libraries.
157 If FULL is non-zero then the caller is printing a detailed message.
158 E.g., the message includes the shared library name.
159 Otherwise, the caller is printing a brief "summary" message. */
162 print_symbol_loading_p (int from_tty
, int exec
, int full
)
164 if (!from_tty
&& !info_verbose
)
169 /* We don't check FULL for executables, there are few such
170 messages, therefore brief == full. */
171 return print_symbol_loading
!= print_symbol_loading_off
;
174 return print_symbol_loading
== print_symbol_loading_full
;
175 return print_symbol_loading
== print_symbol_loading_brief
;
178 /* True if we are reading a symbol table. */
180 int currently_reading_symtab
= 0;
182 /* Increment currently_reading_symtab and return a cleanup that can be
183 used to decrement it. */
185 scoped_restore_tmpl
<int>
186 increment_reading_symtab (void)
188 gdb_assert (currently_reading_symtab
>= 0);
189 return make_scoped_restore (¤tly_reading_symtab
,
190 currently_reading_symtab
+ 1);
193 /* Remember the lowest-addressed loadable section we've seen.
195 In case of equal vmas, the section with the largest size becomes the
196 lowest-addressed loadable section.
198 If the vmas and sizes are equal, the last section is considered the
199 lowest-addressed loadable section. */
202 find_lowest_section (asection
*sect
, asection
**lowest
)
204 if (0 == (bfd_section_flags (sect
) & (SEC_ALLOC
| SEC_LOAD
)))
207 *lowest
= sect
; /* First loadable section */
208 else if (bfd_section_vma (*lowest
) > bfd_section_vma (sect
))
209 *lowest
= sect
; /* A lower loadable section */
210 else if (bfd_section_vma (*lowest
) == bfd_section_vma (sect
)
211 && (bfd_section_size (*lowest
) <= bfd_section_size (sect
)))
215 /* Build (allocate and populate) a section_addr_info struct from
216 an existing section table. */
219 build_section_addr_info_from_section_table (const target_section_table
&table
)
221 section_addr_info sap
;
223 for (const target_section
&stp
: table
)
225 struct bfd_section
*asect
= stp
.the_bfd_section
;
226 bfd
*abfd
= asect
->owner
;
228 if (bfd_section_flags (asect
) & (SEC_ALLOC
| SEC_LOAD
)
229 && sap
.size () < table
.size ())
230 sap
.emplace_back (stp
.addr
,
231 bfd_section_name (asect
),
232 gdb_bfd_section_index (abfd
, asect
));
238 /* Create a section_addr_info from section offsets in ABFD. */
240 static section_addr_info
241 build_section_addr_info_from_bfd (bfd
*abfd
)
243 struct bfd_section
*sec
;
245 section_addr_info sap
;
246 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
247 if (bfd_section_flags (sec
) & (SEC_ALLOC
| SEC_LOAD
))
248 sap
.emplace_back (bfd_section_vma (sec
),
249 bfd_section_name (sec
),
250 gdb_bfd_section_index (abfd
, sec
));
255 /* Create a section_addr_info from section offsets in OBJFILE. */
258 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
262 /* Before reread_symbols gets rewritten it is not safe to call:
263 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
265 section_addr_info sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
266 for (i
= 0; i
< sap
.size (); i
++)
268 int sectindex
= sap
[i
].sectindex
;
270 sap
[i
].addr
+= objfile
->section_offsets
[sectindex
];
275 /* Initialize OBJFILE's sect_index_* members. */
278 init_objfile_sect_indices (struct objfile
*objfile
)
283 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
285 objfile
->sect_index_text
= sect
->index
;
287 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
289 objfile
->sect_index_data
= sect
->index
;
291 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
293 objfile
->sect_index_bss
= sect
->index
;
295 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
297 objfile
->sect_index_rodata
= sect
->index
;
299 /* This is where things get really weird... We MUST have valid
300 indices for the various sect_index_* members or gdb will abort.
301 So if for example, there is no ".text" section, we have to
302 accomodate that. First, check for a file with the standard
303 one or two segments. */
305 symfile_find_segment_sections (objfile
);
307 /* Except when explicitly adding symbol files at some address,
308 section_offsets contains nothing but zeros, so it doesn't matter
309 which slot in section_offsets the individual sect_index_* members
310 index into. So if they are all zero, it is safe to just point
311 all the currently uninitialized indices to the first slot. But
312 beware: if this is the main executable, it may be relocated
313 later, e.g. by the remote qOffsets packet, and then this will
314 be wrong! That's why we try segments first. */
316 for (i
= 0; i
< objfile
->section_offsets
.size (); i
++)
318 if (objfile
->section_offsets
[i
] != 0)
323 if (i
== objfile
->section_offsets
.size ())
325 if (objfile
->sect_index_text
== -1)
326 objfile
->sect_index_text
= 0;
327 if (objfile
->sect_index_data
== -1)
328 objfile
->sect_index_data
= 0;
329 if (objfile
->sect_index_bss
== -1)
330 objfile
->sect_index_bss
= 0;
331 if (objfile
->sect_index_rodata
== -1)
332 objfile
->sect_index_rodata
= 0;
336 /* Find a unique offset to use for loadable section SECT if
337 the user did not provide an offset. */
340 place_section (bfd
*abfd
, asection
*sect
, section_offsets
&offsets
,
343 CORE_ADDR start_addr
;
345 ULONGEST align
= ((ULONGEST
) 1) << bfd_section_alignment (sect
);
347 /* We are only interested in allocated sections. */
348 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
351 /* If the user specified an offset, honor it. */
352 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
355 /* Otherwise, let's try to find a place for the section. */
356 start_addr
= (lowest
+ align
- 1) & -align
;
363 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
365 int indx
= cur_sec
->index
;
367 /* We don't need to compare against ourself. */
371 /* We can only conflict with allocated sections. */
372 if ((bfd_section_flags (cur_sec
) & SEC_ALLOC
) == 0)
375 /* If the section offset is 0, either the section has not been placed
376 yet, or it was the lowest section placed (in which case LOWEST
377 will be past its end). */
378 if (offsets
[indx
] == 0)
381 /* If this section would overlap us, then we must move up. */
382 if (start_addr
+ bfd_section_size (sect
) > offsets
[indx
]
383 && start_addr
< offsets
[indx
] + bfd_section_size (cur_sec
))
385 start_addr
= offsets
[indx
] + bfd_section_size (cur_sec
);
386 start_addr
= (start_addr
+ align
- 1) & -align
;
391 /* Otherwise, we appear to be OK. So far. */
396 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
397 lowest
= start_addr
+ bfd_section_size (sect
);
400 /* Store section_addr_info as prepared (made relative and with SECTINDEX
401 filled-in) by addr_info_make_relative into SECTION_OFFSETS. */
404 relative_addr_info_to_section_offsets (section_offsets
§ion_offsets
,
405 const section_addr_info
&addrs
)
409 section_offsets
.assign (section_offsets
.size (), 0);
411 /* Now calculate offsets for section that were specified by the caller. */
412 for (i
= 0; i
< addrs
.size (); i
++)
414 const struct other_sections
*osp
;
417 if (osp
->sectindex
== -1)
420 /* Record all sections in offsets. */
421 /* The section_offsets in the objfile are here filled in using
423 section_offsets
[osp
->sectindex
] = osp
->addr
;
427 /* Transform section name S for a name comparison. prelink can split section
428 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
429 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
430 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
431 (`.sbss') section has invalid (increased) virtual address. */
434 addr_section_name (const char *s
)
436 if (strcmp (s
, ".dynbss") == 0)
438 if (strcmp (s
, ".sdynbss") == 0)
444 /* std::sort comparator for addrs_section_sort. Sort entries in
445 ascending order by their (name, sectindex) pair. sectindex makes
446 the sort by name stable. */
449 addrs_section_compar (const struct other_sections
*a
,
450 const struct other_sections
*b
)
454 retval
= strcmp (addr_section_name (a
->name
.c_str ()),
455 addr_section_name (b
->name
.c_str ()));
459 return a
->sectindex
< b
->sectindex
;
462 /* Provide sorted array of pointers to sections of ADDRS. */
464 static std::vector
<const struct other_sections
*>
465 addrs_section_sort (const section_addr_info
&addrs
)
469 std::vector
<const struct other_sections
*> array (addrs
.size ());
470 for (i
= 0; i
< addrs
.size (); i
++)
471 array
[i
] = &addrs
[i
];
473 std::sort (array
.begin (), array
.end (), addrs_section_compar
);
478 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
479 also SECTINDEXes specific to ABFD there. This function can be used to
480 rebase ADDRS to start referencing different BFD than before. */
483 addr_info_make_relative (section_addr_info
*addrs
, bfd
*abfd
)
485 asection
*lower_sect
;
486 CORE_ADDR lower_offset
;
489 /* Find lowest loadable section to be used as starting point for
490 contiguous sections. */
492 for (asection
*iter
: gdb_bfd_sections (abfd
))
493 find_lowest_section (iter
, &lower_sect
);
494 if (lower_sect
== NULL
)
496 warning (_("no loadable sections found in added symbol-file %s"),
497 bfd_get_filename (abfd
));
501 lower_offset
= bfd_section_vma (lower_sect
);
503 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
504 in ABFD. Section names are not unique - there can be multiple sections of
505 the same name. Also the sections of the same name do not have to be
506 adjacent to each other. Some sections may be present only in one of the
507 files. Even sections present in both files do not have to be in the same
510 Use stable sort by name for the sections in both files. Then linearly
511 scan both lists matching as most of the entries as possible. */
513 std::vector
<const struct other_sections
*> addrs_sorted
514 = addrs_section_sort (*addrs
);
516 section_addr_info abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
517 std::vector
<const struct other_sections
*> abfd_addrs_sorted
518 = addrs_section_sort (abfd_addrs
);
520 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
521 ABFD_ADDRS_SORTED. */
523 std::vector
<const struct other_sections
*>
524 addrs_to_abfd_addrs (addrs
->size (), nullptr);
526 std::vector
<const struct other_sections
*>::iterator abfd_sorted_iter
527 = abfd_addrs_sorted
.begin ();
528 for (const other_sections
*sect
: addrs_sorted
)
530 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
532 while (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
533 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
537 if (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
538 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
543 /* Make the found item directly addressable from ADDRS. */
544 index_in_addrs
= sect
- addrs
->data ();
545 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
546 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_sorted_iter
;
548 /* Never use the same ABFD entry twice. */
553 /* Calculate offsets for the loadable sections.
554 FIXME! Sections must be in order of increasing loadable section
555 so that contiguous sections can use the lower-offset!!!
557 Adjust offsets if the segments are not contiguous.
558 If the section is contiguous, its offset should be set to
559 the offset of the highest loadable section lower than it
560 (the loadable section directly below it in memory).
561 this_offset = lower_offset = lower_addr - lower_orig_addr */
563 for (i
= 0; i
< addrs
->size (); i
++)
565 const struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
569 /* This is the index used by BFD. */
570 (*addrs
)[i
].sectindex
= sect
->sectindex
;
572 if ((*addrs
)[i
].addr
!= 0)
574 (*addrs
)[i
].addr
-= sect
->addr
;
575 lower_offset
= (*addrs
)[i
].addr
;
578 (*addrs
)[i
].addr
= lower_offset
;
582 /* addr_section_name transformation is not used for SECT_NAME. */
583 const std::string
§_name
= (*addrs
)[i
].name
;
585 /* This section does not exist in ABFD, which is normally
586 unexpected and we want to issue a warning.
588 However, the ELF prelinker does create a few sections which are
589 marked in the main executable as loadable (they are loaded in
590 memory from the DYNAMIC segment) and yet are not present in
591 separate debug info files. This is fine, and should not cause
592 a warning. Shared libraries contain just the section
593 ".gnu.liblist" but it is not marked as loadable there. There is
594 no other way to identify them than by their name as the sections
595 created by prelink have no special flags.
597 For the sections `.bss' and `.sbss' see addr_section_name. */
599 if (!(sect_name
== ".gnu.liblist"
600 || sect_name
== ".gnu.conflict"
601 || (sect_name
== ".bss"
603 && (*addrs
)[i
- 1].name
== ".dynbss"
604 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
605 || (sect_name
== ".sbss"
607 && (*addrs
)[i
- 1].name
== ".sdynbss"
608 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
609 warning (_("section %s not found in %s"), sect_name
.c_str (),
610 bfd_get_filename (abfd
));
612 (*addrs
)[i
].addr
= 0;
613 (*addrs
)[i
].sectindex
= -1;
618 /* Parse the user's idea of an offset for dynamic linking, into our idea
619 of how to represent it for fast symbol reading. This is the default
620 version of the sym_fns.sym_offsets function for symbol readers that
621 don't need to do anything special. It allocates a section_offsets table
622 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
625 default_symfile_offsets (struct objfile
*objfile
,
626 const section_addr_info
&addrs
)
628 objfile
->section_offsets
.resize (gdb_bfd_count_sections (objfile
->obfd
));
629 relative_addr_info_to_section_offsets (objfile
->section_offsets
, addrs
);
631 /* For relocatable files, all loadable sections will start at zero.
632 The zero is meaningless, so try to pick arbitrary addresses such
633 that no loadable sections overlap. This algorithm is quadratic,
634 but the number of sections in a single object file is generally
636 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
638 bfd
*abfd
= objfile
->obfd
;
641 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
642 /* We do not expect this to happen; just skip this step if the
643 relocatable file has a section with an assigned VMA. */
644 if (bfd_section_vma (cur_sec
) != 0)
649 section_offsets
&offsets
= objfile
->section_offsets
;
651 /* Pick non-overlapping offsets for sections the user did not
653 CORE_ADDR lowest
= 0;
654 for (asection
*sect
: gdb_bfd_sections (objfile
->obfd
))
655 place_section (objfile
->obfd
, sect
, objfile
->section_offsets
,
658 /* Correctly filling in the section offsets is not quite
659 enough. Relocatable files have two properties that
660 (most) shared objects do not:
662 - Their debug information will contain relocations. Some
663 shared libraries do also, but many do not, so this can not
666 - If there are multiple code sections they will be loaded
667 at different relative addresses in memory than they are
668 in the objfile, since all sections in the file will start
671 Because GDB has very limited ability to map from an
672 address in debug info to the correct code section,
673 it relies on adding SECT_OFF_TEXT to things which might be
674 code. If we clear all the section offsets, and set the
675 section VMAs instead, then symfile_relocate_debug_section
676 will return meaningful debug information pointing at the
679 GDB has too many different data structures for section
680 addresses - a bfd, objfile, and so_list all have section
681 tables, as does exec_ops. Some of these could probably
684 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
685 cur_sec
= cur_sec
->next
)
687 if ((bfd_section_flags (cur_sec
) & SEC_ALLOC
) == 0)
690 bfd_set_section_vma (cur_sec
, offsets
[cur_sec
->index
]);
691 exec_set_section_address (bfd_get_filename (abfd
),
693 offsets
[cur_sec
->index
]);
694 offsets
[cur_sec
->index
] = 0;
699 /* Remember the bfd indexes for the .text, .data, .bss and
701 init_objfile_sect_indices (objfile
);
704 /* Divide the file into segments, which are individual relocatable units.
705 This is the default version of the sym_fns.sym_segments function for
706 symbol readers that do not have an explicit representation of segments.
707 It assumes that object files do not have segments, and fully linked
708 files have a single segment. */
710 symfile_segment_data_up
711 default_symfile_segments (bfd
*abfd
)
717 /* Relocatable files contain enough information to position each
718 loadable section independently; they should not be relocated
720 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
723 /* Make sure there is at least one loadable section in the file. */
724 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
726 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
734 low
= bfd_section_vma (sect
);
735 high
= low
+ bfd_section_size (sect
);
737 symfile_segment_data_up
data (new symfile_segment_data
);
739 num_sections
= bfd_count_sections (abfd
);
741 /* All elements are initialized to 0 (map to no segment). */
742 data
->segment_info
.resize (num_sections
);
744 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
748 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
751 vma
= bfd_section_vma (sect
);
754 if (vma
+ bfd_section_size (sect
) > high
)
755 high
= vma
+ bfd_section_size (sect
);
757 data
->segment_info
[i
] = 1;
760 data
->segments
.emplace_back (low
, high
- low
);
765 /* This is a convenience function to call sym_read for OBJFILE and
766 possibly force the partial symbols to be read. */
769 read_symbols (struct objfile
*objfile
, symfile_add_flags add_flags
)
771 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
772 objfile
->per_bfd
->minsyms_read
= true;
774 /* find_separate_debug_file_in_section should be called only if there is
775 single binary with no existing separate debug info file. */
776 if (!objfile
->has_partial_symbols ()
777 && objfile
->separate_debug_objfile
== NULL
778 && objfile
->separate_debug_objfile_backlink
== NULL
)
780 gdb_bfd_ref_ptr
abfd (find_separate_debug_file_in_section (objfile
));
784 /* find_separate_debug_file_in_section uses the same filename for the
785 virtual section-as-bfd like the bfd filename containing the
786 section. Therefore use also non-canonical name form for the same
787 file containing the section. */
788 symbol_file_add_separate (abfd
.get (),
789 bfd_get_filename (abfd
.get ()),
790 add_flags
| SYMFILE_NOT_FILENAME
, objfile
);
793 if ((add_flags
& SYMFILE_NO_READ
) == 0)
794 objfile
->require_partial_symbols (false);
797 /* Initialize entry point information for this objfile. */
800 init_entry_point_info (struct objfile
*objfile
)
802 struct entry_info
*ei
= &objfile
->per_bfd
->ei
;
808 /* Save startup file's range of PC addresses to help blockframe.c
809 decide where the bottom of the stack is. */
811 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
813 /* Executable file -- record its entry point so we'll recognize
814 the startup file because it contains the entry point. */
815 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
816 ei
->entry_point_p
= 1;
818 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
819 && bfd_get_start_address (objfile
->obfd
) != 0)
821 /* Some shared libraries may have entry points set and be
822 runnable. There's no clear way to indicate this, so just check
823 for values other than zero. */
824 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
825 ei
->entry_point_p
= 1;
829 /* Examination of non-executable.o files. Short-circuit this stuff. */
830 ei
->entry_point_p
= 0;
833 if (ei
->entry_point_p
)
835 struct obj_section
*osect
;
836 CORE_ADDR entry_point
= ei
->entry_point
;
839 /* Make certain that the address points at real code, and not a
840 function descriptor. */
842 = gdbarch_convert_from_func_ptr_addr (objfile
->arch (),
844 current_top_target ());
846 /* Remove any ISA markers, so that this matches entries in the
849 = gdbarch_addr_bits_remove (objfile
->arch (), entry_point
);
852 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
854 struct bfd_section
*sect
= osect
->the_bfd_section
;
856 if (entry_point
>= bfd_section_vma (sect
)
857 && entry_point
< (bfd_section_vma (sect
)
858 + bfd_section_size (sect
)))
860 ei
->the_bfd_section_index
861 = gdb_bfd_section_index (objfile
->obfd
, sect
);
868 ei
->the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
872 /* Process a symbol file, as either the main file or as a dynamically
875 This function does not set the OBJFILE's entry-point info.
877 OBJFILE is where the symbols are to be read from.
879 ADDRS is the list of section load addresses. If the user has given
880 an 'add-symbol-file' command, then this is the list of offsets and
881 addresses he or she provided as arguments to the command; or, if
882 we're handling a shared library, these are the actual addresses the
883 sections are loaded at, according to the inferior's dynamic linker
884 (as gleaned by GDB's shared library code). We convert each address
885 into an offset from the section VMA's as it appears in the object
886 file, and then call the file's sym_offsets function to convert this
887 into a format-specific offset table --- a `section_offsets'.
888 The sectindex field is used to control the ordering of sections
889 with the same name. Upon return, it is updated to contain the
890 corresponding BFD section index, or -1 if the section was not found.
892 ADD_FLAGS encodes verbosity level, whether this is main symbol or
893 an extra symbol file such as dynamically loaded code, and whether
894 breakpoint reset should be deferred. */
897 syms_from_objfile_1 (struct objfile
*objfile
,
898 section_addr_info
*addrs
,
899 symfile_add_flags add_flags
)
901 section_addr_info local_addr
;
902 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
904 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
905 objfile
->reset_psymtabs ();
906 objfile
->qf
= make_psymbol_functions (objfile
->partial_symtabs
);
908 if (objfile
->sf
== NULL
)
910 /* No symbols to load, but we still need to make sure
911 that the section_offsets table is allocated. */
912 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
914 objfile
->section_offsets
.assign (num_sections
, 0);
918 /* Make sure that partially constructed symbol tables will be cleaned up
919 if an error occurs during symbol reading. */
920 gdb::optional
<clear_symtab_users_cleanup
> defer_clear_users
;
922 objfile_up
objfile_holder (objfile
);
924 /* If ADDRS is NULL, put together a dummy address list.
925 We now establish the convention that an addr of zero means
926 no load address was specified. */
932 /* We will modify the main symbol table, make sure that all its users
933 will be cleaned up if an error occurs during symbol reading. */
934 defer_clear_users
.emplace ((symfile_add_flag
) 0);
936 /* Since no error yet, throw away the old symbol table. */
938 if (current_program_space
->symfile_object_file
!= NULL
)
940 current_program_space
->symfile_object_file
->unlink ();
941 gdb_assert (current_program_space
->symfile_object_file
== NULL
);
944 /* Currently we keep symbols from the add-symbol-file command.
945 If the user wants to get rid of them, they should do "symbol-file"
946 without arguments first. Not sure this is the best behavior
949 (*objfile
->sf
->sym_new_init
) (objfile
);
952 /* Convert addr into an offset rather than an absolute address.
953 We find the lowest address of a loaded segment in the objfile,
954 and assume that <addr> is where that got loaded.
956 We no longer warn if the lowest section is not a text segment (as
957 happens for the PA64 port. */
958 if (addrs
->size () > 0)
959 addr_info_make_relative (addrs
, objfile
->obfd
);
961 /* Initialize symbol reading routines for this objfile, allow complaints to
962 appear for this new file, and record how verbose to be, then do the
963 initial symbol reading for this file. */
965 (*objfile
->sf
->sym_init
) (objfile
);
968 (*objfile
->sf
->sym_offsets
) (objfile
, *addrs
);
970 read_symbols (objfile
, add_flags
);
972 /* Discard cleanups as symbol reading was successful. */
974 objfile_holder
.release ();
975 if (defer_clear_users
)
976 defer_clear_users
->release ();
979 /* Same as syms_from_objfile_1, but also initializes the objfile
983 syms_from_objfile (struct objfile
*objfile
,
984 section_addr_info
*addrs
,
985 symfile_add_flags add_flags
)
987 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
988 init_entry_point_info (objfile
);
991 /* Perform required actions after either reading in the initial
992 symbols for a new objfile, or mapping in the symbols from a reusable
993 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
996 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
998 /* If this is the main symbol file we have to clean up all users of the
999 old main symbol file. Otherwise it is sufficient to fixup all the
1000 breakpoints that may have been redefined by this symbol file. */
1001 if (add_flags
& SYMFILE_MAINLINE
)
1003 /* OK, make it the "real" symbol file. */
1004 current_program_space
->symfile_object_file
= objfile
;
1006 clear_symtab_users (add_flags
);
1008 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1010 breakpoint_re_set ();
1013 /* We're done reading the symbol file; finish off complaints. */
1014 clear_complaints ();
1017 /* Process a symbol file, as either the main file or as a dynamically
1020 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1021 A new reference is acquired by this function.
1023 For NAME description see the objfile constructor.
1025 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1026 extra, such as dynamically loaded code, and what to do with breakpoints.
1028 ADDRS is as described for syms_from_objfile_1, above.
1029 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1031 PARENT is the original objfile if ABFD is a separate debug info file.
1032 Otherwise PARENT is NULL.
1034 Upon success, returns a pointer to the objfile that was added.
1035 Upon failure, jumps back to command level (never returns). */
1037 static struct objfile
*
1038 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
,
1039 symfile_add_flags add_flags
,
1040 section_addr_info
*addrs
,
1041 objfile_flags flags
, struct objfile
*parent
)
1043 struct objfile
*objfile
;
1044 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1045 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1046 const int always_confirm
= add_flags
& SYMFILE_ALWAYS_CONFIRM
;
1047 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1048 && (readnow_symbol_files
1049 || (add_flags
& SYMFILE_NO_READ
) == 0));
1051 if (readnow_symbol_files
)
1053 flags
|= OBJF_READNOW
;
1054 add_flags
&= ~SYMFILE_NO_READ
;
1056 else if (readnever_symbol_files
1057 || (parent
!= NULL
&& (parent
->flags
& OBJF_READNEVER
)))
1059 flags
|= OBJF_READNEVER
;
1060 add_flags
|= SYMFILE_NO_READ
;
1062 if ((add_flags
& SYMFILE_NOT_FILENAME
) != 0)
1063 flags
|= OBJF_NOT_FILENAME
;
1065 /* Give user a chance to burp if ALWAYS_CONFIRM or we'd be
1066 interactively wiping out any existing symbols. */
1070 || ((have_full_symbols () || have_partial_symbols ())
1072 && !query (_("Load new symbol table from \"%s\"? "), name
))
1073 error (_("Not confirmed."));
1076 flags
|= OBJF_MAINLINE
;
1077 objfile
= objfile::make (abfd
, name
, flags
, parent
);
1079 /* We either created a new mapped symbol table, mapped an existing
1080 symbol table file which has not had initial symbol reading
1081 performed, or need to read an unmapped symbol table. */
1084 if (deprecated_pre_add_symbol_hook
)
1085 deprecated_pre_add_symbol_hook (name
);
1087 printf_filtered (_("Reading symbols from %ps...\n"),
1088 styled_string (file_name_style
.style (), name
));
1090 syms_from_objfile (objfile
, addrs
, add_flags
);
1092 /* We now have at least a partial symbol table. Check to see if the
1093 user requested that all symbols be read on initial access via either
1094 the gdb startup command line or on a per symbol file basis. Expand
1095 all partial symbol tables for this objfile if so. */
1097 if ((flags
& OBJF_READNOW
))
1100 printf_filtered (_("Expanding full symbols from %ps...\n"),
1101 styled_string (file_name_style
.style (), name
));
1103 objfile
->expand_all_symtabs ();
1106 /* Note that we only print a message if we have no symbols and have
1107 no separate debug file. If there is a separate debug file which
1108 does not have symbols, we'll have emitted this message for that
1109 file, and so printing it twice is just redundant. */
1110 if (should_print
&& !objfile_has_symbols (objfile
)
1111 && objfile
->separate_debug_objfile
== nullptr)
1112 printf_filtered (_("(No debugging symbols found in %ps)\n"),
1113 styled_string (file_name_style
.style (), name
));
1117 if (deprecated_post_add_symbol_hook
)
1118 deprecated_post_add_symbol_hook ();
1121 /* We print some messages regardless of whether 'from_tty ||
1122 info_verbose' is true, so make sure they go out at the right
1124 gdb_flush (gdb_stdout
);
1126 if (objfile
->sf
== NULL
)
1128 gdb::observers::new_objfile
.notify (objfile
);
1129 return objfile
; /* No symbols. */
1132 finish_new_objfile (objfile
, add_flags
);
1134 gdb::observers::new_objfile
.notify (objfile
);
1136 bfd_cache_close_all ();
1140 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1141 see the objfile constructor. */
1144 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1145 symfile_add_flags symfile_flags
,
1146 struct objfile
*objfile
)
1148 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1149 because sections of BFD may not match sections of OBJFILE and because
1150 vma may have been modified by tools such as prelink. */
1151 section_addr_info sap
= build_section_addr_info_from_objfile (objfile
);
1153 symbol_file_add_with_addrs
1154 (bfd
, name
, symfile_flags
, &sap
,
1155 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1156 | OBJF_USERLOADED
| OBJF_MAINLINE
),
1160 /* Process the symbol file ABFD, as either the main file or as a
1161 dynamically loaded file.
1162 See symbol_file_add_with_addrs's comments for details. */
1165 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1166 symfile_add_flags add_flags
,
1167 section_addr_info
*addrs
,
1168 objfile_flags flags
, struct objfile
*parent
)
1170 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1174 /* Process a symbol file, as either the main file or as a dynamically
1175 loaded file. See symbol_file_add_with_addrs's comments for details. */
1178 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1179 section_addr_info
*addrs
, objfile_flags flags
)
1181 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1183 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1187 /* Call symbol_file_add() with default values and update whatever is
1188 affected by the loading of a new main().
1189 Used when the file is supplied in the gdb command line
1190 and by some targets with special loading requirements.
1191 The auxiliary function, symbol_file_add_main_1(), has the flags
1192 argument for the switches that can only be specified in the symbol_file
1196 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1198 symbol_file_add_main_1 (args
, add_flags
, 0, 0);
1202 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1203 objfile_flags flags
, CORE_ADDR reloff
)
1205 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1207 struct objfile
*objfile
= symbol_file_add (args
, add_flags
, NULL
, flags
);
1209 objfile_rebase (objfile
, reloff
);
1211 /* Getting new symbols may change our opinion about
1212 what is frameless. */
1213 reinit_frame_cache ();
1215 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1216 set_initial_language ();
1220 symbol_file_clear (int from_tty
)
1222 if ((have_full_symbols () || have_partial_symbols ())
1224 && (current_program_space
->symfile_object_file
1225 ? !query (_("Discard symbol table from `%s'? "),
1226 objfile_name (current_program_space
->symfile_object_file
))
1227 : !query (_("Discard symbol table? "))))
1228 error (_("Not confirmed."));
1230 /* solib descriptors may have handles to objfiles. Wipe them before their
1231 objfiles get stale by free_all_objfiles. */
1232 no_shared_libraries (NULL
, from_tty
);
1234 current_program_space
->free_all_objfiles ();
1236 clear_symtab_users (0);
1238 gdb_assert (current_program_space
->symfile_object_file
== NULL
);
1240 printf_filtered (_("No symbol file now.\n"));
1243 /* See symfile.h. */
1245 bool separate_debug_file_debug
= false;
1248 separate_debug_file_exists (const std::string
&name
, unsigned long crc
,
1249 struct objfile
*parent_objfile
)
1251 unsigned long file_crc
;
1253 struct stat parent_stat
, abfd_stat
;
1254 int verified_as_different
;
1256 /* Find a separate debug info file as if symbols would be present in
1257 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1258 section can contain just the basename of PARENT_OBJFILE without any
1259 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1260 the separate debug infos with the same basename can exist. */
1262 if (filename_cmp (name
.c_str (), objfile_name (parent_objfile
)) == 0)
1265 if (separate_debug_file_debug
)
1267 printf_filtered (_(" Trying %s..."), name
.c_str ());
1268 gdb_flush (gdb_stdout
);
1271 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
.c_str (), gnutarget
));
1275 if (separate_debug_file_debug
)
1276 printf_filtered (_(" no, unable to open.\n"));
1281 /* Verify symlinks were not the cause of filename_cmp name difference above.
1283 Some operating systems, e.g. Windows, do not provide a meaningful
1284 st_ino; they always set it to zero. (Windows does provide a
1285 meaningful st_dev.) Files accessed from gdbservers that do not
1286 support the vFile:fstat packet will also have st_ino set to zero.
1287 Do not indicate a duplicate library in either case. While there
1288 is no guarantee that a system that provides meaningful inode
1289 numbers will never set st_ino to zero, this is merely an
1290 optimization, so we do not need to worry about false negatives. */
1292 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1293 && abfd_stat
.st_ino
!= 0
1294 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1296 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1297 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1299 if (separate_debug_file_debug
)
1300 printf_filtered (_(" no, same file as the objfile.\n"));
1304 verified_as_different
= 1;
1307 verified_as_different
= 0;
1309 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1313 if (separate_debug_file_debug
)
1314 printf_filtered (_(" no, error computing CRC.\n"));
1319 if (crc
!= file_crc
)
1321 unsigned long parent_crc
;
1323 /* If the files could not be verified as different with
1324 bfd_stat then we need to calculate the parent's CRC
1325 to verify whether the files are different or not. */
1327 if (!verified_as_different
)
1329 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1331 if (separate_debug_file_debug
)
1332 printf_filtered (_(" no, error computing CRC.\n"));
1338 if (verified_as_different
|| parent_crc
!= file_crc
)
1339 warning (_("the debug information found in \"%s\""
1340 " does not match \"%s\" (CRC mismatch).\n"),
1341 name
.c_str (), objfile_name (parent_objfile
));
1343 if (separate_debug_file_debug
)
1344 printf_filtered (_(" no, CRC doesn't match.\n"));
1349 if (separate_debug_file_debug
)
1350 printf_filtered (_(" yes!\n"));
1355 char *debug_file_directory
= NULL
;
1357 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1358 struct cmd_list_element
*c
, const char *value
)
1360 fprintf_filtered (file
,
1361 _("The directory where separate debug "
1362 "symbols are searched for is \"%s\".\n"),
1366 #if ! defined (DEBUG_SUBDIRECTORY)
1367 #define DEBUG_SUBDIRECTORY ".debug"
1370 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1371 where the original file resides (may not be the same as
1372 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1373 looking for. CANON_DIR is the "realpath" form of DIR.
1374 DIR must contain a trailing '/'.
1375 Returns the path of the file with separate debug info, or an empty
1379 find_separate_debug_file (const char *dir
,
1380 const char *canon_dir
,
1381 const char *debuglink
,
1382 unsigned long crc32
, struct objfile
*objfile
)
1384 if (separate_debug_file_debug
)
1385 printf_filtered (_("\nLooking for separate debug info (debug link) for "
1386 "%s\n"), objfile_name (objfile
));
1388 /* First try in the same directory as the original file. */
1389 std::string debugfile
= dir
;
1390 debugfile
+= debuglink
;
1392 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1395 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1397 debugfile
+= DEBUG_SUBDIRECTORY
;
1399 debugfile
+= debuglink
;
1401 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1404 /* Then try in the global debugfile directories.
1406 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1407 cause "/..." lookups. */
1409 bool target_prefix
= startswith (dir
, "target:");
1410 const char *dir_notarget
= target_prefix
? dir
+ strlen ("target:") : dir
;
1411 std::vector
<gdb::unique_xmalloc_ptr
<char>> debugdir_vec
1412 = dirnames_to_char_ptr_vec (debug_file_directory
);
1413 gdb::unique_xmalloc_ptr
<char> canon_sysroot
= gdb_realpath (gdb_sysroot
);
1415 /* MS-Windows/MS-DOS don't allow colons in file names; we must
1416 convert the drive letter into a one-letter directory, so that the
1417 file name resulting from splicing below will be valid.
1419 FIXME: The below only works when GDB runs on MS-Windows/MS-DOS.
1420 There are various remote-debugging scenarios where such a
1421 transformation of the drive letter might be required when GDB runs
1422 on a Posix host, see
1424 https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
1426 If some of those scenarios need to be supported, we will need to
1427 use a different condition for HAS_DRIVE_SPEC and a different macro
1428 instead of STRIP_DRIVE_SPEC, which work on Posix systems as well. */
1430 if (HAS_DRIVE_SPEC (dir_notarget
))
1432 drive
= dir_notarget
[0];
1433 dir_notarget
= STRIP_DRIVE_SPEC (dir_notarget
);
1436 for (const gdb::unique_xmalloc_ptr
<char> &debugdir
: debugdir_vec
)
1438 debugfile
= target_prefix
? "target:" : "";
1439 debugfile
+= debugdir
.get ();
1442 debugfile
+= dir_notarget
;
1443 debugfile
+= debuglink
;
1445 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1448 const char *base_path
= NULL
;
1449 if (canon_dir
!= NULL
)
1451 if (canon_sysroot
.get () != NULL
)
1452 base_path
= child_path (canon_sysroot
.get (), canon_dir
);
1454 base_path
= child_path (gdb_sysroot
, canon_dir
);
1456 if (base_path
!= NULL
)
1458 /* If the file is in the sysroot, try using its base path in
1459 the global debugfile directory. */
1460 debugfile
= target_prefix
? "target:" : "";
1461 debugfile
+= debugdir
.get ();
1463 debugfile
+= base_path
;
1465 debugfile
+= debuglink
;
1467 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1470 /* If the file is in the sysroot, try using its base path in
1471 the sysroot's global debugfile directory. */
1472 debugfile
= target_prefix
? "target:" : "";
1473 debugfile
+= gdb_sysroot
;
1474 debugfile
+= debugdir
.get ();
1476 debugfile
+= base_path
;
1478 debugfile
+= debuglink
;
1480 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1486 return std::string ();
1489 /* Modify PATH to contain only "[/]directory/" part of PATH.
1490 If there were no directory separators in PATH, PATH will be empty
1491 string on return. */
1494 terminate_after_last_dir_separator (char *path
)
1498 /* Strip off the final filename part, leaving the directory name,
1499 followed by a slash. The directory can be relative or absolute. */
1500 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1501 if (IS_DIR_SEPARATOR (path
[i
]))
1504 /* If I is -1 then no directory is present there and DIR will be "". */
1508 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1509 Returns pathname, or an empty string. */
1512 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1514 unsigned long crc32
;
1516 gdb::unique_xmalloc_ptr
<char> debuglink
1517 (bfd_get_debug_link_info (objfile
->obfd
, &crc32
));
1519 if (debuglink
== NULL
)
1521 /* There's no separate debug info, hence there's no way we could
1522 load it => no warning. */
1523 return std::string ();
1526 std::string dir
= objfile_name (objfile
);
1527 terminate_after_last_dir_separator (&dir
[0]);
1528 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1530 std::string debugfile
1531 = find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1532 debuglink
.get (), crc32
, objfile
);
1534 if (debugfile
.empty ())
1536 /* For PR gdb/9538, try again with realpath (if different from the
1541 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1542 && S_ISLNK (st_buf
.st_mode
))
1544 gdb::unique_xmalloc_ptr
<char> symlink_dir
1545 (lrealpath (objfile_name (objfile
)));
1546 if (symlink_dir
!= NULL
)
1548 terminate_after_last_dir_separator (symlink_dir
.get ());
1549 if (dir
!= symlink_dir
.get ())
1551 /* Different directory, so try using it. */
1552 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1565 /* Make sure that OBJF_{READNOW,READNEVER} are not set
1569 validate_readnow_readnever (objfile_flags flags
)
1571 if ((flags
& OBJF_READNOW
) && (flags
& OBJF_READNEVER
))
1572 error (_("-readnow and -readnever cannot be used simultaneously"));
1575 /* This is the symbol-file command. Read the file, analyze its
1576 symbols, and add a struct symtab to a symtab list. The syntax of
1577 the command is rather bizarre:
1579 1. The function buildargv implements various quoting conventions
1580 which are undocumented and have little or nothing in common with
1581 the way things are quoted (or not quoted) elsewhere in GDB.
1583 2. Options are used, which are not generally used in GDB (perhaps
1584 "set mapped on", "set readnow on" would be better)
1586 3. The order of options matters, which is contrary to GNU
1587 conventions (because it is confusing and inconvenient). */
1590 symbol_file_command (const char *args
, int from_tty
)
1596 symbol_file_clear (from_tty
);
1600 objfile_flags flags
= OBJF_USERLOADED
;
1601 symfile_add_flags add_flags
= 0;
1603 bool stop_processing_options
= false;
1604 CORE_ADDR offset
= 0;
1609 add_flags
|= SYMFILE_VERBOSE
;
1611 gdb_argv
built_argv (args
);
1612 for (arg
= built_argv
[0], idx
= 0; arg
!= NULL
; arg
= built_argv
[++idx
])
1614 if (stop_processing_options
|| *arg
!= '-')
1619 error (_("Unrecognized argument \"%s\""), arg
);
1621 else if (strcmp (arg
, "-readnow") == 0)
1622 flags
|= OBJF_READNOW
;
1623 else if (strcmp (arg
, "-readnever") == 0)
1624 flags
|= OBJF_READNEVER
;
1625 else if (strcmp (arg
, "-o") == 0)
1627 arg
= built_argv
[++idx
];
1629 error (_("Missing argument to -o"));
1631 offset
= parse_and_eval_address (arg
);
1633 else if (strcmp (arg
, "--") == 0)
1634 stop_processing_options
= true;
1636 error (_("Unrecognized argument \"%s\""), arg
);
1640 error (_("no symbol file name was specified"));
1642 validate_readnow_readnever (flags
);
1644 /* Set SYMFILE_DEFER_BP_RESET because the proper displacement for a PIE
1645 (Position Independent Executable) main symbol file will only be
1646 computed by the solib_create_inferior_hook below. Without it,
1647 breakpoint_re_set would fail to insert the breakpoints with the zero
1649 add_flags
|= SYMFILE_DEFER_BP_RESET
;
1651 symbol_file_add_main_1 (name
, add_flags
, flags
, offset
);
1653 solib_create_inferior_hook (from_tty
);
1655 /* Now it's safe to re-add the breakpoints. */
1656 breakpoint_re_set ();
1660 /* Set the initial language. */
1663 set_initial_language (void)
1665 if (language_mode
== language_mode_manual
)
1667 enum language lang
= main_language ();
1668 /* Make C the default language. */
1669 enum language default_lang
= language_c
;
1671 if (lang
== language_unknown
)
1673 const char *name
= main_name ();
1675 = lookup_symbol_in_language (name
, NULL
, VAR_DOMAIN
, default_lang
,
1679 lang
= sym
->language ();
1682 if (lang
== language_unknown
)
1684 lang
= default_lang
;
1687 set_language (lang
);
1688 expected_language
= current_language
; /* Don't warn the user. */
1691 /* Open the file specified by NAME and hand it off to BFD for
1692 preliminary analysis. Return a newly initialized bfd *, which
1693 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1694 absolute). In case of trouble, error() is called. */
1697 symfile_bfd_open (const char *name
)
1701 gdb::unique_xmalloc_ptr
<char> absolute_name
;
1702 if (!is_target_filename (name
))
1704 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1706 /* Look down path for it, allocate 2nd new malloc'd copy. */
1707 desc
= openp (getenv ("PATH"),
1708 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1709 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1710 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1713 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1715 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1716 desc
= openp (getenv ("PATH"),
1717 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1718 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1722 perror_with_name (expanded_name
.get ());
1724 name
= absolute_name
.get ();
1727 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1728 if (sym_bfd
== NULL
)
1729 error (_("`%s': can't open to read symbols: %s."), name
,
1730 bfd_errmsg (bfd_get_error ()));
1732 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1733 bfd_set_cacheable (sym_bfd
.get (), 1);
1735 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1736 error (_("`%s': can't read symbols: %s."), name
,
1737 bfd_errmsg (bfd_get_error ()));
1742 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1743 the section was not found. */
1746 get_section_index (struct objfile
*objfile
, const char *section_name
)
1748 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1756 /* Link SF into the global symtab_fns list.
1757 FLAVOUR is the file format that SF handles.
1758 Called on startup by the _initialize routine in each object file format
1759 reader, to register information about each format the reader is prepared
1763 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1765 symtab_fns
.emplace_back (flavour
, sf
);
1768 /* Initialize OBJFILE to read symbols from its associated BFD. It
1769 either returns or calls error(). The result is an initialized
1770 struct sym_fns in the objfile structure, that contains cached
1771 information about the symbol file. */
1773 static const struct sym_fns
*
1774 find_sym_fns (bfd
*abfd
)
1776 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1778 if (our_flavour
== bfd_target_srec_flavour
1779 || our_flavour
== bfd_target_ihex_flavour
1780 || our_flavour
== bfd_target_tekhex_flavour
)
1781 return NULL
; /* No symbols. */
1783 for (const registered_sym_fns
&rsf
: symtab_fns
)
1784 if (our_flavour
== rsf
.sym_flavour
)
1787 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1788 bfd_get_target (abfd
));
1792 /* This function runs the load command of our current target. */
1795 load_command (const char *arg
, int from_tty
)
1799 /* The user might be reloading because the binary has changed. Take
1800 this opportunity to check. */
1801 reopen_exec_file ();
1807 const char *parg
, *prev
;
1809 arg
= get_exec_file (1);
1811 /* We may need to quote this string so buildargv can pull it
1814 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1816 temp
.append (prev
, parg
- prev
);
1818 temp
.push_back ('\\');
1820 /* If we have not copied anything yet, then we didn't see a
1821 character to quote, and we can just leave ARG unchanged. */
1825 arg
= temp
.c_str ();
1829 target_load (arg
, from_tty
);
1831 /* After re-loading the executable, we don't really know which
1832 overlays are mapped any more. */
1833 overlay_cache_invalid
= 1;
1836 /* This version of "load" should be usable for any target. Currently
1837 it is just used for remote targets, not inftarg.c or core files,
1838 on the theory that only in that case is it useful.
1840 Avoiding xmodem and the like seems like a win (a) because we don't have
1841 to worry about finding it, and (b) On VMS, fork() is very slow and so
1842 we don't want to run a subprocess. On the other hand, I'm not sure how
1843 performance compares. */
1845 static int validate_download
= 0;
1847 /* Opaque data for load_progress. */
1848 struct load_progress_data
1850 /* Cumulative data. */
1851 unsigned long write_count
= 0;
1852 unsigned long data_count
= 0;
1853 bfd_size_type total_size
= 0;
1856 /* Opaque data for load_progress for a single section. */
1857 struct load_progress_section_data
1859 load_progress_section_data (load_progress_data
*cumulative_
,
1860 const char *section_name_
, ULONGEST section_size_
,
1861 CORE_ADDR lma_
, gdb_byte
*buffer_
)
1862 : cumulative (cumulative_
), section_name (section_name_
),
1863 section_size (section_size_
), lma (lma_
), buffer (buffer_
)
1866 struct load_progress_data
*cumulative
;
1868 /* Per-section data. */
1869 const char *section_name
;
1870 ULONGEST section_sent
= 0;
1871 ULONGEST section_size
;
1876 /* Opaque data for load_section_callback. */
1877 struct load_section_data
1879 load_section_data (load_progress_data
*progress_data_
)
1880 : progress_data (progress_data_
)
1883 ~load_section_data ()
1885 for (auto &&request
: requests
)
1887 xfree (request
.data
);
1888 delete ((load_progress_section_data
*) request
.baton
);
1892 CORE_ADDR load_offset
= 0;
1893 struct load_progress_data
*progress_data
;
1894 std::vector
<struct memory_write_request
> requests
;
1897 /* Target write callback routine for progress reporting. */
1900 load_progress (ULONGEST bytes
, void *untyped_arg
)
1902 struct load_progress_section_data
*args
1903 = (struct load_progress_section_data
*) untyped_arg
;
1904 struct load_progress_data
*totals
;
1907 /* Writing padding data. No easy way to get at the cumulative
1908 stats, so just ignore this. */
1911 totals
= args
->cumulative
;
1913 if (bytes
== 0 && args
->section_sent
== 0)
1915 /* The write is just starting. Let the user know we've started
1917 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1919 hex_string (args
->section_size
),
1920 paddress (target_gdbarch (), args
->lma
));
1924 if (validate_download
)
1926 /* Broken memories and broken monitors manifest themselves here
1927 when bring new computers to life. This doubles already slow
1929 /* NOTE: cagney/1999-10-18: A more efficient implementation
1930 might add a verify_memory() method to the target vector and
1931 then use that. remote.c could implement that method using
1932 the ``qCRC'' packet. */
1933 gdb::byte_vector
check (bytes
);
1935 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1936 error (_("Download verify read failed at %s"),
1937 paddress (target_gdbarch (), args
->lma
));
1938 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1939 error (_("Download verify compare failed at %s"),
1940 paddress (target_gdbarch (), args
->lma
));
1942 totals
->data_count
+= bytes
;
1944 args
->buffer
+= bytes
;
1945 totals
->write_count
+= 1;
1946 args
->section_sent
+= bytes
;
1947 if (check_quit_flag ()
1948 || (deprecated_ui_load_progress_hook
!= NULL
1949 && deprecated_ui_load_progress_hook (args
->section_name
,
1950 args
->section_sent
)))
1951 error (_("Canceled the download"));
1953 if (deprecated_show_load_progress
!= NULL
)
1954 deprecated_show_load_progress (args
->section_name
,
1958 totals
->total_size
);
1961 /* Service function for generic_load. */
1964 load_one_section (bfd
*abfd
, asection
*asec
,
1965 struct load_section_data
*args
)
1967 bfd_size_type size
= bfd_section_size (asec
);
1968 const char *sect_name
= bfd_section_name (asec
);
1970 if ((bfd_section_flags (asec
) & SEC_LOAD
) == 0)
1976 ULONGEST begin
= bfd_section_lma (asec
) + args
->load_offset
;
1977 ULONGEST end
= begin
+ size
;
1978 gdb_byte
*buffer
= (gdb_byte
*) xmalloc (size
);
1979 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1981 load_progress_section_data
*section_data
1982 = new load_progress_section_data (args
->progress_data
, sect_name
, size
,
1985 args
->requests
.emplace_back (begin
, end
, buffer
, section_data
);
1988 static void print_transfer_performance (struct ui_file
*stream
,
1989 unsigned long data_count
,
1990 unsigned long write_count
,
1991 std::chrono::steady_clock::duration d
);
1993 /* See symfile.h. */
1996 generic_load (const char *args
, int from_tty
)
1998 struct load_progress_data total_progress
;
1999 struct load_section_data
cbdata (&total_progress
);
2000 struct ui_out
*uiout
= current_uiout
;
2003 error_no_arg (_("file to load"));
2005 gdb_argv
argv (args
);
2007 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2009 if (argv
[1] != NULL
)
2013 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2015 /* If the last word was not a valid number then
2016 treat it as a file name with spaces in. */
2017 if (argv
[1] == endptr
)
2018 error (_("Invalid download offset:%s."), argv
[1]);
2020 if (argv
[2] != NULL
)
2021 error (_("Too many parameters."));
2024 /* Open the file for loading. */
2025 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
));
2026 if (loadfile_bfd
== NULL
)
2027 perror_with_name (filename
.get ());
2029 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2031 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2032 bfd_errmsg (bfd_get_error ()));
2035 for (asection
*asec
: gdb_bfd_sections (loadfile_bfd
))
2036 total_progress
.total_size
+= bfd_section_size (asec
);
2038 for (asection
*asec
: gdb_bfd_sections (loadfile_bfd
))
2039 load_one_section (loadfile_bfd
.get (), asec
, &cbdata
);
2041 using namespace std::chrono
;
2043 steady_clock::time_point start_time
= steady_clock::now ();
2045 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2046 load_progress
) != 0)
2047 error (_("Load failed"));
2049 steady_clock::time_point end_time
= steady_clock::now ();
2051 CORE_ADDR entry
= bfd_get_start_address (loadfile_bfd
.get ());
2052 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2053 uiout
->text ("Start address ");
2054 uiout
->field_core_addr ("address", target_gdbarch (), entry
);
2055 uiout
->text (", load size ");
2056 uiout
->field_unsigned ("load-size", total_progress
.data_count
);
2058 regcache_write_pc (get_current_regcache (), entry
);
2060 /* Reset breakpoints, now that we have changed the load image. For
2061 instance, breakpoints may have been set (or reset, by
2062 post_create_inferior) while connected to the target but before we
2063 loaded the program. In that case, the prologue analyzer could
2064 have read instructions from the target to find the right
2065 breakpoint locations. Loading has changed the contents of that
2068 breakpoint_re_set ();
2070 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2071 total_progress
.write_count
,
2072 end_time
- start_time
);
2075 /* Report on STREAM the performance of a memory transfer operation,
2076 such as 'load'. DATA_COUNT is the number of bytes transferred.
2077 WRITE_COUNT is the number of separate write operations, or 0, if
2078 that information is not available. TIME is how long the operation
2082 print_transfer_performance (struct ui_file
*stream
,
2083 unsigned long data_count
,
2084 unsigned long write_count
,
2085 std::chrono::steady_clock::duration time
)
2087 using namespace std::chrono
;
2088 struct ui_out
*uiout
= current_uiout
;
2090 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2092 uiout
->text ("Transfer rate: ");
2093 if (ms
.count () > 0)
2095 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2097 if (uiout
->is_mi_like_p ())
2099 uiout
->field_unsigned ("transfer-rate", rate
* 8);
2100 uiout
->text (" bits/sec");
2102 else if (rate
< 1024)
2104 uiout
->field_unsigned ("transfer-rate", rate
);
2105 uiout
->text (" bytes/sec");
2109 uiout
->field_unsigned ("transfer-rate", rate
/ 1024);
2110 uiout
->text (" KB/sec");
2115 uiout
->field_unsigned ("transferred-bits", (data_count
* 8));
2116 uiout
->text (" bits in <1 sec");
2118 if (write_count
> 0)
2121 uiout
->field_unsigned ("write-rate", data_count
/ write_count
);
2122 uiout
->text (" bytes/write");
2124 uiout
->text (".\n");
2127 /* Add an OFFSET to the start address of each section in OBJF, except
2128 sections that were specified in ADDRS. */
2131 set_objfile_default_section_offset (struct objfile
*objf
,
2132 const section_addr_info
&addrs
,
2135 /* Add OFFSET to all sections by default. */
2136 section_offsets
offsets (objf
->section_offsets
.size (), offset
);
2138 /* Create sorted lists of all sections in ADDRS as well as all
2139 sections in OBJF. */
2141 std::vector
<const struct other_sections
*> addrs_sorted
2142 = addrs_section_sort (addrs
);
2144 section_addr_info objf_addrs
2145 = build_section_addr_info_from_objfile (objf
);
2146 std::vector
<const struct other_sections
*> objf_addrs_sorted
2147 = addrs_section_sort (objf_addrs
);
2149 /* Walk the BFD section list, and if a matching section is found in
2150 ADDRS_SORTED_LIST, set its offset to zero to keep its address
2153 Note that both lists may contain multiple sections with the same
2154 name, and then the sections from ADDRS are matched in BFD order
2155 (thanks to sectindex). */
2157 std::vector
<const struct other_sections
*>::iterator addrs_sorted_iter
2158 = addrs_sorted
.begin ();
2159 for (const other_sections
*objf_sect
: objf_addrs_sorted
)
2161 const char *objf_name
= addr_section_name (objf_sect
->name
.c_str ());
2164 while (cmp
< 0 && addrs_sorted_iter
!= addrs_sorted
.end ())
2166 const struct other_sections
*sect
= *addrs_sorted_iter
;
2167 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
2168 cmp
= strcmp (sect_name
, objf_name
);
2170 ++addrs_sorted_iter
;
2174 offsets
[objf_sect
->sectindex
] = 0;
2177 /* Apply the new section offsets. */
2178 objfile_relocate (objf
, offsets
);
2181 /* This function allows the addition of incrementally linked object files.
2182 It does not modify any state in the target, only in the debugger. */
2185 add_symbol_file_command (const char *args
, int from_tty
)
2187 struct gdbarch
*gdbarch
= get_current_arch ();
2188 gdb::unique_xmalloc_ptr
<char> filename
;
2191 struct objfile
*objf
;
2192 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2193 symfile_add_flags add_flags
= 0;
2196 add_flags
|= SYMFILE_VERBOSE
;
2204 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2205 bool stop_processing_options
= false;
2206 CORE_ADDR offset
= 0;
2211 error (_("add-symbol-file takes a file name and an address"));
2213 bool seen_addr
= false;
2214 bool seen_offset
= false;
2215 gdb_argv
argv (args
);
2217 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2219 if (stop_processing_options
|| *arg
!= '-')
2221 if (filename
== NULL
)
2223 /* First non-option argument is always the filename. */
2224 filename
.reset (tilde_expand (arg
));
2226 else if (!seen_addr
)
2228 /* The second non-option argument is always the text
2229 address at which to load the program. */
2230 sect_opts
[0].value
= arg
;
2234 error (_("Unrecognized argument \"%s\""), arg
);
2236 else if (strcmp (arg
, "-readnow") == 0)
2237 flags
|= OBJF_READNOW
;
2238 else if (strcmp (arg
, "-readnever") == 0)
2239 flags
|= OBJF_READNEVER
;
2240 else if (strcmp (arg
, "-s") == 0)
2242 if (argv
[argcnt
+ 1] == NULL
)
2243 error (_("Missing section name after \"-s\""));
2244 else if (argv
[argcnt
+ 2] == NULL
)
2245 error (_("Missing section address after \"-s\""));
2247 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2249 sect_opts
.push_back (sect
);
2252 else if (strcmp (arg
, "-o") == 0)
2254 arg
= argv
[++argcnt
];
2256 error (_("Missing argument to -o"));
2258 offset
= parse_and_eval_address (arg
);
2261 else if (strcmp (arg
, "--") == 0)
2262 stop_processing_options
= true;
2264 error (_("Unrecognized argument \"%s\""), arg
);
2267 if (filename
== NULL
)
2268 error (_("You must provide a filename to be loaded."));
2270 validate_readnow_readnever (flags
);
2272 /* Print the prompt for the query below. And save the arguments into
2273 a sect_addr_info structure to be passed around to other
2274 functions. We have to split this up into separate print
2275 statements because hex_string returns a local static
2278 printf_unfiltered (_("add symbol table from file \"%s\""),
2280 section_addr_info section_addrs
;
2281 std::vector
<sect_opt
>::const_iterator it
= sect_opts
.begin ();
2284 for (; it
!= sect_opts
.end (); ++it
)
2287 const char *val
= it
->value
;
2288 const char *sec
= it
->name
;
2290 if (section_addrs
.empty ())
2291 printf_unfiltered (_(" at\n"));
2292 addr
= parse_and_eval_address (val
);
2294 /* Here we store the section offsets in the order they were
2295 entered on the command line. Every array element is
2296 assigned an ascending section index to preserve the above
2297 order over an unstable sorting algorithm. This dummy
2298 index is not used for any other purpose.
2300 section_addrs
.emplace_back (addr
, sec
, section_addrs
.size ());
2301 printf_filtered ("\t%s_addr = %s\n", sec
,
2302 paddress (gdbarch
, addr
));
2304 /* The object's sections are initialized when a
2305 call is made to build_objfile_section_table (objfile).
2306 This happens in reread_symbols.
2307 At this point, we don't know what file type this is,
2308 so we can't determine what section names are valid. */
2311 printf_unfiltered (_("%s offset by %s\n"),
2312 (section_addrs
.empty ()
2313 ? _(" with all sections")
2314 : _("with other sections")),
2315 paddress (gdbarch
, offset
));
2316 else if (section_addrs
.empty ())
2317 printf_unfiltered ("\n");
2319 if (from_tty
&& (!query ("%s", "")))
2320 error (_("Not confirmed."));
2322 objf
= symbol_file_add (filename
.get (), add_flags
, §ion_addrs
,
2324 if (!objfile_has_symbols (objf
) && objf
->per_bfd
->minimal_symbol_count
<= 0)
2325 warning (_("newly-added symbol file \"%s\" does not provide any symbols"),
2329 set_objfile_default_section_offset (objf
, section_addrs
, offset
);
2331 current_program_space
->add_target_sections (objf
);
2333 /* Getting new symbols may change our opinion about what is
2335 reinit_frame_cache ();
2339 /* This function removes a symbol file that was added via add-symbol-file. */
2342 remove_symbol_file_command (const char *args
, int from_tty
)
2344 struct objfile
*objf
= NULL
;
2345 struct program_space
*pspace
= current_program_space
;
2350 error (_("remove-symbol-file: no symbol file provided"));
2352 gdb_argv
argv (args
);
2354 if (strcmp (argv
[0], "-a") == 0)
2356 /* Interpret the next argument as an address. */
2359 if (argv
[1] == NULL
)
2360 error (_("Missing address argument"));
2362 if (argv
[2] != NULL
)
2363 error (_("Junk after %s"), argv
[1]);
2365 addr
= parse_and_eval_address (argv
[1]);
2367 for (objfile
*objfile
: current_program_space
->objfiles ())
2369 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2370 && (objfile
->flags
& OBJF_SHARED
) != 0
2371 && objfile
->pspace
== pspace
2372 && is_addr_in_objfile (addr
, objfile
))
2379 else if (argv
[0] != NULL
)
2381 /* Interpret the current argument as a file name. */
2383 if (argv
[1] != NULL
)
2384 error (_("Junk after %s"), argv
[0]);
2386 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2388 for (objfile
*objfile
: current_program_space
->objfiles ())
2390 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2391 && (objfile
->flags
& OBJF_SHARED
) != 0
2392 && objfile
->pspace
== pspace
2393 && filename_cmp (filename
.get (), objfile_name (objfile
)) == 0)
2402 error (_("No symbol file found"));
2405 && !query (_("Remove symbol table from file \"%s\"? "),
2406 objfile_name (objf
)))
2407 error (_("Not confirmed."));
2410 clear_symtab_users (0);
2413 /* Re-read symbols if a symbol-file has changed. */
2416 reread_symbols (void)
2419 struct stat new_statbuf
;
2421 std::vector
<struct objfile
*> new_objfiles
;
2423 for (objfile
*objfile
: current_program_space
->objfiles ())
2425 if (objfile
->obfd
== NULL
)
2428 /* Separate debug objfiles are handled in the main objfile. */
2429 if (objfile
->separate_debug_objfile_backlink
)
2432 /* If this object is from an archive (what you usually create with
2433 `ar', often called a `static library' on most systems, though
2434 a `shared library' on AIX is also an archive), then you should
2435 stat on the archive name, not member name. */
2436 if (objfile
->obfd
->my_archive
)
2437 res
= stat (bfd_get_filename (objfile
->obfd
->my_archive
), &new_statbuf
);
2439 res
= stat (objfile_name (objfile
), &new_statbuf
);
2442 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2443 printf_filtered (_("`%s' has disappeared; keeping its symbols.\n"),
2444 objfile_name (objfile
));
2447 new_modtime
= new_statbuf
.st_mtime
;
2448 if (new_modtime
!= objfile
->mtime
)
2450 printf_filtered (_("`%s' has changed; re-reading symbols.\n"),
2451 objfile_name (objfile
));
2453 /* There are various functions like symbol_file_add,
2454 symfile_bfd_open, syms_from_objfile, etc., which might
2455 appear to do what we want. But they have various other
2456 effects which we *don't* want. So we just do stuff
2457 ourselves. We don't worry about mapped files (for one thing,
2458 any mapped file will be out of date). */
2460 /* If we get an error, blow away this objfile (not sure if
2461 that is the correct response for things like shared
2463 objfile_up
objfile_holder (objfile
);
2465 /* We need to do this whenever any symbols go away. */
2466 clear_symtab_users_cleanup
defer_clear_users (0);
2468 if (current_program_space
->exec_bfd () != NULL
2469 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2470 bfd_get_filename (current_program_space
->exec_bfd ())) == 0)
2472 /* Reload EXEC_BFD without asking anything. */
2474 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2477 /* Keep the calls order approx. the same as in free_objfile. */
2479 /* Free the separate debug objfiles. It will be
2480 automatically recreated by sym_read. */
2481 free_objfile_separate_debug (objfile
);
2483 /* Clear the stale source cache. */
2484 forget_cached_source_info ();
2486 /* Remove any references to this objfile in the global
2488 preserve_values (objfile
);
2490 /* Nuke all the state that we will re-read. Much of the following
2491 code which sets things to NULL really is necessary to tell
2492 other parts of GDB that there is nothing currently there.
2494 Try to keep the freeing order compatible with free_objfile. */
2496 if (objfile
->sf
!= NULL
)
2498 (*objfile
->sf
->sym_finish
) (objfile
);
2501 clear_objfile_data (objfile
);
2503 /* Clean up any state BFD has sitting around. */
2505 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2506 const char *obfd_filename
;
2508 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2509 /* Open the new BFD before freeing the old one, so that
2510 the filename remains live. */
2511 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
));
2512 objfile
->obfd
= temp
.release ();
2513 if (objfile
->obfd
== NULL
)
2514 error (_("Can't open %s to read symbols."), obfd_filename
);
2517 std::string original_name
= objfile
->original_name
;
2519 /* bfd_openr sets cacheable to true, which is what we want. */
2520 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2521 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2522 bfd_errmsg (bfd_get_error ()));
2524 /* NB: after this call to obstack_free, objfiles_changed
2525 will need to be called (see discussion below). */
2526 obstack_free (&objfile
->objfile_obstack
, 0);
2527 objfile
->sections
= NULL
;
2528 objfile
->section_offsets
.clear ();
2529 objfile
->sect_index_bss
= -1;
2530 objfile
->sect_index_data
= -1;
2531 objfile
->sect_index_rodata
= -1;
2532 objfile
->sect_index_text
= -1;
2533 objfile
->compunit_symtabs
= NULL
;
2534 objfile
->template_symbols
= NULL
;
2535 objfile
->static_links
.reset (nullptr);
2537 /* obstack_init also initializes the obstack so it is
2538 empty. We could use obstack_specify_allocation but
2539 gdb_obstack.h specifies the alloc/dealloc functions. */
2540 obstack_init (&objfile
->objfile_obstack
);
2542 /* set_objfile_per_bfd potentially allocates the per-bfd
2543 data on the objfile's obstack (if sharing data across
2544 multiple users is not possible), so it's important to
2545 do it *after* the obstack has been initialized. */
2546 set_objfile_per_bfd (objfile
);
2548 objfile
->original_name
2549 = obstack_strdup (&objfile
->objfile_obstack
, original_name
);
2551 /* Reset the sym_fns pointer. The ELF reader can change it
2552 based on whether .gdb_index is present, and we need it to
2553 start over. PR symtab/15885 */
2554 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2555 objfile
->reset_psymtabs ();
2556 objfile
->qf
= make_psymbol_functions (objfile
->partial_symtabs
);
2558 build_objfile_section_table (objfile
);
2560 /* What the hell is sym_new_init for, anyway? The concept of
2561 distinguishing between the main file and additional files
2562 in this way seems rather dubious. */
2563 if (objfile
== current_program_space
->symfile_object_file
)
2565 (*objfile
->sf
->sym_new_init
) (objfile
);
2568 (*objfile
->sf
->sym_init
) (objfile
);
2569 clear_complaints ();
2571 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2573 /* We are about to read new symbols and potentially also
2574 DWARF information. Some targets may want to pass addresses
2575 read from DWARF DIE's through an adjustment function before
2576 saving them, like MIPS, which may call into
2577 "find_pc_section". When called, that function will make
2578 use of per-objfile program space data.
2580 Since we discarded our section information above, we have
2581 dangling pointers in the per-objfile program space data
2582 structure. Force GDB to update the section mapping
2583 information by letting it know the objfile has changed,
2584 making the dangling pointers point to correct data
2587 objfiles_changed ();
2589 /* Recompute section offsets and section indices. */
2590 objfile
->sf
->sym_offsets (objfile
, {});
2592 read_symbols (objfile
, 0);
2594 if (!objfile_has_symbols (objfile
))
2597 printf_filtered (_("(no debugging symbols found)\n"));
2601 /* We're done reading the symbol file; finish off complaints. */
2602 clear_complaints ();
2604 /* Getting new symbols may change our opinion about what is
2607 reinit_frame_cache ();
2609 /* Discard cleanups as symbol reading was successful. */
2610 objfile_holder
.release ();
2611 defer_clear_users
.release ();
2613 /* If the mtime has changed between the time we set new_modtime
2614 and now, we *want* this to be out of date, so don't call stat
2616 objfile
->mtime
= new_modtime
;
2617 init_entry_point_info (objfile
);
2619 new_objfiles
.push_back (objfile
);
2623 if (!new_objfiles
.empty ())
2625 clear_symtab_users (0);
2627 /* clear_objfile_data for each objfile was called before freeing it and
2628 gdb::observers::new_objfile.notify (NULL) has been called by
2629 clear_symtab_users above. Notify the new files now. */
2630 for (auto iter
: new_objfiles
)
2631 gdb::observers::new_objfile
.notify (iter
);
2633 /* At least one objfile has changed, so we can consider that
2634 the executable we're debugging has changed too. */
2635 gdb::observers::executable_changed
.notify ();
2640 struct filename_language
2642 filename_language (const std::string
&ext_
, enum language lang_
)
2643 : ext (ext_
), lang (lang_
)
2650 static std::vector
<filename_language
> filename_language_table
;
2652 /* See symfile.h. */
2655 add_filename_language (const char *ext
, enum language lang
)
2657 gdb_assert (ext
!= nullptr);
2658 filename_language_table
.emplace_back (ext
, lang
);
2661 static char *ext_args
;
2663 show_ext_args (struct ui_file
*file
, int from_tty
,
2664 struct cmd_list_element
*c
, const char *value
)
2666 fprintf_filtered (file
,
2667 _("Mapping between filename extension "
2668 "and source language is \"%s\".\n"),
2673 set_ext_lang_command (const char *args
,
2674 int from_tty
, struct cmd_list_element
*e
)
2676 char *cp
= ext_args
;
2679 /* First arg is filename extension, starting with '.' */
2681 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2683 /* Find end of first arg. */
2684 while (*cp
&& !isspace (*cp
))
2688 error (_("'%s': two arguments required -- "
2689 "filename extension and language"),
2692 /* Null-terminate first arg. */
2695 /* Find beginning of second arg, which should be a source language. */
2696 cp
= skip_spaces (cp
);
2699 error (_("'%s': two arguments required -- "
2700 "filename extension and language"),
2703 /* Lookup the language from among those we know. */
2704 lang
= language_enum (cp
);
2706 auto it
= filename_language_table
.begin ();
2707 /* Now lookup the filename extension: do we already know it? */
2708 for (; it
!= filename_language_table
.end (); it
++)
2710 if (it
->ext
== ext_args
)
2714 if (it
== filename_language_table
.end ())
2716 /* New file extension. */
2717 add_filename_language (ext_args
, lang
);
2721 /* Redefining a previously known filename extension. */
2724 /* query ("Really make files of type %s '%s'?", */
2725 /* ext_args, language_str (lang)); */
2732 info_ext_lang_command (const char *args
, int from_tty
)
2734 printf_filtered (_("Filename extensions and the languages they represent:"));
2735 printf_filtered ("\n\n");
2736 for (const filename_language
&entry
: filename_language_table
)
2737 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2738 language_str (entry
.lang
));
2742 deduce_language_from_filename (const char *filename
)
2746 if (filename
!= NULL
)
2747 if ((cp
= strrchr (filename
, '.')) != NULL
)
2749 for (const filename_language
&entry
: filename_language_table
)
2750 if (entry
.ext
== cp
)
2754 return language_unknown
;
2757 /* Allocate and initialize a new symbol table.
2758 CUST is from the result of allocate_compunit_symtab. */
2761 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2763 struct objfile
*objfile
= cust
->objfile
;
2764 struct symtab
*symtab
2765 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2767 symtab
->filename
= objfile
->intern (filename
);
2768 symtab
->fullname
= NULL
;
2769 symtab
->language
= deduce_language_from_filename (filename
);
2771 /* This can be very verbose with lots of headers.
2772 Only print at higher debug levels. */
2773 if (symtab_create_debug
>= 2)
2775 /* Be a bit clever with debugging messages, and don't print objfile
2776 every time, only when it changes. */
2777 static char *last_objfile_name
= NULL
;
2779 if (last_objfile_name
== NULL
2780 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2782 xfree (last_objfile_name
);
2783 last_objfile_name
= xstrdup (objfile_name (objfile
));
2784 fprintf_filtered (gdb_stdlog
,
2785 "Creating one or more symtabs for objfile %s ...\n",
2788 fprintf_filtered (gdb_stdlog
,
2789 "Created symtab %s for module %s.\n",
2790 host_address_to_string (symtab
), filename
);
2793 /* Add it to CUST's list of symtabs. */
2794 if (cust
->filetabs
== NULL
)
2796 cust
->filetabs
= symtab
;
2797 cust
->last_filetab
= symtab
;
2801 cust
->last_filetab
->next
= symtab
;
2802 cust
->last_filetab
= symtab
;
2805 /* Backlink to the containing compunit symtab. */
2806 symtab
->compunit_symtab
= cust
;
2811 /* Allocate and initialize a new compunit.
2812 NAME is the name of the main source file, if there is one, or some
2813 descriptive text if there are no source files. */
2815 struct compunit_symtab
*
2816 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2818 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2819 struct compunit_symtab
);
2820 const char *saved_name
;
2822 cu
->objfile
= objfile
;
2824 /* The name we record here is only for display/debugging purposes.
2825 Just save the basename to avoid path issues (too long for display,
2826 relative vs absolute, etc.). */
2827 saved_name
= lbasename (name
);
2828 cu
->name
= obstack_strdup (&objfile
->objfile_obstack
, saved_name
);
2830 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2832 if (symtab_create_debug
)
2834 fprintf_filtered (gdb_stdlog
,
2835 "Created compunit symtab %s for %s.\n",
2836 host_address_to_string (cu
),
2843 /* Hook CU to the objfile it comes from. */
2846 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2848 cu
->next
= cu
->objfile
->compunit_symtabs
;
2849 cu
->objfile
->compunit_symtabs
= cu
;
2853 /* Reset all data structures in gdb which may contain references to
2854 symbol table data. */
2857 clear_symtab_users (symfile_add_flags add_flags
)
2859 /* Someday, we should do better than this, by only blowing away
2860 the things that really need to be blown. */
2862 /* Clear the "current" symtab first, because it is no longer valid.
2863 breakpoint_re_set may try to access the current symtab. */
2864 clear_current_source_symtab_and_line ();
2867 clear_last_displayed_sal ();
2868 clear_pc_function_cache ();
2869 gdb::observers::new_objfile
.notify (NULL
);
2871 /* Varobj may refer to old symbols, perform a cleanup. */
2872 varobj_invalidate ();
2874 /* Now that the various caches have been cleared, we can re_set
2875 our breakpoints without risking it using stale data. */
2876 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2877 breakpoint_re_set ();
2881 The following code implements an abstraction for debugging overlay sections.
2883 The target model is as follows:
2884 1) The gnu linker will permit multiple sections to be mapped into the
2885 same VMA, each with its own unique LMA (or load address).
2886 2) It is assumed that some runtime mechanism exists for mapping the
2887 sections, one by one, from the load address into the VMA address.
2888 3) This code provides a mechanism for gdb to keep track of which
2889 sections should be considered to be mapped from the VMA to the LMA.
2890 This information is used for symbol lookup, and memory read/write.
2891 For instance, if a section has been mapped then its contents
2892 should be read from the VMA, otherwise from the LMA.
2894 Two levels of debugger support for overlays are available. One is
2895 "manual", in which the debugger relies on the user to tell it which
2896 overlays are currently mapped. This level of support is
2897 implemented entirely in the core debugger, and the information about
2898 whether a section is mapped is kept in the objfile->obj_section table.
2900 The second level of support is "automatic", and is only available if
2901 the target-specific code provides functionality to read the target's
2902 overlay mapping table, and translate its contents for the debugger
2903 (by updating the mapped state information in the obj_section tables).
2905 The interface is as follows:
2907 overlay map <name> -- tell gdb to consider this section mapped
2908 overlay unmap <name> -- tell gdb to consider this section unmapped
2909 overlay list -- list the sections that GDB thinks are mapped
2910 overlay read-target -- get the target's state of what's mapped
2911 overlay off/manual/auto -- set overlay debugging state
2912 Functional interface:
2913 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2914 section, return that section.
2915 find_pc_overlay(pc): find any overlay section that contains
2916 the pc, either in its VMA or its LMA
2917 section_is_mapped(sect): true if overlay is marked as mapped
2918 section_is_overlay(sect): true if section's VMA != LMA
2919 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2920 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2921 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2922 overlay_mapped_address(...): map an address from section's LMA to VMA
2923 overlay_unmapped_address(...): map an address from section's VMA to LMA
2924 symbol_overlayed_address(...): Return a "current" address for symbol:
2925 either in VMA or LMA depending on whether
2926 the symbol's section is currently mapped. */
2928 /* Overlay debugging state: */
2930 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2931 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2933 /* Function: section_is_overlay (SECTION)
2934 Returns true if SECTION has VMA not equal to LMA, ie.
2935 SECTION is loaded at an address different from where it will "run". */
2938 section_is_overlay (struct obj_section
*section
)
2940 if (overlay_debugging
&& section
)
2942 asection
*bfd_section
= section
->the_bfd_section
;
2944 if (bfd_section_lma (bfd_section
) != 0
2945 && bfd_section_lma (bfd_section
) != bfd_section_vma (bfd_section
))
2952 /* Function: overlay_invalidate_all (void)
2953 Invalidate the mapped state of all overlay sections (mark it as stale). */
2956 overlay_invalidate_all (void)
2958 struct obj_section
*sect
;
2960 for (objfile
*objfile
: current_program_space
->objfiles ())
2961 ALL_OBJFILE_OSECTIONS (objfile
, sect
)
2962 if (section_is_overlay (sect
))
2963 sect
->ovly_mapped
= -1;
2966 /* Function: section_is_mapped (SECTION)
2967 Returns true if section is an overlay, and is currently mapped.
2969 Access to the ovly_mapped flag is restricted to this function, so
2970 that we can do automatic update. If the global flag
2971 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2972 overlay_invalidate_all. If the mapped state of the particular
2973 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2976 section_is_mapped (struct obj_section
*osect
)
2978 struct gdbarch
*gdbarch
;
2980 if (osect
== 0 || !section_is_overlay (osect
))
2983 switch (overlay_debugging
)
2987 return 0; /* overlay debugging off */
2988 case ovly_auto
: /* overlay debugging automatic */
2989 /* Unles there is a gdbarch_overlay_update function,
2990 there's really nothing useful to do here (can't really go auto). */
2991 gdbarch
= osect
->objfile
->arch ();
2992 if (gdbarch_overlay_update_p (gdbarch
))
2994 if (overlay_cache_invalid
)
2996 overlay_invalidate_all ();
2997 overlay_cache_invalid
= 0;
2999 if (osect
->ovly_mapped
== -1)
3000 gdbarch_overlay_update (gdbarch
, osect
);
3003 case ovly_on
: /* overlay debugging manual */
3004 return osect
->ovly_mapped
== 1;
3008 /* Function: pc_in_unmapped_range
3009 If PC falls into the lma range of SECTION, return true, else false. */
3012 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3014 if (section_is_overlay (section
))
3016 asection
*bfd_section
= section
->the_bfd_section
;
3018 /* We assume the LMA is relocated by the same offset as the VMA. */
3019 bfd_vma size
= bfd_section_size (bfd_section
);
3020 CORE_ADDR offset
= obj_section_offset (section
);
3022 if (bfd_section_lma (bfd_section
) + offset
<= pc
3023 && pc
< bfd_section_lma (bfd_section
) + offset
+ size
)
3030 /* Function: pc_in_mapped_range
3031 If PC falls into the vma range of SECTION, return true, else false. */
3034 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3036 if (section_is_overlay (section
))
3038 if (obj_section_addr (section
) <= pc
3039 && pc
< obj_section_endaddr (section
))
3046 /* Return true if the mapped ranges of sections A and B overlap, false
3050 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3052 CORE_ADDR a_start
= obj_section_addr (a
);
3053 CORE_ADDR a_end
= obj_section_endaddr (a
);
3054 CORE_ADDR b_start
= obj_section_addr (b
);
3055 CORE_ADDR b_end
= obj_section_endaddr (b
);
3057 return (a_start
< b_end
&& b_start
< a_end
);
3060 /* Function: overlay_unmapped_address (PC, SECTION)
3061 Returns the address corresponding to PC in the unmapped (load) range.
3062 May be the same as PC. */
3065 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3067 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3069 asection
*bfd_section
= section
->the_bfd_section
;
3071 return (pc
+ bfd_section_lma (bfd_section
)
3072 - bfd_section_vma (bfd_section
));
3078 /* Function: overlay_mapped_address (PC, SECTION)
3079 Returns the address corresponding to PC in the mapped (runtime) range.
3080 May be the same as PC. */
3083 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3085 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3087 asection
*bfd_section
= section
->the_bfd_section
;
3089 return (pc
+ bfd_section_vma (bfd_section
)
3090 - bfd_section_lma (bfd_section
));
3096 /* Function: symbol_overlayed_address
3097 Return one of two addresses (relative to the VMA or to the LMA),
3098 depending on whether the section is mapped or not. */
3101 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3103 if (overlay_debugging
)
3105 /* If the symbol has no section, just return its regular address. */
3108 /* If the symbol's section is not an overlay, just return its
3110 if (!section_is_overlay (section
))
3112 /* If the symbol's section is mapped, just return its address. */
3113 if (section_is_mapped (section
))
3116 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3117 * then return its LOADED address rather than its vma address!!
3119 return overlay_unmapped_address (address
, section
);
3124 /* Function: find_pc_overlay (PC)
3125 Return the best-match overlay section for PC:
3126 If PC matches a mapped overlay section's VMA, return that section.
3127 Else if PC matches an unmapped section's VMA, return that section.
3128 Else if PC matches an unmapped section's LMA, return that section. */
3130 struct obj_section
*
3131 find_pc_overlay (CORE_ADDR pc
)
3133 struct obj_section
*osect
, *best_match
= NULL
;
3135 if (overlay_debugging
)
3137 for (objfile
*objfile
: current_program_space
->objfiles ())
3138 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3139 if (section_is_overlay (osect
))
3141 if (pc_in_mapped_range (pc
, osect
))
3143 if (section_is_mapped (osect
))
3148 else if (pc_in_unmapped_range (pc
, osect
))
3155 /* Function: find_pc_mapped_section (PC)
3156 If PC falls into the VMA address range of an overlay section that is
3157 currently marked as MAPPED, return that section. Else return NULL. */
3159 struct obj_section
*
3160 find_pc_mapped_section (CORE_ADDR pc
)
3162 struct obj_section
*osect
;
3164 if (overlay_debugging
)
3166 for (objfile
*objfile
: current_program_space
->objfiles ())
3167 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3168 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3175 /* Function: list_overlays_command
3176 Print a list of mapped sections and their PC ranges. */
3179 list_overlays_command (const char *args
, int from_tty
)
3182 struct obj_section
*osect
;
3184 if (overlay_debugging
)
3186 for (objfile
*objfile
: current_program_space
->objfiles ())
3187 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3188 if (section_is_mapped (osect
))
3190 struct gdbarch
*gdbarch
= objfile
->arch ();
3195 vma
= bfd_section_vma (osect
->the_bfd_section
);
3196 lma
= bfd_section_lma (osect
->the_bfd_section
);
3197 size
= bfd_section_size (osect
->the_bfd_section
);
3198 name
= bfd_section_name (osect
->the_bfd_section
);
3200 printf_filtered ("Section %s, loaded at ", name
);
3201 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3202 puts_filtered (" - ");
3203 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3204 printf_filtered (", mapped at ");
3205 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3206 puts_filtered (" - ");
3207 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3208 puts_filtered ("\n");
3214 printf_filtered (_("No sections are mapped.\n"));
3217 /* Function: map_overlay_command
3218 Mark the named section as mapped (ie. residing at its VMA address). */
3221 map_overlay_command (const char *args
, int from_tty
)
3223 struct obj_section
*sec
, *sec2
;
3225 if (!overlay_debugging
)
3226 error (_("Overlay debugging not enabled. Use "
3227 "either the 'overlay auto' or\n"
3228 "the 'overlay manual' command."));
3230 if (args
== 0 || *args
== 0)
3231 error (_("Argument required: name of an overlay section"));
3233 /* First, find a section matching the user supplied argument. */
3234 for (objfile
*obj_file
: current_program_space
->objfiles ())
3235 ALL_OBJFILE_OSECTIONS (obj_file
, sec
)
3236 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3238 /* Now, check to see if the section is an overlay. */
3239 if (!section_is_overlay (sec
))
3240 continue; /* not an overlay section */
3242 /* Mark the overlay as "mapped". */
3243 sec
->ovly_mapped
= 1;
3245 /* Next, make a pass and unmap any sections that are
3246 overlapped by this new section: */
3247 for (objfile
*objfile2
: current_program_space
->objfiles ())
3248 ALL_OBJFILE_OSECTIONS (objfile2
, sec2
)
3249 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
,
3253 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3254 bfd_section_name (sec2
->the_bfd_section
));
3255 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3259 error (_("No overlay section called %s"), args
);
3262 /* Function: unmap_overlay_command
3263 Mark the overlay section as unmapped
3264 (ie. resident in its LMA address range, rather than the VMA range). */
3267 unmap_overlay_command (const char *args
, int from_tty
)
3269 struct obj_section
*sec
= NULL
;
3271 if (!overlay_debugging
)
3272 error (_("Overlay debugging not enabled. "
3273 "Use 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
*objfile
: current_program_space
->objfiles ())
3281 ALL_OBJFILE_OSECTIONS (objfile
, sec
)
3282 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3284 if (!sec
->ovly_mapped
)
3285 error (_("Section %s is not mapped"), args
);
3286 sec
->ovly_mapped
= 0;
3289 error (_("No overlay section called %s"), args
);
3292 /* Function: overlay_auto_command
3293 A utility command to turn on overlay debugging.
3294 Possibly this should be done via a set/show command. */
3297 overlay_auto_command (const char *args
, int from_tty
)
3299 overlay_debugging
= ovly_auto
;
3300 enable_overlay_breakpoints ();
3302 printf_unfiltered (_("Automatic overlay debugging enabled."));
3305 /* Function: overlay_manual_command
3306 A utility command to turn on overlay debugging.
3307 Possibly this should be done via a set/show command. */
3310 overlay_manual_command (const char *args
, int from_tty
)
3312 overlay_debugging
= ovly_on
;
3313 disable_overlay_breakpoints ();
3315 printf_unfiltered (_("Overlay debugging enabled."));
3318 /* Function: overlay_off_command
3319 A utility command to turn on overlay debugging.
3320 Possibly this should be done via a set/show command. */
3323 overlay_off_command (const char *args
, int from_tty
)
3325 overlay_debugging
= ovly_off
;
3326 disable_overlay_breakpoints ();
3328 printf_unfiltered (_("Overlay debugging disabled."));
3332 overlay_load_command (const char *args
, int from_tty
)
3334 struct gdbarch
*gdbarch
= get_current_arch ();
3336 if (gdbarch_overlay_update_p (gdbarch
))
3337 gdbarch_overlay_update (gdbarch
, NULL
);
3339 error (_("This target does not know how to read its overlay state."));
3342 /* Command list chain containing all defined "overlay" subcommands. */
3343 static struct cmd_list_element
*overlaylist
;
3345 /* Target Overlays for the "Simplest" overlay manager:
3347 This is GDB's default target overlay layer. It works with the
3348 minimal overlay manager supplied as an example by Cygnus. The
3349 entry point is via a function pointer "gdbarch_overlay_update",
3350 so targets that use a different runtime overlay manager can
3351 substitute their own overlay_update function and take over the
3354 The overlay_update function pokes around in the target's data structures
3355 to see what overlays are mapped, and updates GDB's overlay mapping with
3358 In this simple implementation, the target data structures are as follows:
3359 unsigned _novlys; /# number of overlay sections #/
3360 unsigned _ovly_table[_novlys][4] = {
3361 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3362 {..., ..., ..., ...},
3364 unsigned _novly_regions; /# number of overlay regions #/
3365 unsigned _ovly_region_table[_novly_regions][3] = {
3366 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3369 These functions will attempt to update GDB's mappedness state in the
3370 symbol section table, based on the target's mappedness state.
3372 To do this, we keep a cached copy of the target's _ovly_table, and
3373 attempt to detect when the cached copy is invalidated. The main
3374 entry point is "simple_overlay_update(SECT), which looks up SECT in
3375 the cached table and re-reads only the entry for that section from
3376 the target (whenever possible). */
3378 /* Cached, dynamically allocated copies of the target data structures: */
3379 static unsigned (*cache_ovly_table
)[4] = 0;
3380 static unsigned cache_novlys
= 0;
3381 static CORE_ADDR cache_ovly_table_base
= 0;
3384 VMA
, OSIZE
, LMA
, MAPPED
3387 /* Throw away the cached copy of _ovly_table. */
3390 simple_free_overlay_table (void)
3392 xfree (cache_ovly_table
);
3394 cache_ovly_table
= NULL
;
3395 cache_ovly_table_base
= 0;
3398 /* Read an array of ints of size SIZE from the target into a local buffer.
3399 Convert to host order. int LEN is number of ints. */
3402 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3403 int len
, int size
, enum bfd_endian byte_order
)
3405 /* FIXME (alloca): Not safe if array is very large. */
3406 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3409 read_memory (memaddr
, buf
, len
* size
);
3410 for (i
= 0; i
< len
; i
++)
3411 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3414 /* Find and grab a copy of the target _ovly_table
3415 (and _novlys, which is needed for the table's size). */
3418 simple_read_overlay_table (void)
3420 struct bound_minimal_symbol novlys_msym
;
3421 struct bound_minimal_symbol ovly_table_msym
;
3422 struct gdbarch
*gdbarch
;
3424 enum bfd_endian byte_order
;
3426 simple_free_overlay_table ();
3427 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3428 if (! novlys_msym
.minsym
)
3430 error (_("Error reading inferior's overlay table: "
3431 "couldn't find `_novlys' variable\n"
3432 "in inferior. Use `overlay manual' mode."));
3436 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3437 if (! ovly_table_msym
.minsym
)
3439 error (_("Error reading inferior's overlay table: couldn't find "
3440 "`_ovly_table' array\n"
3441 "in inferior. Use `overlay manual' mode."));
3445 gdbarch
= ovly_table_msym
.objfile
->arch ();
3446 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3447 byte_order
= gdbarch_byte_order (gdbarch
);
3449 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3452 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3453 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3454 read_target_long_array (cache_ovly_table_base
,
3455 (unsigned int *) cache_ovly_table
,
3456 cache_novlys
* 4, word_size
, byte_order
);
3458 return 1; /* SUCCESS */
3461 /* Function: simple_overlay_update_1
3462 A helper function for simple_overlay_update. Assuming a cached copy
3463 of _ovly_table exists, look through it to find an entry whose vma,
3464 lma and size match those of OSECT. Re-read the entry and make sure
3465 it still matches OSECT (else the table may no longer be valid).
3466 Set OSECT's mapped state to match the entry. Return: 1 for
3467 success, 0 for failure. */
3470 simple_overlay_update_1 (struct obj_section
*osect
)
3473 asection
*bsect
= osect
->the_bfd_section
;
3474 struct gdbarch
*gdbarch
= osect
->objfile
->arch ();
3475 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3476 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3478 for (i
= 0; i
< cache_novlys
; i
++)
3479 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3480 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3482 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3483 (unsigned int *) cache_ovly_table
[i
],
3484 4, word_size
, byte_order
);
3485 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3486 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3488 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3491 else /* Warning! Warning! Target's ovly table has changed! */
3497 /* Function: simple_overlay_update
3498 If OSECT is NULL, then update all sections' mapped state
3499 (after re-reading the entire target _ovly_table).
3500 If OSECT is non-NULL, then try to find a matching entry in the
3501 cached ovly_table and update only OSECT's mapped state.
3502 If a cached entry can't be found or the cache isn't valid, then
3503 re-read the entire cache, and go ahead and update all sections. */
3506 simple_overlay_update (struct obj_section
*osect
)
3508 /* Were we given an osect to look up? NULL means do all of them. */
3510 /* Have we got a cached copy of the target's overlay table? */
3511 if (cache_ovly_table
!= NULL
)
3513 /* Does its cached location match what's currently in the
3515 struct bound_minimal_symbol minsym
3516 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3518 if (minsym
.minsym
== NULL
)
3519 error (_("Error reading inferior's overlay table: couldn't "
3520 "find `_ovly_table' array\n"
3521 "in inferior. Use `overlay manual' mode."));
3523 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3524 /* Then go ahead and try to look up this single section in
3526 if (simple_overlay_update_1 (osect
))
3527 /* Found it! We're done. */
3531 /* Cached table no good: need to read the entire table anew.
3532 Or else we want all the sections, in which case it's actually
3533 more efficient to read the whole table in one block anyway. */
3535 if (! simple_read_overlay_table ())
3538 /* Now may as well update all sections, even if only one was requested. */
3539 for (objfile
*objfile
: current_program_space
->objfiles ())
3540 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3541 if (section_is_overlay (osect
))
3544 asection
*bsect
= osect
->the_bfd_section
;
3546 for (i
= 0; i
< cache_novlys
; i
++)
3547 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3548 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3549 { /* obj_section matches i'th entry in ovly_table. */
3550 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3551 break; /* finished with inner for loop: break out. */
3556 /* Default implementation for sym_relocate. */
3559 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3562 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3564 bfd
*abfd
= sectp
->owner
;
3566 /* We're only interested in sections with relocation
3568 if ((sectp
->flags
& SEC_RELOC
) == 0)
3571 /* We will handle section offsets properly elsewhere, so relocate as if
3572 all sections begin at 0. */
3573 for (asection
*sect
: gdb_bfd_sections (abfd
))
3575 sect
->output_section
= sect
;
3576 sect
->output_offset
= 0;
3579 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3582 /* Relocate the contents of a debug section SECTP in ABFD. The
3583 contents are stored in BUF if it is non-NULL, or returned in a
3584 malloc'd buffer otherwise.
3586 For some platforms and debug info formats, shared libraries contain
3587 relocations against the debug sections (particularly for DWARF-2;
3588 one affected platform is PowerPC GNU/Linux, although it depends on
3589 the version of the linker in use). Also, ELF object files naturally
3590 have unresolved relocations for their debug sections. We need to apply
3591 the relocations in order to get the locations of symbols correct.
3592 Another example that may require relocation processing, is the
3593 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3597 symfile_relocate_debug_section (struct objfile
*objfile
,
3598 asection
*sectp
, bfd_byte
*buf
)
3600 gdb_assert (objfile
->sf
->sym_relocate
);
3602 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3605 symfile_segment_data_up
3606 get_symfile_segment_data (bfd
*abfd
)
3608 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3613 return sf
->sym_segments (abfd
);
3617 - DATA, containing segment addresses from the object file ABFD, and
3618 the mapping from ABFD's sections onto the segments that own them,
3620 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3621 segment addresses reported by the target,
3622 store the appropriate offsets for each section in OFFSETS.
3624 If there are fewer entries in SEGMENT_BASES than there are segments
3625 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3627 If there are more entries, then ignore the extra. The target may
3628 not be able to distinguish between an empty data segment and a
3629 missing data segment; a missing text segment is less plausible. */
3632 symfile_map_offsets_to_segments (bfd
*abfd
,
3633 const struct symfile_segment_data
*data
,
3634 section_offsets
&offsets
,
3635 int num_segment_bases
,
3636 const CORE_ADDR
*segment_bases
)
3641 /* It doesn't make sense to call this function unless you have some
3642 segment base addresses. */
3643 gdb_assert (num_segment_bases
> 0);
3645 /* If we do not have segment mappings for the object file, we
3646 can not relocate it by segments. */
3647 gdb_assert (data
!= NULL
);
3648 gdb_assert (data
->segments
.size () > 0);
3650 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3652 int which
= data
->segment_info
[i
];
3654 gdb_assert (0 <= which
&& which
<= data
->segments
.size ());
3656 /* Don't bother computing offsets for sections that aren't
3657 loaded as part of any segment. */
3661 /* Use the last SEGMENT_BASES entry as the address of any extra
3662 segments mentioned in DATA->segment_info. */
3663 if (which
> num_segment_bases
)
3664 which
= num_segment_bases
;
3666 offsets
[i
] = segment_bases
[which
- 1] - data
->segments
[which
- 1].base
;
3673 symfile_find_segment_sections (struct objfile
*objfile
)
3675 bfd
*abfd
= objfile
->obfd
;
3679 symfile_segment_data_up data
3680 = get_symfile_segment_data (objfile
->obfd
);
3684 if (data
->segments
.size () != 1 && data
->segments
.size () != 2)
3687 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3689 int which
= data
->segment_info
[i
];
3693 if (objfile
->sect_index_text
== -1)
3694 objfile
->sect_index_text
= sect
->index
;
3696 if (objfile
->sect_index_rodata
== -1)
3697 objfile
->sect_index_rodata
= sect
->index
;
3699 else if (which
== 2)
3701 if (objfile
->sect_index_data
== -1)
3702 objfile
->sect_index_data
= sect
->index
;
3704 if (objfile
->sect_index_bss
== -1)
3705 objfile
->sect_index_bss
= sect
->index
;
3710 /* Listen for free_objfile events. */
3713 symfile_free_objfile (struct objfile
*objfile
)
3715 /* Remove the target sections owned by this objfile. */
3716 if (objfile
!= NULL
)
3717 current_program_space
->remove_target_sections ((void *) objfile
);
3720 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3721 Expand all symtabs that match the specified criteria.
3722 See quick_symbol_functions.expand_symtabs_matching for details. */
3725 expand_symtabs_matching
3726 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3727 const lookup_name_info
&lookup_name
,
3728 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3729 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3730 enum search_domain kind
)
3732 for (objfile
*objfile
: current_program_space
->objfiles ())
3733 objfile
->expand_symtabs_matching (file_matcher
,
3736 expansion_notify
, kind
);
3739 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3740 Map function FUN over every file.
3741 See quick_symbol_functions.map_symbol_filenames for details. */
3744 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3747 for (objfile
*objfile
: current_program_space
->objfiles ())
3748 objfile
->map_symbol_filenames (fun
, data
, need_fullname
);
3753 namespace selftests
{
3754 namespace filename_language
{
3756 static void test_filename_language ()
3758 /* This test messes up the filename_language_table global. */
3759 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3761 /* Test deducing an unknown extension. */
3762 language lang
= deduce_language_from_filename ("myfile.blah");
3763 SELF_CHECK (lang
== language_unknown
);
3765 /* Test deducing a known extension. */
3766 lang
= deduce_language_from_filename ("myfile.c");
3767 SELF_CHECK (lang
== language_c
);
3769 /* Test adding a new extension using the internal API. */
3770 add_filename_language (".blah", language_pascal
);
3771 lang
= deduce_language_from_filename ("myfile.blah");
3772 SELF_CHECK (lang
== language_pascal
);
3776 test_set_ext_lang_command ()
3778 /* This test messes up the filename_language_table global. */
3779 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3781 /* Confirm that the .hello extension is not known. */
3782 language lang
= deduce_language_from_filename ("cake.hello");
3783 SELF_CHECK (lang
== language_unknown
);
3785 /* Test adding a new extension using the CLI command. */
3786 auto args_holder
= make_unique_xstrdup (".hello rust");
3787 ext_args
= args_holder
.get ();
3788 set_ext_lang_command (NULL
, 1, NULL
);
3790 lang
= deduce_language_from_filename ("cake.hello");
3791 SELF_CHECK (lang
== language_rust
);
3793 /* Test overriding an existing extension using the CLI command. */
3794 int size_before
= filename_language_table
.size ();
3795 args_holder
.reset (xstrdup (".hello pascal"));
3796 ext_args
= args_holder
.get ();
3797 set_ext_lang_command (NULL
, 1, NULL
);
3798 int size_after
= filename_language_table
.size ();
3800 lang
= deduce_language_from_filename ("cake.hello");
3801 SELF_CHECK (lang
== language_pascal
);
3802 SELF_CHECK (size_before
== size_after
);
3805 } /* namespace filename_language */
3806 } /* namespace selftests */
3808 #endif /* GDB_SELF_TEST */
3810 void _initialize_symfile ();
3812 _initialize_symfile ()
3814 struct cmd_list_element
*c
;
3816 gdb::observers::free_objfile
.attach (symfile_free_objfile
);
3818 #define READNOW_READNEVER_HELP \
3819 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3820 immediately. This makes the command slower, but may make future operations\n\
3822 The '-readnever' option will prevent GDB from reading the symbol file's\n\
3823 symbolic debug information."
3825 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3826 Load symbol table from executable file FILE.\n\
3827 Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3828 OFF is an optional offset which is added to each section address.\n\
3829 The `file' command can also load symbol tables, as well as setting the file\n\
3830 to execute.\n" READNOW_READNEVER_HELP
), &cmdlist
);
3831 set_cmd_completer (c
, filename_completer
);
3833 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3834 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3835 Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3836 [-s SECT-NAME SECT-ADDR]...\n\
3837 ADDR is the starting address of the file's text.\n\
3838 Each '-s' argument provides a section name and address, and\n\
3839 should be specified if the data and bss segments are not contiguous\n\
3840 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3841 OFF is an optional offset which is added to the default load addresses\n\
3842 of all sections for which no other address was specified.\n"
3843 READNOW_READNEVER_HELP
),
3845 set_cmd_completer (c
, filename_completer
);
3847 c
= add_cmd ("remove-symbol-file", class_files
,
3848 remove_symbol_file_command
, _("\
3849 Remove a symbol file added via the add-symbol-file command.\n\
3850 Usage: remove-symbol-file FILENAME\n\
3851 remove-symbol-file -a ADDRESS\n\
3852 The file to remove can be identified by its filename or by an address\n\
3853 that lies within the boundaries of this symbol file in memory."),
3856 c
= add_cmd ("load", class_files
, load_command
, _("\
3857 Dynamically load FILE into the running program.\n\
3858 FILE symbols are recorded for access from GDB.\n\
3859 Usage: load [FILE] [OFFSET]\n\
3860 An optional load OFFSET may also be given as a literal address.\n\
3861 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3862 on its own."), &cmdlist
);
3863 set_cmd_completer (c
, filename_completer
);
3865 add_basic_prefix_cmd ("overlay", class_support
,
3866 _("Commands for debugging overlays."), &overlaylist
,
3867 "overlay ", 0, &cmdlist
);
3869 add_com_alias ("ovly", "overlay", class_support
, 1);
3870 add_com_alias ("ov", "overlay", class_support
, 1);
3872 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3873 _("Assert that an overlay section is mapped."), &overlaylist
);
3875 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3876 _("Assert that an overlay section is unmapped."), &overlaylist
);
3878 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3879 _("List mappings of overlay sections."), &overlaylist
);
3881 add_cmd ("manual", class_support
, overlay_manual_command
,
3882 _("Enable overlay debugging."), &overlaylist
);
3883 add_cmd ("off", class_support
, overlay_off_command
,
3884 _("Disable overlay debugging."), &overlaylist
);
3885 add_cmd ("auto", class_support
, overlay_auto_command
,
3886 _("Enable automatic overlay debugging."), &overlaylist
);
3887 add_cmd ("load-target", class_support
, overlay_load_command
,
3888 _("Read the overlay mapping state from the target."), &overlaylist
);
3890 /* Filename extension to source language lookup table: */
3891 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3893 Set mapping between filename extension and source language."), _("\
3894 Show mapping between filename extension and source language."), _("\
3895 Usage: set extension-language .foo bar"),
3896 set_ext_lang_command
,
3898 &setlist
, &showlist
);
3900 add_info ("extensions", info_ext_lang_command
,
3901 _("All filename extensions associated with a source language."));
3903 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3904 &debug_file_directory
, _("\
3905 Set the directories where separate debug symbols are searched for."), _("\
3906 Show the directories where separate debug symbols are searched for."), _("\
3907 Separate debug symbols are first searched for in the same\n\
3908 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3909 and lastly at the path of the directory of the binary with\n\
3910 each global debug-file-directory component prepended."),
3912 show_debug_file_directory
,
3913 &setlist
, &showlist
);
3915 add_setshow_enum_cmd ("symbol-loading", no_class
,
3916 print_symbol_loading_enums
, &print_symbol_loading
,
3918 Set printing of symbol loading messages."), _("\
3919 Show printing of symbol loading messages."), _("\
3920 off == turn all messages off\n\
3921 brief == print messages for the executable,\n\
3922 and brief messages for shared libraries\n\
3923 full == print messages for the executable,\n\
3924 and messages for each shared library."),
3927 &setprintlist
, &showprintlist
);
3929 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
3930 &separate_debug_file_debug
, _("\
3931 Set printing of separate debug info file search debug."), _("\
3932 Show printing of separate debug info file search debug."), _("\
3933 When on, GDB prints the searched locations while looking for separate debug \
3934 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
3937 selftests::register_test
3938 ("filename_language", selftests::filename_language::test_filename_language
);
3939 selftests::register_test
3940 ("set_ext_lang_command",
3941 selftests::filename_language::test_set_ext_lang_command
);