1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2023 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"
42 #include "gdbsupport/gdb_obstack.h"
43 #include "completer.h"
46 #include "readline/tilde.h"
48 #include "observable.h"
50 #include "parser-defs.h"
57 #include "cli/cli-utils.h"
58 #include "gdbsupport/byte-vector.h"
59 #include "gdbsupport/pathstuff.h"
60 #include "gdbsupport/selftest.h"
61 #include "cli/cli-style.h"
62 #include "gdbsupport/forward-scope-exit.h"
63 #include "gdbsupport/buildargv.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 std::vector
<target_section
> &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
266 = build_section_addr_info_from_bfd (objfile
->obfd
.get ());
267 for (i
= 0; i
< sap
.size (); i
++)
269 int sectindex
= sap
[i
].sectindex
;
271 sap
[i
].addr
+= objfile
->section_offsets
[sectindex
];
276 /* Initialize OBJFILE's sect_index_* members. */
279 init_objfile_sect_indices (struct objfile
*objfile
)
284 sect
= bfd_get_section_by_name (objfile
->obfd
.get (), ".text");
286 objfile
->sect_index_text
= sect
->index
;
288 sect
= bfd_get_section_by_name (objfile
->obfd
.get (), ".data");
290 objfile
->sect_index_data
= sect
->index
;
292 sect
= bfd_get_section_by_name (objfile
->obfd
.get (), ".bss");
294 objfile
->sect_index_bss
= sect
->index
;
296 sect
= bfd_get_section_by_name (objfile
->obfd
.get (), ".rodata");
298 objfile
->sect_index_rodata
= sect
->index
;
300 /* This is where things get really weird... We MUST have valid
301 indices for the various sect_index_* members or gdb will abort.
302 So if for example, there is no ".text" section, we have to
303 accommodate that. First, check for a file with the standard
304 one or two segments. */
306 symfile_find_segment_sections (objfile
);
308 /* Except when explicitly adding symbol files at some address,
309 section_offsets contains nothing but zeros, so it doesn't matter
310 which slot in section_offsets the individual sect_index_* members
311 index into. So if they are all zero, it is safe to just point
312 all the currently uninitialized indices to the first slot. But
313 beware: if this is the main executable, it may be relocated
314 later, e.g. by the remote qOffsets packet, and then this will
315 be wrong! That's why we try segments first. */
317 for (i
= 0; i
< objfile
->section_offsets
.size (); i
++)
319 if (objfile
->section_offsets
[i
] != 0)
324 if (i
== objfile
->section_offsets
.size ())
326 if (objfile
->sect_index_text
== -1)
327 objfile
->sect_index_text
= 0;
328 if (objfile
->sect_index_data
== -1)
329 objfile
->sect_index_data
= 0;
330 if (objfile
->sect_index_bss
== -1)
331 objfile
->sect_index_bss
= 0;
332 if (objfile
->sect_index_rodata
== -1)
333 objfile
->sect_index_rodata
= 0;
337 /* Find a unique offset to use for loadable section SECT if
338 the user did not provide an offset. */
341 place_section (bfd
*abfd
, asection
*sect
, section_offsets
&offsets
,
344 CORE_ADDR start_addr
;
346 ULONGEST align
= ((ULONGEST
) 1) << bfd_section_alignment (sect
);
348 /* We are only interested in allocated sections. */
349 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
352 /* If the user specified an offset, honor it. */
353 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
356 /* Otherwise, let's try to find a place for the section. */
357 start_addr
= (lowest
+ align
- 1) & -align
;
364 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
366 int indx
= cur_sec
->index
;
368 /* We don't need to compare against ourself. */
372 /* We can only conflict with allocated sections. */
373 if ((bfd_section_flags (cur_sec
) & SEC_ALLOC
) == 0)
376 /* If the section offset is 0, either the section has not been placed
377 yet, or it was the lowest section placed (in which case LOWEST
378 will be past its end). */
379 if (offsets
[indx
] == 0)
382 /* If this section would overlap us, then we must move up. */
383 if (start_addr
+ bfd_section_size (sect
) > offsets
[indx
]
384 && start_addr
< offsets
[indx
] + bfd_section_size (cur_sec
))
386 start_addr
= offsets
[indx
] + bfd_section_size (cur_sec
);
387 start_addr
= (start_addr
+ align
- 1) & -align
;
392 /* Otherwise, we appear to be OK. So far. */
397 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
398 lowest
= start_addr
+ bfd_section_size (sect
);
401 /* Store section_addr_info as prepared (made relative and with SECTINDEX
402 filled-in) by addr_info_make_relative into SECTION_OFFSETS. */
405 relative_addr_info_to_section_offsets (section_offsets
§ion_offsets
,
406 const section_addr_info
&addrs
)
410 section_offsets
.assign (section_offsets
.size (), 0);
412 /* Now calculate offsets for section that were specified by the caller. */
413 for (i
= 0; i
< addrs
.size (); i
++)
415 const struct other_sections
*osp
;
418 if (osp
->sectindex
== -1)
421 /* Record all sections in offsets. */
422 /* The section_offsets in the objfile are here filled in using
424 section_offsets
[osp
->sectindex
] = osp
->addr
;
428 /* Transform section name S for a name comparison. prelink can split section
429 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
430 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
431 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
432 (`.sbss') section has invalid (increased) virtual address. */
435 addr_section_name (const char *s
)
437 if (strcmp (s
, ".dynbss") == 0)
439 if (strcmp (s
, ".sdynbss") == 0)
445 /* std::sort comparator for addrs_section_sort. Sort entries in
446 ascending order by their (name, sectindex) pair. sectindex makes
447 the sort by name stable. */
450 addrs_section_compar (const struct other_sections
*a
,
451 const struct other_sections
*b
)
455 retval
= strcmp (addr_section_name (a
->name
.c_str ()),
456 addr_section_name (b
->name
.c_str ()));
460 return a
->sectindex
< b
->sectindex
;
463 /* Provide sorted array of pointers to sections of ADDRS. */
465 static std::vector
<const struct other_sections
*>
466 addrs_section_sort (const section_addr_info
&addrs
)
470 std::vector
<const struct other_sections
*> array (addrs
.size ());
471 for (i
= 0; i
< addrs
.size (); i
++)
472 array
[i
] = &addrs
[i
];
474 std::sort (array
.begin (), array
.end (), addrs_section_compar
);
479 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
480 also SECTINDEXes specific to ABFD there. This function can be used to
481 rebase ADDRS to start referencing different BFD than before. */
484 addr_info_make_relative (section_addr_info
*addrs
, bfd
*abfd
)
486 asection
*lower_sect
;
487 CORE_ADDR lower_offset
;
490 /* Find lowest loadable section to be used as starting point for
491 contiguous sections. */
493 for (asection
*iter
: gdb_bfd_sections (abfd
))
494 find_lowest_section (iter
, &lower_sect
);
495 if (lower_sect
== NULL
)
497 warning (_("no loadable sections found in added symbol-file %s"),
498 bfd_get_filename (abfd
));
502 lower_offset
= bfd_section_vma (lower_sect
);
504 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
505 in ABFD. Section names are not unique - there can be multiple sections of
506 the same name. Also the sections of the same name do not have to be
507 adjacent to each other. Some sections may be present only in one of the
508 files. Even sections present in both files do not have to be in the same
511 Use stable sort by name for the sections in both files. Then linearly
512 scan both lists matching as most of the entries as possible. */
514 std::vector
<const struct other_sections
*> addrs_sorted
515 = addrs_section_sort (*addrs
);
517 section_addr_info abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
518 std::vector
<const struct other_sections
*> abfd_addrs_sorted
519 = addrs_section_sort (abfd_addrs
);
521 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
522 ABFD_ADDRS_SORTED. */
524 std::vector
<const struct other_sections
*>
525 addrs_to_abfd_addrs (addrs
->size (), nullptr);
527 std::vector
<const struct other_sections
*>::iterator abfd_sorted_iter
528 = abfd_addrs_sorted
.begin ();
529 for (const other_sections
*sect
: addrs_sorted
)
531 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
533 while (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
534 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
538 if (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
539 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
544 /* Make the found item directly addressable from ADDRS. */
545 index_in_addrs
= sect
- addrs
->data ();
546 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
547 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_sorted_iter
;
549 /* Never use the same ABFD entry twice. */
554 /* Calculate offsets for the loadable sections.
555 FIXME! Sections must be in order of increasing loadable section
556 so that contiguous sections can use the lower-offset!!!
558 Adjust offsets if the segments are not contiguous.
559 If the section is contiguous, its offset should be set to
560 the offset of the highest loadable section lower than it
561 (the loadable section directly below it in memory).
562 this_offset = lower_offset = lower_addr - lower_orig_addr */
564 for (i
= 0; i
< addrs
->size (); i
++)
566 const struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
570 /* This is the index used by BFD. */
571 (*addrs
)[i
].sectindex
= sect
->sectindex
;
573 if ((*addrs
)[i
].addr
!= 0)
575 (*addrs
)[i
].addr
-= sect
->addr
;
576 lower_offset
= (*addrs
)[i
].addr
;
579 (*addrs
)[i
].addr
= lower_offset
;
583 /* addr_section_name transformation is not used for SECT_NAME. */
584 const std::string
§_name
= (*addrs
)[i
].name
;
586 /* This section does not exist in ABFD, which is normally
587 unexpected and we want to issue a warning.
589 However, the ELF prelinker does create a few sections which are
590 marked in the main executable as loadable (they are loaded in
591 memory from the DYNAMIC segment) and yet are not present in
592 separate debug info files. This is fine, and should not cause
593 a warning. Shared libraries contain just the section
594 ".gnu.liblist" but it is not marked as loadable there. There is
595 no other way to identify them than by their name as the sections
596 created by prelink have no special flags.
598 For the sections `.bss' and `.sbss' see addr_section_name. */
600 if (!(sect_name
== ".gnu.liblist"
601 || sect_name
== ".gnu.conflict"
602 || (sect_name
== ".bss"
604 && (*addrs
)[i
- 1].name
== ".dynbss"
605 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
606 || (sect_name
== ".sbss"
608 && (*addrs
)[i
- 1].name
== ".sdynbss"
609 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
610 warning (_("section %s not found in %s"), sect_name
.c_str (),
611 bfd_get_filename (abfd
));
613 (*addrs
)[i
].addr
= 0;
614 (*addrs
)[i
].sectindex
= -1;
619 /* Parse the user's idea of an offset for dynamic linking, into our idea
620 of how to represent it for fast symbol reading. This is the default
621 version of the sym_fns.sym_offsets function for symbol readers that
622 don't need to do anything special. It allocates a section_offsets table
623 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
626 default_symfile_offsets (struct objfile
*objfile
,
627 const section_addr_info
&addrs
)
629 objfile
->section_offsets
.resize (gdb_bfd_count_sections (objfile
->obfd
.get ()));
630 relative_addr_info_to_section_offsets (objfile
->section_offsets
, addrs
);
632 /* For relocatable files, all loadable sections will start at zero.
633 The zero is meaningless, so try to pick arbitrary addresses such
634 that no loadable sections overlap. This algorithm is quadratic,
635 but the number of sections in a single object file is generally
637 if ((bfd_get_file_flags (objfile
->obfd
.get ()) & (EXEC_P
| DYNAMIC
)) == 0)
639 bfd
*abfd
= objfile
->obfd
.get ();
642 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
643 /* We do not expect this to happen; just skip this step if the
644 relocatable file has a section with an assigned VMA. */
645 if (bfd_section_vma (cur_sec
) != 0)
650 section_offsets
&offsets
= objfile
->section_offsets
;
652 /* Pick non-overlapping offsets for sections the user did not
654 CORE_ADDR lowest
= 0;
655 for (asection
*sect
: gdb_bfd_sections (objfile
->obfd
.get ()))
656 place_section (objfile
->obfd
.get (), sect
, objfile
->section_offsets
,
659 /* Correctly filling in the section offsets is not quite
660 enough. Relocatable files have two properties that
661 (most) shared objects do not:
663 - Their debug information will contain relocations. Some
664 shared libraries do also, but many do not, so this can not
667 - If there are multiple code sections they will be loaded
668 at different relative addresses in memory than they are
669 in the objfile, since all sections in the file will start
672 Because GDB has very limited ability to map from an
673 address in debug info to the correct code section,
674 it relies on adding SECT_OFF_TEXT to things which might be
675 code. If we clear all the section offsets, and set the
676 section VMAs instead, then symfile_relocate_debug_section
677 will return meaningful debug information pointing at the
680 GDB has too many different data structures for section
681 addresses - a bfd, objfile, and so_list all have section
682 tables, as does exec_ops. Some of these could probably
685 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
686 cur_sec
= cur_sec
->next
)
688 if ((bfd_section_flags (cur_sec
) & SEC_ALLOC
) == 0)
691 bfd_set_section_vma (cur_sec
, offsets
[cur_sec
->index
]);
692 exec_set_section_address (bfd_get_filename (abfd
),
694 offsets
[cur_sec
->index
]);
695 offsets
[cur_sec
->index
] = 0;
700 /* Remember the bfd indexes for the .text, .data, .bss and
702 init_objfile_sect_indices (objfile
);
705 /* Divide the file into segments, which are individual relocatable units.
706 This is the default version of the sym_fns.sym_segments function for
707 symbol readers that do not have an explicit representation of segments.
708 It assumes that object files do not have segments, and fully linked
709 files have a single segment. */
711 symfile_segment_data_up
712 default_symfile_segments (bfd
*abfd
)
718 /* Relocatable files contain enough information to position each
719 loadable section independently; they should not be relocated
721 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
724 /* Make sure there is at least one loadable section in the file. */
725 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
727 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
735 low
= bfd_section_vma (sect
);
736 high
= low
+ bfd_section_size (sect
);
738 symfile_segment_data_up
data (new symfile_segment_data
);
740 num_sections
= bfd_count_sections (abfd
);
742 /* All elements are initialized to 0 (map to no segment). */
743 data
->segment_info
.resize (num_sections
);
745 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
749 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
752 vma
= bfd_section_vma (sect
);
755 if (vma
+ bfd_section_size (sect
) > high
)
756 high
= vma
+ bfd_section_size (sect
);
758 data
->segment_info
[i
] = 1;
761 data
->segments
.emplace_back (low
, high
- low
);
766 /* This is a convenience function to call sym_read for OBJFILE and
767 possibly force the partial symbols to be read. */
770 read_symbols (struct objfile
*objfile
, symfile_add_flags add_flags
)
772 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
773 objfile
->per_bfd
->minsyms_read
= true;
775 /* find_separate_debug_file_in_section should be called only if there is
776 single binary with no existing separate debug info file. */
777 if (!objfile
->has_partial_symbols ()
778 && objfile
->separate_debug_objfile
== NULL
779 && objfile
->separate_debug_objfile_backlink
== NULL
)
781 gdb_bfd_ref_ptr
abfd (find_separate_debug_file_in_section (objfile
));
785 /* find_separate_debug_file_in_section uses the same filename for the
786 virtual section-as-bfd like the bfd filename containing the
787 section. Therefore use also non-canonical name form for the same
788 file containing the section. */
789 symbol_file_add_separate (abfd
, 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
.get ()) & 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
.get ());
816 ei
->entry_point_p
= 1;
818 else if (bfd_get_file_flags (objfile
->obfd
.get ()) & DYNAMIC
819 && bfd_get_start_address (objfile
->obfd
.get ()) != 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
.get ());
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 CORE_ADDR entry_point
= ei
->entry_point
;
838 /* Make certain that the address points at real code, and not a
839 function descriptor. */
840 entry_point
= gdbarch_convert_from_func_ptr_addr
841 (objfile
->arch (), entry_point
, current_inferior ()->top_target ());
843 /* Remove any ISA markers, so that this matches entries in the
846 = gdbarch_addr_bits_remove (objfile
->arch (), entry_point
);
849 for (obj_section
*osect
: objfile
->sections ())
851 struct bfd_section
*sect
= osect
->the_bfd_section
;
853 if (entry_point
>= bfd_section_vma (sect
)
854 && entry_point
< (bfd_section_vma (sect
)
855 + bfd_section_size (sect
)))
857 ei
->the_bfd_section_index
858 = gdb_bfd_section_index (objfile
->obfd
.get (), sect
);
865 ei
->the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
869 /* Process a symbol file, as either the main file or as a dynamically
872 This function does not set the OBJFILE's entry-point info.
874 OBJFILE is where the symbols are to be read from.
876 ADDRS is the list of section load addresses. If the user has given
877 an 'add-symbol-file' command, then this is the list of offsets and
878 addresses he or she provided as arguments to the command; or, if
879 we're handling a shared library, these are the actual addresses the
880 sections are loaded at, according to the inferior's dynamic linker
881 (as gleaned by GDB's shared library code). We convert each address
882 into an offset from the section VMA's as it appears in the object
883 file, and then call the file's sym_offsets function to convert this
884 into a format-specific offset table --- a `section_offsets'.
885 The sectindex field is used to control the ordering of sections
886 with the same name. Upon return, it is updated to contain the
887 corresponding BFD section index, or -1 if the section was not found.
889 ADD_FLAGS encodes verbosity level, whether this is main symbol or
890 an extra symbol file such as dynamically loaded code, and whether
891 breakpoint reset should be deferred. */
894 syms_from_objfile_1 (struct objfile
*objfile
,
895 section_addr_info
*addrs
,
896 symfile_add_flags add_flags
)
898 section_addr_info local_addr
;
899 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
901 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
.get ()));
902 objfile
->qf
.clear ();
904 if (objfile
->sf
== NULL
)
906 /* No symbols to load, but we still need to make sure
907 that the section_offsets table is allocated. */
908 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
.get ());
910 objfile
->section_offsets
.assign (num_sections
, 0);
914 /* Make sure that partially constructed symbol tables will be cleaned up
915 if an error occurs during symbol reading. */
916 gdb::optional
<clear_symtab_users_cleanup
> defer_clear_users
;
918 objfile_up
objfile_holder (objfile
);
920 /* If ADDRS is NULL, put together a dummy address list.
921 We now establish the convention that an addr of zero means
922 no load address was specified. */
928 /* We will modify the main symbol table, make sure that all its users
929 will be cleaned up if an error occurs during symbol reading. */
930 defer_clear_users
.emplace ((symfile_add_flag
) 0);
932 /* Since no error yet, throw away the old symbol table. */
934 if (current_program_space
->symfile_object_file
!= NULL
)
936 current_program_space
->symfile_object_file
->unlink ();
937 gdb_assert (current_program_space
->symfile_object_file
== NULL
);
940 /* Currently we keep symbols from the add-symbol-file command.
941 If the user wants to get rid of them, they should do "symbol-file"
942 without arguments first. Not sure this is the best behavior
945 (*objfile
->sf
->sym_new_init
) (objfile
);
948 /* Convert addr into an offset rather than an absolute address.
949 We find the lowest address of a loaded segment in the objfile,
950 and assume that <addr> is where that got loaded.
952 We no longer warn if the lowest section is not a text segment (as
953 happens for the PA64 port. */
954 if (addrs
->size () > 0)
955 addr_info_make_relative (addrs
, objfile
->obfd
.get ());
957 /* Initialize symbol reading routines for this objfile, allow complaints to
958 appear for this new file, and record how verbose to be, then do the
959 initial symbol reading for this file. */
961 (*objfile
->sf
->sym_init
) (objfile
);
964 (*objfile
->sf
->sym_offsets
) (objfile
, *addrs
);
966 read_symbols (objfile
, add_flags
);
968 /* Discard cleanups as symbol reading was successful. */
970 objfile_holder
.release ();
971 if (defer_clear_users
)
972 defer_clear_users
->release ();
975 /* Same as syms_from_objfile_1, but also initializes the objfile
979 syms_from_objfile (struct objfile
*objfile
,
980 section_addr_info
*addrs
,
981 symfile_add_flags add_flags
)
983 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
984 init_entry_point_info (objfile
);
987 /* Perform required actions after either reading in the initial
988 symbols for a new objfile, or mapping in the symbols from a reusable
989 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
992 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
994 /* If this is the main symbol file we have to clean up all users of the
995 old main symbol file. Otherwise it is sufficient to fixup all the
996 breakpoints that may have been redefined by this symbol file. */
997 if (add_flags
& SYMFILE_MAINLINE
)
999 /* OK, make it the "real" symbol file. */
1000 current_program_space
->symfile_object_file
= objfile
;
1002 clear_symtab_users (add_flags
);
1004 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1006 breakpoint_re_set ();
1009 /* We're done reading the symbol file; finish off complaints. */
1010 clear_complaints ();
1013 /* Process a symbol file, as either the main file or as a dynamically
1016 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1017 A new reference is acquired by this function.
1019 For NAME description see the objfile constructor.
1021 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1022 extra, such as dynamically loaded code, and what to do with breakpoints.
1024 ADDRS is as described for syms_from_objfile_1, above.
1025 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1027 PARENT is the original objfile if ABFD is a separate debug info file.
1028 Otherwise PARENT is NULL.
1030 Upon success, returns a pointer to the objfile that was added.
1031 Upon failure, jumps back to command level (never returns). */
1033 static struct objfile
*
1034 symbol_file_add_with_addrs (const gdb_bfd_ref_ptr
&abfd
, const char *name
,
1035 symfile_add_flags add_flags
,
1036 section_addr_info
*addrs
,
1037 objfile_flags flags
, struct objfile
*parent
)
1039 struct objfile
*objfile
;
1040 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1041 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1042 const int always_confirm
= add_flags
& SYMFILE_ALWAYS_CONFIRM
;
1043 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1044 && (readnow_symbol_files
1045 || (add_flags
& SYMFILE_NO_READ
) == 0));
1047 if (readnow_symbol_files
)
1049 flags
|= OBJF_READNOW
;
1050 add_flags
&= ~SYMFILE_NO_READ
;
1052 else if (readnever_symbol_files
1053 || (parent
!= NULL
&& (parent
->flags
& OBJF_READNEVER
)))
1055 flags
|= OBJF_READNEVER
;
1056 add_flags
|= SYMFILE_NO_READ
;
1058 if ((add_flags
& SYMFILE_NOT_FILENAME
) != 0)
1059 flags
|= OBJF_NOT_FILENAME
;
1061 /* Give user a chance to burp if ALWAYS_CONFIRM or we'd be
1062 interactively wiping out any existing symbols. */
1066 || ((have_full_symbols () || have_partial_symbols ())
1068 && !query (_("Load new symbol table from \"%s\"? "), name
))
1069 error (_("Not confirmed."));
1072 flags
|= OBJF_MAINLINE
;
1073 objfile
= objfile::make (abfd
, name
, flags
, parent
);
1075 /* We either created a new mapped symbol table, mapped an existing
1076 symbol table file which has not had initial symbol reading
1077 performed, or need to read an unmapped symbol table. */
1080 if (deprecated_pre_add_symbol_hook
)
1081 deprecated_pre_add_symbol_hook (name
);
1083 gdb_printf (_("Reading symbols from %ps...\n"),
1084 styled_string (file_name_style
.style (), name
));
1086 syms_from_objfile (objfile
, addrs
, add_flags
);
1088 /* We now have at least a partial symbol table. Check to see if the
1089 user requested that all symbols be read on initial access via either
1090 the gdb startup command line or on a per symbol file basis. Expand
1091 all partial symbol tables for this objfile if so. */
1093 if ((flags
& OBJF_READNOW
))
1096 gdb_printf (_("Expanding full symbols from %ps...\n"),
1097 styled_string (file_name_style
.style (), name
));
1099 objfile
->expand_all_symtabs ();
1102 /* Note that we only print a message if we have no symbols and have
1103 no separate debug file. If there is a separate debug file which
1104 does not have symbols, we'll have emitted this message for that
1105 file, and so printing it twice is just redundant. */
1106 if (should_print
&& !objfile_has_symbols (objfile
)
1107 && objfile
->separate_debug_objfile
== nullptr)
1108 gdb_printf (_("(No debugging symbols found in %ps)\n"),
1109 styled_string (file_name_style
.style (), name
));
1113 if (deprecated_post_add_symbol_hook
)
1114 deprecated_post_add_symbol_hook ();
1117 /* We print some messages regardless of whether 'from_tty ||
1118 info_verbose' is true, so make sure they go out at the right
1120 gdb_flush (gdb_stdout
);
1122 if (objfile
->sf
!= nullptr)
1123 finish_new_objfile (objfile
, add_flags
);
1125 gdb::observers::new_objfile
.notify (objfile
);
1127 bfd_cache_close_all ();
1131 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1132 see the objfile constructor. */
1135 symbol_file_add_separate (const gdb_bfd_ref_ptr
&bfd
, const char *name
,
1136 symfile_add_flags symfile_flags
,
1137 struct objfile
*objfile
)
1139 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1140 because sections of BFD may not match sections of OBJFILE and because
1141 vma may have been modified by tools such as prelink. */
1142 section_addr_info sap
= build_section_addr_info_from_objfile (objfile
);
1144 symbol_file_add_with_addrs
1145 (bfd
, name
, symfile_flags
, &sap
,
1146 objfile
->flags
& (OBJF_SHARED
| OBJF_READNOW
1147 | OBJF_USERLOADED
| OBJF_MAINLINE
),
1151 /* Process the symbol file ABFD, as either the main file or as a
1152 dynamically loaded file.
1153 See symbol_file_add_with_addrs's comments for details. */
1156 symbol_file_add_from_bfd (const gdb_bfd_ref_ptr
&abfd
, const char *name
,
1157 symfile_add_flags add_flags
,
1158 section_addr_info
*addrs
,
1159 objfile_flags flags
, struct objfile
*parent
)
1161 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1165 /* Process a symbol file, as either the main file or as a dynamically
1166 loaded file. See symbol_file_add_with_addrs's comments for details. */
1169 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1170 section_addr_info
*addrs
, objfile_flags flags
)
1172 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1174 return symbol_file_add_from_bfd (bfd
, name
, add_flags
, addrs
,
1178 /* Call symbol_file_add() with default values and update whatever is
1179 affected by the loading of a new main().
1180 Used when the file is supplied in the gdb command line
1181 and by some targets with special loading requirements.
1182 The auxiliary function, symbol_file_add_main_1(), has the flags
1183 argument for the switches that can only be specified in the symbol_file
1187 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1189 symbol_file_add_main_1 (args
, add_flags
, 0, 0);
1193 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1194 objfile_flags flags
, CORE_ADDR reloff
)
1196 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1198 struct objfile
*objfile
= symbol_file_add (args
, add_flags
, NULL
, flags
);
1200 objfile_rebase (objfile
, reloff
);
1202 /* Getting new symbols may change our opinion about
1203 what is frameless. */
1204 reinit_frame_cache ();
1206 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1207 set_initial_language ();
1211 symbol_file_clear (int from_tty
)
1213 if ((have_full_symbols () || have_partial_symbols ())
1215 && (current_program_space
->symfile_object_file
1216 ? !query (_("Discard symbol table from `%s'? "),
1217 objfile_name (current_program_space
->symfile_object_file
))
1218 : !query (_("Discard symbol table? "))))
1219 error (_("Not confirmed."));
1221 /* solib descriptors may have handles to objfiles. Wipe them before their
1222 objfiles get stale by free_all_objfiles. */
1223 no_shared_libraries (NULL
, from_tty
);
1225 current_program_space
->free_all_objfiles ();
1227 clear_symtab_users (0);
1229 gdb_assert (current_program_space
->symfile_object_file
== NULL
);
1231 gdb_printf (_("No symbol file now.\n"));
1234 /* See symfile.h. */
1236 bool separate_debug_file_debug
= false;
1239 separate_debug_file_exists (const std::string
&name
, unsigned long crc
,
1240 struct objfile
*parent_objfile
,
1241 deferred_warnings
*warnings
)
1243 unsigned long file_crc
;
1245 struct stat parent_stat
, abfd_stat
;
1246 int verified_as_different
;
1248 /* Find a separate debug info file as if symbols would be present in
1249 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1250 section can contain just the basename of PARENT_OBJFILE without any
1251 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1252 the separate debug infos with the same basename can exist. */
1254 if (filename_cmp (name
.c_str (), objfile_name (parent_objfile
)) == 0)
1257 if (separate_debug_file_debug
)
1259 gdb_printf (gdb_stdlog
, _(" Trying %s..."), name
.c_str ());
1260 gdb_flush (gdb_stdlog
);
1263 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
.c_str (), gnutarget
));
1267 if (separate_debug_file_debug
)
1268 gdb_printf (gdb_stdlog
, _(" no, unable to open.\n"));
1273 /* Verify symlinks were not the cause of filename_cmp name difference above.
1275 Some operating systems, e.g. Windows, do not provide a meaningful
1276 st_ino; they always set it to zero. (Windows does provide a
1277 meaningful st_dev.) Files accessed from gdbservers that do not
1278 support the vFile:fstat packet will also have st_ino set to zero.
1279 Do not indicate a duplicate library in either case. While there
1280 is no guarantee that a system that provides meaningful inode
1281 numbers will never set st_ino to zero, this is merely an
1282 optimization, so we do not need to worry about false negatives. */
1284 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1285 && abfd_stat
.st_ino
!= 0
1286 && bfd_stat (parent_objfile
->obfd
.get (), &parent_stat
) == 0)
1288 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1289 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1291 if (separate_debug_file_debug
)
1292 gdb_printf (gdb_stdlog
,
1293 _(" no, same file as the objfile.\n"));
1297 verified_as_different
= 1;
1300 verified_as_different
= 0;
1302 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1306 if (separate_debug_file_debug
)
1307 gdb_printf (gdb_stdlog
, _(" no, error computing CRC.\n"));
1312 if (crc
!= file_crc
)
1314 unsigned long parent_crc
;
1316 /* If the files could not be verified as different with
1317 bfd_stat then we need to calculate the parent's CRC
1318 to verify whether the files are different or not. */
1320 if (!verified_as_different
)
1322 if (!gdb_bfd_crc (parent_objfile
->obfd
.get (), &parent_crc
))
1324 if (separate_debug_file_debug
)
1325 gdb_printf (gdb_stdlog
,
1326 _(" no, error computing CRC.\n"));
1332 if (verified_as_different
|| parent_crc
!= file_crc
)
1334 if (separate_debug_file_debug
)
1335 gdb_printf (gdb_stdlog
, "the debug information found in \"%s\""
1336 " does not match \"%s\" (CRC mismatch).\n",
1337 name
.c_str (), objfile_name (parent_objfile
));
1338 warnings
->warn (_("the debug information found in \"%ps\""
1339 " does not match \"%ps\" (CRC mismatch)."),
1340 styled_string (file_name_style
.style (),
1342 styled_string (file_name_style
.style (),
1343 objfile_name (parent_objfile
)));
1349 if (separate_debug_file_debug
)
1350 gdb_printf (gdb_stdlog
, _(" yes!\n"));
1355 std::string debug_file_directory
;
1357 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1358 struct cmd_list_element
*c
, const char *value
)
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
1378 Any warnings generated as part of the lookup process are added to
1379 WARNINGS. If some other mechanism can be used to lookup the debug
1380 information then the warning will not be shown, however, if GDB fails to
1381 find suitable debug information using any approach, then any warnings
1385 find_separate_debug_file (const char *dir
,
1386 const char *canon_dir
,
1387 const char *debuglink
,
1388 unsigned long crc32
, struct objfile
*objfile
,
1389 deferred_warnings
*warnings
)
1391 if (separate_debug_file_debug
)
1392 gdb_printf (gdb_stdlog
,
1393 _("\nLooking for separate debug info (debug link) for "
1394 "%s\n"), objfile_name (objfile
));
1396 /* First try in the same directory as the original file. */
1397 std::string debugfile
= dir
;
1398 debugfile
+= debuglink
;
1400 if (separate_debug_file_exists (debugfile
, crc32
, objfile
, warnings
))
1403 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1405 debugfile
+= DEBUG_SUBDIRECTORY
;
1407 debugfile
+= debuglink
;
1409 if (separate_debug_file_exists (debugfile
, crc32
, objfile
, warnings
))
1412 /* Then try in the global debugfile directories.
1414 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1415 cause "/..." lookups. */
1417 bool target_prefix
= startswith (dir
, "target:");
1418 const char *dir_notarget
= target_prefix
? dir
+ strlen ("target:") : dir
;
1419 std::vector
<gdb::unique_xmalloc_ptr
<char>> debugdir_vec
1420 = dirnames_to_char_ptr_vec (debug_file_directory
.c_str ());
1421 gdb::unique_xmalloc_ptr
<char> canon_sysroot
1422 = gdb_realpath (gdb_sysroot
.c_str ());
1424 /* MS-Windows/MS-DOS don't allow colons in file names; we must
1425 convert the drive letter into a one-letter directory, so that the
1426 file name resulting from splicing below will be valid.
1428 FIXME: The below only works when GDB runs on MS-Windows/MS-DOS.
1429 There are various remote-debugging scenarios where such a
1430 transformation of the drive letter might be required when GDB runs
1431 on a Posix host, see
1433 https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
1435 If some of those scenarios need to be supported, we will need to
1436 use a different condition for HAS_DRIVE_SPEC and a different macro
1437 instead of STRIP_DRIVE_SPEC, which work on Posix systems as well. */
1439 if (HAS_DRIVE_SPEC (dir_notarget
))
1441 drive
= dir_notarget
[0];
1442 dir_notarget
= STRIP_DRIVE_SPEC (dir_notarget
);
1445 for (const gdb::unique_xmalloc_ptr
<char> &debugdir
: debugdir_vec
)
1447 debugfile
= target_prefix
? "target:" : "";
1448 debugfile
+= debugdir
;
1451 debugfile
+= dir_notarget
;
1452 debugfile
+= debuglink
;
1454 if (separate_debug_file_exists (debugfile
, crc32
, objfile
, warnings
))
1457 const char *base_path
= NULL
;
1458 if (canon_dir
!= NULL
)
1460 if (canon_sysroot
.get () != NULL
)
1461 base_path
= child_path (canon_sysroot
.get (), canon_dir
);
1463 base_path
= child_path (gdb_sysroot
.c_str (), canon_dir
);
1465 if (base_path
!= NULL
)
1467 /* If the file is in the sysroot, try using its base path in
1468 the global debugfile directory. */
1469 debugfile
= target_prefix
? "target:" : "";
1470 debugfile
+= debugdir
;
1472 debugfile
+= base_path
;
1474 debugfile
+= debuglink
;
1476 if (separate_debug_file_exists (debugfile
, crc32
, objfile
, warnings
))
1479 /* If the file is in the sysroot, try using its base path in
1480 the sysroot's global debugfile directory. GDB_SYSROOT
1481 might refer to a target: path; we strip the "target:"
1482 prefix -- but if that would yield the empty string, we
1483 don't bother at all, because that would just give the
1484 same result as above. */
1485 if (gdb_sysroot
!= "target:")
1487 debugfile
= target_prefix
? "target:" : "";
1488 if (startswith (gdb_sysroot
, "target:"))
1490 std::string root
= gdb_sysroot
.substr (strlen ("target:"));
1491 gdb_assert (!root
.empty ());
1495 debugfile
+= gdb_sysroot
;
1496 debugfile
+= debugdir
;
1498 debugfile
+= base_path
;
1500 debugfile
+= debuglink
;
1502 if (separate_debug_file_exists (debugfile
, crc32
, objfile
,
1509 return std::string ();
1512 /* Modify PATH to contain only "[/]directory/" part of PATH.
1513 If there were no directory separators in PATH, PATH will be empty
1514 string on return. */
1517 terminate_after_last_dir_separator (char *path
)
1521 /* Strip off the final filename part, leaving the directory name,
1522 followed by a slash. The directory can be relative or absolute. */
1523 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1524 if (IS_DIR_SEPARATOR (path
[i
]))
1527 /* If I is -1 then no directory is present there and DIR will be "". */
1534 find_separate_debug_file_by_debuglink
1535 (struct objfile
*objfile
, deferred_warnings
*warnings
)
1539 gdb::unique_xmalloc_ptr
<char> debuglink
1540 (bfd_get_debug_link_info (objfile
->obfd
.get (), &crc32
));
1542 if (debuglink
== NULL
)
1544 /* There's no separate debug info, hence there's no way we could
1545 load it => no warning. */
1546 return std::string ();
1549 std::string dir
= objfile_name (objfile
);
1550 terminate_after_last_dir_separator (&dir
[0]);
1551 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1553 std::string debugfile
1554 = find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1555 debuglink
.get (), crc32
, objfile
,
1558 if (debugfile
.empty ())
1560 /* For PR gdb/9538, try again with realpath (if different from the
1565 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1566 && S_ISLNK (st_buf
.st_mode
))
1568 gdb::unique_xmalloc_ptr
<char> symlink_dir
1569 (lrealpath (objfile_name (objfile
)));
1570 if (symlink_dir
!= NULL
)
1572 terminate_after_last_dir_separator (symlink_dir
.get ());
1573 if (dir
!= symlink_dir
.get ())
1575 /* Different directory, so try using it. */
1576 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1590 /* Make sure that OBJF_{READNOW,READNEVER} are not set
1594 validate_readnow_readnever (objfile_flags flags
)
1596 if ((flags
& OBJF_READNOW
) && (flags
& OBJF_READNEVER
))
1597 error (_("-readnow and -readnever cannot be used simultaneously"));
1600 /* This is the symbol-file command. Read the file, analyze its
1601 symbols, and add a struct symtab to a symtab list. The syntax of
1602 the command is rather bizarre:
1604 1. The function buildargv implements various quoting conventions
1605 which are undocumented and have little or nothing in common with
1606 the way things are quoted (or not quoted) elsewhere in GDB.
1608 2. Options are used, which are not generally used in GDB (perhaps
1609 "set mapped on", "set readnow on" would be better)
1611 3. The order of options matters, which is contrary to GNU
1612 conventions (because it is confusing and inconvenient). */
1615 symbol_file_command (const char *args
, int from_tty
)
1621 symbol_file_clear (from_tty
);
1625 objfile_flags flags
= OBJF_USERLOADED
;
1626 symfile_add_flags add_flags
= 0;
1628 bool stop_processing_options
= false;
1629 CORE_ADDR offset
= 0;
1634 add_flags
|= SYMFILE_VERBOSE
;
1636 gdb_argv
built_argv (args
);
1637 for (arg
= built_argv
[0], idx
= 0; arg
!= NULL
; arg
= built_argv
[++idx
])
1639 if (stop_processing_options
|| *arg
!= '-')
1644 error (_("Unrecognized argument \"%s\""), arg
);
1646 else if (strcmp (arg
, "-readnow") == 0)
1647 flags
|= OBJF_READNOW
;
1648 else if (strcmp (arg
, "-readnever") == 0)
1649 flags
|= OBJF_READNEVER
;
1650 else if (strcmp (arg
, "-o") == 0)
1652 arg
= built_argv
[++idx
];
1654 error (_("Missing argument to -o"));
1656 offset
= parse_and_eval_address (arg
);
1658 else if (strcmp (arg
, "--") == 0)
1659 stop_processing_options
= true;
1661 error (_("Unrecognized argument \"%s\""), arg
);
1665 error (_("no symbol file name was specified"));
1667 validate_readnow_readnever (flags
);
1669 /* Set SYMFILE_DEFER_BP_RESET because the proper displacement for a PIE
1670 (Position Independent Executable) main symbol file will only be
1671 computed by the solib_create_inferior_hook below. Without it,
1672 breakpoint_re_set would fail to insert the breakpoints with the zero
1674 add_flags
|= SYMFILE_DEFER_BP_RESET
;
1676 symbol_file_add_main_1 (name
, add_flags
, flags
, offset
);
1678 solib_create_inferior_hook (from_tty
);
1680 /* Now it's safe to re-add the breakpoints. */
1681 breakpoint_re_set ();
1683 /* Also, it's safe to re-add varobjs. */
1688 /* Set the initial language. */
1691 set_initial_language (void)
1693 if (language_mode
== language_mode_manual
)
1695 enum language lang
= main_language ();
1696 /* Make C the default language. */
1697 enum language default_lang
= language_c
;
1699 if (lang
== language_unknown
)
1701 const char *name
= main_name ();
1703 = lookup_symbol_in_language (name
, NULL
, VAR_DOMAIN
, default_lang
,
1707 lang
= sym
->language ();
1710 if (lang
== language_unknown
)
1712 lang
= default_lang
;
1715 set_language (lang
);
1716 expected_language
= current_language
; /* Don't warn the user. */
1719 /* Open the file specified by NAME and hand it off to BFD for
1720 preliminary analysis. Return a newly initialized bfd *, which
1721 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1722 absolute). In case of trouble, error() is called. */
1725 symfile_bfd_open (const char *name
)
1729 gdb::unique_xmalloc_ptr
<char> absolute_name
;
1730 if (!is_target_filename (name
))
1732 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1734 /* Look down path for it, allocate 2nd new malloc'd copy. */
1735 desc
= openp (getenv ("PATH"),
1736 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1737 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1738 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1741 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1743 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1744 desc
= openp (getenv ("PATH"),
1745 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1746 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1750 perror_with_name (expanded_name
.get ());
1752 name
= absolute_name
.get ();
1755 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1756 if (sym_bfd
== NULL
)
1757 error (_("`%s': can't open to read symbols: %s."), name
,
1758 bfd_errmsg (bfd_get_error ()));
1760 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1761 error (_("`%s': can't read symbols: %s."), name
,
1762 bfd_errmsg (bfd_get_error ()));
1767 /* See symfile.h. */
1770 symfile_bfd_open_no_error (const char *name
) noexcept
1774 return symfile_bfd_open (name
);
1776 catch (const gdb_exception_error
&err
)
1778 warning ("%s", err
.what ());
1784 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1785 the section was not found. */
1788 get_section_index (struct objfile
*objfile
, const char *section_name
)
1790 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
.get (), section_name
);
1798 /* Link SF into the global symtab_fns list.
1799 FLAVOUR is the file format that SF handles.
1800 Called on startup by the _initialize routine in each object file format
1801 reader, to register information about each format the reader is prepared
1805 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1807 symtab_fns
.emplace_back (flavour
, sf
);
1810 /* Initialize OBJFILE to read symbols from its associated BFD. It
1811 either returns or calls error(). The result is an initialized
1812 struct sym_fns in the objfile structure, that contains cached
1813 information about the symbol file. */
1815 static const struct sym_fns
*
1816 find_sym_fns (bfd
*abfd
)
1818 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1820 if (our_flavour
== bfd_target_srec_flavour
1821 || our_flavour
== bfd_target_ihex_flavour
1822 || our_flavour
== bfd_target_tekhex_flavour
)
1823 return NULL
; /* No symbols. */
1825 for (const registered_sym_fns
&rsf
: symtab_fns
)
1826 if (our_flavour
== rsf
.sym_flavour
)
1829 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1830 bfd_get_target (abfd
));
1834 /* This function runs the load command of our current target. */
1837 load_command (const char *arg
, int from_tty
)
1841 /* The user might be reloading because the binary has changed. Take
1842 this opportunity to check. */
1843 reopen_exec_file ();
1844 reread_symbols (from_tty
);
1849 const char *parg
, *prev
;
1851 arg
= get_exec_file (1);
1853 /* We may need to quote this string so buildargv can pull it
1856 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1858 temp
.append (prev
, parg
- prev
);
1860 temp
.push_back ('\\');
1862 /* If we have not copied anything yet, then we didn't see a
1863 character to quote, and we can just leave ARG unchanged. */
1867 arg
= temp
.c_str ();
1871 target_load (arg
, from_tty
);
1873 /* After re-loading the executable, we don't really know which
1874 overlays are mapped any more. */
1875 overlay_cache_invalid
= 1;
1878 /* This version of "load" should be usable for any target. Currently
1879 it is just used for remote targets, not inftarg.c or core files,
1880 on the theory that only in that case is it useful.
1882 Avoiding xmodem and the like seems like a win (a) because we don't have
1883 to worry about finding it, and (b) On VMS, fork() is very slow and so
1884 we don't want to run a subprocess. On the other hand, I'm not sure how
1885 performance compares. */
1887 static int validate_download
= 0;
1889 /* Opaque data for load_progress. */
1890 struct load_progress_data
1892 /* Cumulative data. */
1893 unsigned long write_count
= 0;
1894 unsigned long data_count
= 0;
1895 bfd_size_type total_size
= 0;
1898 /* Opaque data for load_progress for a single section. */
1899 struct load_progress_section_data
1901 load_progress_section_data (load_progress_data
*cumulative_
,
1902 const char *section_name_
, ULONGEST section_size_
,
1903 CORE_ADDR lma_
, gdb_byte
*buffer_
)
1904 : cumulative (cumulative_
), section_name (section_name_
),
1905 section_size (section_size_
), lma (lma_
), buffer (buffer_
)
1908 struct load_progress_data
*cumulative
;
1910 /* Per-section data. */
1911 const char *section_name
;
1912 ULONGEST section_sent
= 0;
1913 ULONGEST section_size
;
1918 /* Opaque data for load_section_callback. */
1919 struct load_section_data
1921 load_section_data (load_progress_data
*progress_data_
)
1922 : progress_data (progress_data_
)
1925 ~load_section_data ()
1927 for (auto &&request
: requests
)
1929 xfree (request
.data
);
1930 delete ((load_progress_section_data
*) request
.baton
);
1934 CORE_ADDR load_offset
= 0;
1935 struct load_progress_data
*progress_data
;
1936 std::vector
<struct memory_write_request
> requests
;
1939 /* Target write callback routine for progress reporting. */
1942 load_progress (ULONGEST bytes
, void *untyped_arg
)
1944 struct load_progress_section_data
*args
1945 = (struct load_progress_section_data
*) untyped_arg
;
1946 struct load_progress_data
*totals
;
1949 /* Writing padding data. No easy way to get at the cumulative
1950 stats, so just ignore this. */
1953 totals
= args
->cumulative
;
1955 if (bytes
== 0 && args
->section_sent
== 0)
1957 /* The write is just starting. Let the user know we've started
1959 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1961 hex_string (args
->section_size
),
1962 paddress (current_inferior ()->arch (),
1967 if (validate_download
)
1969 /* Broken memories and broken monitors manifest themselves here
1970 when bring new computers to life. This doubles already slow
1972 /* NOTE: cagney/1999-10-18: A more efficient implementation
1973 might add a verify_memory() method to the target vector and
1974 then use that. remote.c could implement that method using
1975 the ``qCRC'' packet. */
1976 gdb::byte_vector
check (bytes
);
1978 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1979 error (_("Download verify read failed at %s"),
1980 paddress (current_inferior ()->arch (), args
->lma
));
1981 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1982 error (_("Download verify compare failed at %s"),
1983 paddress (current_inferior ()->arch (), args
->lma
));
1985 totals
->data_count
+= bytes
;
1987 args
->buffer
+= bytes
;
1988 totals
->write_count
+= 1;
1989 args
->section_sent
+= bytes
;
1990 if (check_quit_flag ()
1991 || (deprecated_ui_load_progress_hook
!= NULL
1992 && deprecated_ui_load_progress_hook (args
->section_name
,
1993 args
->section_sent
)))
1994 error (_("Canceled the download"));
1996 if (deprecated_show_load_progress
!= NULL
)
1997 deprecated_show_load_progress (args
->section_name
,
2001 totals
->total_size
);
2004 /* Service function for generic_load. */
2007 load_one_section (bfd
*abfd
, asection
*asec
,
2008 struct load_section_data
*args
)
2010 bfd_size_type size
= bfd_section_size (asec
);
2011 const char *sect_name
= bfd_section_name (asec
);
2013 if ((bfd_section_flags (asec
) & SEC_LOAD
) == 0)
2019 ULONGEST begin
= bfd_section_lma (asec
) + args
->load_offset
;
2020 ULONGEST end
= begin
+ size
;
2021 gdb_byte
*buffer
= (gdb_byte
*) xmalloc (size
);
2022 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2024 load_progress_section_data
*section_data
2025 = new load_progress_section_data (args
->progress_data
, sect_name
, size
,
2028 args
->requests
.emplace_back (begin
, end
, buffer
, section_data
);
2031 static void print_transfer_performance (struct ui_file
*stream
,
2032 unsigned long data_count
,
2033 unsigned long write_count
,
2034 std::chrono::steady_clock::duration d
);
2036 /* See symfile.h. */
2039 generic_load (const char *args
, int from_tty
)
2041 struct load_progress_data total_progress
;
2042 struct load_section_data
cbdata (&total_progress
);
2043 struct ui_out
*uiout
= current_uiout
;
2046 error_no_arg (_("file to load"));
2048 gdb_argv
argv (args
);
2050 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2052 if (argv
[1] != NULL
)
2056 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2058 /* If the last word was not a valid number then
2059 treat it as a file name with spaces in. */
2060 if (argv
[1] == endptr
)
2061 error (_("Invalid download offset:%s."), argv
[1]);
2063 if (argv
[2] != NULL
)
2064 error (_("Too many parameters."));
2067 /* Open the file for loading. */
2068 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
));
2069 if (loadfile_bfd
== NULL
)
2070 perror_with_name (filename
.get ());
2072 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2074 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2075 bfd_errmsg (bfd_get_error ()));
2078 for (asection
*asec
: gdb_bfd_sections (loadfile_bfd
))
2079 total_progress
.total_size
+= bfd_section_size (asec
);
2081 for (asection
*asec
: gdb_bfd_sections (loadfile_bfd
))
2082 load_one_section (loadfile_bfd
.get (), asec
, &cbdata
);
2084 using namespace std::chrono
;
2086 steady_clock::time_point start_time
= steady_clock::now ();
2088 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2089 load_progress
) != 0)
2090 error (_("Load failed"));
2092 steady_clock::time_point end_time
= steady_clock::now ();
2094 CORE_ADDR entry
= bfd_get_start_address (loadfile_bfd
.get ());
2095 entry
= gdbarch_addr_bits_remove (current_inferior ()->arch (), entry
);
2096 uiout
->text ("Start address ");
2097 uiout
->field_core_addr ("address", current_inferior ()->arch (), entry
);
2098 uiout
->text (", load size ");
2099 uiout
->field_unsigned ("load-size", total_progress
.data_count
);
2101 regcache_write_pc (get_current_regcache (), entry
);
2103 /* Reset breakpoints, now that we have changed the load image. For
2104 instance, breakpoints may have been set (or reset, by
2105 post_create_inferior) while connected to the target but before we
2106 loaded the program. In that case, the prologue analyzer could
2107 have read instructions from the target to find the right
2108 breakpoint locations. Loading has changed the contents of that
2111 breakpoint_re_set ();
2113 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2114 total_progress
.write_count
,
2115 end_time
- start_time
);
2118 /* Report on STREAM the performance of a memory transfer operation,
2119 such as 'load'. DATA_COUNT is the number of bytes transferred.
2120 WRITE_COUNT is the number of separate write operations, or 0, if
2121 that information is not available. TIME is how long the operation
2125 print_transfer_performance (struct ui_file
*stream
,
2126 unsigned long data_count
,
2127 unsigned long write_count
,
2128 std::chrono::steady_clock::duration time
)
2130 using namespace std::chrono
;
2131 struct ui_out
*uiout
= current_uiout
;
2133 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2135 uiout
->text ("Transfer rate: ");
2136 if (ms
.count () > 0)
2138 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2140 if (uiout
->is_mi_like_p ())
2142 uiout
->field_unsigned ("transfer-rate", rate
* 8);
2143 uiout
->text (" bits/sec");
2145 else if (rate
< 1024)
2147 uiout
->field_unsigned ("transfer-rate", rate
);
2148 uiout
->text (" bytes/sec");
2152 uiout
->field_unsigned ("transfer-rate", rate
/ 1024);
2153 uiout
->text (" KB/sec");
2158 uiout
->field_unsigned ("transferred-bits", (data_count
* 8));
2159 uiout
->text (" bits in <1 sec");
2161 if (write_count
> 0)
2164 uiout
->field_unsigned ("write-rate", data_count
/ write_count
);
2165 uiout
->text (" bytes/write");
2167 uiout
->text (".\n");
2170 /* Add an OFFSET to the start address of each section in OBJF, except
2171 sections that were specified in ADDRS. */
2174 set_objfile_default_section_offset (struct objfile
*objf
,
2175 const section_addr_info
&addrs
,
2178 /* Add OFFSET to all sections by default. */
2179 section_offsets
offsets (objf
->section_offsets
.size (), offset
);
2181 /* Create sorted lists of all sections in ADDRS as well as all
2182 sections in OBJF. */
2184 std::vector
<const struct other_sections
*> addrs_sorted
2185 = addrs_section_sort (addrs
);
2187 section_addr_info objf_addrs
2188 = build_section_addr_info_from_objfile (objf
);
2189 std::vector
<const struct other_sections
*> objf_addrs_sorted
2190 = addrs_section_sort (objf_addrs
);
2192 /* Walk the BFD section list, and if a matching section is found in
2193 ADDRS_SORTED_LIST, set its offset to zero to keep its address
2196 Note that both lists may contain multiple sections with the same
2197 name, and then the sections from ADDRS are matched in BFD order
2198 (thanks to sectindex). */
2200 std::vector
<const struct other_sections
*>::iterator addrs_sorted_iter
2201 = addrs_sorted
.begin ();
2202 for (const other_sections
*objf_sect
: objf_addrs_sorted
)
2204 const char *objf_name
= addr_section_name (objf_sect
->name
.c_str ());
2207 while (cmp
< 0 && addrs_sorted_iter
!= addrs_sorted
.end ())
2209 const struct other_sections
*sect
= *addrs_sorted_iter
;
2210 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
2211 cmp
= strcmp (sect_name
, objf_name
);
2213 ++addrs_sorted_iter
;
2217 offsets
[objf_sect
->sectindex
] = 0;
2220 /* Apply the new section offsets. */
2221 objfile_relocate (objf
, offsets
);
2224 /* This function allows the addition of incrementally linked object files.
2225 It does not modify any state in the target, only in the debugger. */
2228 add_symbol_file_command (const char *args
, int from_tty
)
2230 struct gdbarch
*gdbarch
= get_current_arch ();
2231 gdb::unique_xmalloc_ptr
<char> filename
;
2234 struct objfile
*objf
;
2235 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2236 symfile_add_flags add_flags
= 0;
2239 add_flags
|= SYMFILE_VERBOSE
;
2247 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2248 bool stop_processing_options
= false;
2249 CORE_ADDR offset
= 0;
2254 error (_("add-symbol-file takes a file name and an address"));
2256 bool seen_addr
= false;
2257 bool seen_offset
= false;
2258 gdb_argv
argv (args
);
2260 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2262 if (stop_processing_options
|| *arg
!= '-')
2264 if (filename
== NULL
)
2266 /* First non-option argument is always the filename. */
2267 filename
.reset (tilde_expand (arg
));
2269 else if (!seen_addr
)
2271 /* The second non-option argument is always the text
2272 address at which to load the program. */
2273 sect_opts
[0].value
= arg
;
2277 error (_("Unrecognized argument \"%s\""), arg
);
2279 else if (strcmp (arg
, "-readnow") == 0)
2280 flags
|= OBJF_READNOW
;
2281 else if (strcmp (arg
, "-readnever") == 0)
2282 flags
|= OBJF_READNEVER
;
2283 else if (strcmp (arg
, "-s") == 0)
2285 if (argv
[argcnt
+ 1] == NULL
)
2286 error (_("Missing section name after \"-s\""));
2287 else if (argv
[argcnt
+ 2] == NULL
)
2288 error (_("Missing section address after \"-s\""));
2290 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2292 sect_opts
.push_back (sect
);
2295 else if (strcmp (arg
, "-o") == 0)
2297 arg
= argv
[++argcnt
];
2299 error (_("Missing argument to -o"));
2301 offset
= parse_and_eval_address (arg
);
2304 else if (strcmp (arg
, "--") == 0)
2305 stop_processing_options
= true;
2307 error (_("Unrecognized argument \"%s\""), arg
);
2310 if (filename
== NULL
)
2311 error (_("You must provide a filename to be loaded."));
2313 validate_readnow_readnever (flags
);
2315 /* Print the prompt for the query below. And save the arguments into
2316 a sect_addr_info structure to be passed around to other
2317 functions. We have to split this up into separate print
2318 statements because hex_string returns a local static
2321 gdb_printf (_("add symbol table from file \"%ps\""),
2322 styled_string (file_name_style
.style (), filename
.get ()));
2323 section_addr_info section_addrs
;
2324 std::vector
<sect_opt
>::const_iterator it
= sect_opts
.begin ();
2327 for (; it
!= sect_opts
.end (); ++it
)
2330 const char *val
= it
->value
;
2331 const char *sec
= it
->name
;
2333 if (section_addrs
.empty ())
2334 gdb_printf (_(" at\n"));
2335 addr
= parse_and_eval_address (val
);
2337 /* Here we store the section offsets in the order they were
2338 entered on the command line. Every array element is
2339 assigned an ascending section index to preserve the above
2340 order over an unstable sorting algorithm. This dummy
2341 index is not used for any other purpose.
2343 section_addrs
.emplace_back (addr
, sec
, section_addrs
.size ());
2344 gdb_printf ("\t%s_addr = %s\n", sec
,
2345 paddress (gdbarch
, addr
));
2347 /* The object's sections are initialized when a
2348 call is made to build_objfile_section_table (objfile).
2349 This happens in reread_symbols.
2350 At this point, we don't know what file type this is,
2351 so we can't determine what section names are valid. */
2354 gdb_printf (_("%s offset by %s\n"),
2355 (section_addrs
.empty ()
2356 ? _(" with all sections")
2357 : _("with other sections")),
2358 paddress (gdbarch
, offset
));
2359 else if (section_addrs
.empty ())
2362 if (from_tty
&& (!query ("%s", "")))
2363 error (_("Not confirmed."));
2365 objf
= symbol_file_add (filename
.get (), add_flags
, §ion_addrs
,
2367 if (!objfile_has_symbols (objf
) && objf
->per_bfd
->minimal_symbol_count
<= 0)
2368 warning (_("newly-added symbol file \"%ps\" does not provide any symbols"),
2369 styled_string (file_name_style
.style (), filename
.get ()));
2372 set_objfile_default_section_offset (objf
, section_addrs
, offset
);
2374 current_program_space
->add_target_sections (objf
);
2376 /* Getting new symbols may change our opinion about what is
2378 reinit_frame_cache ();
2382 /* This function removes a symbol file that was added via add-symbol-file. */
2385 remove_symbol_file_command (const char *args
, int from_tty
)
2387 struct objfile
*objf
= NULL
;
2388 struct program_space
*pspace
= current_program_space
;
2393 error (_("remove-symbol-file: no symbol file provided"));
2395 gdb_argv
argv (args
);
2397 if (strcmp (argv
[0], "-a") == 0)
2399 /* Interpret the next argument as an address. */
2402 if (argv
[1] == NULL
)
2403 error (_("Missing address argument"));
2405 if (argv
[2] != NULL
)
2406 error (_("Junk after %s"), argv
[1]);
2408 addr
= parse_and_eval_address (argv
[1]);
2410 for (objfile
*objfile
: current_program_space
->objfiles ())
2412 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2413 && (objfile
->flags
& OBJF_SHARED
) != 0
2414 && objfile
->pspace
== pspace
2415 && is_addr_in_objfile (addr
, objfile
))
2422 else if (argv
[0] != NULL
)
2424 /* Interpret the current argument as a file name. */
2426 if (argv
[1] != NULL
)
2427 error (_("Junk after %s"), argv
[0]);
2429 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2431 for (objfile
*objfile
: current_program_space
->objfiles ())
2433 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2434 && (objfile
->flags
& OBJF_SHARED
) != 0
2435 && objfile
->pspace
== pspace
2436 && filename_cmp (filename
.get (), objfile_name (objfile
)) == 0)
2445 error (_("No symbol file found"));
2448 && !query (_("Remove symbol table from file \"%s\"? "),
2449 objfile_name (objf
)))
2450 error (_("Not confirmed."));
2453 clear_symtab_users (0);
2456 /* Re-read symbols if a symbol-file has changed. */
2459 reread_symbols (int from_tty
)
2461 std::vector
<struct objfile
*> new_objfiles
;
2463 /* Check to see if the executable has changed, and if so reopen it. The
2464 executable might not be in the list of objfiles (if the user set
2465 different values for 'exec-file' and 'symbol-file'), and even if it
2466 is, then we use a separate timestamp (within the program_space) to
2467 indicate when the executable was last reloaded. */
2468 reopen_exec_file ();
2470 for (objfile
*objfile
: current_program_space
->objfiles ())
2472 if (objfile
->obfd
.get () == NULL
)
2475 /* Separate debug objfiles are handled in the main objfile. */
2476 if (objfile
->separate_debug_objfile_backlink
)
2479 /* When a in-memory BFD is initially created, it's mtime (as
2480 returned by bfd_get_mtime) is the creation time of the BFD.
2481 However, we call bfd_stat here as we want to see if the
2482 underlying file has changed, and in this case an in-memory BFD
2483 will return an st_mtime of zero, so it appears that the in-memory
2484 file has changed, which isn't what we want here -- this code is
2485 about reloading BFDs that changed on disk.
2487 Just skip any in-memory BFD. */
2488 if (objfile
->obfd
.get ()->flags
& BFD_IN_MEMORY
)
2491 struct stat new_statbuf
;
2492 int res
= bfd_stat (objfile
->obfd
.get (), &new_statbuf
);
2495 /* If this object is from an archive (what you usually create
2496 with `ar', often called a `static library' on most systems,
2497 though a `shared library' on AIX is also an archive), then you
2498 should stat on the archive name, not member name. */
2499 const char *filename
;
2500 if (objfile
->obfd
->my_archive
)
2501 filename
= bfd_get_filename (objfile
->obfd
->my_archive
);
2503 filename
= objfile_name (objfile
);
2505 warning (_("`%ps' has disappeared; keeping its symbols."),
2506 styled_string (file_name_style
.style (), filename
));
2509 time_t new_modtime
= new_statbuf
.st_mtime
;
2510 if (new_modtime
!= objfile
->mtime
)
2512 gdb_printf (_("`%ps' has changed; re-reading symbols.\n"),
2513 styled_string (file_name_style
.style (),
2514 objfile_name (objfile
)));
2516 /* There are various functions like symbol_file_add,
2517 symfile_bfd_open, syms_from_objfile, etc., which might
2518 appear to do what we want. But they have various other
2519 effects which we *don't* want. So we just do stuff
2520 ourselves. We don't worry about mapped files (for one thing,
2521 any mapped file will be out of date). */
2523 /* If we get an error, blow away this objfile (not sure if
2524 that is the correct response for things like shared
2526 objfile_up
objfile_holder (objfile
);
2528 /* We need to do this whenever any symbols go away. */
2529 clear_symtab_users_cleanup
defer_clear_users (0);
2531 /* Keep the calls order approx. the same as in free_objfile. */
2533 /* Free the separate debug objfiles. It will be
2534 automatically recreated by sym_read. */
2535 free_objfile_separate_debug (objfile
);
2537 /* Clear the stale source cache. */
2538 forget_cached_source_info ();
2540 /* Remove any references to this objfile in the global
2542 preserve_values (objfile
);
2544 /* Nuke all the state that we will re-read. Much of the following
2545 code which sets things to NULL really is necessary to tell
2546 other parts of GDB that there is nothing currently there.
2548 Try to keep the freeing order compatible with free_objfile. */
2550 if (objfile
->sf
!= NULL
)
2552 (*objfile
->sf
->sym_finish
) (objfile
);
2555 objfile
->registry_fields
.clear_registry ();
2557 /* Clean up any state BFD has sitting around. */
2559 gdb_bfd_ref_ptr obfd
= objfile
->obfd
;
2560 const char *obfd_filename
;
2562 obfd_filename
= bfd_get_filename (objfile
->obfd
.get ());
2563 /* Open the new BFD before freeing the old one, so that
2564 the filename remains live. */
2565 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
));
2566 objfile
->obfd
= std::move (temp
);
2567 if (objfile
->obfd
== NULL
)
2568 error (_("Can't open %s to read symbols."), obfd_filename
);
2571 std::string original_name
= objfile
->original_name
;
2573 /* bfd_openr sets cacheable to true, which is what we want. */
2574 if (!bfd_check_format (objfile
->obfd
.get (), bfd_object
))
2575 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2576 bfd_errmsg (bfd_get_error ()));
2578 /* NB: after this call to obstack_free, objfiles_changed
2579 will need to be called (see discussion below). */
2580 obstack_free (&objfile
->objfile_obstack
, 0);
2581 objfile
->sections_start
= NULL
;
2582 objfile
->section_offsets
.clear ();
2583 objfile
->sect_index_bss
= -1;
2584 objfile
->sect_index_data
= -1;
2585 objfile
->sect_index_rodata
= -1;
2586 objfile
->sect_index_text
= -1;
2587 objfile
->compunit_symtabs
= NULL
;
2588 objfile
->template_symbols
= NULL
;
2589 objfile
->static_links
.reset (nullptr);
2591 /* obstack_init also initializes the obstack so it is
2592 empty. We could use obstack_specify_allocation but
2593 gdb_obstack.h specifies the alloc/dealloc functions. */
2594 obstack_init (&objfile
->objfile_obstack
);
2596 /* set_objfile_per_bfd potentially allocates the per-bfd
2597 data on the objfile's obstack (if sharing data across
2598 multiple users is not possible), so it's important to
2599 do it *after* the obstack has been initialized. */
2600 set_objfile_per_bfd (objfile
);
2602 objfile
->original_name
2603 = obstack_strdup (&objfile
->objfile_obstack
, original_name
);
2605 /* Reset the sym_fns pointer. The ELF reader can change it
2606 based on whether .gdb_index is present, and we need it to
2607 start over. PR symtab/15885 */
2608 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
.get ()));
2609 objfile
->qf
.clear ();
2611 build_objfile_section_table (objfile
);
2613 /* What the hell is sym_new_init for, anyway? The concept of
2614 distinguishing between the main file and additional files
2615 in this way seems rather dubious. */
2616 if (objfile
== current_program_space
->symfile_object_file
)
2618 (*objfile
->sf
->sym_new_init
) (objfile
);
2621 (*objfile
->sf
->sym_init
) (objfile
);
2622 clear_complaints ();
2624 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2626 /* We are about to read new symbols and potentially also
2627 DWARF information. Some targets may want to pass addresses
2628 read from DWARF DIE's through an adjustment function before
2629 saving them, like MIPS, which may call into
2630 "find_pc_section". When called, that function will make
2631 use of per-objfile program space data.
2633 Since we discarded our section information above, we have
2634 dangling pointers in the per-objfile program space data
2635 structure. Force GDB to update the section mapping
2636 information by letting it know the objfile has changed,
2637 making the dangling pointers point to correct data
2640 objfiles_changed ();
2642 /* Recompute section offsets and section indices. */
2643 objfile
->sf
->sym_offsets (objfile
, {});
2645 read_symbols (objfile
, 0);
2647 if ((objfile
->flags
& OBJF_READNOW
))
2649 const int mainline
= objfile
->flags
& OBJF_MAINLINE
;
2650 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
2651 && readnow_symbol_files
);
2653 gdb_printf (_("Expanding full symbols from %ps...\n"),
2654 styled_string (file_name_style
.style (),
2655 objfile_name (objfile
)));
2657 objfile
->expand_all_symtabs ();
2660 if (!objfile_has_symbols (objfile
))
2662 gdb_stdout
->wrap_here (0);
2663 gdb_printf (_("(no debugging symbols found)\n"));
2664 gdb_stdout
->wrap_here (0);
2667 /* We're done reading the symbol file; finish off complaints. */
2668 clear_complaints ();
2670 /* Getting new symbols may change our opinion about what is
2673 reinit_frame_cache ();
2675 /* Discard cleanups as symbol reading was successful. */
2676 objfile_holder
.release ();
2677 defer_clear_users
.release ();
2679 /* If the mtime has changed between the time we set new_modtime
2680 and now, we *want* this to be out of date, so don't call stat
2682 objfile
->mtime
= new_modtime
;
2683 init_entry_point_info (objfile
);
2685 new_objfiles
.push_back (objfile
);
2689 if (!new_objfiles
.empty ())
2691 clear_symtab_users (0);
2693 /* The registry for each objfile was cleared and
2694 gdb::observers::new_objfile.notify (NULL) has been called by
2695 clear_symtab_users above. Notify the new files now. */
2696 for (auto iter
: new_objfiles
)
2697 gdb::observers::new_objfile
.notify (iter
);
2702 struct filename_language
2704 filename_language (const std::string
&ext_
, enum language lang_
)
2705 : ext (ext_
), lang (lang_
)
2712 static std::vector
<filename_language
> filename_language_table
;
2714 /* See symfile.h. */
2717 add_filename_language (const char *ext
, enum language lang
)
2719 gdb_assert (ext
!= nullptr);
2720 filename_language_table
.emplace_back (ext
, lang
);
2723 static std::string ext_args
;
2725 show_ext_args (struct ui_file
*file
, int from_tty
,
2726 struct cmd_list_element
*c
, const char *value
)
2729 _("Mapping between filename extension "
2730 "and source language is \"%s\".\n"),
2735 set_ext_lang_command (const char *args
,
2736 int from_tty
, struct cmd_list_element
*e
)
2738 const char *begin
= ext_args
.c_str ();
2739 const char *end
= ext_args
.c_str ();
2741 /* First arg is filename extension, starting with '.' */
2743 error (_("'%s': Filename extension must begin with '.'"), ext_args
.c_str ());
2745 /* Find end of first arg. */
2746 while (*end
!= '\0' && !isspace (*end
))
2750 error (_("'%s': two arguments required -- "
2751 "filename extension and language"),
2754 /* Extract first arg, the extension. */
2755 std::string extension
= ext_args
.substr (0, end
- begin
);
2757 /* Find beginning of second arg, which should be a source language. */
2758 begin
= skip_spaces (end
);
2761 error (_("'%s': two arguments required -- "
2762 "filename extension and language"),
2765 /* Lookup the language from among those we know. */
2766 language lang
= language_enum (begin
);
2768 auto it
= filename_language_table
.begin ();
2769 /* Now lookup the filename extension: do we already know it? */
2770 for (; it
!= filename_language_table
.end (); it
++)
2772 if (it
->ext
== extension
)
2776 if (it
== filename_language_table
.end ())
2778 /* New file extension. */
2779 add_filename_language (extension
.data (), lang
);
2783 /* Redefining a previously known filename extension. */
2786 /* query ("Really make files of type %s '%s'?", */
2787 /* ext_args, language_str (lang)); */
2794 info_ext_lang_command (const char *args
, int from_tty
)
2796 gdb_printf (_("Filename extensions and the languages they represent:"));
2797 gdb_printf ("\n\n");
2798 for (const filename_language
&entry
: filename_language_table
)
2799 gdb_printf ("\t%s\t- %s\n", entry
.ext
.c_str (),
2800 language_str (entry
.lang
));
2804 deduce_language_from_filename (const char *filename
)
2808 if (filename
!= NULL
)
2809 if ((cp
= strrchr (filename
, '.')) != NULL
)
2811 for (const filename_language
&entry
: filename_language_table
)
2812 if (entry
.ext
== cp
)
2816 return language_unknown
;
2819 /* Allocate and initialize a new symbol table.
2820 CUST is from the result of allocate_compunit_symtab. */
2823 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
,
2824 const char *filename_for_id
)
2826 struct objfile
*objfile
= cust
->objfile ();
2827 struct symtab
*symtab
2828 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2830 symtab
->filename
= objfile
->intern (filename
);
2831 symtab
->filename_for_id
= objfile
->intern (filename_for_id
);
2832 symtab
->fullname
= NULL
;
2833 symtab
->set_language (deduce_language_from_filename (filename
));
2835 /* This can be very verbose with lots of headers.
2836 Only print at higher debug levels. */
2837 if (symtab_create_debug
>= 2)
2839 /* Be a bit clever with debugging messages, and don't print objfile
2840 every time, only when it changes. */
2841 static std::string last_objfile_name
;
2842 const char *this_objfile_name
= objfile_name (objfile
);
2844 if (last_objfile_name
.empty () || last_objfile_name
!= this_objfile_name
)
2846 last_objfile_name
= this_objfile_name
;
2848 symtab_create_debug_printf_v
2849 ("creating one or more symtabs for objfile %s", this_objfile_name
);
2852 symtab_create_debug_printf_v ("created symtab %s for module %s",
2853 host_address_to_string (symtab
), filename
);
2856 /* Add it to CUST's list of symtabs. */
2857 cust
->add_filetab (symtab
);
2859 /* Backlink to the containing compunit symtab. */
2860 symtab
->set_compunit (cust
);
2865 /* Allocate and initialize a new compunit.
2866 NAME is the name of the main source file, if there is one, or some
2867 descriptive text if there are no source files. */
2869 struct compunit_symtab
*
2870 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2872 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2873 struct compunit_symtab
);
2874 const char *saved_name
;
2876 cu
->set_objfile (objfile
);
2878 /* The name we record here is only for display/debugging purposes.
2879 Just save the basename to avoid path issues (too long for display,
2880 relative vs absolute, etc.). */
2881 saved_name
= lbasename (name
);
2882 cu
->name
= obstack_strdup (&objfile
->objfile_obstack
, saved_name
);
2884 cu
->set_debugformat ("unknown");
2886 symtab_create_debug_printf_v ("created compunit symtab %s for %s",
2887 host_address_to_string (cu
),
2893 /* Hook CU to the objfile it comes from. */
2896 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2898 cu
->next
= cu
->objfile ()->compunit_symtabs
;
2899 cu
->objfile ()->compunit_symtabs
= cu
;
2903 /* Reset all data structures in gdb which may contain references to
2904 symbol table data. */
2907 clear_symtab_users (symfile_add_flags add_flags
)
2909 /* Someday, we should do better than this, by only blowing away
2910 the things that really need to be blown. */
2912 /* Clear the "current" symtab first, because it is no longer valid.
2913 breakpoint_re_set may try to access the current symtab. */
2914 clear_current_source_symtab_and_line ();
2917 clear_last_displayed_sal ();
2918 clear_pc_function_cache ();
2919 gdb::observers::all_objfiles_removed
.notify (current_program_space
);
2921 /* Now that the various caches have been cleared, we can re_set
2922 our breakpoints without risking it using stale data. */
2923 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2924 breakpoint_re_set ();
2928 The following code implements an abstraction for debugging overlay sections.
2930 The target model is as follows:
2931 1) The gnu linker will permit multiple sections to be mapped into the
2932 same VMA, each with its own unique LMA (or load address).
2933 2) It is assumed that some runtime mechanism exists for mapping the
2934 sections, one by one, from the load address into the VMA address.
2935 3) This code provides a mechanism for gdb to keep track of which
2936 sections should be considered to be mapped from the VMA to the LMA.
2937 This information is used for symbol lookup, and memory read/write.
2938 For instance, if a section has been mapped then its contents
2939 should be read from the VMA, otherwise from the LMA.
2941 Two levels of debugger support for overlays are available. One is
2942 "manual", in which the debugger relies on the user to tell it which
2943 overlays are currently mapped. This level of support is
2944 implemented entirely in the core debugger, and the information about
2945 whether a section is mapped is kept in the objfile->obj_section table.
2947 The second level of support is "automatic", and is only available if
2948 the target-specific code provides functionality to read the target's
2949 overlay mapping table, and translate its contents for the debugger
2950 (by updating the mapped state information in the obj_section tables).
2952 The interface is as follows:
2954 overlay map <name> -- tell gdb to consider this section mapped
2955 overlay unmap <name> -- tell gdb to consider this section unmapped
2956 overlay list -- list the sections that GDB thinks are mapped
2957 overlay read-target -- get the target's state of what's mapped
2958 overlay off/manual/auto -- set overlay debugging state
2959 Functional interface:
2960 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2961 section, return that section.
2962 find_pc_overlay(pc): find any overlay section that contains
2963 the pc, either in its VMA or its LMA
2964 section_is_mapped(sect): true if overlay is marked as mapped
2965 section_is_overlay(sect): true if section's VMA != LMA
2966 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2967 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2968 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2969 overlay_mapped_address(...): map an address from section's LMA to VMA
2970 overlay_unmapped_address(...): map an address from section's VMA to LMA
2971 symbol_overlayed_address(...): Return a "current" address for symbol:
2972 either in VMA or LMA depending on whether
2973 the symbol's section is currently mapped. */
2975 /* Overlay debugging state: */
2977 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2978 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2980 /* Function: section_is_overlay (SECTION)
2981 Returns true if SECTION has VMA not equal to LMA, ie.
2982 SECTION is loaded at an address different from where it will "run". */
2985 section_is_overlay (struct obj_section
*section
)
2987 if (overlay_debugging
&& section
)
2989 asection
*bfd_section
= section
->the_bfd_section
;
2991 if (bfd_section_lma (bfd_section
) != 0
2992 && bfd_section_lma (bfd_section
) != bfd_section_vma (bfd_section
))
2999 /* Function: overlay_invalidate_all (void)
3000 Invalidate the mapped state of all overlay sections (mark it as stale). */
3003 overlay_invalidate_all (void)
3005 for (objfile
*objfile
: current_program_space
->objfiles ())
3006 for (obj_section
*sect
: objfile
->sections ())
3007 if (section_is_overlay (sect
))
3008 sect
->ovly_mapped
= -1;
3011 /* Function: section_is_mapped (SECTION)
3012 Returns true if section is an overlay, and is currently mapped.
3014 Access to the ovly_mapped flag is restricted to this function, so
3015 that we can do automatic update. If the global flag
3016 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3017 overlay_invalidate_all. If the mapped state of the particular
3018 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3021 section_is_mapped (struct obj_section
*osect
)
3023 struct gdbarch
*gdbarch
;
3025 if (osect
== 0 || !section_is_overlay (osect
))
3028 switch (overlay_debugging
)
3032 return 0; /* overlay debugging off */
3033 case ovly_auto
: /* overlay debugging automatic */
3034 /* Unles there is a gdbarch_overlay_update function,
3035 there's really nothing useful to do here (can't really go auto). */
3036 gdbarch
= osect
->objfile
->arch ();
3037 if (gdbarch_overlay_update_p (gdbarch
))
3039 if (overlay_cache_invalid
)
3041 overlay_invalidate_all ();
3042 overlay_cache_invalid
= 0;
3044 if (osect
->ovly_mapped
== -1)
3045 gdbarch_overlay_update (gdbarch
, osect
);
3048 case ovly_on
: /* overlay debugging manual */
3049 return osect
->ovly_mapped
== 1;
3053 /* Function: pc_in_unmapped_range
3054 If PC falls into the lma range of SECTION, return true, else false. */
3057 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3059 if (section_is_overlay (section
))
3061 asection
*bfd_section
= section
->the_bfd_section
;
3063 /* We assume the LMA is relocated by the same offset as the VMA. */
3064 bfd_vma size
= bfd_section_size (bfd_section
);
3065 CORE_ADDR offset
= section
->offset ();
3067 if (bfd_section_lma (bfd_section
) + offset
<= pc
3068 && pc
< bfd_section_lma (bfd_section
) + offset
+ size
)
3075 /* Function: pc_in_mapped_range
3076 If PC falls into the vma range of SECTION, return true, else false. */
3079 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3081 if (section_is_overlay (section
))
3083 if (section
->addr () <= pc
3084 && pc
< section
->endaddr ())
3091 /* Return true if the mapped ranges of sections A and B overlap, false
3095 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3097 CORE_ADDR a_start
= a
->addr ();
3098 CORE_ADDR a_end
= a
->endaddr ();
3099 CORE_ADDR b_start
= b
->addr ();
3100 CORE_ADDR b_end
= b
->endaddr ();
3102 return (a_start
< b_end
&& b_start
< a_end
);
3105 /* Function: overlay_unmapped_address (PC, SECTION)
3106 Returns the address corresponding to PC in the unmapped (load) range.
3107 May be the same as PC. */
3110 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3112 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3114 asection
*bfd_section
= section
->the_bfd_section
;
3116 return (pc
+ bfd_section_lma (bfd_section
)
3117 - bfd_section_vma (bfd_section
));
3123 /* Function: overlay_mapped_address (PC, SECTION)
3124 Returns the address corresponding to PC in the mapped (runtime) range.
3125 May be the same as PC. */
3128 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3130 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3132 asection
*bfd_section
= section
->the_bfd_section
;
3134 return (pc
+ bfd_section_vma (bfd_section
)
3135 - bfd_section_lma (bfd_section
));
3141 /* Function: symbol_overlayed_address
3142 Return one of two addresses (relative to the VMA or to the LMA),
3143 depending on whether the section is mapped or not. */
3146 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3148 if (overlay_debugging
)
3150 /* If the symbol has no section, just return its regular address. */
3153 /* If the symbol's section is not an overlay, just return its
3155 if (!section_is_overlay (section
))
3157 /* If the symbol's section is mapped, just return its address. */
3158 if (section_is_mapped (section
))
3161 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3162 * then return its LOADED address rather than its vma address!!
3164 return overlay_unmapped_address (address
, section
);
3169 /* Function: find_pc_overlay (PC)
3170 Return the best-match overlay section for PC:
3171 If PC matches a mapped overlay section's VMA, return that section.
3172 Else if PC matches an unmapped section's VMA, return that section.
3173 Else if PC matches an unmapped section's LMA, return that section. */
3175 struct obj_section
*
3176 find_pc_overlay (CORE_ADDR pc
)
3178 struct obj_section
*best_match
= NULL
;
3180 if (overlay_debugging
)
3182 for (objfile
*objfile
: current_program_space
->objfiles ())
3183 for (obj_section
*osect
: objfile
->sections ())
3184 if (section_is_overlay (osect
))
3186 if (pc_in_mapped_range (pc
, osect
))
3188 if (section_is_mapped (osect
))
3193 else if (pc_in_unmapped_range (pc
, osect
))
3200 /* Function: find_pc_mapped_section (PC)
3201 If PC falls into the VMA address range of an overlay section that is
3202 currently marked as MAPPED, return that section. Else return NULL. */
3204 struct obj_section
*
3205 find_pc_mapped_section (CORE_ADDR pc
)
3207 if (overlay_debugging
)
3209 for (objfile
*objfile
: current_program_space
->objfiles ())
3210 for (obj_section
*osect
: objfile
->sections ())
3211 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3218 /* Function: list_overlays_command
3219 Print a list of mapped sections and their PC ranges. */
3222 list_overlays_command (const char *args
, int from_tty
)
3226 if (overlay_debugging
)
3228 for (objfile
*objfile
: current_program_space
->objfiles ())
3229 for (obj_section
*osect
: objfile
->sections ())
3230 if (section_is_mapped (osect
))
3232 struct gdbarch
*gdbarch
= objfile
->arch ();
3237 vma
= bfd_section_vma (osect
->the_bfd_section
);
3238 lma
= bfd_section_lma (osect
->the_bfd_section
);
3239 size
= bfd_section_size (osect
->the_bfd_section
);
3240 name
= bfd_section_name (osect
->the_bfd_section
);
3242 gdb_printf ("Section %s, loaded at ", name
);
3243 gdb_puts (paddress (gdbarch
, lma
));
3245 gdb_puts (paddress (gdbarch
, lma
+ size
));
3246 gdb_printf (", mapped at ");
3247 gdb_puts (paddress (gdbarch
, vma
));
3249 gdb_puts (paddress (gdbarch
, vma
+ size
));
3256 gdb_printf (_("No sections are mapped.\n"));
3259 /* Function: map_overlay_command
3260 Mark the named section as mapped (ie. residing at its VMA address). */
3263 map_overlay_command (const char *args
, int from_tty
)
3265 if (!overlay_debugging
)
3266 error (_("Overlay debugging not enabled. Use "
3267 "either the 'overlay auto' or\n"
3268 "the 'overlay manual' command."));
3270 if (args
== 0 || *args
== 0)
3271 error (_("Argument required: name of an overlay section"));
3273 /* First, find a section matching the user supplied argument. */
3274 for (objfile
*obj_file
: current_program_space
->objfiles ())
3275 for (obj_section
*sec
: obj_file
->sections ())
3276 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3278 /* Now, check to see if the section is an overlay. */
3279 if (!section_is_overlay (sec
))
3280 continue; /* not an overlay section */
3282 /* Mark the overlay as "mapped". */
3283 sec
->ovly_mapped
= 1;
3285 /* Next, make a pass and unmap any sections that are
3286 overlapped by this new section: */
3287 for (objfile
*objfile2
: current_program_space
->objfiles ())
3288 for (obj_section
*sec2
: objfile2
->sections ())
3289 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
,
3293 gdb_printf (_("Note: section %s unmapped by overlap\n"),
3294 bfd_section_name (sec2
->the_bfd_section
));
3295 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3299 error (_("No overlay section called %s"), args
);
3302 /* Function: unmap_overlay_command
3303 Mark the overlay section as unmapped
3304 (ie. resident in its LMA address range, rather than the VMA range). */
3307 unmap_overlay_command (const char *args
, int from_tty
)
3309 if (!overlay_debugging
)
3310 error (_("Overlay debugging not enabled. "
3311 "Use either the 'overlay auto' or\n"
3312 "the 'overlay manual' command."));
3314 if (args
== 0 || *args
== 0)
3315 error (_("Argument required: name of an overlay section"));
3317 /* First, find a section matching the user supplied argument. */
3318 for (objfile
*objfile
: current_program_space
->objfiles ())
3319 for (obj_section
*sec
: objfile
->sections ())
3320 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3322 if (!sec
->ovly_mapped
)
3323 error (_("Section %s is not mapped"), args
);
3324 sec
->ovly_mapped
= 0;
3327 error (_("No overlay section called %s"), args
);
3330 /* Function: overlay_auto_command
3331 A utility command to turn on overlay debugging.
3332 Possibly this should be done via a set/show command. */
3335 overlay_auto_command (const char *args
, int from_tty
)
3337 overlay_debugging
= ovly_auto
;
3338 enable_overlay_breakpoints ();
3340 gdb_printf (_("Automatic overlay debugging enabled."));
3343 /* Function: overlay_manual_command
3344 A utility command to turn on overlay debugging.
3345 Possibly this should be done via a set/show command. */
3348 overlay_manual_command (const char *args
, int from_tty
)
3350 overlay_debugging
= ovly_on
;
3351 disable_overlay_breakpoints ();
3353 gdb_printf (_("Overlay debugging enabled."));
3356 /* Function: overlay_off_command
3357 A utility command to turn on overlay debugging.
3358 Possibly this should be done via a set/show command. */
3361 overlay_off_command (const char *args
, int from_tty
)
3363 overlay_debugging
= ovly_off
;
3364 disable_overlay_breakpoints ();
3366 gdb_printf (_("Overlay debugging disabled."));
3370 overlay_load_command (const char *args
, int from_tty
)
3372 struct gdbarch
*gdbarch
= get_current_arch ();
3374 if (gdbarch_overlay_update_p (gdbarch
))
3375 gdbarch_overlay_update (gdbarch
, NULL
);
3377 error (_("This target does not know how to read its overlay state."));
3380 /* Command list chain containing all defined "overlay" subcommands. */
3381 static struct cmd_list_element
*overlaylist
;
3383 /* Target Overlays for the "Simplest" overlay manager:
3385 This is GDB's default target overlay layer. It works with the
3386 minimal overlay manager supplied as an example by Cygnus. The
3387 entry point is via a function pointer "gdbarch_overlay_update",
3388 so targets that use a different runtime overlay manager can
3389 substitute their own overlay_update function and take over the
3392 The overlay_update function pokes around in the target's data structures
3393 to see what overlays are mapped, and updates GDB's overlay mapping with
3396 In this simple implementation, the target data structures are as follows:
3397 unsigned _novlys; /# number of overlay sections #/
3398 unsigned _ovly_table[_novlys][4] = {
3399 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3400 {..., ..., ..., ...},
3402 unsigned _novly_regions; /# number of overlay regions #/
3403 unsigned _ovly_region_table[_novly_regions][3] = {
3404 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3407 These functions will attempt to update GDB's mappedness state in the
3408 symbol section table, based on the target's mappedness state.
3410 To do this, we keep a cached copy of the target's _ovly_table, and
3411 attempt to detect when the cached copy is invalidated. The main
3412 entry point is "simple_overlay_update(SECT), which looks up SECT in
3413 the cached table and re-reads only the entry for that section from
3414 the target (whenever possible). */
3416 /* Cached, dynamically allocated copies of the target data structures: */
3417 static unsigned (*cache_ovly_table
)[4] = 0;
3418 static unsigned cache_novlys
= 0;
3419 static CORE_ADDR cache_ovly_table_base
= 0;
3422 VMA
, OSIZE
, LMA
, MAPPED
3425 /* Throw away the cached copy of _ovly_table. */
3428 simple_free_overlay_table (void)
3430 xfree (cache_ovly_table
);
3432 cache_ovly_table
= NULL
;
3433 cache_ovly_table_base
= 0;
3436 /* Read an array of ints of size SIZE from the target into a local buffer.
3437 Convert to host order. int LEN is number of ints. */
3440 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3441 int len
, int size
, enum bfd_endian byte_order
)
3443 /* FIXME (alloca): Not safe if array is very large. */
3444 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3447 read_memory (memaddr
, buf
, len
* size
);
3448 for (i
= 0; i
< len
; i
++)
3449 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3452 /* Find and grab a copy of the target _ovly_table
3453 (and _novlys, which is needed for the table's size). */
3456 simple_read_overlay_table (void)
3458 struct bound_minimal_symbol novlys_msym
;
3459 struct bound_minimal_symbol ovly_table_msym
;
3460 struct gdbarch
*gdbarch
;
3462 enum bfd_endian byte_order
;
3464 simple_free_overlay_table ();
3465 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3466 if (! novlys_msym
.minsym
)
3468 error (_("Error reading inferior's overlay table: "
3469 "couldn't find `_novlys' variable\n"
3470 "in inferior. Use `overlay manual' mode."));
3474 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3475 if (! ovly_table_msym
.minsym
)
3477 error (_("Error reading inferior's overlay table: couldn't find "
3478 "`_ovly_table' array\n"
3479 "in inferior. Use `overlay manual' mode."));
3483 gdbarch
= ovly_table_msym
.objfile
->arch ();
3484 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3485 byte_order
= gdbarch_byte_order (gdbarch
);
3487 cache_novlys
= read_memory_integer (novlys_msym
.value_address (),
3490 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3491 cache_ovly_table_base
= ovly_table_msym
.value_address ();
3492 read_target_long_array (cache_ovly_table_base
,
3493 (unsigned int *) cache_ovly_table
,
3494 cache_novlys
* 4, word_size
, byte_order
);
3496 return 1; /* SUCCESS */
3499 /* Function: simple_overlay_update_1
3500 A helper function for simple_overlay_update. Assuming a cached copy
3501 of _ovly_table exists, look through it to find an entry whose vma,
3502 lma and size match those of OSECT. Re-read the entry and make sure
3503 it still matches OSECT (else the table may no longer be valid).
3504 Set OSECT's mapped state to match the entry. Return: 1 for
3505 success, 0 for failure. */
3508 simple_overlay_update_1 (struct obj_section
*osect
)
3511 asection
*bsect
= osect
->the_bfd_section
;
3512 struct gdbarch
*gdbarch
= osect
->objfile
->arch ();
3513 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3514 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3516 for (i
= 0; i
< cache_novlys
; i
++)
3517 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3518 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3520 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3521 (unsigned int *) cache_ovly_table
[i
],
3522 4, word_size
, byte_order
);
3523 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3524 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3526 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3529 else /* Warning! Warning! Target's ovly table has changed! */
3535 /* Function: simple_overlay_update
3536 If OSECT is NULL, then update all sections' mapped state
3537 (after re-reading the entire target _ovly_table).
3538 If OSECT is non-NULL, then try to find a matching entry in the
3539 cached ovly_table and update only OSECT's mapped state.
3540 If a cached entry can't be found or the cache isn't valid, then
3541 re-read the entire cache, and go ahead and update all sections. */
3544 simple_overlay_update (struct obj_section
*osect
)
3546 /* Were we given an osect to look up? NULL means do all of them. */
3548 /* Have we got a cached copy of the target's overlay table? */
3549 if (cache_ovly_table
!= NULL
)
3551 /* Does its cached location match what's currently in the
3553 struct bound_minimal_symbol minsym
3554 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3556 if (minsym
.minsym
== NULL
)
3557 error (_("Error reading inferior's overlay table: couldn't "
3558 "find `_ovly_table' array\n"
3559 "in inferior. Use `overlay manual' mode."));
3561 if (cache_ovly_table_base
== minsym
.value_address ())
3562 /* Then go ahead and try to look up this single section in
3564 if (simple_overlay_update_1 (osect
))
3565 /* Found it! We're done. */
3569 /* Cached table no good: need to read the entire table anew.
3570 Or else we want all the sections, in which case it's actually
3571 more efficient to read the whole table in one block anyway. */
3573 if (! simple_read_overlay_table ())
3576 /* Now may as well update all sections, even if only one was requested. */
3577 for (objfile
*objfile
: current_program_space
->objfiles ())
3578 for (obj_section
*sect
: objfile
->sections ())
3579 if (section_is_overlay (sect
))
3582 asection
*bsect
= sect
->the_bfd_section
;
3584 for (i
= 0; i
< cache_novlys
; i
++)
3585 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3586 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3587 { /* obj_section matches i'th entry in ovly_table. */
3588 sect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3589 break; /* finished with inner for loop: break out. */
3594 /* Default implementation for sym_relocate. */
3597 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3600 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3602 bfd
*abfd
= sectp
->owner
;
3604 /* We're only interested in sections with relocation
3606 if ((sectp
->flags
& SEC_RELOC
) == 0)
3609 /* We will handle section offsets properly elsewhere, so relocate as if
3610 all sections begin at 0. */
3611 for (asection
*sect
: gdb_bfd_sections (abfd
))
3613 sect
->output_section
= sect
;
3614 sect
->output_offset
= 0;
3617 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3620 /* Relocate the contents of a debug section SECTP in ABFD. The
3621 contents are stored in BUF if it is non-NULL, or returned in a
3622 malloc'd buffer otherwise.
3624 For some platforms and debug info formats, shared libraries contain
3625 relocations against the debug sections (particularly for DWARF-2;
3626 one affected platform is PowerPC GNU/Linux, although it depends on
3627 the version of the linker in use). Also, ELF object files naturally
3628 have unresolved relocations for their debug sections. We need to apply
3629 the relocations in order to get the locations of symbols correct.
3630 Another example that may require relocation processing, is the
3631 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3635 symfile_relocate_debug_section (struct objfile
*objfile
,
3636 asection
*sectp
, bfd_byte
*buf
)
3638 gdb_assert (objfile
->sf
->sym_relocate
);
3640 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3643 symfile_segment_data_up
3644 get_symfile_segment_data (bfd
*abfd
)
3646 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3651 return sf
->sym_segments (abfd
);
3655 - DATA, containing segment addresses from the object file ABFD, and
3656 the mapping from ABFD's sections onto the segments that own them,
3658 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3659 segment addresses reported by the target,
3660 store the appropriate offsets for each section in OFFSETS.
3662 If there are fewer entries in SEGMENT_BASES than there are segments
3663 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3665 If there are more entries, then ignore the extra. The target may
3666 not be able to distinguish between an empty data segment and a
3667 missing data segment; a missing text segment is less plausible. */
3670 symfile_map_offsets_to_segments (bfd
*abfd
,
3671 const struct symfile_segment_data
*data
,
3672 section_offsets
&offsets
,
3673 int num_segment_bases
,
3674 const CORE_ADDR
*segment_bases
)
3679 /* It doesn't make sense to call this function unless you have some
3680 segment base addresses. */
3681 gdb_assert (num_segment_bases
> 0);
3683 /* If we do not have segment mappings for the object file, we
3684 can not relocate it by segments. */
3685 gdb_assert (data
!= NULL
);
3686 gdb_assert (data
->segments
.size () > 0);
3688 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3690 int which
= data
->segment_info
[i
];
3692 gdb_assert (0 <= which
&& which
<= data
->segments
.size ());
3694 /* Don't bother computing offsets for sections that aren't
3695 loaded as part of any segment. */
3699 /* Use the last SEGMENT_BASES entry as the address of any extra
3700 segments mentioned in DATA->segment_info. */
3701 if (which
> num_segment_bases
)
3702 which
= num_segment_bases
;
3704 offsets
[i
] = segment_bases
[which
- 1] - data
->segments
[which
- 1].base
;
3711 symfile_find_segment_sections (struct objfile
*objfile
)
3713 bfd
*abfd
= objfile
->obfd
.get ();
3717 symfile_segment_data_up data
= get_symfile_segment_data (abfd
);
3721 if (data
->segments
.size () != 1 && data
->segments
.size () != 2)
3724 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3726 int which
= data
->segment_info
[i
];
3730 if (objfile
->sect_index_text
== -1)
3731 objfile
->sect_index_text
= sect
->index
;
3733 if (objfile
->sect_index_rodata
== -1)
3734 objfile
->sect_index_rodata
= sect
->index
;
3736 else if (which
== 2)
3738 if (objfile
->sect_index_data
== -1)
3739 objfile
->sect_index_data
= sect
->index
;
3741 if (objfile
->sect_index_bss
== -1)
3742 objfile
->sect_index_bss
= sect
->index
;
3747 /* Listen for free_objfile events. */
3750 symfile_free_objfile (struct objfile
*objfile
)
3752 /* Remove the target sections owned by this objfile. */
3753 objfile
->pspace
->remove_target_sections (objfile
);
3756 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3757 Expand all symtabs that match the specified criteria.
3758 See quick_symbol_functions.expand_symtabs_matching for details. */
3761 expand_symtabs_matching
3762 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3763 const lookup_name_info
&lookup_name
,
3764 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3765 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3766 block_search_flags search_flags
,
3767 enum search_domain kind
)
3769 for (objfile
*objfile
: current_program_space
->objfiles ())
3770 if (!objfile
->expand_symtabs_matching (file_matcher
,
3781 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3782 Map function FUN over every file.
3783 See quick_symbol_functions.map_symbol_filenames for details. */
3786 map_symbol_filenames (gdb::function_view
<symbol_filename_ftype
> fun
,
3789 for (objfile
*objfile
: current_program_space
->objfiles ())
3790 objfile
->map_symbol_filenames (fun
, need_fullname
);
3795 namespace selftests
{
3796 namespace filename_language
{
3798 static void test_filename_language ()
3800 /* This test messes up the filename_language_table global. */
3801 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3803 /* Test deducing an unknown extension. */
3804 language lang
= deduce_language_from_filename ("myfile.blah");
3805 SELF_CHECK (lang
== language_unknown
);
3807 /* Test deducing a known extension. */
3808 lang
= deduce_language_from_filename ("myfile.c");
3809 SELF_CHECK (lang
== language_c
);
3811 /* Test adding a new extension using the internal API. */
3812 add_filename_language (".blah", language_pascal
);
3813 lang
= deduce_language_from_filename ("myfile.blah");
3814 SELF_CHECK (lang
== language_pascal
);
3818 test_set_ext_lang_command ()
3820 /* This test messes up the filename_language_table global. */
3821 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3823 /* Confirm that the .hello extension is not known. */
3824 language lang
= deduce_language_from_filename ("cake.hello");
3825 SELF_CHECK (lang
== language_unknown
);
3827 /* Test adding a new extension using the CLI command. */
3828 ext_args
= ".hello rust";
3829 set_ext_lang_command (NULL
, 1, NULL
);
3831 lang
= deduce_language_from_filename ("cake.hello");
3832 SELF_CHECK (lang
== language_rust
);
3834 /* Test overriding an existing extension using the CLI command. */
3835 int size_before
= filename_language_table
.size ();
3836 ext_args
= ".hello pascal";
3837 set_ext_lang_command (NULL
, 1, NULL
);
3838 int size_after
= filename_language_table
.size ();
3840 lang
= deduce_language_from_filename ("cake.hello");
3841 SELF_CHECK (lang
== language_pascal
);
3842 SELF_CHECK (size_before
== size_after
);
3845 } /* namespace filename_language */
3846 } /* namespace selftests */
3848 #endif /* GDB_SELF_TEST */
3850 void _initialize_symfile ();
3852 _initialize_symfile ()
3854 struct cmd_list_element
*c
;
3856 gdb::observers::free_objfile
.attach (symfile_free_objfile
, "symfile");
3858 #define READNOW_READNEVER_HELP \
3859 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3860 immediately. This makes the command slower, but may make future operations\n\
3862 The '-readnever' option will prevent GDB from reading the symbol file's\n\
3863 symbolic debug information."
3865 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3866 Load symbol table from executable file FILE.\n\
3867 Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3868 OFF is an optional offset which is added to each section address.\n\
3869 The `file' command can also load symbol tables, as well as setting the file\n\
3870 to execute.\n" READNOW_READNEVER_HELP
), &cmdlist
);
3871 set_cmd_completer (c
, filename_completer
);
3873 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3874 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3875 Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3876 [-s SECT-NAME SECT-ADDR]...\n\
3877 ADDR is the starting address of the file's text.\n\
3878 Each '-s' argument provides a section name and address, and\n\
3879 should be specified if the data and bss segments are not contiguous\n\
3880 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3881 OFF is an optional offset which is added to the default load addresses\n\
3882 of all sections for which no other address was specified.\n"
3883 READNOW_READNEVER_HELP
),
3885 set_cmd_completer (c
, filename_completer
);
3887 c
= add_cmd ("remove-symbol-file", class_files
,
3888 remove_symbol_file_command
, _("\
3889 Remove a symbol file added via the add-symbol-file command.\n\
3890 Usage: remove-symbol-file FILENAME\n\
3891 remove-symbol-file -a ADDRESS\n\
3892 The file to remove can be identified by its filename or by an address\n\
3893 that lies within the boundaries of this symbol file in memory."),
3896 c
= add_cmd ("load", class_files
, load_command
, _("\
3897 Dynamically load FILE into the running program.\n\
3898 FILE symbols are recorded for access from GDB.\n\
3899 Usage: load [FILE] [OFFSET]\n\
3900 An optional load OFFSET may also be given as a literal address.\n\
3901 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3902 on its own."), &cmdlist
);
3903 set_cmd_completer (c
, filename_completer
);
3905 cmd_list_element
*overlay_cmd
3906 = add_basic_prefix_cmd ("overlay", class_support
,
3907 _("Commands for debugging overlays."), &overlaylist
,
3910 add_com_alias ("ovly", overlay_cmd
, class_support
, 1);
3911 add_com_alias ("ov", overlay_cmd
, class_support
, 1);
3913 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3914 _("Assert that an overlay section is mapped."), &overlaylist
);
3916 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3917 _("Assert that an overlay section is unmapped."), &overlaylist
);
3919 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3920 _("List mappings of overlay sections."), &overlaylist
);
3922 add_cmd ("manual", class_support
, overlay_manual_command
,
3923 _("Enable overlay debugging."), &overlaylist
);
3924 add_cmd ("off", class_support
, overlay_off_command
,
3925 _("Disable overlay debugging."), &overlaylist
);
3926 add_cmd ("auto", class_support
, overlay_auto_command
,
3927 _("Enable automatic overlay debugging."), &overlaylist
);
3928 add_cmd ("load-target", class_support
, overlay_load_command
,
3929 _("Read the overlay mapping state from the target."), &overlaylist
);
3931 /* Filename extension to source language lookup table: */
3932 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3934 Set mapping between filename extension and source language."), _("\
3935 Show mapping between filename extension and source language."), _("\
3936 Usage: set extension-language .foo bar"),
3937 set_ext_lang_command
,
3939 &setlist
, &showlist
);
3941 add_info ("extensions", info_ext_lang_command
,
3942 _("All filename extensions associated with a source language."));
3944 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3945 &debug_file_directory
, _("\
3946 Set the directories where separate debug symbols are searched for."), _("\
3947 Show the directories where separate debug symbols are searched for."), _("\
3948 Separate debug symbols are first searched for in the same\n\
3949 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3950 and lastly at the path of the directory of the binary with\n\
3951 each global debug-file-directory component prepended."),
3953 show_debug_file_directory
,
3954 &setlist
, &showlist
);
3956 add_setshow_enum_cmd ("symbol-loading", no_class
,
3957 print_symbol_loading_enums
, &print_symbol_loading
,
3959 Set printing of symbol loading messages."), _("\
3960 Show printing of symbol loading messages."), _("\
3961 off == turn all messages off\n\
3962 brief == print messages for the executable,\n\
3963 and brief messages for shared libraries\n\
3964 full == print messages for the executable,\n\
3965 and messages for each shared library."),
3968 &setprintlist
, &showprintlist
);
3970 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
3971 &separate_debug_file_debug
, _("\
3972 Set printing of separate debug info file search debug."), _("\
3973 Show printing of separate debug info file search debug."), _("\
3974 When on, GDB prints the searched locations while looking for separate debug \
3975 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
3978 selftests::register_test
3979 ("filename_language", selftests::filename_language::test_filename_language
);
3980 selftests::register_test
3981 ("set_ext_lang_command",
3982 selftests::filename_language::test_set_ext_lang_command
);