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" /* for DOSish file names */
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 target_section_table
&table
)
221 section_addr_info sap
;
223 for (const target_section
&stp
: table
)
225 struct bfd_section
*asect
= stp
.the_bfd_section
;
226 bfd
*abfd
= asect
->owner
;
228 if (bfd_section_flags (asect
) & (SEC_ALLOC
| SEC_LOAD
)
229 && sap
.size () < table
.size ())
230 sap
.emplace_back (stp
.addr
,
231 bfd_section_name (asect
),
232 gdb_bfd_section_index (abfd
, asect
));
238 /* Create a section_addr_info from section offsets in ABFD. */
240 static section_addr_info
241 build_section_addr_info_from_bfd (bfd
*abfd
)
243 struct bfd_section
*sec
;
245 section_addr_info sap
;
246 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
247 if (bfd_section_flags (sec
) & (SEC_ALLOC
| SEC_LOAD
))
248 sap
.emplace_back (bfd_section_vma (sec
),
249 bfd_section_name (sec
),
250 gdb_bfd_section_index (abfd
, sec
));
255 /* Create a section_addr_info from section offsets in OBJFILE. */
258 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
262 /* Before reread_symbols gets rewritten it is not safe to call:
263 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
265 section_addr_info sap
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 (target_gdbarch (), args
->lma
));
1966 if (validate_download
)
1968 /* Broken memories and broken monitors manifest themselves here
1969 when bring new computers to life. This doubles already slow
1971 /* NOTE: cagney/1999-10-18: A more efficient implementation
1972 might add a verify_memory() method to the target vector and
1973 then use that. remote.c could implement that method using
1974 the ``qCRC'' packet. */
1975 gdb::byte_vector
check (bytes
);
1977 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1978 error (_("Download verify read failed at %s"),
1979 paddress (target_gdbarch (), args
->lma
));
1980 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1981 error (_("Download verify compare failed at %s"),
1982 paddress (target_gdbarch (), args
->lma
));
1984 totals
->data_count
+= bytes
;
1986 args
->buffer
+= bytes
;
1987 totals
->write_count
+= 1;
1988 args
->section_sent
+= bytes
;
1989 if (check_quit_flag ()
1990 || (deprecated_ui_load_progress_hook
!= NULL
1991 && deprecated_ui_load_progress_hook (args
->section_name
,
1992 args
->section_sent
)))
1993 error (_("Canceled the download"));
1995 if (deprecated_show_load_progress
!= NULL
)
1996 deprecated_show_load_progress (args
->section_name
,
2000 totals
->total_size
);
2003 /* Service function for generic_load. */
2006 load_one_section (bfd
*abfd
, asection
*asec
,
2007 struct load_section_data
*args
)
2009 bfd_size_type size
= bfd_section_size (asec
);
2010 const char *sect_name
= bfd_section_name (asec
);
2012 if ((bfd_section_flags (asec
) & SEC_LOAD
) == 0)
2018 ULONGEST begin
= bfd_section_lma (asec
) + args
->load_offset
;
2019 ULONGEST end
= begin
+ size
;
2020 gdb_byte
*buffer
= (gdb_byte
*) xmalloc (size
);
2021 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2023 load_progress_section_data
*section_data
2024 = new load_progress_section_data (args
->progress_data
, sect_name
, size
,
2027 args
->requests
.emplace_back (begin
, end
, buffer
, section_data
);
2030 static void print_transfer_performance (struct ui_file
*stream
,
2031 unsigned long data_count
,
2032 unsigned long write_count
,
2033 std::chrono::steady_clock::duration d
);
2035 /* See symfile.h. */
2038 generic_load (const char *args
, int from_tty
)
2040 struct load_progress_data total_progress
;
2041 struct load_section_data
cbdata (&total_progress
);
2042 struct ui_out
*uiout
= current_uiout
;
2045 error_no_arg (_("file to load"));
2047 gdb_argv
argv (args
);
2049 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2051 if (argv
[1] != NULL
)
2055 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2057 /* If the last word was not a valid number then
2058 treat it as a file name with spaces in. */
2059 if (argv
[1] == endptr
)
2060 error (_("Invalid download offset:%s."), argv
[1]);
2062 if (argv
[2] != NULL
)
2063 error (_("Too many parameters."));
2066 /* Open the file for loading. */
2067 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
));
2068 if (loadfile_bfd
== NULL
)
2069 perror_with_name (filename
.get ());
2071 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2073 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2074 bfd_errmsg (bfd_get_error ()));
2077 for (asection
*asec
: gdb_bfd_sections (loadfile_bfd
))
2078 total_progress
.total_size
+= bfd_section_size (asec
);
2080 for (asection
*asec
: gdb_bfd_sections (loadfile_bfd
))
2081 load_one_section (loadfile_bfd
.get (), asec
, &cbdata
);
2083 using namespace std::chrono
;
2085 steady_clock::time_point start_time
= steady_clock::now ();
2087 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2088 load_progress
) != 0)
2089 error (_("Load failed"));
2091 steady_clock::time_point end_time
= steady_clock::now ();
2093 CORE_ADDR entry
= bfd_get_start_address (loadfile_bfd
.get ());
2094 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2095 uiout
->text ("Start address ");
2096 uiout
->field_core_addr ("address", target_gdbarch (), entry
);
2097 uiout
->text (", load size ");
2098 uiout
->field_unsigned ("load-size", total_progress
.data_count
);
2100 regcache_write_pc (get_current_regcache (), entry
);
2102 /* Reset breakpoints, now that we have changed the load image. For
2103 instance, breakpoints may have been set (or reset, by
2104 post_create_inferior) while connected to the target but before we
2105 loaded the program. In that case, the prologue analyzer could
2106 have read instructions from the target to find the right
2107 breakpoint locations. Loading has changed the contents of that
2110 breakpoint_re_set ();
2112 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2113 total_progress
.write_count
,
2114 end_time
- start_time
);
2117 /* Report on STREAM the performance of a memory transfer operation,
2118 such as 'load'. DATA_COUNT is the number of bytes transferred.
2119 WRITE_COUNT is the number of separate write operations, or 0, if
2120 that information is not available. TIME is how long the operation
2124 print_transfer_performance (struct ui_file
*stream
,
2125 unsigned long data_count
,
2126 unsigned long write_count
,
2127 std::chrono::steady_clock::duration time
)
2129 using namespace std::chrono
;
2130 struct ui_out
*uiout
= current_uiout
;
2132 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2134 uiout
->text ("Transfer rate: ");
2135 if (ms
.count () > 0)
2137 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2139 if (uiout
->is_mi_like_p ())
2141 uiout
->field_unsigned ("transfer-rate", rate
* 8);
2142 uiout
->text (" bits/sec");
2144 else if (rate
< 1024)
2146 uiout
->field_unsigned ("transfer-rate", rate
);
2147 uiout
->text (" bytes/sec");
2151 uiout
->field_unsigned ("transfer-rate", rate
/ 1024);
2152 uiout
->text (" KB/sec");
2157 uiout
->field_unsigned ("transferred-bits", (data_count
* 8));
2158 uiout
->text (" bits in <1 sec");
2160 if (write_count
> 0)
2163 uiout
->field_unsigned ("write-rate", data_count
/ write_count
);
2164 uiout
->text (" bytes/write");
2166 uiout
->text (".\n");
2169 /* Add an OFFSET to the start address of each section in OBJF, except
2170 sections that were specified in ADDRS. */
2173 set_objfile_default_section_offset (struct objfile
*objf
,
2174 const section_addr_info
&addrs
,
2177 /* Add OFFSET to all sections by default. */
2178 section_offsets
offsets (objf
->section_offsets
.size (), offset
);
2180 /* Create sorted lists of all sections in ADDRS as well as all
2181 sections in OBJF. */
2183 std::vector
<const struct other_sections
*> addrs_sorted
2184 = addrs_section_sort (addrs
);
2186 section_addr_info objf_addrs
2187 = build_section_addr_info_from_objfile (objf
);
2188 std::vector
<const struct other_sections
*> objf_addrs_sorted
2189 = addrs_section_sort (objf_addrs
);
2191 /* Walk the BFD section list, and if a matching section is found in
2192 ADDRS_SORTED_LIST, set its offset to zero to keep its address
2195 Note that both lists may contain multiple sections with the same
2196 name, and then the sections from ADDRS are matched in BFD order
2197 (thanks to sectindex). */
2199 std::vector
<const struct other_sections
*>::iterator addrs_sorted_iter
2200 = addrs_sorted
.begin ();
2201 for (const other_sections
*objf_sect
: objf_addrs_sorted
)
2203 const char *objf_name
= addr_section_name (objf_sect
->name
.c_str ());
2206 while (cmp
< 0 && addrs_sorted_iter
!= addrs_sorted
.end ())
2208 const struct other_sections
*sect
= *addrs_sorted_iter
;
2209 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
2210 cmp
= strcmp (sect_name
, objf_name
);
2212 ++addrs_sorted_iter
;
2216 offsets
[objf_sect
->sectindex
] = 0;
2219 /* Apply the new section offsets. */
2220 objfile_relocate (objf
, offsets
);
2223 /* This function allows the addition of incrementally linked object files.
2224 It does not modify any state in the target, only in the debugger. */
2227 add_symbol_file_command (const char *args
, int from_tty
)
2229 struct gdbarch
*gdbarch
= get_current_arch ();
2230 gdb::unique_xmalloc_ptr
<char> filename
;
2233 struct objfile
*objf
;
2234 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2235 symfile_add_flags add_flags
= 0;
2238 add_flags
|= SYMFILE_VERBOSE
;
2246 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2247 bool stop_processing_options
= false;
2248 CORE_ADDR offset
= 0;
2253 error (_("add-symbol-file takes a file name and an address"));
2255 bool seen_addr
= false;
2256 bool seen_offset
= false;
2257 gdb_argv
argv (args
);
2259 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2261 if (stop_processing_options
|| *arg
!= '-')
2263 if (filename
== NULL
)
2265 /* First non-option argument is always the filename. */
2266 filename
.reset (tilde_expand (arg
));
2268 else if (!seen_addr
)
2270 /* The second non-option argument is always the text
2271 address at which to load the program. */
2272 sect_opts
[0].value
= arg
;
2276 error (_("Unrecognized argument \"%s\""), arg
);
2278 else if (strcmp (arg
, "-readnow") == 0)
2279 flags
|= OBJF_READNOW
;
2280 else if (strcmp (arg
, "-readnever") == 0)
2281 flags
|= OBJF_READNEVER
;
2282 else if (strcmp (arg
, "-s") == 0)
2284 if (argv
[argcnt
+ 1] == NULL
)
2285 error (_("Missing section name after \"-s\""));
2286 else if (argv
[argcnt
+ 2] == NULL
)
2287 error (_("Missing section address after \"-s\""));
2289 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2291 sect_opts
.push_back (sect
);
2294 else if (strcmp (arg
, "-o") == 0)
2296 arg
= argv
[++argcnt
];
2298 error (_("Missing argument to -o"));
2300 offset
= parse_and_eval_address (arg
);
2303 else if (strcmp (arg
, "--") == 0)
2304 stop_processing_options
= true;
2306 error (_("Unrecognized argument \"%s\""), arg
);
2309 if (filename
== NULL
)
2310 error (_("You must provide a filename to be loaded."));
2312 validate_readnow_readnever (flags
);
2314 /* Print the prompt for the query below. And save the arguments into
2315 a sect_addr_info structure to be passed around to other
2316 functions. We have to split this up into separate print
2317 statements because hex_string returns a local static
2320 gdb_printf (_("add symbol table from file \"%ps\""),
2321 styled_string (file_name_style
.style (), filename
.get ()));
2322 section_addr_info section_addrs
;
2323 std::vector
<sect_opt
>::const_iterator it
= sect_opts
.begin ();
2326 for (; it
!= sect_opts
.end (); ++it
)
2329 const char *val
= it
->value
;
2330 const char *sec
= it
->name
;
2332 if (section_addrs
.empty ())
2333 gdb_printf (_(" at\n"));
2334 addr
= parse_and_eval_address (val
);
2336 /* Here we store the section offsets in the order they were
2337 entered on the command line. Every array element is
2338 assigned an ascending section index to preserve the above
2339 order over an unstable sorting algorithm. This dummy
2340 index is not used for any other purpose.
2342 section_addrs
.emplace_back (addr
, sec
, section_addrs
.size ());
2343 gdb_printf ("\t%s_addr = %s\n", sec
,
2344 paddress (gdbarch
, addr
));
2346 /* The object's sections are initialized when a
2347 call is made to build_objfile_section_table (objfile).
2348 This happens in reread_symbols.
2349 At this point, we don't know what file type this is,
2350 so we can't determine what section names are valid. */
2353 gdb_printf (_("%s offset by %s\n"),
2354 (section_addrs
.empty ()
2355 ? _(" with all sections")
2356 : _("with other sections")),
2357 paddress (gdbarch
, offset
));
2358 else if (section_addrs
.empty ())
2361 if (from_tty
&& (!query ("%s", "")))
2362 error (_("Not confirmed."));
2364 objf
= symbol_file_add (filename
.get (), add_flags
, §ion_addrs
,
2366 if (!objfile_has_symbols (objf
) && objf
->per_bfd
->minimal_symbol_count
<= 0)
2367 warning (_("newly-added symbol file \"%ps\" does not provide any symbols"),
2368 styled_string (file_name_style
.style (), filename
.get ()));
2371 set_objfile_default_section_offset (objf
, section_addrs
, offset
);
2373 current_program_space
->add_target_sections (objf
);
2375 /* Getting new symbols may change our opinion about what is
2377 reinit_frame_cache ();
2381 /* This function removes a symbol file that was added via add-symbol-file. */
2384 remove_symbol_file_command (const char *args
, int from_tty
)
2386 struct objfile
*objf
= NULL
;
2387 struct program_space
*pspace
= current_program_space
;
2392 error (_("remove-symbol-file: no symbol file provided"));
2394 gdb_argv
argv (args
);
2396 if (strcmp (argv
[0], "-a") == 0)
2398 /* Interpret the next argument as an address. */
2401 if (argv
[1] == NULL
)
2402 error (_("Missing address argument"));
2404 if (argv
[2] != NULL
)
2405 error (_("Junk after %s"), argv
[1]);
2407 addr
= parse_and_eval_address (argv
[1]);
2409 for (objfile
*objfile
: current_program_space
->objfiles ())
2411 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2412 && (objfile
->flags
& OBJF_SHARED
) != 0
2413 && objfile
->pspace
== pspace
2414 && is_addr_in_objfile (addr
, objfile
))
2421 else if (argv
[0] != NULL
)
2423 /* Interpret the current argument as a file name. */
2425 if (argv
[1] != NULL
)
2426 error (_("Junk after %s"), argv
[0]);
2428 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2430 for (objfile
*objfile
: current_program_space
->objfiles ())
2432 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2433 && (objfile
->flags
& OBJF_SHARED
) != 0
2434 && objfile
->pspace
== pspace
2435 && filename_cmp (filename
.get (), objfile_name (objfile
)) == 0)
2444 error (_("No symbol file found"));
2447 && !query (_("Remove symbol table from file \"%s\"? "),
2448 objfile_name (objf
)))
2449 error (_("Not confirmed."));
2452 clear_symtab_users (0);
2455 /* Re-read symbols if a symbol-file has changed. */
2458 reread_symbols (int from_tty
)
2461 struct stat new_statbuf
;
2463 std::vector
<struct objfile
*> new_objfiles
;
2465 for (objfile
*objfile
: current_program_space
->objfiles ())
2467 if (objfile
->obfd
.get () == NULL
)
2470 /* Separate debug objfiles are handled in the main objfile. */
2471 if (objfile
->separate_debug_objfile_backlink
)
2474 /* If this object is from an archive (what you usually create with
2475 `ar', often called a `static library' on most systems, though
2476 a `shared library' on AIX is also an archive), then you should
2477 stat on the archive name, not member name. */
2478 if (objfile
->obfd
->my_archive
)
2479 res
= stat (bfd_get_filename (objfile
->obfd
->my_archive
), &new_statbuf
);
2481 res
= stat (objfile_name (objfile
), &new_statbuf
);
2484 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2485 gdb_printf (_("`%s' has disappeared; keeping its symbols.\n"),
2486 objfile_name (objfile
));
2489 new_modtime
= new_statbuf
.st_mtime
;
2490 if (new_modtime
!= objfile
->mtime
)
2492 gdb_printf (_("`%ps' has changed; re-reading symbols.\n"),
2493 styled_string (file_name_style
.style (),
2494 objfile_name (objfile
)));
2496 /* There are various functions like symbol_file_add,
2497 symfile_bfd_open, syms_from_objfile, etc., which might
2498 appear to do what we want. But they have various other
2499 effects which we *don't* want. So we just do stuff
2500 ourselves. We don't worry about mapped files (for one thing,
2501 any mapped file will be out of date). */
2503 /* If we get an error, blow away this objfile (not sure if
2504 that is the correct response for things like shared
2506 objfile_up
objfile_holder (objfile
);
2508 /* We need to do this whenever any symbols go away. */
2509 clear_symtab_users_cleanup
defer_clear_users (0);
2511 if (current_program_space
->exec_bfd () != NULL
2512 && filename_cmp (bfd_get_filename (objfile
->obfd
.get ()),
2513 bfd_get_filename (current_program_space
->exec_bfd ())) == 0)
2515 /* Reload EXEC_BFD without asking anything. */
2517 exec_file_attach (bfd_get_filename (objfile
->obfd
.get ()), 0);
2520 /* Keep the calls order approx. the same as in free_objfile. */
2522 /* Free the separate debug objfiles. It will be
2523 automatically recreated by sym_read. */
2524 free_objfile_separate_debug (objfile
);
2526 /* Clear the stale source cache. */
2527 forget_cached_source_info ();
2529 /* Remove any references to this objfile in the global
2531 preserve_values (objfile
);
2533 /* Nuke all the state that we will re-read. Much of the following
2534 code which sets things to NULL really is necessary to tell
2535 other parts of GDB that there is nothing currently there.
2537 Try to keep the freeing order compatible with free_objfile. */
2539 if (objfile
->sf
!= NULL
)
2541 (*objfile
->sf
->sym_finish
) (objfile
);
2544 objfile
->registry_fields
.clear_registry ();
2546 /* Clean up any state BFD has sitting around. */
2548 gdb_bfd_ref_ptr obfd
= objfile
->obfd
;
2549 const char *obfd_filename
;
2551 obfd_filename
= bfd_get_filename (objfile
->obfd
.get ());
2552 /* Open the new BFD before freeing the old one, so that
2553 the filename remains live. */
2554 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
));
2555 objfile
->obfd
= std::move (temp
);
2556 if (objfile
->obfd
== NULL
)
2557 error (_("Can't open %s to read symbols."), obfd_filename
);
2560 std::string original_name
= objfile
->original_name
;
2562 /* bfd_openr sets cacheable to true, which is what we want. */
2563 if (!bfd_check_format (objfile
->obfd
.get (), bfd_object
))
2564 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2565 bfd_errmsg (bfd_get_error ()));
2567 /* NB: after this call to obstack_free, objfiles_changed
2568 will need to be called (see discussion below). */
2569 obstack_free (&objfile
->objfile_obstack
, 0);
2570 objfile
->sections_start
= NULL
;
2571 objfile
->section_offsets
.clear ();
2572 objfile
->sect_index_bss
= -1;
2573 objfile
->sect_index_data
= -1;
2574 objfile
->sect_index_rodata
= -1;
2575 objfile
->sect_index_text
= -1;
2576 objfile
->compunit_symtabs
= NULL
;
2577 objfile
->template_symbols
= NULL
;
2578 objfile
->static_links
.reset (nullptr);
2580 /* obstack_init also initializes the obstack so it is
2581 empty. We could use obstack_specify_allocation but
2582 gdb_obstack.h specifies the alloc/dealloc functions. */
2583 obstack_init (&objfile
->objfile_obstack
);
2585 /* set_objfile_per_bfd potentially allocates the per-bfd
2586 data on the objfile's obstack (if sharing data across
2587 multiple users is not possible), so it's important to
2588 do it *after* the obstack has been initialized. */
2589 set_objfile_per_bfd (objfile
);
2591 objfile
->original_name
2592 = obstack_strdup (&objfile
->objfile_obstack
, original_name
);
2594 /* Reset the sym_fns pointer. The ELF reader can change it
2595 based on whether .gdb_index is present, and we need it to
2596 start over. PR symtab/15885 */
2597 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
.get ()));
2598 objfile
->qf
.clear ();
2600 build_objfile_section_table (objfile
);
2602 /* What the hell is sym_new_init for, anyway? The concept of
2603 distinguishing between the main file and additional files
2604 in this way seems rather dubious. */
2605 if (objfile
== current_program_space
->symfile_object_file
)
2607 (*objfile
->sf
->sym_new_init
) (objfile
);
2610 (*objfile
->sf
->sym_init
) (objfile
);
2611 clear_complaints ();
2613 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2615 /* We are about to read new symbols and potentially also
2616 DWARF information. Some targets may want to pass addresses
2617 read from DWARF DIE's through an adjustment function before
2618 saving them, like MIPS, which may call into
2619 "find_pc_section". When called, that function will make
2620 use of per-objfile program space data.
2622 Since we discarded our section information above, we have
2623 dangling pointers in the per-objfile program space data
2624 structure. Force GDB to update the section mapping
2625 information by letting it know the objfile has changed,
2626 making the dangling pointers point to correct data
2629 objfiles_changed ();
2631 /* Recompute section offsets and section indices. */
2632 objfile
->sf
->sym_offsets (objfile
, {});
2634 read_symbols (objfile
, 0);
2636 if ((objfile
->flags
& OBJF_READNOW
))
2638 const int mainline
= objfile
->flags
& OBJF_MAINLINE
;
2639 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
2640 && readnow_symbol_files
);
2642 gdb_printf (_("Expanding full symbols from %ps...\n"),
2643 styled_string (file_name_style
.style (),
2644 objfile_name (objfile
)));
2646 objfile
->expand_all_symtabs ();
2649 if (!objfile_has_symbols (objfile
))
2651 gdb_stdout
->wrap_here (0);
2652 gdb_printf (_("(no debugging symbols found)\n"));
2653 gdb_stdout
->wrap_here (0);
2656 /* We're done reading the symbol file; finish off complaints. */
2657 clear_complaints ();
2659 /* Getting new symbols may change our opinion about what is
2662 reinit_frame_cache ();
2664 /* Discard cleanups as symbol reading was successful. */
2665 objfile_holder
.release ();
2666 defer_clear_users
.release ();
2668 /* If the mtime has changed between the time we set new_modtime
2669 and now, we *want* this to be out of date, so don't call stat
2671 objfile
->mtime
= new_modtime
;
2672 init_entry_point_info (objfile
);
2674 new_objfiles
.push_back (objfile
);
2678 if (!new_objfiles
.empty ())
2680 clear_symtab_users (0);
2682 /* The registry for each objfile was cleared and
2683 gdb::observers::new_objfile.notify (NULL) has been called by
2684 clear_symtab_users above. Notify the new files now. */
2685 for (auto iter
: new_objfiles
)
2686 gdb::observers::new_objfile
.notify (iter
);
2688 /* At least one objfile has changed, so we can consider that
2689 the executable we're debugging has changed too. */
2690 gdb::observers::executable_changed
.notify ();
2695 struct filename_language
2697 filename_language (const std::string
&ext_
, enum language lang_
)
2698 : ext (ext_
), lang (lang_
)
2705 static std::vector
<filename_language
> filename_language_table
;
2707 /* See symfile.h. */
2710 add_filename_language (const char *ext
, enum language lang
)
2712 gdb_assert (ext
!= nullptr);
2713 filename_language_table
.emplace_back (ext
, lang
);
2716 static std::string ext_args
;
2718 show_ext_args (struct ui_file
*file
, int from_tty
,
2719 struct cmd_list_element
*c
, const char *value
)
2722 _("Mapping between filename extension "
2723 "and source language is \"%s\".\n"),
2728 set_ext_lang_command (const char *args
,
2729 int from_tty
, struct cmd_list_element
*e
)
2731 const char *begin
= ext_args
.c_str ();
2732 const char *end
= ext_args
.c_str ();
2734 /* First arg is filename extension, starting with '.' */
2736 error (_("'%s': Filename extension must begin with '.'"), ext_args
.c_str ());
2738 /* Find end of first arg. */
2739 while (*end
!= '\0' && !isspace (*end
))
2743 error (_("'%s': two arguments required -- "
2744 "filename extension and language"),
2747 /* Extract first arg, the extension. */
2748 std::string extension
= ext_args
.substr (0, end
- begin
);
2750 /* Find beginning of second arg, which should be a source language. */
2751 begin
= skip_spaces (end
);
2754 error (_("'%s': two arguments required -- "
2755 "filename extension and language"),
2758 /* Lookup the language from among those we know. */
2759 language lang
= language_enum (begin
);
2761 auto it
= filename_language_table
.begin ();
2762 /* Now lookup the filename extension: do we already know it? */
2763 for (; it
!= filename_language_table
.end (); it
++)
2765 if (it
->ext
== extension
)
2769 if (it
== filename_language_table
.end ())
2771 /* New file extension. */
2772 add_filename_language (extension
.data (), lang
);
2776 /* Redefining a previously known filename extension. */
2779 /* query ("Really make files of type %s '%s'?", */
2780 /* ext_args, language_str (lang)); */
2787 info_ext_lang_command (const char *args
, int from_tty
)
2789 gdb_printf (_("Filename extensions and the languages they represent:"));
2790 gdb_printf ("\n\n");
2791 for (const filename_language
&entry
: filename_language_table
)
2792 gdb_printf ("\t%s\t- %s\n", entry
.ext
.c_str (),
2793 language_str (entry
.lang
));
2797 deduce_language_from_filename (const char *filename
)
2801 if (filename
!= NULL
)
2802 if ((cp
= strrchr (filename
, '.')) != NULL
)
2804 for (const filename_language
&entry
: filename_language_table
)
2805 if (entry
.ext
== cp
)
2809 return language_unknown
;
2812 /* Allocate and initialize a new symbol table.
2813 CUST is from the result of allocate_compunit_symtab. */
2816 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
,
2817 const char *filename_for_id
)
2819 struct objfile
*objfile
= cust
->objfile ();
2820 struct symtab
*symtab
2821 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2823 symtab
->filename
= objfile
->intern (filename
);
2824 symtab
->filename_for_id
= objfile
->intern (filename_for_id
);
2825 symtab
->fullname
= NULL
;
2826 symtab
->set_language (deduce_language_from_filename (filename
));
2828 /* This can be very verbose with lots of headers.
2829 Only print at higher debug levels. */
2830 if (symtab_create_debug
>= 2)
2832 /* Be a bit clever with debugging messages, and don't print objfile
2833 every time, only when it changes. */
2834 static std::string last_objfile_name
;
2835 const char *this_objfile_name
= objfile_name (objfile
);
2837 if (last_objfile_name
.empty () || last_objfile_name
!= this_objfile_name
)
2839 last_objfile_name
= this_objfile_name
;
2841 symtab_create_debug_printf_v
2842 ("creating one or more symtabs for objfile %s", this_objfile_name
);
2845 symtab_create_debug_printf_v ("created symtab %s for module %s",
2846 host_address_to_string (symtab
), filename
);
2849 /* Add it to CUST's list of symtabs. */
2850 cust
->add_filetab (symtab
);
2852 /* Backlink to the containing compunit symtab. */
2853 symtab
->set_compunit (cust
);
2858 /* Allocate and initialize a new compunit.
2859 NAME is the name of the main source file, if there is one, or some
2860 descriptive text if there are no source files. */
2862 struct compunit_symtab
*
2863 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2865 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2866 struct compunit_symtab
);
2867 const char *saved_name
;
2869 cu
->set_objfile (objfile
);
2871 /* The name we record here is only for display/debugging purposes.
2872 Just save the basename to avoid path issues (too long for display,
2873 relative vs absolute, etc.). */
2874 saved_name
= lbasename (name
);
2875 cu
->name
= obstack_strdup (&objfile
->objfile_obstack
, saved_name
);
2877 cu
->set_debugformat ("unknown");
2879 symtab_create_debug_printf_v ("created compunit symtab %s for %s",
2880 host_address_to_string (cu
),
2886 /* Hook CU to the objfile it comes from. */
2889 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2891 cu
->next
= cu
->objfile ()->compunit_symtabs
;
2892 cu
->objfile ()->compunit_symtabs
= cu
;
2896 /* Reset all data structures in gdb which may contain references to
2897 symbol table data. */
2900 clear_symtab_users (symfile_add_flags add_flags
)
2902 /* Someday, we should do better than this, by only blowing away
2903 the things that really need to be blown. */
2905 /* Clear the "current" symtab first, because it is no longer valid.
2906 breakpoint_re_set may try to access the current symtab. */
2907 clear_current_source_symtab_and_line ();
2910 clear_last_displayed_sal ();
2911 clear_pc_function_cache ();
2912 gdb::observers::new_objfile
.notify (NULL
);
2914 /* Now that the various caches have been cleared, we can re_set
2915 our breakpoints without risking it using stale data. */
2916 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2917 breakpoint_re_set ();
2921 The following code implements an abstraction for debugging overlay sections.
2923 The target model is as follows:
2924 1) The gnu linker will permit multiple sections to be mapped into the
2925 same VMA, each with its own unique LMA (or load address).
2926 2) It is assumed that some runtime mechanism exists for mapping the
2927 sections, one by one, from the load address into the VMA address.
2928 3) This code provides a mechanism for gdb to keep track of which
2929 sections should be considered to be mapped from the VMA to the LMA.
2930 This information is used for symbol lookup, and memory read/write.
2931 For instance, if a section has been mapped then its contents
2932 should be read from the VMA, otherwise from the LMA.
2934 Two levels of debugger support for overlays are available. One is
2935 "manual", in which the debugger relies on the user to tell it which
2936 overlays are currently mapped. This level of support is
2937 implemented entirely in the core debugger, and the information about
2938 whether a section is mapped is kept in the objfile->obj_section table.
2940 The second level of support is "automatic", and is only available if
2941 the target-specific code provides functionality to read the target's
2942 overlay mapping table, and translate its contents for the debugger
2943 (by updating the mapped state information in the obj_section tables).
2945 The interface is as follows:
2947 overlay map <name> -- tell gdb to consider this section mapped
2948 overlay unmap <name> -- tell gdb to consider this section unmapped
2949 overlay list -- list the sections that GDB thinks are mapped
2950 overlay read-target -- get the target's state of what's mapped
2951 overlay off/manual/auto -- set overlay debugging state
2952 Functional interface:
2953 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2954 section, return that section.
2955 find_pc_overlay(pc): find any overlay section that contains
2956 the pc, either in its VMA or its LMA
2957 section_is_mapped(sect): true if overlay is marked as mapped
2958 section_is_overlay(sect): true if section's VMA != LMA
2959 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2960 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2961 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2962 overlay_mapped_address(...): map an address from section's LMA to VMA
2963 overlay_unmapped_address(...): map an address from section's VMA to LMA
2964 symbol_overlayed_address(...): Return a "current" address for symbol:
2965 either in VMA or LMA depending on whether
2966 the symbol's section is currently mapped. */
2968 /* Overlay debugging state: */
2970 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2971 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2973 /* Function: section_is_overlay (SECTION)
2974 Returns true if SECTION has VMA not equal to LMA, ie.
2975 SECTION is loaded at an address different from where it will "run". */
2978 section_is_overlay (struct obj_section
*section
)
2980 if (overlay_debugging
&& section
)
2982 asection
*bfd_section
= section
->the_bfd_section
;
2984 if (bfd_section_lma (bfd_section
) != 0
2985 && bfd_section_lma (bfd_section
) != bfd_section_vma (bfd_section
))
2992 /* Function: overlay_invalidate_all (void)
2993 Invalidate the mapped state of all overlay sections (mark it as stale). */
2996 overlay_invalidate_all (void)
2998 for (objfile
*objfile
: current_program_space
->objfiles ())
2999 for (obj_section
*sect
: objfile
->sections ())
3000 if (section_is_overlay (sect
))
3001 sect
->ovly_mapped
= -1;
3004 /* Function: section_is_mapped (SECTION)
3005 Returns true if section is an overlay, and is currently mapped.
3007 Access to the ovly_mapped flag is restricted to this function, so
3008 that we can do automatic update. If the global flag
3009 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3010 overlay_invalidate_all. If the mapped state of the particular
3011 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3014 section_is_mapped (struct obj_section
*osect
)
3016 struct gdbarch
*gdbarch
;
3018 if (osect
== 0 || !section_is_overlay (osect
))
3021 switch (overlay_debugging
)
3025 return 0; /* overlay debugging off */
3026 case ovly_auto
: /* overlay debugging automatic */
3027 /* Unles there is a gdbarch_overlay_update function,
3028 there's really nothing useful to do here (can't really go auto). */
3029 gdbarch
= osect
->objfile
->arch ();
3030 if (gdbarch_overlay_update_p (gdbarch
))
3032 if (overlay_cache_invalid
)
3034 overlay_invalidate_all ();
3035 overlay_cache_invalid
= 0;
3037 if (osect
->ovly_mapped
== -1)
3038 gdbarch_overlay_update (gdbarch
, osect
);
3041 case ovly_on
: /* overlay debugging manual */
3042 return osect
->ovly_mapped
== 1;
3046 /* Function: pc_in_unmapped_range
3047 If PC falls into the lma range of SECTION, return true, else false. */
3050 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3052 if (section_is_overlay (section
))
3054 asection
*bfd_section
= section
->the_bfd_section
;
3056 /* We assume the LMA is relocated by the same offset as the VMA. */
3057 bfd_vma size
= bfd_section_size (bfd_section
);
3058 CORE_ADDR offset
= section
->offset ();
3060 if (bfd_section_lma (bfd_section
) + offset
<= pc
3061 && pc
< bfd_section_lma (bfd_section
) + offset
+ size
)
3068 /* Function: pc_in_mapped_range
3069 If PC falls into the vma range of SECTION, return true, else false. */
3072 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3074 if (section_is_overlay (section
))
3076 if (section
->addr () <= pc
3077 && pc
< section
->endaddr ())
3084 /* Return true if the mapped ranges of sections A and B overlap, false
3088 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3090 CORE_ADDR a_start
= a
->addr ();
3091 CORE_ADDR a_end
= a
->endaddr ();
3092 CORE_ADDR b_start
= b
->addr ();
3093 CORE_ADDR b_end
= b
->endaddr ();
3095 return (a_start
< b_end
&& b_start
< a_end
);
3098 /* Function: overlay_unmapped_address (PC, SECTION)
3099 Returns the address corresponding to PC in the unmapped (load) range.
3100 May be the same as PC. */
3103 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3105 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3107 asection
*bfd_section
= section
->the_bfd_section
;
3109 return (pc
+ bfd_section_lma (bfd_section
)
3110 - bfd_section_vma (bfd_section
));
3116 /* Function: overlay_mapped_address (PC, SECTION)
3117 Returns the address corresponding to PC in the mapped (runtime) range.
3118 May be the same as PC. */
3121 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3123 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3125 asection
*bfd_section
= section
->the_bfd_section
;
3127 return (pc
+ bfd_section_vma (bfd_section
)
3128 - bfd_section_lma (bfd_section
));
3134 /* Function: symbol_overlayed_address
3135 Return one of two addresses (relative to the VMA or to the LMA),
3136 depending on whether the section is mapped or not. */
3139 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3141 if (overlay_debugging
)
3143 /* If the symbol has no section, just return its regular address. */
3146 /* If the symbol's section is not an overlay, just return its
3148 if (!section_is_overlay (section
))
3150 /* If the symbol's section is mapped, just return its address. */
3151 if (section_is_mapped (section
))
3154 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3155 * then return its LOADED address rather than its vma address!!
3157 return overlay_unmapped_address (address
, section
);
3162 /* Function: find_pc_overlay (PC)
3163 Return the best-match overlay section for PC:
3164 If PC matches a mapped overlay section's VMA, return that section.
3165 Else if PC matches an unmapped section's VMA, return that section.
3166 Else if PC matches an unmapped section's LMA, return that section. */
3168 struct obj_section
*
3169 find_pc_overlay (CORE_ADDR pc
)
3171 struct obj_section
*best_match
= NULL
;
3173 if (overlay_debugging
)
3175 for (objfile
*objfile
: current_program_space
->objfiles ())
3176 for (obj_section
*osect
: objfile
->sections ())
3177 if (section_is_overlay (osect
))
3179 if (pc_in_mapped_range (pc
, osect
))
3181 if (section_is_mapped (osect
))
3186 else if (pc_in_unmapped_range (pc
, osect
))
3193 /* Function: find_pc_mapped_section (PC)
3194 If PC falls into the VMA address range of an overlay section that is
3195 currently marked as MAPPED, return that section. Else return NULL. */
3197 struct obj_section
*
3198 find_pc_mapped_section (CORE_ADDR pc
)
3200 if (overlay_debugging
)
3202 for (objfile
*objfile
: current_program_space
->objfiles ())
3203 for (obj_section
*osect
: objfile
->sections ())
3204 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3211 /* Function: list_overlays_command
3212 Print a list of mapped sections and their PC ranges. */
3215 list_overlays_command (const char *args
, int from_tty
)
3219 if (overlay_debugging
)
3221 for (objfile
*objfile
: current_program_space
->objfiles ())
3222 for (obj_section
*osect
: objfile
->sections ())
3223 if (section_is_mapped (osect
))
3225 struct gdbarch
*gdbarch
= objfile
->arch ();
3230 vma
= bfd_section_vma (osect
->the_bfd_section
);
3231 lma
= bfd_section_lma (osect
->the_bfd_section
);
3232 size
= bfd_section_size (osect
->the_bfd_section
);
3233 name
= bfd_section_name (osect
->the_bfd_section
);
3235 gdb_printf ("Section %s, loaded at ", name
);
3236 gdb_puts (paddress (gdbarch
, lma
));
3238 gdb_puts (paddress (gdbarch
, lma
+ size
));
3239 gdb_printf (", mapped at ");
3240 gdb_puts (paddress (gdbarch
, vma
));
3242 gdb_puts (paddress (gdbarch
, vma
+ size
));
3249 gdb_printf (_("No sections are mapped.\n"));
3252 /* Function: map_overlay_command
3253 Mark the named section as mapped (ie. residing at its VMA address). */
3256 map_overlay_command (const char *args
, int from_tty
)
3258 if (!overlay_debugging
)
3259 error (_("Overlay debugging not enabled. Use "
3260 "either the 'overlay auto' or\n"
3261 "the 'overlay manual' command."));
3263 if (args
== 0 || *args
== 0)
3264 error (_("Argument required: name of an overlay section"));
3266 /* First, find a section matching the user supplied argument. */
3267 for (objfile
*obj_file
: current_program_space
->objfiles ())
3268 for (obj_section
*sec
: obj_file
->sections ())
3269 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3271 /* Now, check to see if the section is an overlay. */
3272 if (!section_is_overlay (sec
))
3273 continue; /* not an overlay section */
3275 /* Mark the overlay as "mapped". */
3276 sec
->ovly_mapped
= 1;
3278 /* Next, make a pass and unmap any sections that are
3279 overlapped by this new section: */
3280 for (objfile
*objfile2
: current_program_space
->objfiles ())
3281 for (obj_section
*sec2
: objfile2
->sections ())
3282 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
,
3286 gdb_printf (_("Note: section %s unmapped by overlap\n"),
3287 bfd_section_name (sec2
->the_bfd_section
));
3288 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3292 error (_("No overlay section called %s"), args
);
3295 /* Function: unmap_overlay_command
3296 Mark the overlay section as unmapped
3297 (ie. resident in its LMA address range, rather than the VMA range). */
3300 unmap_overlay_command (const char *args
, int from_tty
)
3302 if (!overlay_debugging
)
3303 error (_("Overlay debugging not enabled. "
3304 "Use either the 'overlay auto' or\n"
3305 "the 'overlay manual' command."));
3307 if (args
== 0 || *args
== 0)
3308 error (_("Argument required: name of an overlay section"));
3310 /* First, find a section matching the user supplied argument. */
3311 for (objfile
*objfile
: current_program_space
->objfiles ())
3312 for (obj_section
*sec
: objfile
->sections ())
3313 if (!strcmp (bfd_section_name (sec
->the_bfd_section
), args
))
3315 if (!sec
->ovly_mapped
)
3316 error (_("Section %s is not mapped"), args
);
3317 sec
->ovly_mapped
= 0;
3320 error (_("No overlay section called %s"), args
);
3323 /* Function: overlay_auto_command
3324 A utility command to turn on overlay debugging.
3325 Possibly this should be done via a set/show command. */
3328 overlay_auto_command (const char *args
, int from_tty
)
3330 overlay_debugging
= ovly_auto
;
3331 enable_overlay_breakpoints ();
3333 gdb_printf (_("Automatic overlay debugging enabled."));
3336 /* Function: overlay_manual_command
3337 A utility command to turn on overlay debugging.
3338 Possibly this should be done via a set/show command. */
3341 overlay_manual_command (const char *args
, int from_tty
)
3343 overlay_debugging
= ovly_on
;
3344 disable_overlay_breakpoints ();
3346 gdb_printf (_("Overlay debugging enabled."));
3349 /* Function: overlay_off_command
3350 A utility command to turn on overlay debugging.
3351 Possibly this should be done via a set/show command. */
3354 overlay_off_command (const char *args
, int from_tty
)
3356 overlay_debugging
= ovly_off
;
3357 disable_overlay_breakpoints ();
3359 gdb_printf (_("Overlay debugging disabled."));
3363 overlay_load_command (const char *args
, int from_tty
)
3365 struct gdbarch
*gdbarch
= get_current_arch ();
3367 if (gdbarch_overlay_update_p (gdbarch
))
3368 gdbarch_overlay_update (gdbarch
, NULL
);
3370 error (_("This target does not know how to read its overlay state."));
3373 /* Command list chain containing all defined "overlay" subcommands. */
3374 static struct cmd_list_element
*overlaylist
;
3376 /* Target Overlays for the "Simplest" overlay manager:
3378 This is GDB's default target overlay layer. It works with the
3379 minimal overlay manager supplied as an example by Cygnus. The
3380 entry point is via a function pointer "gdbarch_overlay_update",
3381 so targets that use a different runtime overlay manager can
3382 substitute their own overlay_update function and take over the
3385 The overlay_update function pokes around in the target's data structures
3386 to see what overlays are mapped, and updates GDB's overlay mapping with
3389 In this simple implementation, the target data structures are as follows:
3390 unsigned _novlys; /# number of overlay sections #/
3391 unsigned _ovly_table[_novlys][4] = {
3392 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3393 {..., ..., ..., ...},
3395 unsigned _novly_regions; /# number of overlay regions #/
3396 unsigned _ovly_region_table[_novly_regions][3] = {
3397 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3400 These functions will attempt to update GDB's mappedness state in the
3401 symbol section table, based on the target's mappedness state.
3403 To do this, we keep a cached copy of the target's _ovly_table, and
3404 attempt to detect when the cached copy is invalidated. The main
3405 entry point is "simple_overlay_update(SECT), which looks up SECT in
3406 the cached table and re-reads only the entry for that section from
3407 the target (whenever possible). */
3409 /* Cached, dynamically allocated copies of the target data structures: */
3410 static unsigned (*cache_ovly_table
)[4] = 0;
3411 static unsigned cache_novlys
= 0;
3412 static CORE_ADDR cache_ovly_table_base
= 0;
3415 VMA
, OSIZE
, LMA
, MAPPED
3418 /* Throw away the cached copy of _ovly_table. */
3421 simple_free_overlay_table (void)
3423 xfree (cache_ovly_table
);
3425 cache_ovly_table
= NULL
;
3426 cache_ovly_table_base
= 0;
3429 /* Read an array of ints of size SIZE from the target into a local buffer.
3430 Convert to host order. int LEN is number of ints. */
3433 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3434 int len
, int size
, enum bfd_endian byte_order
)
3436 /* FIXME (alloca): Not safe if array is very large. */
3437 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3440 read_memory (memaddr
, buf
, len
* size
);
3441 for (i
= 0; i
< len
; i
++)
3442 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3445 /* Find and grab a copy of the target _ovly_table
3446 (and _novlys, which is needed for the table's size). */
3449 simple_read_overlay_table (void)
3451 struct bound_minimal_symbol novlys_msym
;
3452 struct bound_minimal_symbol ovly_table_msym
;
3453 struct gdbarch
*gdbarch
;
3455 enum bfd_endian byte_order
;
3457 simple_free_overlay_table ();
3458 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3459 if (! novlys_msym
.minsym
)
3461 error (_("Error reading inferior's overlay table: "
3462 "couldn't find `_novlys' variable\n"
3463 "in inferior. Use `overlay manual' mode."));
3467 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3468 if (! ovly_table_msym
.minsym
)
3470 error (_("Error reading inferior's overlay table: couldn't find "
3471 "`_ovly_table' array\n"
3472 "in inferior. Use `overlay manual' mode."));
3476 gdbarch
= ovly_table_msym
.objfile
->arch ();
3477 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3478 byte_order
= gdbarch_byte_order (gdbarch
);
3480 cache_novlys
= read_memory_integer (novlys_msym
.value_address (),
3483 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3484 cache_ovly_table_base
= ovly_table_msym
.value_address ();
3485 read_target_long_array (cache_ovly_table_base
,
3486 (unsigned int *) cache_ovly_table
,
3487 cache_novlys
* 4, word_size
, byte_order
);
3489 return 1; /* SUCCESS */
3492 /* Function: simple_overlay_update_1
3493 A helper function for simple_overlay_update. Assuming a cached copy
3494 of _ovly_table exists, look through it to find an entry whose vma,
3495 lma and size match those of OSECT. Re-read the entry and make sure
3496 it still matches OSECT (else the table may no longer be valid).
3497 Set OSECT's mapped state to match the entry. Return: 1 for
3498 success, 0 for failure. */
3501 simple_overlay_update_1 (struct obj_section
*osect
)
3504 asection
*bsect
= osect
->the_bfd_section
;
3505 struct gdbarch
*gdbarch
= osect
->objfile
->arch ();
3506 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3507 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3509 for (i
= 0; i
< cache_novlys
; i
++)
3510 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3511 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3513 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3514 (unsigned int *) cache_ovly_table
[i
],
3515 4, word_size
, byte_order
);
3516 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3517 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3519 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3522 else /* Warning! Warning! Target's ovly table has changed! */
3528 /* Function: simple_overlay_update
3529 If OSECT is NULL, then update all sections' mapped state
3530 (after re-reading the entire target _ovly_table).
3531 If OSECT is non-NULL, then try to find a matching entry in the
3532 cached ovly_table and update only OSECT's mapped state.
3533 If a cached entry can't be found or the cache isn't valid, then
3534 re-read the entire cache, and go ahead and update all sections. */
3537 simple_overlay_update (struct obj_section
*osect
)
3539 /* Were we given an osect to look up? NULL means do all of them. */
3541 /* Have we got a cached copy of the target's overlay table? */
3542 if (cache_ovly_table
!= NULL
)
3544 /* Does its cached location match what's currently in the
3546 struct bound_minimal_symbol minsym
3547 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3549 if (minsym
.minsym
== NULL
)
3550 error (_("Error reading inferior's overlay table: couldn't "
3551 "find `_ovly_table' array\n"
3552 "in inferior. Use `overlay manual' mode."));
3554 if (cache_ovly_table_base
== minsym
.value_address ())
3555 /* Then go ahead and try to look up this single section in
3557 if (simple_overlay_update_1 (osect
))
3558 /* Found it! We're done. */
3562 /* Cached table no good: need to read the entire table anew.
3563 Or else we want all the sections, in which case it's actually
3564 more efficient to read the whole table in one block anyway. */
3566 if (! simple_read_overlay_table ())
3569 /* Now may as well update all sections, even if only one was requested. */
3570 for (objfile
*objfile
: current_program_space
->objfiles ())
3571 for (obj_section
*sect
: objfile
->sections ())
3572 if (section_is_overlay (sect
))
3575 asection
*bsect
= sect
->the_bfd_section
;
3577 for (i
= 0; i
< cache_novlys
; i
++)
3578 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (bsect
)
3579 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (bsect
))
3580 { /* obj_section matches i'th entry in ovly_table. */
3581 sect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3582 break; /* finished with inner for loop: break out. */
3587 /* Default implementation for sym_relocate. */
3590 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3593 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3595 bfd
*abfd
= sectp
->owner
;
3597 /* We're only interested in sections with relocation
3599 if ((sectp
->flags
& SEC_RELOC
) == 0)
3602 /* We will handle section offsets properly elsewhere, so relocate as if
3603 all sections begin at 0. */
3604 for (asection
*sect
: gdb_bfd_sections (abfd
))
3606 sect
->output_section
= sect
;
3607 sect
->output_offset
= 0;
3610 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3613 /* Relocate the contents of a debug section SECTP in ABFD. The
3614 contents are stored in BUF if it is non-NULL, or returned in a
3615 malloc'd buffer otherwise.
3617 For some platforms and debug info formats, shared libraries contain
3618 relocations against the debug sections (particularly for DWARF-2;
3619 one affected platform is PowerPC GNU/Linux, although it depends on
3620 the version of the linker in use). Also, ELF object files naturally
3621 have unresolved relocations for their debug sections. We need to apply
3622 the relocations in order to get the locations of symbols correct.
3623 Another example that may require relocation processing, is the
3624 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3628 symfile_relocate_debug_section (struct objfile
*objfile
,
3629 asection
*sectp
, bfd_byte
*buf
)
3631 gdb_assert (objfile
->sf
->sym_relocate
);
3633 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3636 symfile_segment_data_up
3637 get_symfile_segment_data (bfd
*abfd
)
3639 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3644 return sf
->sym_segments (abfd
);
3648 - DATA, containing segment addresses from the object file ABFD, and
3649 the mapping from ABFD's sections onto the segments that own them,
3651 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3652 segment addresses reported by the target,
3653 store the appropriate offsets for each section in OFFSETS.
3655 If there are fewer entries in SEGMENT_BASES than there are segments
3656 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3658 If there are more entries, then ignore the extra. The target may
3659 not be able to distinguish between an empty data segment and a
3660 missing data segment; a missing text segment is less plausible. */
3663 symfile_map_offsets_to_segments (bfd
*abfd
,
3664 const struct symfile_segment_data
*data
,
3665 section_offsets
&offsets
,
3666 int num_segment_bases
,
3667 const CORE_ADDR
*segment_bases
)
3672 /* It doesn't make sense to call this function unless you have some
3673 segment base addresses. */
3674 gdb_assert (num_segment_bases
> 0);
3676 /* If we do not have segment mappings for the object file, we
3677 can not relocate it by segments. */
3678 gdb_assert (data
!= NULL
);
3679 gdb_assert (data
->segments
.size () > 0);
3681 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3683 int which
= data
->segment_info
[i
];
3685 gdb_assert (0 <= which
&& which
<= data
->segments
.size ());
3687 /* Don't bother computing offsets for sections that aren't
3688 loaded as part of any segment. */
3692 /* Use the last SEGMENT_BASES entry as the address of any extra
3693 segments mentioned in DATA->segment_info. */
3694 if (which
> num_segment_bases
)
3695 which
= num_segment_bases
;
3697 offsets
[i
] = segment_bases
[which
- 1] - data
->segments
[which
- 1].base
;
3704 symfile_find_segment_sections (struct objfile
*objfile
)
3706 bfd
*abfd
= objfile
->obfd
.get ();
3710 symfile_segment_data_up data
= get_symfile_segment_data (abfd
);
3714 if (data
->segments
.size () != 1 && data
->segments
.size () != 2)
3717 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3719 int which
= data
->segment_info
[i
];
3723 if (objfile
->sect_index_text
== -1)
3724 objfile
->sect_index_text
= sect
->index
;
3726 if (objfile
->sect_index_rodata
== -1)
3727 objfile
->sect_index_rodata
= sect
->index
;
3729 else if (which
== 2)
3731 if (objfile
->sect_index_data
== -1)
3732 objfile
->sect_index_data
= sect
->index
;
3734 if (objfile
->sect_index_bss
== -1)
3735 objfile
->sect_index_bss
= sect
->index
;
3740 /* Listen for free_objfile events. */
3743 symfile_free_objfile (struct objfile
*objfile
)
3745 /* Remove the target sections owned by this objfile. */
3746 if (objfile
!= NULL
)
3747 current_program_space
->remove_target_sections ((void *) objfile
);
3750 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3751 Expand all symtabs that match the specified criteria.
3752 See quick_symbol_functions.expand_symtabs_matching for details. */
3755 expand_symtabs_matching
3756 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3757 const lookup_name_info
&lookup_name
,
3758 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3759 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3760 block_search_flags search_flags
,
3761 enum search_domain kind
)
3763 for (objfile
*objfile
: current_program_space
->objfiles ())
3764 if (!objfile
->expand_symtabs_matching (file_matcher
,
3775 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3776 Map function FUN over every file.
3777 See quick_symbol_functions.map_symbol_filenames for details. */
3780 map_symbol_filenames (gdb::function_view
<symbol_filename_ftype
> fun
,
3783 for (objfile
*objfile
: current_program_space
->objfiles ())
3784 objfile
->map_symbol_filenames (fun
, need_fullname
);
3789 namespace selftests
{
3790 namespace filename_language
{
3792 static void test_filename_language ()
3794 /* This test messes up the filename_language_table global. */
3795 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3797 /* Test deducing an unknown extension. */
3798 language lang
= deduce_language_from_filename ("myfile.blah");
3799 SELF_CHECK (lang
== language_unknown
);
3801 /* Test deducing a known extension. */
3802 lang
= deduce_language_from_filename ("myfile.c");
3803 SELF_CHECK (lang
== language_c
);
3805 /* Test adding a new extension using the internal API. */
3806 add_filename_language (".blah", language_pascal
);
3807 lang
= deduce_language_from_filename ("myfile.blah");
3808 SELF_CHECK (lang
== language_pascal
);
3812 test_set_ext_lang_command ()
3814 /* This test messes up the filename_language_table global. */
3815 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3817 /* Confirm that the .hello extension is not known. */
3818 language lang
= deduce_language_from_filename ("cake.hello");
3819 SELF_CHECK (lang
== language_unknown
);
3821 /* Test adding a new extension using the CLI command. */
3822 ext_args
= ".hello rust";
3823 set_ext_lang_command (NULL
, 1, NULL
);
3825 lang
= deduce_language_from_filename ("cake.hello");
3826 SELF_CHECK (lang
== language_rust
);
3828 /* Test overriding an existing extension using the CLI command. */
3829 int size_before
= filename_language_table
.size ();
3830 ext_args
= ".hello pascal";
3831 set_ext_lang_command (NULL
, 1, NULL
);
3832 int size_after
= filename_language_table
.size ();
3834 lang
= deduce_language_from_filename ("cake.hello");
3835 SELF_CHECK (lang
== language_pascal
);
3836 SELF_CHECK (size_before
== size_after
);
3839 } /* namespace filename_language */
3840 } /* namespace selftests */
3842 #endif /* GDB_SELF_TEST */
3844 void _initialize_symfile ();
3846 _initialize_symfile ()
3848 struct cmd_list_element
*c
;
3850 gdb::observers::free_objfile
.attach (symfile_free_objfile
, "symfile");
3852 #define READNOW_READNEVER_HELP \
3853 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3854 immediately. This makes the command slower, but may make future operations\n\
3856 The '-readnever' option will prevent GDB from reading the symbol file's\n\
3857 symbolic debug information."
3859 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3860 Load symbol table from executable file FILE.\n\
3861 Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3862 OFF is an optional offset which is added to each section address.\n\
3863 The `file' command can also load symbol tables, as well as setting the file\n\
3864 to execute.\n" READNOW_READNEVER_HELP
), &cmdlist
);
3865 set_cmd_completer (c
, filename_completer
);
3867 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3868 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3869 Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3870 [-s SECT-NAME SECT-ADDR]...\n\
3871 ADDR is the starting address of the file's text.\n\
3872 Each '-s' argument provides a section name and address, and\n\
3873 should be specified if the data and bss segments are not contiguous\n\
3874 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3875 OFF is an optional offset which is added to the default load addresses\n\
3876 of all sections for which no other address was specified.\n"
3877 READNOW_READNEVER_HELP
),
3879 set_cmd_completer (c
, filename_completer
);
3881 c
= add_cmd ("remove-symbol-file", class_files
,
3882 remove_symbol_file_command
, _("\
3883 Remove a symbol file added via the add-symbol-file command.\n\
3884 Usage: remove-symbol-file FILENAME\n\
3885 remove-symbol-file -a ADDRESS\n\
3886 The file to remove can be identified by its filename or by an address\n\
3887 that lies within the boundaries of this symbol file in memory."),
3890 c
= add_cmd ("load", class_files
, load_command
, _("\
3891 Dynamically load FILE into the running program.\n\
3892 FILE symbols are recorded for access from GDB.\n\
3893 Usage: load [FILE] [OFFSET]\n\
3894 An optional load OFFSET may also be given as a literal address.\n\
3895 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3896 on its own."), &cmdlist
);
3897 set_cmd_completer (c
, filename_completer
);
3899 cmd_list_element
*overlay_cmd
3900 = add_basic_prefix_cmd ("overlay", class_support
,
3901 _("Commands for debugging overlays."), &overlaylist
,
3904 add_com_alias ("ovly", overlay_cmd
, class_support
, 1);
3905 add_com_alias ("ov", overlay_cmd
, class_support
, 1);
3907 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3908 _("Assert that an overlay section is mapped."), &overlaylist
);
3910 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3911 _("Assert that an overlay section is unmapped."), &overlaylist
);
3913 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3914 _("List mappings of overlay sections."), &overlaylist
);
3916 add_cmd ("manual", class_support
, overlay_manual_command
,
3917 _("Enable overlay debugging."), &overlaylist
);
3918 add_cmd ("off", class_support
, overlay_off_command
,
3919 _("Disable overlay debugging."), &overlaylist
);
3920 add_cmd ("auto", class_support
, overlay_auto_command
,
3921 _("Enable automatic overlay debugging."), &overlaylist
);
3922 add_cmd ("load-target", class_support
, overlay_load_command
,
3923 _("Read the overlay mapping state from the target."), &overlaylist
);
3925 /* Filename extension to source language lookup table: */
3926 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3928 Set mapping between filename extension and source language."), _("\
3929 Show mapping between filename extension and source language."), _("\
3930 Usage: set extension-language .foo bar"),
3931 set_ext_lang_command
,
3933 &setlist
, &showlist
);
3935 add_info ("extensions", info_ext_lang_command
,
3936 _("All filename extensions associated with a source language."));
3938 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3939 &debug_file_directory
, _("\
3940 Set the directories where separate debug symbols are searched for."), _("\
3941 Show the directories where separate debug symbols are searched for."), _("\
3942 Separate debug symbols are first searched for in the same\n\
3943 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3944 and lastly at the path of the directory of the binary with\n\
3945 each global debug-file-directory component prepended."),
3947 show_debug_file_directory
,
3948 &setlist
, &showlist
);
3950 add_setshow_enum_cmd ("symbol-loading", no_class
,
3951 print_symbol_loading_enums
, &print_symbol_loading
,
3953 Set printing of symbol loading messages."), _("\
3954 Show printing of symbol loading messages."), _("\
3955 off == turn all messages off\n\
3956 brief == print messages for the executable,\n\
3957 and brief messages for shared libraries\n\
3958 full == print messages for the executable,\n\
3959 and messages for each shared library."),
3962 &setprintlist
, &showprintlist
);
3964 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
3965 &separate_debug_file_debug
, _("\
3966 Set printing of separate debug info file search debug."), _("\
3967 Show printing of separate debug info file search debug."), _("\
3968 When on, GDB prints the searched locations while looking for separate debug \
3969 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
3972 selftests::register_test
3973 ("filename_language", selftests::filename_language::test_filename_language
);
3974 selftests::register_test
3975 ("set_ext_lang_command",
3976 selftests::filename_language::test_set_ext_lang_command
);